accept（）调用不会初始化sockaddr结构

Question

I have written a short TCP server example in C which continually listens for connections on port 12701, and outputs the value of the peer's sockaddr.sa_family to stdout. The program calls accept() in an infinite loop, which should fill in a struct sockaddr with the details of the connection, including sa_family.

However, this doesn't happen correctly for the first TCP connection; sockaddr.sa_family is always zero. All subsequent connections provide a correct value of two - only the first one is wrong. Why does this happen? I haven't been able to find any reports of similar problems, but I suspect I am initializing something incorrectly or misinterpreting the parameters of accept().

Here is the program:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(void)
{
    struct sockaddr_in saddr =
    {
        .sin_family      = AF_INET,
        .sin_addr.s_addr = htonl(INADDR_ANY),
        .sin_port        = htons(12701),
    };

    // open socket to accept() tcp connections
    int accept_fd = socket(AF_INET, SOCK_STREAM, 0);
    bind(accept_fd, (struct sockaddr *) &saddr, sizeof(struct sockaddr_in));
    listen(accept_fd, SOMAXCONN);

    socklen_t addrlen;
    struct sockaddr * addr;
    for(;;)
    {
        addr = (struct sockaddr *) malloc(sizeof(struct sockaddr));
        int child_fd = accept(accept_fd, addr, &addrlen);

        // why is this always zero the first time?
        printf("addr->sa_family = %d\n", addr->sa_family);

        close(child_fd);
        free(addr);
    }

    return 0;
}

Answer 1

This assumes AF_INET for the connection to be setup.

You want to pass to accept() the address of a structure suitable to what you bound the listening socket to, that is a struct sockaddr_in .

Also addrlen needs to be set to the size of what the address of is passed to accept() .

  for (;;)
  {
    struct sockaddr_in * addr = malloc(sizeof *addr);
    socklen_t addrlen = sizeof *addr;

    if (NULL == addr)
    {
       perror("malloc() failed");
       /* exit(), break, continue, whatever ... */
    }

    int child_fd = accept(accept_fd, (struct sockaddr *) addr, &addrlen);
    if (-1 == child_fd)
    {
       perror("accept() failed");
       free(addr);
       addr = NULL;
       /* exit(), break, continue, whatever ... */
    }

    /* Do stuff. */

    close(child_fd);
    free(addr);
  }

Answer 2

the call to accept() is not being handled correctly.

in the posted code:

1. the call to accept() must be checked for a failure.
2. the call to malloc() must be checked for a failure
3. the allocated memory must be free'd
4. the addrlen parameter to accept() must be properly initialized before each call to accept() .

The posted code can only handle one connection at a time. It would be a good idea to allow for multiple simultaneous connections by having each connection be routed to a thread . However, generating/destroying threads takes a long time, so suggest having a 'pool' of threads that are initially set to 'unused' and passing each connection to a 'currently unused' thread, after marking that thread as 'in use' When the thread returns, mark it as 'unused', again.

In the following code, no effort has been made to allow for multiple simultaneous connections.

for(;;)
{
    addr = malloc(sizeof(struct sockaddr));
    if( !addr )
    {
        perror( "malloc failed" );
        exit( EXIT_FAILURE );  // exit() and EXIT_FAILURE from stdlib.h
    }

    // implied else, malloc successful

    addrlen = sizeof( struct sockaddr );
    int child_fd = accept(accept_fd, addr, &addrlen);

    if( -1 == child_fd )
    { // then an error occurred
        perror( "accept failed" );
    }

    else
    { // else, accept successful
        printf("addr->sa_family = %d\n", addr->sa_family);
        close(child_fd);
    }

    free( addr ); // to avoid memory leak
    addr = NULL;  // for safety
}

Answer 3

Take a look at for instance this documentation : http://man7.org/linux/man-pages/man2/accept.2.html

And more specifically the description of the addrlen parameter. This is an inout parameter and you must initialise it properly.

The addrlen argument is a value-result argument: the caller must initialize it to contain the size (in bytes) of the structure pointed to by addr; on return it will contain the actual size of the peer address.'