在sockaddr和sockaddr_in之间进行转换

Question

I came across a socket programming tutorial in which it is quoted

"a pointer to a struct sockaddr_in can be cast to a pointer to a struct sockaddr and vice-versa "

I dont understand how can sockaddr_in be cast to sockaddr. Casting a pointer of Big type to Small type should give UD behavior.

struct sockaddr {
unsigned short sa_family; // address family, AF_xxx
char sa_data[14]; // 14 bytes of protocol address
};


struct sockaddr_in {
short int sin_family; // Address family, AF_INET
unsigned short int sin_port; // Port number
struct in_addr sin_addr; // Internet address
unsigned char sin_zero[8]; // Same size as struct sockaddr
};

How can the cast not be undefined? Isn't it unsafe to cast these to each other?

If i have a class A having only two ints and class B having 4 ints. And if i have a pointer of type B and i cast it to type A then sure i can fetch the first two elements. But if class A has 2 chars declared first and 2 ints declared later then the pointers would not right fetch the values since the object layout in this case would be different.

Edit 1:

class Anu
{
public:
    char a;
    int b;
    Anu()
    {
        a='a';
    }
};
class Anurag
{
public:
    Anurag() { a=4;}
    int a;
    int b;
    int c;
    int d;
};
int main()
{
        Anu objanu;
        Anurag objanurag;
        Anurag *ptrAnurag= &objanurag;
        ptrAnurag= (Anurag*)&objanu;
        cout<<ptrAnurag->a; //Some weird value here
        return 0;
}

Assuming i change the example so that both classes have same size by adjusting the variables types...still the object layout might be different even though the size remains the same.

Answer 1

I'll add to @gsamaras answer by saying that Undefined Behaviour doesn't always means that bad things are about to happen. Undefined Behaviour actually says "we* don't provide any specifications on what should happen next if XYZ occurs".

(*the C++ standard).

this is the place where the OS takes place and say "it is defined by us".

although casting unrelated structs ( sockaddr_in , sockaddr ) may be undefined behaviour by the standard, the OS API specify that it is valid with their API.

Answer 2

They are of equal size , so no, you don't get any UB !

Proof:

#include <stdio.h>

struct sockaddr {
  unsigned short sa_family; // address family, AF_xxx
  char sa_data[14]; // 14 bytes of protocol address
};

// src: http://www.gta.ufrj.br/ensino/eel878/sockets/sockaddr_inman.html
struct in_addr {
    unsigned long s_addr;  // load with inet_aton()
};

struct sockaddr_in {
  short int sin_family; // Address family, AF_INET
  unsigned short int sin_port; // Port number
  struct in_addr sin_addr; // Internet address
  unsigned char sin_zero[8]; // Same size as struct sockaddr
};

int main (void) {
  printf("%zu\n", sizeof(unsigned short) + sizeof(char) * 14);
  printf("%zu\n", sizeof(short int) + sizeof(unsigned short int) + sizeof(struct in_addr) + sizeof(unsigned char) * 8);
  return 0;
}

Output:

16
16

A good comment: sockaddr: 2+14=16, sockaddr_in:2+2+4+8=16 – Amer Agovic

You may also want to take a look at this question: Why isn't sizeof for a struct equal to the sum of sizeof of each member?

---

Please, check this question: Is it possible to cast struct to another?

I am copying the answer of Benoit here too:

This is refered as Type Punning . Here, both structures have the same size, so there is no question of struct size. Although you can cast almost anything to anything, doing it with structures is error-prone.

and this one by Richard J. Ross III too:

This is C's form of "inheritance" (notice the quotes). This works because C does not care about the underlying data in an address, just what you represent it as.

The function determines what structure it actually is by using the sa_family field, and casting it into the proper sockaddr_in inside the function.

Answer 3

The different sizes don't matter. Just like you can pass strings of different lengths to the various string-handling functions, you can pass struct sockaddr of different lengths to the various socket-handling functions.

The size of the struct sockaddr is interpreted by the called function per the contents of the sa_family member of the structure. Note also that all functions that take a struct sockaddr * address also take a socklen_t argument that holds the size of the structure being passed.

For example, the struct sockaddr_un structure is 110 bytes:

   struct sockaddr_un {
       sa_family_t sun_family;               /* AF_UNIX */
       char        sun_path[108];            /* pathname */
   };

The called function such as bind() or getpeername() have declarations similar to

int getpeerame(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 

for the very reason that the size(s) of various socket structures vary.

Note that the first member of every struct sockaddr_??? is the sa_family . Thus it's always in the same place.