How can I send a struct containing a char * with a socket?

Dear all,

I have a struct like this:

struct sample{
int a;
int b;
char* c;
struct sample* next;
};

struct sample* data_sample;

I wanted to send it to a server using a write statement:

data_sample = (struct sample *)malloc(sizeof(struct sample));
strcpy(data_sample->c, "testing");
data_sample->a = 1;
data_sample->b = 2;
...............
n = write(sockfd, data_sample, sizeof(data_sample));
..................

I notice that the string inside the struct is not being sent over to the
server while everything else is OK. I have to use a char* instead of an
array because the length of c is supposed to be an input argument.

So am I not able to send such a struct with a socket at all? If not so,
what have I done wrong?

Thanks so very much in advance.

Regards,

Patrick

Patrick Lam wrote:
> Dear all,
>
> I have a struct like this:
>
> struct sample{
> int a;
> int b;
> char* c;
> struct sample* next;
> };
>
> struct sample* data_sample;
>
> I wanted to send it to a server using a write statement:
>
> data_sample = (struct sample *)malloc(sizeof(struct sample));
> strcpy(data_sample->c, "testing");
> data_sample->a = 1;
> data_sample->b = 2;
> ..............
> n = write(sockfd, data_sample, sizeof(data_sample));
> .................
>
> I notice that the string inside the struct is not being sent over to the
> server while everything else is OK. I have to use a char* instead of an
> array because the length of c is supposed to be an input argument.
>
> So am I not able to send such a struct with a socket at all? If not so,
> what have I done wrong?


If you transfer the pointer, you're going to tell
the receiving host where in the sending host's
process memory the string is.

You need to send the string itself, either inside
the structure or as a separate entity.

The link pointer is as well invalid for the receiver.

--

Tauno Voipio
tauno voipio (at) iki fi

Hi Tauno,

Thanks very much for your suggestion.

I thought about sending the string separately, but then I would have to
reassemble the struct at the receiver, right?

Is this a normal way to do such a thing though?

Thanks again.

Regards,

Patrick

"Tauno Voipio" <(E-Mail Removed)> wrote in message
news:zocYf.202$(E-Mail Removed)...
> Patrick Lam wrote:
>> Dear all,
>>
>> I have a struct like this:
>>
>> struct sample{
>> int a;
>> int b;
>> char* c;
>> struct sample* next;
>> };
>>
>> struct sample* data_sample;
>>
>> I wanted to send it to a server using a write statement:
>>
>> data_sample = (struct sample *)malloc(sizeof(struct sample));
>> strcpy(data_sample->c, "testing");
>> data_sample->a = 1;
>> data_sample->b = 2;
>> ..............
>> n = write(sockfd, data_sample, sizeof(data_sample));
>> .................
>>
>> I notice that the string inside the struct is not being sent over to the
>> server while everything else is OK. I have to use a char* instead of an
>> array because the length of c is supposed to be an input argument.
>>
>> So am I not able to send such a struct with a socket at all? If not so,
>> what have I done wrong?
>
>
> If you transfer the pointer, you're going to tell
> the receiving host where in the sending host's
> process memory the string is.
>
> You need to send the string itself, either inside
> the structure or as a separate entity.
>
> The link pointer is as well invalid for the receiver.
>
> --
>
> Tauno Voipio
> tauno voipio (at) iki fi

