Question

我搜索了很多内容并没有得到答案，因此将其发布在此处。

在下面的C程序（服务器代码）中，我想要一个在/tmp/unix-test-socket监听的Unix域套接字服务器。我的问题是客户端代码成功连接到服务器。然而，一旦它连接起来，我已经接受了＃34;连接时，select调用不会阻止。

让我解释一下。

最初是unix_domain_socket = 3

我收到第一个请求后，立即接受连接，并将其存储在unix_domain_socket_connections [max_unix_domain_socket_connections]中。套接字fd的值为4。

当我运行服务器时，代码进入循环，因为select调用认为socket 4中总是存在数据。

我将客户端运行为：

./unix-client "/tmp/unix-test-socket" SEND_DATA

来自SERVER端的输出：

Client sent us a message!

Successfully accepted the new ION connection with fd 4!

[program_select_to_look_at_right_sockets]: Storing fd 4

Data Arrived on UNIX domain socket 4

length 10 SEND_DATA  <-- I get the data sent by the client

[program_select_to_look_at_right_sockets]: Storing fd 4 *<-- Why isnt select blocking and why does it think there is still data on socket 4*

Data Arrived on UNIX domain socket 4

[program_select_to_look_at_right_sockets]: Storing fd 4

Data Arrived on UNIX domain socket 4

服务器代码：

int unix_domain_socket = 0;

int max_unix_domain_socket_connections;
int unix_domain_socket_connections[2];

char *unix_domain_socket_name = "/tmp/unix-test-socket";

int open_unix_domain_server()
{
  int socket_fd, result;
  struct sockaddr_un name;
  int client_sent_quit_message;
  socklen_t socket_length;

  max_unix_domain_socket_connections = 0;
  memset((void *) &name, 0, sizeof(name));

  socket_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
  name.sun_family = AF_UNIX;
  strcpy(name.sun_path, unix_domain_socket_name);
  socket_length = strlen(name.sun_path) + sizeof(name.sun_family);

  /* Remove this socket if it already exists */
  unlink(name.sun_path);

  result = bind(socket_fd, (struct sockaddr *) &name, socket_length);

  if (result < 0)
    goto Error;

  result = listen(socket_fd, MAX_UNIX_DOMAIN_SOCKETS);

  return socket_fd;

  Error:

  printf("[%s] Error in either listen or bind!\n", __FUNCTION__);

  return -1;

}

int accept_new_unix_domain_connection()
{
  int client_fd;
  struct sockaddr_un new_connection;
  socklen_t new_conn_length = sizeof(new_connection);

  memset((void *) &new_connection, 0, sizeof(new_connection));

  client_fd = accept(unix_domain_socket, (struct sockaddr *) &new_connection,
      &new_conn_length);

  if (client_fd < 0)
  {
    printf("The following error occurred accept failed %d %d\n", errno,
        unix_domain_socket);
  }

  unix_domain_socket_connections[max_unix_domain_socket_connections] =
      client_fd;

  max_unix_domain_socket_connections++;

  return client_fd;
}

int check_if_new_client_is_unix_domain(fd_set readfds)
{
  int unix_fd = 0;

  for (unix_fd = 0; unix_fd < 2; unix_fd++)
  {
    if (FD_ISSET(unix_domain_socket_connections[unix_fd], &readfds))
    {
      printf("Data Arrived on UNIX domain socket %d\n",
          unix_domain_socket_connections[unix_fd]);
      return 1;
    }
  }

  return 0;
}

int process_data_on_unix_domain_socket(int unix_socket)
{
  int length = 0;
  char* data_from_gridFtp;

  /* First, read the length of the text message from the socket. If
   read returns zero, the client closed the connection. */

  if (read(unix_socket, &length, sizeof(length)) == 0)
    return 0;

  /* Allocate a buffer to hold the text. */
  data_from_gridFtp = (char*) malloc(length + 1);

  /* Read the text itself, and print it. */
  recv(unix_socket, data_from_gridFtp, length, 0);

  printf("length %d %s\n", length, data_from_gridFtp);

  return length;
}

