socket send() hangs after sending certain amount of bytes - c++

Question

I want to send a string to my nodejs TCP server.
This is the code for my client (C++):
#include <nds.h>
#include <dswifi9.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string>
std::string hostname = "hostname";
int port = 61733;
int sock;
int main(){
Connect(); //function to connect with a WiFi network
ConnectToServer();
unsigned long lastSendTime = 0;
unsigned long sendInterval = 200; //send a message every 200 milliseconds
unsigned int nMsgSent = 0;
while (1){
unsigned long now = milliseconds(); //function to get the time in milliseconds
if ((now - lastSendTime) > sendInterval){
std::string request = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
request += request;
request += std::to_string(nMsgSent);
request += "\n";
int sendResult = ::send(sock, request.c_str(), request.length(), 0);
iprintf("req(%d): %d\n", nMsgSent, sendResult);
nMsgSent++;
lastSendTime = now;
}
}
return 0;
}
This is my server code (JS):
var net = require('net');
var tcpServer = net.createServer();
var tcpPort = 61733;
tcpServer.on('connection', onConnection);
function onConnection(conn){
var remoteAddress = conn.remoteAddress + ':' + conn.remotePort;
console.log('New client connection from: %s', remoteAddress);
conn.on('data', onData);
conn.once('close', onClose);
conn.on('error', onError);
function onData(data){
console.log('connection data from %s: %s', remoteAddress, data);
}
function onClose(){
console.log('connection from %s closed', remoteAddress);
}
function onError(err){
console.log('Connection %s error: %s', remoteAddress, err.message);
}
}
tcpServer.listen(tcpPort, function(){
console.log('Server listening on: %j', tcpServer.address());
});
Here comes the problem:
The client only sends about 180 messages and then send hangs. The server only receives ~120 messages. When I increase the length of the request, the client sends less requests and when I decrease the length, the clients sends more requests. I also found out that when I decrease the sendInterval, I can send more requests before send hangs. I don't know what I'm doing wrong. When I execute similar code with a nodejs client, everything is okay, so the problem lies with the C++ client.
EDIT:
I don't really think this is necessary, but here is the code of connectToServer():
void ConnectToServer()
{
sock = socket(AF_INET, SOCK_STREAM, 0);
if (socket >= 0)
{
printf("Created Socket!\n");
}
else
{
printf("Couldn't create socket");
}
struct hostent * host = gethostbyname(hostname.c_str());
if (host != NULL)
{
printf("Found IP Address!\n");
}
else
{
printf("IP not found");
}
struct sockaddr_in server;
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = *((unsigned long *)(host->h_addr_list[0]));
int connectResult = ::connect(sock, (struct sockaddr *)&server, sizeof(server));
if (connectResult >= 0)
{
printf("Connected to server!\n");
}
else
{
printf("Not connected to server. Err: %d\n", connectResult);
}
}
Output from C++ client(send interval: 2000ms, msgLength: 126-127 chars):
req(1): 126
req(2: 126
req(3): 126
...keeps going on for a while...
req(9): 126
req(10): 126
req(11): 127
req(12): 127
...keeps going on for a while...
req(74): 64
send() hangs after this
Output from nodejs server(only receives 9 messages):
connection data from ip::port: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678900
...keeps going on for a while...
connection data from ip::port: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678909
Test results to see if there's a connection between send interval, message length and the number of sent messages:
sendInterval | msgLength | nMsg
---------------------------------------
200 | 127 | 26
200 | 65 | 33
---------------------------------------
400 | 65 | 59
400 | 127 | 53
---------------------------------------
2000 | 65 | 47
2000 | 127 | 21
(I don't see a connection between these values)

Answer 1

As i can see there are some issues that you should attend:
You are trying to send many message into the while of the client's
code, but you are not checking if there is an error, using the
variable sendResult . It should be checked before send another
message.
You are using the same thread to send data and check for the interval which has an infinity loop to send each message, it consume a lot of CPU. I suggest to create a thread (TSync) to attend the interval with sleep or std::chrono and invoke a method which send the message by socket, but not in the same thread TSync because you will block socket with sleeps.
Finally, you should use FD_SET and selectto check when you can send data by sockets, when the socket is ready to send more bytes.
It is probably that the way you are sending message without control is afecting the TX channel because it is getting fulled so you should control the output operation with FD_SET and select to get synchronized with the socket. In the case of write, Microsoft documentation says:
The select function is used to determine the status of one or more sockets. For each socket, the caller can request information on read, write, or error status.
writefds: Data can be sent.
UPDATED, April 21th: I suggest you share more information about your problem, like the code and configuration of your server to know if there is some time out configured or buffer size. The information that you are supplied is not enough and don't understimated the request that us make you, like this comment:
I don't really think this is necessary, but here is the code of connectToServer():
The connection process is important because we can see if the socket server has some options setted.
In this case all information that you shared us could be helpful instead of assume that is not important.
So, at this moment, that is all that i can help you.
UPDATE April 24th: Try these steps to control the socket transmition and setting a NON-Blocing socket:
After you get a successful connection, in the client, set the socket as NON-BLOCKING.
Use in your loop File Descriptor (FD_SET) and select to check when the socket is ready to write.
Your code should has a code as follow:
void ConnectToServer()
{
//... your code
int connectResult = ::connect(sock, (struct sockaddr *)&server, sizeof(server));
if (connectResult >= 0)
{
u_long iMode = 1;
int iResult = ioctlsocket(sock, FIONBIO, &iMode); //Set the socket Non-Blocking
printf("Connected to server!\n");
}
else
{
printf("Not connected to server. Err: %d\n", connectResult);
}
}
int main(){
Connect(); //function to connect with a WiFi network
ConnectToServer();
unsigned long lastSendTime = 0;
unsigned long sendInterval = 200; //send a message every 200 milliseconds
unsigned int nMsgSent = 0;
fd_set write_fd;
while (1){
unsigned long now = milliseconds(); //function to get the time in milliseconds
if ((now - lastSendTime) > sendInterval){
std::string request = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
request += request;
request += std::to_string(nMsgSent);
request += "\n";
FD_ZERO(&write_fd); //Reset the File Descriptor
FD_SET(sock, &write_fd); //Set se File descriptor to the socket.
int result = select(max_sd, NULL, &write_fd, NULL, NULL); //Wait until the socket is ready to write
if (result < 0)
{
iprintf("There was a problem with the sockets reading.\n");
FD_ZERO(&write_fd);
}
int sendResult = ::send(sock, request.c_str(), request.length(), 0);
iprintf("req(%d): %d\n", nMsgSent, sendResult);
nMsgSent++;
lastSendTime = now;
}
}
return 0;
}