Another question about `warning:address of local variable returned`

[raczzoli]

Hi.

I know that this warning was subject of many topics here, but i have a question about the solution for that.

Let`s say I have a function which reads data from a socket (just example).
I did read, that the best way to avoid returning a local variable is to pass a char pointer to the function in which the data will be stored.

But in your oppinion, where exactly should I allocate the necessary memory for this variable.

Should I allocate the memory before I pass the variable to the function (but in this case, i don`t know how many bytes long is the received data. I can write a function which returns the size of the data, but this means that i have to cycle two times through the data), or to pass a null pointer to the function, and use realloc internally?

The only problem is, that as I know, realloc doesn`t return all the time the same pointer, so this can be an error source.


What do you think?


Thanks.

[CommonTater]

char *my_function()
  { char buffer[LONGER_THAN_NEEDED] = {0};
     int   length = 0;
     receivefromsocket(buffer, &length);
     if (length)
       return strdup(buffer);
     else
       return null;  
   }


// call like this
char *text = NULL;

text = MyFunction();

// do whatever

free(text);

[anduril462]

strdup is fine, so long as you only have textual data that is null terminated. If you have binary data that may contain zero-valued bytes, look you will need to allocate and memcpy. Also, you can expand Tater's suggestion to include a loop using your read function and realloc to grow the buffer as necessary.

[CommonTater]

strdup is fine, so long as you only have textual data that is null terminated. If you have binary data that may contain zero-valued bytes, look you will need to allocate and memcpy. Also, you can expand Tater's suggestion to include a loop using your read function and realloc to grow the buffer as necessary.

Making the solution look like this...

unsigned char *my_function()
  { unsigned char buffer[LONGER_THAN_NEEDED] = {0};
     int   length = 0;
     receivefromsocket(buffer, &length);
     if (length)
       { unsigned char *data = malloc(length);
          return memcpy(data,buffer,length); }
     else
       return NULL;  
   }


// call like this
unsigned char *data = NULL;

data = MyFunction();

// do whatever

free(data);

[MK27]

Should I allocate the memory before I pass the variable to the function

I find it easier not to do so, because if you use that function a lot (eg, a "slurp text file" function), you will have to do this all the time:

char *data = malloc(bufsz);
slurpTextFile(path, data, bufsz);

Whereas if you make the allocation internal:

char *data = slurpTextFile(path);

use realloc internally?

Yes, use a loop like:

#define CHUNK_SZ 1024

int total, cur, chunks, check;
char *data = malloc(CHUNK_SZ+1), *test;
[ ...error check *data...]
cur = total = 0;
chunks = 1;
while ((check = read(fd, &data[total], CHUNK_SZ - cur)) {
     if (check == -1)  [ ...handle error...]
     total += check;
     if (check < CHUNK_SZ) {
     // possible partial read, so try once more...
          cur += check;
          continue;
     }
     chunks++;
     cur = 0;
     test = realloc(data, chunks*CHUNK_SZ+1);
     if (!test) {
            free(data);  // give mem back to system
            [...return error...]
     }   
     data = test;
}
data[total] = '\0';
return data;

So that reads data into a 1kB buffer. If that is not enough, we add another 1kB via realloc and so on. Another algorithm for this is to multiply the buffer size by 2 each time, starting fairly small. The first (linear) version is better when you know the amount of data is always going to be in a certain range. The second (power of two) version is better when the amount of data can vary from tiny to huge.

For binary data, you can do without adding the null terminator at the end and the extra byte to hold it in the allocation (and probably use an unsigned char* for the buffer).