Sending a C char array over a socket

Question

I want to send a character array over a tcp socket in unix.

My first idea was to use an ordinary char array for the struct that will be sent over the socket:

typedef struct __attribute__((packed))
{
   uint8_t type;
   uint8_t id_index;
   char char_value[STR_MSG_MAX];
} a_msg;

Simply because a C char is always 8 bit long. However, after some googling I found out that even if a char is always 8 bit long the underlying representation could actually be a 32 bit integer. So my impression is that char is maybe not the best way of representing a string in a message that will be sent over a socket from FreeBSd to Linux (or input some other unixes if you want to =) ...).

stdint.h is present on all modern unixes to day (I hope) and my thoughts is that maybe a array of uint8_t or a int8_t could do the trick.

typedef struct __attribute__((packed))
{
   uint8_t type;
   uint8_t id_index;
   uint8_t char_value[STR_MSG_MAX];
} a_msg;

or

typedef struct __attribute__((packed))
{
   uint8_t type;
   uint8_t id_index;
   int8_t char_value[STR_MSG_MAX];
} a_msg;

However, uint8_t is a unsigned char and int8_t is a signed char. A standard C char is neither of that because the implementation is undefined as I understand it.

My questions is: What is the best way of representing a character array (string) in C that will be sent over tcp/ip in a *nix (Linux, FreeBSD etc.) platform independent way.

Answer 1

You can not say what are you sending whit c. This info is not transferred.

All you have to do is:

char* buffer = (char*)(&a_msg);

An the safest way is to use unsigned characters if posssible.

Answer 2

I personally would go for something like:

typedef struct __attribute__((packed))
{
   uint8_t type;
   uint8_t id_index;
   uint8_t padding[2]; //this is to align to 32bit boundary
   uint8_t char_value[STR_MSG_MAX];
} a_msg;

But it will work without the padding.

In C a char is always 8 bits long. So an array of char is always an array of bytes. However the character literal 'x' is 32 bits. This can be verified using the sizeof operator on a character literal. You will also see that all the functions that return a single character like getch return an int. The reason is that we need a way of indicating an End of File EOF. This can only be done using a value outside of the 8 bit range.

Answer 3

Although char may be more than 8 bits wide, it must always be the (equal) narrowest type. (Since, among other reasons, sizeof(char) is defined to be 1).

So if the platform provides int8_t, then char must be exactly 8 bits too (since char is separately restricted to be at least 8 bits). This implies that you might as well use char.

Answer 4

I think the idea of packing the struct is the way to go. I would write some test code to make sure it is working. Do a sizeof(a_msg) to see what size it is. You should be able to tell if the packing worked without having to send messages over the socket.