Why is the select call not blocking on a unix domain socket?

I googled a lot and didn't get an answer, hence posting it here.

In the following C program(the server code) I want a Unix domain socket server that's listening at /tmp/unix-test-socket. My problem is that the client code is sucessfully able to connect to the server. However, once its connected and I have "accepted" the connection, the select call does NOT block.

So let me explain.

Initially the unix_domain_socket = 3

As soon as I get the first request, accept the connection and, store it in unix_domain_socket_connections[max_unix_domain_socket_connections]. The value of the socket fd is 4.

When I run the server code goes into a loop because the select call believes that always there is data in socket 4.

I run the CLIENT side as:

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

Output from the SERVER side:

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

SERVER CODE:

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);
    }
  }
}

CLIENT CODE:

/* 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;
}