Passing char array to a function by reference when the size is not known

Question

I am learning about pointers and char arrays and was wondering if you could help me find the optimal solution here. I want to avoid using malloc hence I chose to pass a char array to a function by reference where the values are getting filled. In my main.c

    char saved_networks[100]; // create an array to save data
    readFile123(SPIFFS, "/wifi.txt",saved_networks);
    Serial.print("saved networks=");
    Serial.println(saved_networks);

And the function:

void readFile123(fs::FS &fs, const char *path, char* return_data)
{
   
    int n=0;
    Serial.printf("Reading file: %s\n", path);

    File file = fs.open(path);
    if (!file || file.isDirectory())
    {
        Serial.println("Failed to open file for reading");
        return;
    }
    Serial.print("Read from file: ");
    while (file.available())
    {
        char c =  file.read();
        delayMicroseconds(100);
        Serial.print(c);
        //strcat(return_data, &c); //returns meditation error
        return_data[n]=c; 
        n=n+1;
    }
    file.close();

}

In the program above, I create a char array size of 100 and pass it to the function. Inside a function, I read data inside my SPIFFS file system and then assing whatever string I found there to my char array. The code above works however I have 3 questions:

1. Why I cannot use strcat(return_data, &c);

The causes the cpu to crash and return an error:

Stack smashing protect failure!
abort() was called at PC 0x40137793 on core 1
ELF file SHA256: 0000000000000000 

2. Why I cannot declare my char array as following : char* saved_networks;. If I do that, my microcontroller will crash and return an error:

Read from file: TGuru Meditation Error: Core 1 panic'ed (StoreProhibited). Exception was unhandled

3. What is the most optimal way to solve this problem? Since I do not know what will be the maximum size of the data that I read form SPIFFS, simply declaring it size of 100 may not be enough. Is there any way to declare it dynamically ? I assume the only way to do that is by using malloc? Is that true?

Answer 1

1. strcat(return_data, &c) is a <string> function, and as such, it expects actual strings and not char arrays.
   In your example, you pass the address of a char, which can be interpreted as a char array of size 1. What is the difference?
   Well, strings are null terminated char arrays, which means their last valid element is a '\0', everything after that char is ignored by those str functions.

2. char* saved_networks; Declares a variable that can store an address of type char, you still have to allocate space! That space's address will then be stored in saved_networks.

3. You can try to find out how big the file is before reading it. Or you can incrementally read it. Since you're using C++ you could also use std::string

Edit: when you pass the name of an array it is already a reference, so I'd say you're passing it correctly already, just need to be careful you don't exceed the space allocated (100 chars in this case).

To make it more clear, let me show you some examples of syntatic sugar:

char saved_networks[100];
saved_networks == &saved_networks[0]; // true
saved_networks[0] == *saved_networks; // true
saved_networks[50] == *(saved_networks + 50); // true
&saved_networks[50] == saved_networks + 50; // true

The +50 depends of the array type: in this case it means 50 bytes because chars are 1 byte each.

Edit 2: "h" in reality is more similar to:

char const arr[2] = {'h', '\0'};

Which implies that " is used for strings and ' for chars! This is important because str functions are expecting strings to be null terminated, or else there will be invalid memory accesses from infinite loops.

I think that's what you were missing and now you'll be able to better understand my first point.

Answer 2

Pass the length of the array:

size_t len = sizeof(saved_networks)/sizeof(*saved_networks);
char *saved_networks = readFile123(SPIFFS, "/wifi.txt",saved_networks, &len);

And then make sure that the length is not exceeded:

char *readFile123(fs::FS &fs, const char *path, size_t *lenp)
{
    size_t chunksize = *lenp; // You can pass in chunksize you want to use
    size_t n = 0;
    size_t chunk_len = 0;
    char *return_data = malloc(chunksize);
    return_data[0]=0;
    *lenp = 0;

    ...
    while (file.available())
    {
        char c =  file.read();
        delayMicroseconds(100);
        Serial.print(c);
        return_data[n]=c; 
        n=n+1;
        chunk_len++;
        if (chunk_len == chunksize-1)
        {
            return_data = realloc(return_data, n+chunksize);
            chunk_len = 0;
        }
    }
    return_data[n]=0;
    *lenp = n;

    return return_data;
}