Issue with Structs

Hi,

I just wanted to clear something up regarding structs.

Why is it that I can declare a strut like this:

Code:

---


typedef struct date_header {
        uint16_t year;
        uint8_t month;
        uint8_t day;

} DATE;

---

And do this kind of thing without any problems:

Code Segement 1:

Code:

---

DATE *datePtr;
uint8_t rx_buffer[4];

// assume the rx_buffer has been filled with 4 bytes of data at this point

datePtr = (DATE *)rx_buffer;

printf("Year is: %d", datePtr->year);

---

However, if I do this:


Code Segment 2:

Code:

---

DATE *datePtr;

datePtr->year = 1;
datePtr->month = 2;
datePtr->day = 3;

printf("Year is: %d", datePtr->year);

---

It gives me a segmentation fault at the point where year is being assigned a value.

For some reason, doing this works:

Code Segment 3:

Code:

---

DATE date, *datePtr;

datePtr = &date;

datePtr->year = 1;
datePtr->month = 2;
datePtr->day = 3;

printf("Year is: %d", datePtr->year);

---

How come I don't need to declare:

Code:

---

DATE date, *datePtr;

datePtr = &date;

---

for the code in segment 1?

Thanks.

The reason it crashes in segment two is because you've only created a pointer to the struct, but not allocated memory for it. It could point anywhere - even read-only memory, in which you are trying to write = crash.

Anyway, the reason you don't have to allocate memory in the first is because you've made the struct pointer point to the array, which is allocated data. In segment three, you declare an instance of the struct, not a pointer to it - eg, the struct is allocated on the stack and is this valid memory. You then make the pointer point to that struct, thus making it point to valid memory.

Thanks for your amazingly fast reply!

That make perfect sense now.

Do you also know how I could string together the following to make one argument
to pass to sendto() which takes a message in the form

Code:

---

const void *buffer

---

?

Code:

---

DATE date, *datePtr;
uint8_t options[100];
uint8_t message[100];

datePtr = &date;

// date is filled with data
// options is filled with data
// message is filled with data

---

I've tried simply passing:

Code:

---

(datePtr + options + message)

---

as the argument to the function, but I was doubtful from the beginning that it would work.

I just get a message "Invalid operands to binary +".

I know Java can string together stuff like this with all sorts, but I was doubtful C could.

make one big buffer and fill it withall the data you need to send (using sprintf for example)

You can, but it depends on what you want to do.
With strings, you can append them using strcat.
If it's plain memory, you can place them after each other in a buffer using memcpy.
But if you just put everything on the stack after each other, like your example, then all you have to do is pass the address of the first variable.
Since they're placed after each other in memory, it works just as well. But the function you're passing it to need to be aware of exactly how long (or big) the buffer is, because it cannot say. And if it thinks it's bigger than it really is, it can read or overwrite data that it shouldn't.

Quote:

---

But if you just put everything on the stack after each other, like your example, then all you have to do is pass the address of the first variable.

---

Very bad idea...
You cannot know if addresses of local vars are going Up or Down
You cannot know if there is some space in addresses between two vars
And also you intend to increment the starting address outside the first array - whic results in undefined behaviour... So NO, never do it!
If you do not want to use everything into a string - use one struct at least with all info presented as its members

Agreed. A bad idea. You should never be working with raw memory, if possible, anyway.
And I don't fancy a it a good idea to slam those 3 variables together either. Just pass the 3 variables as 3 arguments.
Easiest. Fastest. Securest.

Code:

---

#include <sys/socket.h>

ssize_t sendto(int socket, const void *message, size_t length,
      int flags, const struct sockaddr *dest_addr,
      socklen_t dest_len);

---

With that definition, I cannot pass datePtr, options and message as three different arguments.

You can do the function call 3 times.
Otherwise allocate another buffer and copy them together.

Quote:

---

Otherwise allocate another buffer and copy them together.

---

Could you please give me an example of how you would do this?
Thanks!

Code:

---

DATE date;
uint8_t options[100];
uint8_t message[100];

void* pBuffer = malloc(sizeof(date) + sizeof(options) + sizeof(message));
memcpy(pBuffer, &date, sizeof(date));
memcpy(pBuffer + sizeof(date), options, sizeof(options));
memcpy(pBuffer + sizeof(date) + sizeof(options), message, sizeof(message));
/* Do whatever */
free(pBuffer);

---

I think.

Thanks all! :)

hmm slight problem:

I have this kind of thing:

Code:

---

