如何 memcpy() 结构 sockaddr_in

Question

I'm programming a server-client program. On the server I manage the clients through an array of this data structure:

struct Client
{
    struct sockaddr_in addr;
    /*...*/
}; 

struct Client CLIENTS[MAX_CLI];

When I receive the first packet from the client through my UDP socket

struct sockaddr_in addr_cli;

memset(&addr_cli,0,sizeof(struct sockaddr_in));
b=recvfrom(SOCK_UDP_FATHER, &pdu, sizeof(pdu), MSG_DONTWAIT,
    (struct sockaddr *)&addr_cli, (socklen_t *)&laddr_cli);

I want to copy his address to my struct. So I do:

memcpy(&CLIENTS[client].addr,(struct sockaddr*)&addr_cli,
    sizeof(struct sockaddr_in));

printf("IP client: %s",inet_ntoa(CLIENTS[client].addr.sin_addr);

The strange thing is that the first try of communication fails, printing 0.0.0.0 . But the next try that the client does, is successful and everything goes fine. Why that happens?

Answer 1

The addr_cli was not filled by the call to recvfrom . The last two arguments of recvfrom are a little bit tricky. They are

struct sockaddr *src_addr,
socklen_t *addrlen

If src_addr is not NULL, the recvfrom expects that addrlen points to the length of src_addr buffer. (Normally it is the size of sockaddr structure). If the value of addrlen is too small, the returned address will be truncated. After the call to recvfrom the addrlen will be set to the actual address length. Look at documentation for details.

So you need to initialize laddr_cli before calling recvfrom() :

struct sockaddr_in addr_cli;
socklen_t laddr_cli = sizeof(addr_cli); // <--

memset(&addr_cli,0,laddr_cli);    
b=recvfrom(SOCK_UDP_FATHER, &pdu, sizeof(pdu), MSG_DONTWAIT,
    (struct sockaddr *)&addr_cli, &laddr_cli);

Answer 2

I had a problem just this morning when I tried to copy an address returned from getaddrinfo. It's probably similar to your problem copying an address returned from recvfrom.

I had a struct addrinfo *rp, and I wanted to copy rp->ai_addr to local storage so I could be sure it would stick around after calling freeaddrinfo. This worked:

struct sockaddr_storage addr;
memcpy(&addr, rp->ai_addr, rp->ai_addrlen);

In my case I could not declare addr as a sockaddr_in because that would overflow the buffer when I saw an AF_INET6 address. Using sockaddr_in6 worked, but I am sticking with sockaddr_storage so I can be absolutely protocol neutral in case new address families crop up.

EDIT: That said, it does seem a bit wasteful to keep an entire struct sockaddr_storage as a field in a client structure. That thing is 128 bytes. A struct sockaddr_in6 is only 28 bytes. How "protocol neutral" do I really need to be?

Probably better to keep a sockaddr_in6 and if I ever see an address length greater than that, just have the program die. That way if someone comes up with a new family AF_WEIRD that's 37 bytes long, I could adapt to it then without having to burn 128 bytes all time until then.

Not only that, but my server sets hints to AF_INET6 anyway, which allows it to receive either AF_INET or AF_INET6 packets, while presumably dropping any new AF_WEIRD.