Segmentation fault when initialization array

I have a structure called string

typedef struct {
    char *s;
    int len;
} string_t;


typedef struct {
    uint32_t                numb;
} msg_t;

where in the function

void myfunct()
{
msg_t msg;
memset(&msg, 0, sizeof(msg));
msg.numb = 1;
char *ClientSendBuf[sizeof(msg)];
string_t buffer = {ClientSendBuf[sizeof(msg)],strlen(ClientSendBuf[sizeof(msg)])};
}

Tried to initialize an array (basically a buffer that I need to send later on) using UDP, but it gives me an error of segmentation fault (on the third line in void myfunct. So the thing with buffer is that it should be a type of string_t, how can I fix this segmentation fault?

P.S. I forgot to mention, I want to copy the whole struc开发者_如何学编程ture to the buffer variable (that should be type string_t) using memcopy. So am I doing the wrong thing above? How can I do this?

There are a few things you have to consider in initializing your structure, as it has a pointer member char *s simple assignment will not work. Simple assignment will just copy the pointer address and not the content it is pointing to.
There are a few problems in your assignment code:
1. You declared an array of char * with sizeof(msg) elements, none of which are allocated memory; but your structure need char * and not char *[]
2. You are accessing an array element which is out of bounds (ClientSendBuf[sizeof(msg)]) and also not pointing to any valid address.
You can create a simple char array & copy it to the structure. As you are using a pointer member it is your responsibility to allocate memory and free memory.
Hope the code below can provide you with some references:

void myfunct()
{
   msg_t msg;
   memset(&msg, 0, sizeof(msg));
   msg.numb = 1;
   char ClientSendBuf[] = "This is my message";

   string_t buffer = {
                     strdup(ClientSendBuf), /*Can return NULL so add error check*/
                     strlen(ClientSendBuf)
   };
    /** Or **/
    string_t buffer;
    buffer.s = malloc(strlen(ClientSendBuf)+1);
    if(NULL == buffer.s)
    {
      /* Memory allocation failed. Handle error.*/
    }
    /* Zero fill */ 
    memset(buffer.s, 0, strlen(ClientSendBuf)+1);
    strcpy(buffer.s, ClientSendBuf);
    buffer.len = strlen(ClientSendBuf);
     /*Opeartions with buffer*/
     /*Call free in both cases !*/
     free(buffer.s);
}

Hope this help!

ClientSendBuf - put some thing in it and also put it on the heap.

The problem is that you don't allocate memory to any element of ClientSendBuf. You should use malloc here to first allocate the memory.

I see two things that are wrong. First, accessing ClientSendBuf[sizeof(msg)] is undefined behavior, because that character is after the end of CliendSendBuf. Then you're assigning a char (namely ClientSendBuf[sizeof(msg)]) when a char * is expected.
And if you want to use buffer outside that function you have to put ClientSendBuf on the heap, because it will be overwritten by other stack frames after you exit (i.e. sort of deleted), so the pointed data will be throwed off.
Now, since you want a copy of the whole ClientSendBuff, you need an array of string_t. Then, you assign every pointer in ClienSendBuff to buffer:

char *ClientSendBuff[sizeof(msg)];
string_t buffer[sizeof(msg)];
int i;

for(i = 0; i < sizeof(msg); i++) {
    ClientSendBuff[i] = malloc(100); // you have to initialize (and free when
    buffer[i].s = ClientSendBuff[i]; // you don't need them anymore) every pointer
    buffer[i].len = 100;
}

But I'm not sure if I got your point. How can a char * [] fit in a char*?