prepend and remove from a ( void * ) in C

i think this is a pretty straight forward problem , but i still can not figure it out .

I have function which sends stream over the network . naturally , this takes const void * as argument:

void network_send(const void* data, long data_length)

i am trying to prepend a specific header in the form of char* to this before sending it out 开发者_运维技巧over the socket:

  long sent_size = strlen(header)+data_length;
  data_to_send = malloc(sent_size);
  memcpy(data_to_send,header,strlen(header)); /*first copy the header*/
  memcpy((char*)data_to_send+strlen(header),data,dat_length); /*now copy the actual data*/

This works fine as long as the data is actually char* . but if it changes to some other data type , then this stops working .

when receiving , i need to remove the header from the data before processing it . so this is how it do it:

void network_data_received(const void* data, long data_length)
{
 ........
 memmove(data_from_network,(char*)data_from_network + strlen(header),data_length); /*move the data to the beginning of the array*/
 ProcessFurther(data_from_network ,data_length - strlen(header)) /*data_length - strlen(header) causes the function ProcessFurther to read only certain part of the array*/
}

This again works ok if the data is char type . but crashes if it is of any different type .

Can anyone suggest how to properly implement this ?

Regards, Khan

Sounds like alignment could be the issue, but you don't specify which platform you're doing this on (different CPU architectures have different alignment requirements).

If the header's length is "wrong" for the alignment of the following data, that could cause access violations.

Something surprise me in this code. Is your header actually a string ? If it is a struct, of something similar you should replace strlen with sizeof. Calling strlen on non zero terminated string is likely to cause crashes.

The second thing that surprise me is that when reading received data, you should copy the header somewhere. If not using it, why bother sending it over the wire ?

EDIT: OK, the header is some http like header string. There should not be any problem from there, and it indeed does not need to be analysed if you're just testing.

And you should move the data to the place you actually need it, moving it to the beginning of the buffer does not look like the right thing to do.

If the problem comes from alignment, it will disappear if you copy the data to some variable of the real target type at byte level before using it.

There is another solution: allocate your buffer with malloc and put the data structure you want at the beginning. Then you should be able to cast it. Addresses returned by malloc are compatible with any type.

Also be aware that if you were working with C++, casting to a non-trivial class is unlikely to work (for one thing vtables are likely to get a wrong addresses, and there is other issues).

Another possible source of problem is the way you get data_length. It should be a number of bytes. Are you sure it is not a number of items ? To be sure we need some hint of the calling code.

memcpy's behaviour is undefined if the source and target overlap (as in this instance) you should be using memmove()

What exactly is happening when what is not char*? These functions will generally cast to void* before actually doing any work...

It's possible that data_length is not calculated correctly in the calling code. Otherwise this code seems to be fine apart from possible alignment issues mentioned by @unwind.

How is header declared? Does it have variable length? Are you missing a terminating NUL character after the header?

I'd also check to make sure that both sender and receiver use the same byte ordering architecture (little endian vs. big endian).

using unsigned char * solved the issue . thankyou all for your comments.