Passing a structure through Sockets in C

Answer 1

This is a very bad idea. Binary data should always be sent in a way that:

• Handles different endianness
• Handles different padding
• Handles differences in the byte-sizes of intrinsic types

Don't ever write a whole struct in a binary way, not to a file, not to a socket.

Always write each field separately, and read them the same way.

You need to have functions like

unsigned char * serialize_int(unsigned char *buffer, int value)
{
  /* Write big-endian int value into buffer; assumes 32-bit int and 8-bit char. */
  buffer[0] = value >> 24;
  buffer[1] = value >> 16;
  buffer[2] = value >> 8;
  buffer[3] = value;
  return buffer + 4;
}

unsigned char * serialize_char(unsigned char *buffer, char value)
{
  buffer[0] = value;
  return buffer + 1;
}

unsigned char * serialize_temp(unsigned char *buffer, struct temp *value)
{
  buffer = serialize_int(buffer, value->a);
  buffer = serialize_char(buffer, value->b);
  return buffer;
}

unsigned char * deserialize_int(unsigned char *buffer, int *value);

Or the equivalent, there are of course several ways to set this up with regards to buffer management and so on. Then you need to do the higher-level functions that serialize/deserialize entire structs.

This assumes serializing is done to/from buffers, which means the serialization doesn't need to know if the final destination is a file or a socket. It also means you pay some memory overhead, but it's generally a good design for performance reasons (you don't want to do a write() of each value to the socket).

Once you have the above, here's how you could serialize and transmit a structure instance:

int send_temp(int socket, const struct sockaddr *dest, socklen_t dlen,
              const struct temp *temp)
{
  unsigned char buffer[32], *ptr;

  ptr = serialize_temp(buffer, temp);
  return sendto(socket, buffer, ptr - buffer, 0, dest, dlen) == ptr - buffer;
}

A few points to note about the above:

• The struct to send is first serialized, field by field, into buffer.
• The serialization routine returns a pointer to the next free byte in the buffer, which we use to compute how many bytes it serialized to
• Obviously my example serialization routines don't protect against buffer overflow.
• Return value is 1 if the sendto() call succeeded, else it will be 0.

Answer 2

Serialization is a good idea. You can also use "wireshark" to monitor the traffic and understand what is actually passed in the packets.

Answer 3

If you don't want to write the serialisation code yourself, find a proper serialisation framework, and use that.

Maybe Google's protocol buffers would be possible?

Answer 4

There is no need to write own serialisation routines for short and long integer types - use htons()/htonl() POSIX functions.

Answer 5

Instead of serialising and depending on 3rd party libraries its easy to come up with a primitive protocol using tag, length and value.

Tag: 32 bit value identifying the field
Length: 32 bit value specifying the length in bytes of the field
Value: the field

Concatenate as required. Use enums for the tags. And use network byte order...

Easy to encode, easy to decode.

Also if you use TCP remember it is a stream of data so if you send e.g. 3 packets you will not necessarily receive 3 packets. They maybe be "merged" into a stream depending on nodelay/nagel algorithm amongst other things and you may get them all in one recv... You need to delimit the data for example using RFC1006.

UDP is easier, you'll receive a distinct packet for each packet sent, but its a lot less secure.

Answer 6

If the format of the data you want to transfer is very simple then converting to and from an ANSI string is simple and portable.

Answer 7

Using the 'pragma' pack option did solved my problem but I am not sure if it has any dependencies ??

#pragma pack(1)   // this helps to pack the struct to 5-bytes
struct packet {
int i;
char j;
};
#pragma pack(0)   // turn packing off

Then the following lines of code worked out fine without any problem

n = sendto(sock,&pkt,sizeof(struct packet),0,&server,length);

n = recvfrom(sock, &pkt, sizeof(struct packet), 0, (struct sockaddr *)&from, &fromlen);

Answer 8

here is a program...

#include <stdio.h>                 //H
#include <stdlib.h>                //E
#include <string.h>                //A
#include <unistd.h>                //D
#include <sys/types.h>             //E
#include <sys/socket.h>            //R
#include <netinet/in.h>            //FILE
#include <netdb.h>                 //S

#define BUFSIZE 1024

/* 
 * error - wrapper for perror
 */
void error(char *err) {
    perror(err);
    exit(0);
}
              struct student 
              {
                  char name[16];
                  unsigned short student_id;
                  char host[16];
                  unsigned short pid;
                  char email[32];

              }r1;

void main(int argc, char **argv) {
    int sockfd, portno, n;
    int serverlen;
    struct sockaddr_in serveraddr;
    struct hostent *server;
    char *hostname;
    char buf[BUFSIZE];
struct student r1 = {"Parikshit Tiwari", htons(0x6160), "Parikx-Laptop", htons(getpid()),"[email protected]"};

    if (argc != 3) {
       fprintf(stderr,"usage: %s <hostname> <port>\n", argv[0]);
       exit(0);
    }
    hostname = argv[1];
    portno = atoi(argv[2]);

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);//socket created
    if (sockfd < 0) 
        error("ERROR opening socket");

    /* gethostbyname: get the server's DNS entry */
    server = gethostbyname(hostname);
    if (server == NULL) {
        fprintf(stderr,"ERROR, hostname %s\n does not exist", hostname);
        exit(0);
    }

    /* build the server's Internet address */
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, (char *)&serveraddr.sin_addr.s_addr, server->h_length);
    serveraddr.sin_port = htons(portno);


   /* send the message to the server */
    serverlen = sizeof(serveraddr);
    n = sendto(sockfd, (void *) &r1, sizeof(r1), 0, (struct sockaddr *)&serveraddr, serverlen);
    printf("%d", n);//Test to check the size of data send to the server 
    if (n < 0) 
      error("ERROR in sendto");

    close(sockfd);
}