On Mon, 03 Apr 2006 12:59:07 -0400, Patrick Lam <yahoo_mail@nospam_tom.com> wrote:
> "Tauno Voipio" <(E-Mail Removed)> wrote in message
> news:zocYf.202$(E-Mail Removed)...
>> Patrick Lam wrote:
>>> Dear all,
>>>
>>> I have a struct like this:
>>>
>>> struct sample{
>>> int a;
>>> int b;
>>> char* c;
>>> struct sample* next;
>>> };
>>>
>>> struct sample* data_sample;
>>>
>>> I wanted to send it to a server using a write statement:
>>>
>>> data_sample = (struct sample *)malloc(sizeof(struct sample));
>>> strcpy(data_sample->c, "testing");
>>> data_sample->a = 1;
>>> data_sample->b = 2;
>>> ..............
>>> n = write(sockfd, data_sample, sizeof(data_sample));
>>> .................
>>>
>>> I notice that the string inside the struct is not being sent over to the
>>> server while everything else is OK. I have to use a char* instead of an
>>> array because the length of c is supposed to be an input argument.
>>>
>>> So am I not able to send such a struct with a socket at all? If not so,
>>> what have I done wrong?
>>
>>
>> If you transfer the pointer, you're going to tell
>> the receiving host where in the sending host's
>> process memory the string is.
>>
>> You need to send the string itself, either inside
>> the structure or as a separate entity.
>>
>> The link pointer is as well invalid for the receiver.
> Hi Tauno,
>
> Thanks very much for your suggestion.
>
> I thought about sending the string separately, but then I would have to
> reassemble the struct at the receiver, right?
>
> Is this a normal way to do such a thing though?

That's Normal. A packet would usually consist of some kind of size
indicator followed by that much data.

I'm sure someone will rant at me for this but you could play some
memory games with the struct.

struct sample{
int a;
int b;
struct sample* next;
size_t clen;
char c[1];
};

Then allocate the structure to sizeof struct+strlen data and put the data
into c[] as if it was the proper sized array. Keep the len of c in clen.
You can then send it with one write. The receiver will still have to do 2
reads to get the struct to know how much to allocate. Then get the string.

On Mon, 03 Apr 2006 14:33:00 -0400, Joe Beanfish <(E-Mail Removed)> wrote:

> On Mon, 03 Apr 2006 12:59:07 -0400, Patrick Lam <yahoo_mail@nospam_tom.com> wrote:
>> "Tauno Voipio" <(E-Mail Removed)> wrote in message
>> news:zocYf.202$(E-Mail Removed)...
>>> Patrick Lam wrote:
>>>> Dear all,
>>>>
>>>> I have a struct like this:
>>>>
>>>> struct sample{
>>>> int a;
>>>> int b;
>>>> char* c;
>>>> struct sample* next;
>>>> };
>>>>
>>>> struct sample* data_sample;
>>>>
>>>> I wanted to send it to a server using a write statement:
>>>>
>>>> data_sample = (struct sample *)malloc(sizeof(struct sample));
>>>> strcpy(data_sample->c, "testing");
>>>> data_sample->a = 1;
>>>> data_sample->b = 2;
>>>> ..............
>>>> n = write(sockfd, data_sample, sizeof(data_sample));
>>>> .................
>>>>
>>>> I notice that the string inside the struct is not being sent over to the
>>>> server while everything else is OK. I have to use a char* instead of an
>>>> array because the length of c is supposed to be an input argument.
>>>>
>>>> So am I not able to send such a struct with a socket at all? If not so,
>>>> what have I done wrong?
>>>
>>>
>>> If you transfer the pointer, you're going to tell
>>> the receiving host where in the sending host's
>>> process memory the string is.
>>>
>>> You need to send the string itself, either inside
>>> the structure or as a separate entity.
>>>
>>> The link pointer is as well invalid for the receiver.
>> Hi Tauno,
>>
>> Thanks very much for your suggestion.
>>
>> I thought about sending the string separately, but then I would have to
>> reassemble the struct at the receiver, right?
>>
>> Is this a normal way to do such a thing though?
>
> That's Normal. A packet would usually consist of some kind of size
> indicator followed by that much data.
>
> I'm sure someone will rant at me for this but you could play some
> memory games with the struct.
>
> struct sample{
> int a;
> int b;
> struct sample* next;
> size_t clen;
> char c[1];
> };
>
> Then allocate the structure to sizeof struct+strlen data and put the data
> into c[] as if it was the proper sized array. Keep the len of c in clen.
> You can then send it with one write. The receiver will still have to do 2
> reads to get the struct to know how much to allocate. Then get the string.
>

p.s.
Just to be clear, writing and reading structures directly isn't remotely
portable. The sender and receiver must be using same data type sizes,
endianness, and structure packing.

Patrick Lam wrote:

[]

> So am I not able to send such a struct with a socket at all? If not so,
> what have I done wrong?

You might like learning about serialization:
http://boost.org/libs/serialization/doc/index.html