How would I go about sending bit-fields through a socket? - c

Question

I need to send a set of bit fields along with a string of characters from a client to a server.
So given I have:
#define YES 1
#define FLAG 2
int main(int argc, char* argv[])
{
return sendToServer("The Message", YES | FLAG);
}
int sendToServer(char* msg, int bitfields)
{
/* create socket and connect to server */
/* Assume sock is set */
send(sock, msg, strlen(msg), 0);
return 0;
}
What would be the best way to send the bitfields? Is there anyway to send the bitfields along with the string?
EDIT: Ok I'm trying to implement Vlad's method. My client is pretty much identical to what he wrote. I have put the flag at the beginning data[0] and I used htonl instead of bswap. My server:
int main(int argc, char* argv[])
{
/* create socket and wait for connection */
char buffer[BUFFERSIZE];
size_t rcvdB = recv(clntSock, buffer, sizeof(int),0);
int flags = ntohl((int) buffer);
rcvdB = recv(clntSock, buffer, sizeof(size_t),0);
size_t msgSize = ntohl((size_t) buffer);
rcvdB = recv(clntSock,buffer,msgSize,0);
/* Then I send back to the client */
ssize_t sntB = send(clntSock,buffer,msgSize,0);
}
When the client prints the message there are multiple ascii characters at the end of the message.
EDIT2:
The issue seems to occur when I read more than 8 bytes of data

Answer 1

As others have pointed out, it depends on a protocol. I'd use something like this:
int sendToServer(char* msg, int bitfields)
{
unsigned int bits = bswap32 (bitfields); // Convert host to network byte order.
size_t len = strlen (msg); // Calculate string length.
size_t nlen = bswap64 (len); // Convert length's byte order from host to network.
iovec data[3]; // Prepare 3 I/O buffers to send data by performing a single system call (they are expensive).
// Send length of the string first.
data[0].iov_base = &nlen;
data[0].iov_len = sizeof (nlen);
// Send string...
data[1].iov_base = msg;
data[1].iov_len = len;
// And, of course, send bits.
data[2].iov_base = &bits;
data[2].iov_len = sizeof (bits);
// Write all of those to the socket.
writev (fd, &data, sizeof (data) / sizeof (data[0]));
}
On the receiving side, you can read the first sizeof (size_t) bytes, convert from network to host byte order, cast to size_t. That will tell you length of string. Then read buffer of that length - that will be your string. Finally, read another sizeof (int) bytes - that will be your bitfield.
See also:
Endianess
writev

Answer 2

This depends on your network protocol, of course. If you're designing it, and you have a maximum of 8 flags to send, put them in the first byte of the message. If you have at most 16, but them in the first two bytes, etc.
int sendToServer(int sock, char* msg, int flags)
{
size_t siz = strlen(msg) + 1; // +1 for NUL
unsigned char *buf = malloc_or_die(siz + 1);
buf[0] = flags;
memcpy(buf + 1, msg, size);
send(sock, msg, strlen(msg), 0);
free(buf);
return 0;
}
(I changed bitfields to flags since that's what they are. A bitfield is a collection of flags.)

Answer 3

It's probably best to send the bitfields as the bytes for a raw int (e.g., send(sock, &bitfields, sizeof(bitfields), 0)), making sure that the size & endianness is the same for both the client & server. It'd probably be easiest to send the bits before the string, as the server could then easily extract the string after a fixed number of bytes.

Answer 4

The bitfield forms a number, for instance 1|2 gives 3 since %01 | %10 = %11.
So all you have to send is that number. Kind of
snprintf(buffer, buffer_size, "%s-%d", message, number);
send(sockfd, buffer, buffer_size, 0);