int some_function(char *message) {

DATE tx_header;
uint8_t options[64]; // this isn't always totally full (normally only the first two elements) so hence the strlen below:

void* tx_buffer = malloc(sizeof(tx_header) + strlen(options) + strlen(message));
       
// fill the transmit buffer
memcpy(tx_buffer, &tx_header, sizeof(tx_header));
memcpy(tx_buffer + sizeof(tx_header), options, strlen(options));
memcpy(tx_buffer + sizeof(tx_header) + strlen(options), message, strlen(message));
       
printf("strlen(options): %d\n", strlen(options));
printf("strlen(message): %d\n", strlen(message));
printf("sizeof(tx_header) is : %d\n", sizeof(tx_header));
       
printf("sizeof(tx_buffer) is: %d, strlen(tx_buffer) is: %d\n", sizeof(tx_buffer), strlen(tx_buffer));

}

---

this gives the following output with a message of :"the quick" (minus quotes):

Code:

---

strlen(options): 2 // two options
strlen(message): 10 // 9 characters plus the \n
sizeof(tx_header) is : 12 // this should be twelve (this is a differen't struct to the one in the first post)
sizeof(tx_buffer) is: 4, strlen(tx_buffer) is: 9 // what the hell?

---

Strlen is only used to get the length of strings.
If you need to get the length of how many elements in an array you've filled, you must manually keep track of it.
Sizeof can be used on arrays to calculate the total size of the array.
However, when used on a pointer, it returns the size of the pointer, or if you dereference it, the size of one element.

Both options and message are strings, so I don't see the problem. I pass in a char line_buf[300] as the argument to the function, so I'd assume strlen would be ok for this?

The point I'm trying to make is that:

Code:

---

strlen(options): 2 // two options
strlen(message): 10 // 9 characters plus the \n
sizeof(tx_header) is : 12 // this should be twelve (this is a differen't struct to the one in the first post)

---

is fine and is what I would expect.

it's just:

Code:

---

sizeof(tx_buffer) is: 4, strlen(tx_buffer) is: 9 // what the hell?

---

which is confusing.

I was expecting tx_buffer to be 24 in length (or 25 including a \0)

I basically need to return the length of tx_buffer as a sum of bytes of all the strings and headers in it.

Any ideas?

Well, as I explained, tx_buffer is a pointer, right?
Then sizeof(tx_buffer) will return 4 and sizeof(*tx_buffer) won't work because void has no size.
Strlen, however, is different. It searches the string you pass for '\0' and returns the length it found. In other words, strlen returns the actual length of your string and sizeof returns the actual size of your buffer.
But remember that sizeof an array returns the total length of the array, but sizeof a pointer returns the size of the pointer or sizeof(*type) gives the size of one element, not the whole buffer/array.

Strlen is not to be used for finding the length of binary data. It is only guaranteed to work for finding the length of C-style strings.

Ok, so presumably:

tx_buffer will look like this:

options[0] = 0;
options[1] = 1;

[<-12 bytes of header->][<- 2 bytes of options ->][<-10 bytes of message->]

so what function will get the total length (in this case = 24)?

Thanks.

Presumably it is 24 total length, but there's no way you can find out. Strlen does not work on binary data.
If you used that with strlen, it would return 0, because the first element is '\0' or 0, which marks the end of a C-style string.
The only way is to keep track of the size yourself.

btw, tx_header is a struct - I made a mistake in my prev post.

corrected to : "DATE tx_header"

Ok, so I need to pass the size of tx_header to function.

Shall I just pass: "sizeof(tx_header) + strlen(options) + strlen(message) + 1"

to the function?

Sure, that works. The function that creates the buffer also knows the size, so that's fine.
That's the usual approach, too.

Am I right in assuming the "+ 1" is needed because tx_buffer will have a \0 on the end of it?

If you copy a string into it, then yes. The length of a string is always strlen(string) + 1 since strlen return the length up unto the '\0' (but does not take into account this char).

hmm, do I actually need to do this then:

void* tx_buffer = malloc(sizeof(tx_header) + strlen(options) + 1 + strlen(message) + 1);

"sizeof(tx_header) + strlen(options) + 1 + strlen(message) + 1" to get the correct total size?

actually - you probably want both options and message nul-terminated - otherwise how you will know on the reciving side where options end and message begins?

For all strings, the actual size in memory they take is strlen + 1. But it's usually easier to just split the things and send them one by one. That way you don't have to gut up the data when you receive it at the other end, provided you want to do that, of course.

Quote:

---

Originally Posted by vart

actually - you probably want both options and message nul-terminated - otherwise how you will know on the reciving side where options end and message begins?

---

that should be fine because in the tx_header, there is a an offset field and a length_of_message field which tell the receiver where everything is.

Quote:

---

Originally Posted by eponymous

hmm, do I actually need to do this then:

void* tx_buffer = malloc(sizeof(tx_header) + strlen(options) + 1 + strlen(message) + 1);

"sizeof(tx_header) + strlen(options) + 1 + strlen(message) + 1" to get the correct total size?

---

NO.
Elysia was wrong to give you the okay on your suggestion that uses strlen. The size of the binary data to send is the size of the buffer you allocated which is:

Code:

---

