fopen() crashing on second use in c [closed] - c

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 5 years ago.
Improve this question
for some reason, fopens keeps crashing in my program.
It works once when I am reading the input file and putting the contents into a variable. But for some reason, when I try to make it use fopens again, it crashes...
Could someone please help
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *buf = "\0";
char buffer[99999] ;
int main(int argc, char *argv[])
{
ptr_file =fopen(inputFileLocation,"r");
if (!ptr_file)
{
return 1;
}
while (fgets(buf,maxvalue, ptr_file)!=NULL)
{
strcat(buffer,buf);
}
fclose(ptr_file);
... //workings
//then the program crashes if I add an fopen() and fclose() at the end
}

Answer 1

The accepted answer misses the point. It is not only about buffer overrun.
There is no buffer overrun for maxvalue = 2; yet the program will crash.
But step by step:
fgets(buf, maxvalue, ptr_file) != NULL
The C library function char *fgets(char *str, int n, FILE *stream)
reads a line from the specified stream and stores it into the string
pointed to by str. It stops when either (n-1) characters are read,
the newline character is read, or the end-of-file is reached,
whichever comes first. A null character is automatically appended in
str after the characters read to signal the end of the C string.
In your case buf is string literal of size 2. This is quite likely too small for your needs.
But its not just about the size of buf!
You cannot copy anything to the (constant) string literal! That operation crashes your program with signal 11 even if you read one character.
Constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals.
What you need is a char array of the proper size.
You could either declare it the same way as char buffer[99999]
// 1.
char buf[SIZE_OF_THE_BUF]; // remember that buf has to accept maxvalue-1 characters + `null` character
or dynamically allocate memory for it in the main()
// 2.a
char *buf;
//
int main()
{
// 2.b
buf = malloc(maxvalue * sizeof(char));
//...
}

Answer 2

You create a pointer named buf that points to space containing a single character '\0'.
Then you use fgets() to try to read an unknown number of characters (you don't show what maxvalue is) into the space pointed to by buf. But that space is only one character long. Reading into it will overrun the space, causing undefined behavior.