Thread: Socket Programming

Yes, that's correct.

However, struct sockaddr * would be a pointer to a struct sockaddr

You'll probably see in the manual, http://www.hmug.org/man/2/connect.php that connect() expects a pointer to a struct sockaddr but dest_addr is a struct sockaddr_in. Hence the cast.

http://www.beej.us/guide/bgnet/outpu...ddr_inman.html tells you the difference between the two.

These are the basic structures for all syscalls and functions that deal with internet addresses. In memory, the struct sockaddr_in is the same size as struct sockaddr, and you can freely cast the pointer of one type to the other without any harm, except the possible end of the universe.

Just kidding on that end-of-the-universe thing...if the universe does end when you cast a struct sockaddr_in* to a struct sockaddr*, I promise you it's pure coincidence and you shouldn't even worry about it.

So, with that in mind, remember that whenever a function says it takes a struct sockaddr* you can cast your struct sockaddr_in* to that type with ease and safety.

...

Code:

connect(sockfd, struct sockaddr *dest_addr, sizeof dest_addr)

Is invalid for one.

As you know, pointers hold addresses to certain things (they have a type so you know what they point to),

ie: char * test;

test is a pointer to a character (it holds the address of a character).

connect() expects the address of a struct sockaddr, since sockaddr and sockaddr_in are the same in size, and it's perfectly fine to cast one to the other you can do so.

&dest_addr will give you the address of dest_addr, you then use must cast this address to a struct sockaddr * (pointer) as connect() expects.

It's the same as writing:

Code:

struct sockaddr_in dest_addr;
struct sockaddr_in * pointerToDestAddr = &dest_addr;  /* a pointer to dest_addr of type sockaddr_in */

                /* cast the pointer to sockaddr, so the compiler knows what you're pointing to */
connect(sockfd, (struct sockaddr *)pointerToDestAddr, sizeof dest_addr);

Basically, a simplified version:

Code:

#include <stdio.h>

struct a_s
{
    int something;
};

struct b_s
{
    int value;
};

void foo(struct b_s * blah)
{
    printf("&#37;d\n", blah->value);
}

int main(void)
{
    struct a_s dest_addr;
    struct b_s tmp;

    foo(&dest_addr);  /* This is illegal, incompatible pointer types -- a_s is different from b_s as expected by foo() */

    /* legal */
    foo((struct b_s *) &dest_addr);

    /* also legal (essentially the same thing) */
    tmp = (struct b_s) dest_addr;
    foo(&tmp);

    return 0;
}

You can see foo() expects a pointer to a struct b_s, but you have a struct a_s -- thus you must cast the pointer or the object.

Be careful, this doesn't work all the time (in this example it does, sizeof(struct a_s) == sizeof(struct b_s)) and they both have the same type & # of elements.

I hope I cleared it up.

A cast just basically changes the type to the compiler.

Code:

int a = 0;
short b = (short)a;

Data is stored as raw in memory, so the compiler relies on the type of the variable to know what data is stored in the memory. This is especially important to know with pointers. We're just telling the compiler to treat the data as a different type:

Code:

int a;
int* b = &a;
short* c = (short*)b;

We're telling the compiler basically, the data stored at the location stored in b is short, not int and saves it in variable c.

Code:

void foo(int* a) { }
int main()
{
    short a;
    foo((int*)&a);
    /* Is equalient to... */
    short b;
    short* c = &b;
    int* d = (int*)c;
    foo(d);
    /* In other words, first take address of b and store in c.
    Then take the address stored in c and store in d.
    We also need to tell the compiler (or assure it) that the data
    stored at the location stored in c is really an int and not a short.
    That's what we use a cast for.
    Then we can safely pass the data to foo. */
}

I do hope that example gives you a better understanding.
(This is an unsafe practice example, but it's meant to help you understand what's going on and nothing else.)