Passing chars from structs through sockets in c - c

Question

I am trying to send/receive messages between my server and client. I currently have a stuct in my server that holds a char value. I am trying to pass this value to my client. See the following:
tileInfo->tiles[user_cords_x][user_cords_y].identifier = '+'; // Char i want to pass
write_client_msg(cli_sockfd, &tileInfo->tiles[user_cords_x][user_cords_y].identifier);
/* Writes a message to a client socket. */
void write_client_msg(int cli_sockfd, char * msg)
{
int n = write(cli_sockfd, msg, strlen(msg));
if (n < 0)
error("ERROR writing msg to client socket");
}
On my client side i am receiving it with the following:
char *msg;
char identity = read(sockfd, msg, 1);
printf("This is the value: %d \n", identity);
Currently the output i am getting is This is the value: 1. I am new to sockets and dont fully understand passing chars. Could someone please explain and show me how to pass the '+' to my client side?

Answer 1

You are making several mistakes with your code.
On the server side, in this code:
write_client_msg(cli_sockfd, &tileInfo->tiles[user_cords_x][user_cords_y].identifier);
It is clear that identifier is a single char, or else the code would not compile. In which case, using strlen() inside of write_client_msg() is wrong, since msg will not have a null terminator when passing in a pointer to a single char. You would end up transmitting garbage to the other party, if not just crash altogether from accessing invalid memory.
Then, on the client side, you are passing an uninitialized msg pointer to read(). But also, you are displaying read()'s return value, which is the number of bytes actually received. That is why your display is showing 1, since you are asking for 1 byte to be received.
To send and receive the identifier correctly, you would need something more like this instead:
void write_client_msg(int sockfd, char *msg, size_t msg_len)
{
int n = write(sockfd, msg, msg_len);
if (n < 0)
error("ERROR writing msg to client socket");
}
...
write_client_msg(cli_sockfd, &tileInfo->tiles[user_cords_x][user_cords_y].identifier, 1);
char identity;
int n = read(sockfd, &identity, 1);
if (n < 0)
error("ERROR reading identity from client socket");
else if (n == 0)
error("DISCONNECTED while reading identity from client socket");
else
printf("This is the value: %c \n", identity);
That being said, a better solution is to make write_client_msg() send the msg_len before sending the msg. Especially since write_client_msg() doesn't know what kind of data it is sending. Then the client can read the msg_len to know how many bytes to read for the msg, and then process the msg as needed.
Also, write() and read() can return fewer bytes than requested, so you need to call them in loops to make sure you actually send/receive everything.
For example:
int write_all(int sockfd, void *data, size_t data_len)
{
char *d = (char*) data;
while (data_len > 0)
{
int n = write(sockfd, d, data_len);
if (n < 0)
return n;
d += n;
data_len -= n;
}
return 1;
}
void write_client_msg(int sockfd, char *msg, size_t msg_len)
{
uint32_t len = htonl(msg_len);
int n = write_all(sockfd, &len, sizeof(len));
if (n == 1)
n = write_all(sockfd, msg, msg_len);
if (n < 0)
error("ERROR writing msg to client socket");
}
...
write_client_msg(cli_sockfd, &tileInfo->tiles[user_cords_x][user_cords_y].identifier, 1);
int read_all(int sockfd, void *data, size_t data_len)
{
char *d = (char*) data;
while (data_len > 0)
{
int n = read(sockfd, d, data_len);
if (n <= 0)
return n;
d += n;
data_len -= n;
}
return 1;
}
char *read_server_msg(int sockfd)
{
uint32_t len;
int n = read_all(sockfd, &len, sizeof(len));
if (n <= 0)
return NULL;
len = ntohl(len);
char *msg = malloc(len+1);
if (!msg)
return NULL;
n = read_all(sockfd, msg, len);
if (n <= 0) {
free(msg);
return NULL;
}
msg[len] = '\0';
return msg;
}
...
char *msg = read_server_msg(sockfd);
if (!msg)
error("ERROR reading msg from client socket");
else {
printf("This is the value: %s \n", msg);
free(msg);
}

Answer 2

The proper solution (based on your code) would be:
char *msg;
msg = malloc(2);
if (read(sockfd, msg, 1)!=1) {
printf("Something wrong\n");
return 0;
}
msg[1]= '\0';
printf("Sent received: %s \n", msg);

Answer 3

Solved:
char *msg;
msg = (char*) malloc (1);
read(sockfd, msg, 1);
printf("Sent received: %s \n", msg);