Error when reading a file with "fgetc" (Overflow)

Question

I am using this code to read a file:

char* fs_read_line(FILE* file)
{
   if (file == NULL) {
       return "CFILEIO: Error while reading the file: Invalid File";
   }

   long threshold = ftell(file);
   fseek(file, 0, SEEK_END);
   uint8_t* buffer = calloc(ftell(file)-threshold, sizeof(uint8_t));

   if(buffer == NULL)
      return;

   int8_t _;
   fseek(file, threshold, SEEK_SET);

   uint32_t ct = 0;
   while ((_ = (char)(fgetc(file))) != '\n' 
        && _ != '\0' &&  _ != '\r' && _ != EOF) {
       buffer[ct++] = _;
   }

   buffer = realloc(buffer, sizeof *buffer * (ct + 1)); 
   buffer[ct] = '\0';
   return buffer;
}

If the file is too big, I get (heap) overflow errors, probably because I initally allocate the file with the total amount of characters it contains.

an other way I tried to do this is by realloc the buffer after every iteration, but that's kinda not the approach I want.

Is there any way to dynamicly change the size of the array depending on the the current iteration without always uisng realloc ? or is there an way to determine how long the current line is by using ftell and fseek?

Answer 1

If your file can't fit in memory it can't fit in memory. You are allocating the memory buffer in advance, but you're making two mistakes that can cause you to allocate more than you need.

1. You're starting at some arbitrary position in the file, but allocate memory as if you're starting at the beginning of the file. Allocate ftell(file) - threshold bytes.
2. You are are allocation way too much memory. The sizeof(uint8_t *) should be sizeof(uint8_t) instead. You're allocating 4 or 8 times more memory than you should.

Other than that, what's the point of reallocating the buffer after you're done writing to it? The memory overflow has already happened. You should allocate before writing (inside the while loop). I don't see the point of reallocating at all, though, since you're allocating more than enough memory to begin with.

Answer 2

Code does not return a pointer to a string.

There is no null character in the returned buffer, so the calling code lacks the ability to know the length of the allocated memory. This certainly causes the calling code to error.

When re-allocating, add 1.

// buffer = realloc(buffer, ct * sizeof(uint8_t*));
//                                          v--- no star
buffer = realloc(buffer, ct * sizeof(uint8_t ) + 1);
buffer[ct] = '\0';

// or better
size_t ct = 0;
...
buffer = realloc(buffer, sizeof *buffer * (ct + 1));
buffer[ct] = '\0';

---

Is there any way to dynamically change the size of the array allocated memory depending on the the current iteration without always using realloc?

Array sizes cannot change. To dynamically change the size of the allocated memory requires realloc(). Note: the amount of needed memory could be determined before a memory allocation call.

or is there an way to determine how long the current line is by using ftell and fseek?

Like this code, you have found an upper bound to the current line's length. ftell and fseek do not locate the end of line.

Code could "seek" to the end of line with fscanf(file, "%*[^\n]"); or 1 beyond with a following fgetc(file).

Answer 3

the following code:

1. cleanly compiles
2. performs the desired operation
3. properly handles error conditions
4. properly declares variable types
5. properly returns a char* rather than a uint8_t*
6. leaves open the question: why return 2x the needed buffer length
7. the error message displayed when the passed in parameter is NULL is not correct. Suggest changing to indicate passed in file pointer was NULL
8. the OPs posted code fails to check the returned value from each call to fseek() and fails to check the return value from each call to ftell() which it should be doing to assure the operation(s) was successful. I did not add that error checking in my answer so as to not clutter the code, however, it should be performed.

and now, the code:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


char* fs_read_line(FILE* file);


char* fs_read_line(FILE* file)
{
   if ( !file )
   {
       return "CFILEIO: Error while reading the file: Invalid File";
   }

   // implied else, valid parameter

   long threshold = ftell(file);
   fseek(file, 0, SEEK_END);

   char* buffer = calloc( (size_t)(ftell(file) - threshold) *2 +1, sizeof(char));
   if(buffer == NULL)
      return NULL;

   // implied else, calloc successful

   int ch;
   fseek(file, threshold, SEEK_SET);

   size_t ct;
   while ( (ch = fgetc(file)) != '\n'
        &&  ch != '\0'
        &&  ch != '\r'
        &&  ch != EOF)
   {
       buffer[ct++] = (char)ch;
   }

   return buffer;
} // end function: fs_read_line