Why reinterpret_cast fails while memcpy works?

Question

I'm writing some socket code and based on some params I'm using either IPv4 or IPv6. For that I have a code like this:

struct sockaddr final_addr;
...
struct sockaddr_in6 addr6;
... 
memcpy(&final_addr, &addr6, size);
...
bind(fd, &final_addr, size);

This works fine. However if I do (which was my initial idea)

struct sockaddr final_addr;
...
struct sockaddr_in6 addr6;
... 
final_addr = *reinterpret_cast<struct sockaddr*>(&addr6);
...
bind(fd, &final_addr, size);

then it fails on bind with Cannot assign requested address error.

Note that this incorrect code works fine if I switch to IPv4's sockaddr_in.

What's going on here? Why can't I just reinterpret sockaddr_in6 as sockaddr?

Answer 1

If in the first version of the code size is sizeof(addr6) (as you stated in the comments), then the first version of the code uses memcpy to copy sizeof(struct sockaddr_in6) bytes of data.

The second version of the code uses regular struct sockaddr assignment to copy only sizeof(struct sockaddr) bytes.

sizeof(struct sockaddr) is smaller than sizeof(struct sockaddr_in6), which makes these two code samples different.

Note that in the first version the recipient object in that memcpy is of struct sockaddr type, i.e. it is smaller than the number of bytes copied. Memory overrun occurs, which clobbers some other data stored in adjacent memory locations. The code "works" only by accident. I.e. if this bit "works", then some other piece of code (the one that relies on the now-clobbered data) is likely to fail.

Answer 2

sockaddr is not large enough to hold data from a sockaddr_in6. The first code example "works" only because the source address data is being copied in full, and you are passing a full address to bind(), but you have also trashed stack memory during the copying. The second code example does not work because it is truncating the address data during the assignment, but it is not trashing stack memory anymore.

Neither code example will work correctly for IPv6, but both will "work" OK for IPv4 because sockaddr is large enough to hold data from a sockaddr_in, so no trashing or truncating is happening.

To ensure final_addr is large enough to hold data from either sockaddr_in or sockaddr_in6, it needs to be declared as a sockaddr_storage instead, which is guaranteed to be large enough to hold data from any sockaddr_... struct type:

struct sockaddr_storage final_addr;
int size;

if (use IPv6)
{
    struct sockaddr_in6 addr6;
    // populate addr6 as needed...

    memcpy(&final_addr, &addr6, sizeof(addr6));
    or
    *reinterpret_cast<struct sockaddr_in6*>(&final_addr) = addr6;

    size = sizeof(addr6);
}
else
{
    struct sockaddr_in addr4;
    // populate addr4 as needed...

    memcpy(&final_addr, &addr4, sizeof(addr4));
    or
    *reinterpret_cast<struct sockaddr_in*>(&final_addr) = addr4;

    size = sizeof(addr4);
}

bind(fd, reinterpret_cast<struct sockaddr*>(&final_addr), size);

A better option would be to use getaddrinfo() or equivalent to create a suitable sockaddr_... memory block for you:

struct addrinfo hints;
memset(&hints, 0, sizeof(hints));

hints.ai_flags = AI_NUMERICHOST;
hints.ai_family = AF_UNSPEC;

struct addrinfo *addr = NULL;

if (getaddrinfo("ip address here", "port here", &hints, &addr) == 0)
{
    bind(fd, addr->ai_addr, addr->ai_addrlen);
    freeaddrinfo(addr);
}

Alternatively:

struct addrinfo hints;
memset(&hints, 0, sizeof(hints));

hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = ...; // SOCK_STREAM, SOCK_DGRAM, etc...
hints.ai_protocol = ...; // IPPROTO_TCP, IPPROTO_UDP, etc...

struct addrinfo *addrs = NULL;

if (getaddrinfo(NULL, "port here", &hints, &addrs) == 0)
{
    for (struct addrinfo *addr = addrs; addr != NULL; addr = addr->ai_next)
    {
        int fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
        if (fd != -1)
        {
            bind(fd, addr->ai_addr, addr->ai_addrlen);
            // save fd somewhere for later use
            ...
        }
    }
    freeaddrinfo(addrs);
}