sizeof(date) + sizeof(options) + sizeof(message));

---

No '+1', and No strlen!

First off strlen should again NOT be used for 'options', and if you were to use strlen for 'message' then you'd have to write an annoying little loop on the receiving end that read characters one at a time until you got a nul char. Not to mention it was just plain wrong as well.

Fixed size buffers makes life much easier when multiple data structures are to be passed
using recv/send. The first approach, first posted by Elysia, would be my choice too.

Quote:

---

Originally Posted by iMalc

NO.
Elysia was wrong to give you the okay on your suggestion that uses strlen. The size of the binary data to send is the size of the buffer you allocated which is:

Code:

---

sizeof(date) + sizeof(options) + sizeof(message));

---

No '+1', and No strlen!

First off strlen should again NOT be used for 'options', and if you were to use strlen for 'message' then you'd have to write an annoying little loop on the receiving end that read characters one at a time until you got a nul char. Not to mention it was just plain wrong as well.

---

Code:

---

int some_function(char *message) {

DATE tx_header;
uint8_t options[64]; // this isn't always totally full (normally only the first two elements) so hence the strlen below:

void* tx_buffer = malloc(sizeof(tx_header) + strlen(options) + strlen(message));
       
// fill the transmit buffer
memcpy(tx_buffer, &tx_header, sizeof(tx_header));
memcpy(tx_buffer + sizeof(tx_header), options, strlen(options));
memcpy(tx_buffer + sizeof(tx_header) + strlen(options), message, strlen(message));
       
printf("strlen(options): %d\n", strlen(options));
printf("strlen(message): %d\n", strlen(message));
printf("sizeof(tx_header) is : %d\n", sizeof(tx_header));
       
printf("sizeof(tx_buffer) is: %d, strlen(tx_buffer) is: %d\n", sizeof(tx_buffer), strlen(tx_buffer));

}

---

If I use sizeof for everything, it's going to return 64 for the options which is larger than what will be sent using the sendto() function. I need to support UP TO 64 options, but not always 64 options. Most of the time, there will be only two options. Options is a string (uint8_t = char if I'm not mistaken).

The same applies for the message that will be passed in. It can handle up to 300 bytes but will not always be this long. Sizeof(message) is going to return 4 every time as it is getting the size of the pointer.

Can you please explain some more why you think I should sizeof()?

Quote:

---

Originally Posted by iMalc

Elysia was wrong to give you the okay on your suggestion that uses strlen. The size of the binary data to send is the size of the buffer you allocated which is:

Code:

---

sizeof(date) + sizeof(options) + sizeof(message));

---

No '+1', and No strlen!

---

Just to be clear:
I was mentioning the the length, in bytes, of an ANSI string is strlen(string) + 1. I never did suggest that it was the proper way to do, only that it might work.
Of course, I had no idea of how the receiving code would use that data.
And I did suggest splitting it and sending it as 3 parts instead of a whole in the first place.

And I might also have been somewhat confused, because I wasn't exactly keeping track of the types or how the data was passed to the function. Everyone makes mistakes. Anyway.

Quote:

---

If I use sizeof for everything, it's going to return 64 for the options which is larger than what will be sent using the sendto() function. I need to support UP TO 64 options, but not always 64 options. Most of the time, there will be only two options. Options is a string (uint8_t = char if I'm not mistaken).

The same applies for the message that will be passed in. It can handle up to 300 bytes but will not always be this long. Sizeof(message) is going to return 4 every time as it is getting the size of the pointer.

Can you please explain some more why you think I should sizeof()?

---

You're making this much harder than you have to. You have a bug in your allocation size too. You actually allocate size for the length of options - 1, but are copying tx_header, which is not a string, into your buffer.
And, I think, the suggestion to use sizeof is because then you will have fixed-size buffers. That means you can just hack the data to pieces on the other side because you know how big each of the parts of the buffers are.

Surely I can't use sizeof(message) though...

That's going to be 4 bytes wihch is wrong as the message could be up to 300 bytes long...

Yes, this is true. But I'm not sure what the solution iMalc had in mind is.

The way it stands I have little choice as the program I'm communicating with is already made and cannot be changed.

I need to send one buffer in the form:

[<- 12 bytes of header->][<- variable length up to 64 bytes - of options->][-< variable length up to 300 bytes - of message->]

There's no way to change that.

I doubt sending the sizeof(options) (= 64) is a good plan, because it will expect 64 bytes of options probably. Most of the time only the first 2 elements of the array are set.

Then make it fixed.
Use 12 bytes, 64 bytes and then 300 bytes.
No hassle with size and it will be easy to gut the data when received at the other end.

Can you explain what you mean please?

Thanks.

Actually, I think I will make it so that the message is no longer passed in as an argument and I could just get the message inside the function and that way, both options and message will be local arrays inside the function and I will be able to sue sizeof without any problems.