C++ Winsock2 sending integers with byte order - c++

Question

I have been looking for a way to have an integer sent over a Windows Socket using Winsock2. I have looked at most, if not all, of the questions people have asked on stackoverflow already.
This is what I have for the client, that sends the integer:
struct struct_var
{
int Packet;
int Number;
};
struct_var *arraystruct;
arraystruct = (struct_var *) malloc(sizeof(struct_var));
(*arraystruct).Packet = 100;
(*arraystruct).Number = 150;
int bytes = send(client,(char*)arraystruct,sizeof(*arraystruct),0);`
I have also tried to send using:
int int_data = 4;
int bytes = send(server, (char*) &int_data, sizeof(int), 0);`
This was recommended on another stackoverflow question
This is the receiving side, which was also recommended:
int int_data;
int bytes = recv(server, (char*) &int_data, sizeof(int), 0);
cout << int_data;`
When I run these the output I get from command line is: -858993460
Does anyone know why this is happening?
I would also like it to have the correct byte order as this will be sent over multiple kinds of computers.
Thanks in advance who can help me out
Full Server Code:
int main() {
WSADATA wsaData;
WORD version;
int error;
version = MAKEWORD(2, 0);
error = WSAStartup(version, &wsaData);
if ( error != 0 )
{
return FALSE;
}
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 0 )
{
WSACleanup();
return FALSE;
}
SOCKET server;
server = socket(AF_INET, SOCK_STREAM, 0);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(5555);
if (bind( server, (SOCKADDR*)&sin, sizeof(sin) ) == SOCKET_ERROR ){
DWORD ec=WSAGetLastError();
cerr << hex << "bind ERROR" << ec << endl;
return FALSE;
}
if ( listen( server, SOMAXCONN ) == SOCKET_ERROR ) {
DWORD ec=WSAGetLastError();
cerr << hex << "listen ERROR" << ec << endl;
return FALSE;
}
SOCKET client;
int length;
while(1) {
if ( listen( server, SOMAXCONN ) == SOCKET_ERROR ) {
DWORD ec=WSAGetLastError();
cerr << hex << "listen ERROR" << ec << endl;
return FALSE;
}
length = sizeof sin;
client = accept( server, (SOCKADDR*)&sin, &length );
cout << "Client connected" << endl;
cout << "Sending Instructions..." << endl;
int int_data;
int bytes;
bytes = recv(client, (char*) &int_data, sizeof(int), 0);
cout << int_data << endl;
}
}
}
Full Client Code:
int main() {
WSADATA wsaData;
WORD version;
int error;
version = MAKEWORD(2, 0);
error = WSAStartup(version, &wsaData);
if ( error != 0 )
{
return FALSE;
}
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 0 )
{
WSACleanup();
return FALSE;
}
SOCKET client;
client = socket( AF_INET, SOCK_STREAM, 0 );
sockaddr_in sin;
memset( &sin, 0, sizeof sin );
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = inet_addr("127.0.0.1");
sin.sin_port = htons(5555);
if ( connect(client, (SOCKADDR*)(&sin), sizeof sin ) == SOCKET_ERROR ){
return FALSE;
}
int int_data = 4;
int bytes = send(client, (char*) &int_data, sizeof(int), 0);
}

Answer 1

Here's the problem:
int bytes = recv(server, (char*) &int_data, sizeof(int), 0);
Should be:
int bytes = recv(client, (char*) &int_data, sizeof(int), MSG_WAITALL);
A few other nitpicky things, that aren't causing your problem, but you should know:
Don't bind your server socket to 10.0.0.5. Bind to 0 (INADDR_ANY). That way, your code still works when you run it on machine who's IP addrss is 10.0.0.6.
Use htonl(), htons(), ntohs(), and ntohl() for interoperating with big-endian boxes.
Always check the return values from socket calls. If recv returns 0 or -1, it means the remote side has disconnected. (0 technically means the client has stopped sending, but unless you are doing shutdown half-close stuff, it means he disconnected).
TCP sockets are not message oriented, they are stream oriented. That is, just because you tell recv() to get N bytes, doesn't mean it will return N bytes. IP fragmentation, TCP segmentations, and other factors can make recv() return partial data. Use the MSG_WAITALL flag as appropriate.

Answer 2

You're making this almost impossible on yourself. Instead of starting with code, start with a protocol specification. You can look at the specifications of existing protocols that use TCP, such as HTTP, IMAP, and so on, to see what a protocol specification should include.
The protocol specification should explain everything that is sent or received at the byte level. It should explain how connections are established and torn down. It should explain how dead connections are detected from either end. If the protocol has application-layer messages, it should explain how they are delimited and how the receiver finds the ends of messages. It should specify who transmits when.
Then, debugging is easy. Follow this flowchart:
1) Does the server follow the specification? If not, the server is broken.
2) Does the client follow the specification? If not, the client is broken.
3) If it still doesn't work, the specification is broken.
This makes it possible to ensure that the server and client work together. And when they don't, it makes it possible to know which side needs to be fixed.
It only take an hour or two to sketch out a protocol specification, and I promise you the time saved will be more than worth it. All it takes is one time you change the wrong end when something doesn't work (and then find lots of things are newly-broken because you fixed one of the places that was right) to pay for the time taken. Plus, as a bonus, it is then possible to make other implementations.

Answer 3

I was stuck at this problem as well and I noticed that my client wasn't even connecting.
Try to save the value returned by connect() and recv() making sure its > -1 or print out some error.