Copying C Structures to a character array

Question

I am facing a strange issue while trying to copy the data from structures to an character array which is then send over the socket to the server. Below is my code for your reference

#include <stdio.h>
#define MAX_MSG_SIZE 1024
#pragma pack(1)
struct msgheader{
unsigned int messageLength;
unsigned int messageType;
};
struct floating_field{
unsigned char tag;
unsigned char length;
};
struct open_req{
    struct msgheader mhdr;
unsigned int invokeid;
unsigned int version;
unsigned int timeout;
unsigned int peripheralid;
unsigned int servicesrequested;
unsigned int callmsgmask;
unsigned int agentstatemask;
unsigned int configmsgmask;
unsigned int reserved_1;
unsigned int reserved_2;
unsigned int reserved_3;
};
char uccebuf[MAX_MSG_SIZE];
unsigned int invokeid = 1;
char clientid[256];
char clientpassword[256];
int main(int argc, char *argv[]);
void func1();
int main(int argc, char *argv[]){
func1();
exit(0);
}
void func1(){
int retval, error, bytes;
struct open_req *request;
struct floating_field *ff;
char *p = uccebuf;
unsigned int total_bytes, result;
int templen,cnt;
cnt = 0;
//socklen_t len;
error = 0;
//request = (struct open_req *)malloc(sizeof(struct open_req));
//ff = (struct ffloating_field *)malloc(sizeof(struct floating_field));
strcpy(clientid,"admin");
strcpy(clientpassword,"12345");
request = (struct open_req *)uccebuf;
total_bytes = 0;
request->mhdr.messageType = 3;
//memcpy(&uccebuf[cnt], &request->mhdr.messageType, sizeof(request->mhdr.messageType));
request->invokeid = invokeid++;
request->version = 13;
request->timeout = 0xFFFFFFFF;
request->peripheralid = 0xFFFFFFFF;
request->servicesrequested = 0x00000010;
request->callmsgmask = 0x00000001 | 0x00000002 | 0x00000004 | 0x00000020 | 0x00000200 | 0x00000100 | 0x00040000 | 0x00000400 | 0x00010000;
request->agentstatemask = 0x00000000;
request->configmsgmask = 0x00000000;
request->reserved_1 = 0x00000000;
request->reserved_2 = 0x00000000;
request->reserved_3 = 0x00000000;
//memcpy(uccebuf,&request,sizeof(struct open_req));
printf("request->peripheralid: %u\n", request->peripheralid);
printf("request->callmsgmask: %u\n", request->callmsgmask);
p = p + sizeof(struct open_req);
total_bytes += sizeof(struct open_req);
ff=(struct floating_field *)p;
ff->tag = 1;
templen = strlen(clientid);
ff->length = templen;
//memset(uccebuf,&ff,sizeof(struct floating_field));
total_bytes +=sizeof(struct floating_field);
p = p + sizeof(struct floating_field);
strcpy(p, clientid);
total_bytes += ff->length;
p = p + ff->length;
ff=(struct floating_field *)p;
ff->tag = 2;
templen = strlen(clientpassword);
ff->length = templen;
total_bytes +=sizeof(struct floating_field);
p = p + sizeof(struct floating_field);
strcpy(p, clientpassword);
total_bytes += strlen(clientpassword);
//memset(uccebuf,&ff,sizeof(struct floating_field));
request->mhdr.messageLength = (total_bytes - sizeof(struct msgheader));
printf("\nMessage to be send is: %s", uccebuf);

}

When I try to print the contents of the character array, it does not show up anything. Can you please tell me where I am going wrong? Any help is highly appreciated

Please indent code to make it readable, and consider if a more minimal version might exhibit the problem. — unwind, Jul 31 '12 at 11:06
Why are you copying them? Can you not use, say, a packed union? — Martin James, Jul 31 '12 at 11:07

score 1 · Answer 1 · answered Jul 31 '12 at 11:06

printf() (and all other functions that operate on char strings, assume that the string terminates when a zero byte is encountered. The very first byte of your struct is, in fact, a 0, and so printing the buffer will print nothing. Furthermore, besides the zeroes, most of the other characters are unprintable control characters as well, and wouldn't appear on the screen.

If you want to render the buffer onscreen so you can inspect it, you should probably loop over the characters and print each one as a hexadecimal byte.

Be careful with this approach; make sure none of the other functions you use to operate on your char array will be accidentally terminated by the zeroes.

score 1 · Answer 2 · edited May 23 '17 at 12:29

1

If you want to dump out the contents of the array, you'll need to tell printf how many characters to write, as otherwise it will stop at the first zero byte:

printf("\nMessage to be send is: %.*s", (int) sizeof(open_req), uccebuf);

This will contain unprintable characters, so I'd recommend a hex dump: how to get hexdump of a structure data

edited May 23 '17 at 12:29

Community

1
1

answered Jul 31 '12 at 11:10

ecatmur

152,476
27
293
366

Copying C Structures to a character array

2 Answers2