Sending multiple times and recv multiple times - c

Question

I am very very very very new to TCP/IP socket programming.
there is 2 argv value from client.c
and I need to send this two into server.c
I thought if I send() two times from client.c and recv two times in server.c, it would be fine but actually it is not. can anyone let me know how to send two buffers into server.c?
in client.c
ssize_t byteNumSentAccName = send(clientSock, accountName, strlen(accountName), 0);
ssize_t byteNumSentCmd = send(clientSock, command, strlen(accountName), 0);
where both accountName and command are char buffer.
in server.c
ssize_t byteNumRecvAccName = recv(clientSock, nameBuf, BUFSIZE-1, 0);
ssize_t byteNumRecvCmd = recv(clientSock, cmdBuf, BUFSIZE-1, 0);

Answer 1

TCP is a byte stream, there is no 1:1 relationship between send() and recv(), like there is in UDP.
In TCP, send() can send fewer bytes than requested, and recv() can return fewer bytes than requested. So you need to call them in loops until all bytes have been sent/received. And you need to frame your data in such a way that the receiver knows where one value ends and the next begins. For instance, when sending a variable-length string, you can either
send the string length as a fixed-width integer before sending the actual string characters. The receiver can then read the length first, and then read until the specified number of characters have been received.
bool sendRaw(int sock, const void *data, int size)
{
const char *buffer = (const char*) data;
while (size > 0)
{
ssize_t sent = send(sock, buffer, size, 0);
if (sent < 0)
return false;
buffer += sent;
size -= sent;
}
return true;
}
bool sendInt32(int sock, int32_t value)
{
value = htonl(value);
return sendRaw(sock, &value, sizeof(value));
}
bool sendString(int sock, const char *s)
{
int32_t len = strlen(s);
if (!sendInt32(sock, len))
return false;
return sendRaw(sock, s, len);
}
...
sendString(clientSock, accountName);
sendString(clientSock, command);
int readRaw(int sock, void *data, int size)
{
char *buffer = (char*) data;
while (size > 0)
{
ssize_t recvd = recv(sock, buffer, size, 0);
if (recvd < 0)
return -1;
if (recvd == 0)
return 0;
buffer += recvd;
size -= recvd;
}
return 1;
}
int readInt32(int sock, int32_t *value)
{
int ret = readRaw(sock, value, sizeof(*value));
if (ret == 1)
*value = ntohl(*value);
return ret;
}
char* readString(int sock)
{
int32_t len = 0;
if (readInt32(sock, &len) <= 0)
return NULL;
char *ret = (char*) malloc(len+1);
if (!ret)
return NULL;
if (readRaw(sock, ret, len) <= 0)
{
free(ret);
return NULL;
}
ret[len] = '\0';
return ret;
}
...
nameBuf = readString(clientSock);
cmdBuf = readString(clientSock);
...
free(nameBuf);
free(cmdBuf);
send a unique delimiter after sending the actual string characters (a null terminator, a line break, whatever you want, as long as it never appears in strings). The receiver can then read until that delimiter is received.
bool sendRaw(int sock, const void *data, int size)
{
const char *buffer = (const char*) data;
while (size > 0)
{
ssize_t sent = send(sock, buffer, size, 0);
if (sent < 0)
return false;
buffer += sent;
size -= sent;
}
return true;
}
bool sendString(int sock, const char *s)
{
int32_t len = strlen(s) + 1;
return sendRaw(s, len);
}
sendString(clientSock, accountName);
sendString(clientSock, command);
int readRaw(int sock, void *data, int size)
{
char *buffer = (char*) data;
while (size > 0)
{
ssize_t recvd = recv(sock, buffer, size, 0);
if (recvd < 0)
return -1;
if (recvd == 0)
return 0;
buffer += recvd;
size -= recvd;
}
return 1;
}
char* readString(int sock)
{
char *ret = NULL, *tmp;
size_t len = 0, cap = 0;
char ch;
do
{
if (readRaw(sock, &ch, 1) <= 0)
{
free(ret);
return NULL;
}
if (ch == '\0')
break;
if (len == cap)
{
cap += 100;
tmp = (char*) realloc(ret, cap);
if (!tmp)
{
free(ret);
return NULL;
}
ret = tmp;
}
ret[len] = ch;
++len;
}
while (true);
if (len == cap)
{
tmp = (char*) realloc(ret, cap+1);
if (!tmp)
{
free(ret);
return NULL;
}
ret = tmp;
}
ret[len] = '\0';
return ret;
}
...
nameBuf = readString(clientSock);
cmdBuf = sendString(clientSock);
...
free(nameBuf);
free(cmdBuf);