void program_select_to_look_at_right_sockets(fd_set *readfds, int *maxfds)
{
  int unix_fd = 0;

  FD_ZERO(readfds);

  FD_SET(unix_domain_socket, readfds);

  for (unix_fd = 0; unix_fd < 2; unix_fd++)
  {
    if (unix_domain_socket_connections[unix_fd])
    {
      printf("[%s]: Storing fd %d\n", __FUNCTION__,
          unix_domain_socket_connections[unix_fd]);

      FD_SET(unix_domain_socket_connections[unix_fd], readfds);

      if (*maxfds < unix_domain_socket_connections[unix_fd])
        *maxfds = unix_domain_socket_connections[unix_fd];
    }

  }
}

int main(int argc, char**argv)
{
  int result, maxfds, clientfd, loop;
  fd_set readfds;
  int activity;
  socklen_t client_len;
  struct sockaddr_in client_address;

  FD_ZERO(&readfds);

  unix_domain_socket = open_unix_domain_server();

  if (unix_domain_socket < 0)
    return -1;

  maxfds = unix_domain_socket;

  FD_SET(unix_domain_socket, &readfds);

  for (loop = 0; loop < 4; loop++)
  {
    program_select_to_look_at_right_sockets(&readfds, &maxfds);

    activity = select(maxfds + 1, &readfds, NULL, NULL, NULL);

    if (FD_ISSET(unix_domain_socket, &readfds))
    {
      printf("client sent us a message!\n");
      clientfd = accept_new_unix_domain_connection();

      if (clientfd < 0)
        break;
    }
    else if (check_if_new_client_is_unix_domain(readfds))
    {
      process_data_on_unix_domain_socket(clientfd);
    }
  }
}

客户代码：

/* Write TEXT to the socket given by file descriptor SOCKET_FD. */
void write_text(int socket_fd, const char* text)
{
  /* Write the number of bytes in the string, including
   NUL-termination. */
  int length = strlen(text) + 1;
  send(socket_fd, &length, sizeof(length), 0);
  /* Write the string. */
  send(socket_fd, text, length, 0);
}

int main(int argc, char* const argv[])
{
  const char* const socket_name = argv[1];
  const char* const message = argv[2];
  int socket_fd;
  struct sockaddr_un name;
  /* Create the socket. */
  socket_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
  /* Store the serverâ€™s name in the socket address. */
  name.sun_family = AF_UNIX;
  strcpy(name.sun_path, socket_name);
  /* Connect the socket. */
  connect(socket_fd, (struct sockaddr *) &name, SUN_LEN(&name));
  /* Write the text on the command line to the socket. */
  write_text(socket_fd, message);
  close(socket_fd);
  return 0;
}

Answer 1

您会发现select()将返回＆＃34;准备好阅读＆＃34;如果远端已经关闭......准备阅读的规则＆＃34;如果read()不会阻止，那就是真的。 read()如果返回0则不会阻止。

Answer 2

根据select linux手册页，有一个与此行为相关的错误：

在Linux下，select（）可以将套接字文件描述符报告为＆＃34;准备好读取＆＃34;，然后是后续的读取块。这可能例如在数据到达时发生但在检查时具有错误的校验和并被丢弃。可能存在其他情况，其中虚假地报告文件描述符为就绪。

另一方面，我建议您考虑处理活动的策略并将数据处理到循环中（删除不相关的部分）：

for (loop = 0; loop<4; loop++)
{
    // ...
    activity = select( maxfds + 1 , &readfds , NULL , NULL , NULL);
    // ...
}

这将阻止第一个sockect，而第二个，第三个和第四个可能已准备就绪。至少使用超时并检查errno是否有句柄超时事件。有关详细信息，请参阅选择手册页。

为什么unix域套接字上的select调用没有阻塞？

我将客户端运行为：

来自SERVER端的输出：

2 个答案: