Join two unsigned chars + mallock u_chars

Question

How does one properly allocate array of unsigned chars?

packet = (u_char*) malloc (20*sizeof(u_char)); //is it simmilar to u_char packet[20]?

I have 2 functions which are declared as follows

u_char *frame(bool type, char* srcmac, char* dstmac);
u_char *ip(bool type, char* srcip, char* dstip);

how can I concatenate those 2 unsigned chars? I tried memcpy, strcat[only for char].

u_char *concat(u_char *s1, u_char *s2) {

    u_char *result = (u_char*) malloc((sizeof(s1)+sizeof(s2)+1));//+1 for the zero-terminator

    memcpy(result, s1, sizeof(s1));
    memcpy(result, s2, sizeof(s2)); //I am overwriting result already and sizeof is size of pointer...
    return result;
}

`printf("sizeof(s1) = %i", sizeof(s1));` outputs: **sizeof(s1) = 4**, (I know its C syntax, I have snippets for that) — Kyslik, Apr 03 '14 at 23:27
@Kyslik: They are different languages. You are using C idioms right now. You shouldn't, if you're writing C++. The advice will differ completely depending on the language. — Lightness Races in Orbit, Apr 03 '14 at 23:46
Are ù_char`s by any chance `unsigned char`, and thus per definition size 1 char? No need for sizeof(u_char) then... — Deduplicator, Apr 04 '14 at 00:02
Yes, I figured that myself that `malloc (20*sizeof(u_char))` is "same" as `malloc (20)`, thank you for input. — Kyslik, Apr 05 '14 at 14:31
@LightnessRacesinOrbit I have made snippets for C therefore I use C idioms for this kind of "debuging" (accesing quick variable data). — Kyslik, Apr 07 '14 at 19:30
@Kyslik: I have occasionally written in other languages too but I don't see that as any reason to do this... — Lightness Races in Orbit, Apr 07 '14 at 19:56

score 1 · Accepted Answer · answered Apr 03 '14 at 23:35

You have:

u_char *concat(u_char *s1, u_char *s2) {
u_char *result = (u_char*) malloc((sizeof(s1)+sizeof(s2)+1));

This doesn't make any sense. Why do you care how big the pointers are? And how is this function supposed to concatenate two things without knowing how big they are? Also:

memcpy(result, s1, sizeof(s1));
memcpy(result, s2, sizeof(s2));

Should be:

memcpy(result, s1, s1_size);
memcpy(result + s1_size, s2, s2_size);

You have to track the sizes of the s1 and s2 objects yourself. I called those variables s1_size and s2_size, but they can be constants. Don't use sizeof on a pointer or you get the size of the pointer. The sizeof function tells you the size of a type, known at compile time.

Since this is C++, why not just use std::vector<unsigned char> and then + and += will work nicely. Otherwise, consider a struct that encapsulates both a pointer and a size_t.

"You have to track the sizes of the s1 and s2 objects yourself." That is thing I was worried about. Thanks a lot. :) — Kyslik, Apr 03 '14 at 23:50

Join two unsigned chars + mallock u_chars

1 Answers1