Printable View
In my program i have a couple of void pointers (pointing to a chunk of data) a few integer variables and so on...
I need to send all this data(say over the network)..
for example
so i need to send the data together.. how do i clump the data together..Code:
void *a,*b;
int c,d,e;
----
----
---
/*something like*/
send(a+b+c+d+e)
Put it all into a character buffer and send the buffer. Just make sure you delimit it somehow
So what does 1 send call have which 5 send calls doesn't?
well I have to send this stream of data to the Cisco call manager and the call manager runs its own protocol and each time a stream of data is sent its inepreted as one set of commands.. If i break it down the call manager ignores the messages....Quote:
Originally Posted by Salem
But i should be able to achieve this by 5 sends if I modify the way send works...
As Thantos said I did plan to create a temp buffer but I think i will try to modify the send stuff..
thank you both..
Well one problem is this: You can never guartnee how much will be sent before you send it. So if the call manager requires everything in one shot then there is something seriously wrong. Granted anything under 1k should be ok but still...
the data anyways is still broken into packets before being sent.. so my guess is as Salem pointed out there should be no problem with 5 send calls as long as the data sent... what I think is happening in the send function is adding some extra data at the end which tell the call manager that this particular set is complete.... I think I will try running ethereal and see whats happening..
yeah a end of transmission signal would be the most likely course.
Are you sending data using TCP or UDP ?
TCP is a stream protocol, so it really doesn't matter how many send calls there are, because you have no control over fragmentation at the lower levels.
UDP is a datagram protocol, so each send is matched exactly with each receive.
The call manager uses a protocol by name Skinny over TCP... the send function adds the skinny protocol flags and other details before sending the data over TCP.. so my guess is skinny protocol is adding somehting on every send call...
>>my guess is skinny protocol is adding somehting on every send call
How are you doing the send? Via a standard send() or write() call, or something "skinny specific"?
If it's of any use (and is available to you), check out the writev() function. It can write multiple buffers to a file stream (socket) in one call, thus reducing the chances of packet fragmentation.
thanks I will check it out... I will try to create a stream which can be picked up by the send stuff.. yes its skinny specific...Quote:
Originally Posted by Hammer