Reading/making a backup of a text file - c

Question

I have the following code that is attempting to read a text file, make a backup, and pass the read file string on to further processing routines. The behaviour I am seeing is very unexpected.
01: rewind(PPLFile);
02: fseek(PPLFile, 0, SEEK_END);
03: unsigned long fsize = ftell(PPLFile);
04: char *string = (char*)calloc(fsize + 1, sizeof(char));
05: rewind(PPLFile);
06: fread(string, sizeof(char), fsize, PPLFile);
07: FILE* PPLBackup;
08: char* fileSuffix = ".backup";
09: char* PPLBackupLocation = (char*)calloc(strlen(basePath) + strlen(fileSuffix) + 1, sizeof(char));
10: strcpy(PPLBackupLocation, basePath);
11: strcat(PPLBackupLocation, fileSuffix);
12: PPLBackup = fopen(PPLBackupLocation, "w");
13: fprintf(PPLBackup, fileContent);
14: fclose(PPLBackup);
15: free(PPLBackupLocation);
The file handle *PPLFile has been opened previously with the w+ or a+ flag depending on certain cases in the previous code that wrote the file initially.
The concept I thought was quite simple:
Move the pointer past the end of the file and sense its location to establish file size in bytes
Create null string of the byte size plus one (for the null terminator)
Rewind and read the whole file content into the string, up to the sensed file size
Create backup file name and file pointer
Write the whole string read from the original file to the new backup file.
Close the backup file and continue by processing the read string
There are a two disturbing symptoms:
The *char string containing the original file has many more zeroes (thousands in a text file ~=20MB), so the last non-zero value might be 3000 bytes from the end. Seemingly smaller than the original file.
When writing the backup file, the resulting file is a small amount larger than the original file, with a seemingly random extra sample of the original file attached to the end, again a few thousand bytes.
Quite simply, what on earth is going on?

Answer 1

This row not good:
13: fprintf(PPLBackup, fileContent);
If the file contains character sequences like %s then fprintf will look for additional data on the stack.
You should use fwrite instead:
13: fwrite(fileContent, fsize, 1, PPLBackup);
or at least do this:
13: fprintf(PPLBackup, "%s", fileContent);

Answer 2

Why are you reading with fread() and writing with fprintf() instead of fwrite()? And the way you're using fprintf(), you're at the mercy of the first % sign in the file (format string vulnerability).
Also, make sure both files are open in the same mode (text mode vs. binary mode). Usually, fread()/fwrite() tend to be used with binary mode.

Answer 3

This complete program works for me on Linux. It has the alteration by Klas. Note I had to use fsize as a global because passing around the char * contents of the file to be copied broke if it was later strlen'd - for obvious reasons
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
unsigned long fsize=0L;
char *get_file(FILE *PPLFile) {
rewind(PPLFile);
fseek(PPLFile, 0, SEEK_END);
fsize = ftell(PPLFile);
char *string = (char*)calloc(fsize + 1, sizeof(char));
rewind(PPLFile);
fread(string, sizeof(char), fsize, PPLFile);
return string;
}
void write_file(char *basePath, char *fileContent) {
FILE* PPLBackup;
char* fileSuffix = ".backup";
char* PPLBackupLocation = (char*)calloc(strlen(basePath) + strlen(fileSuffix) + 1, sizeof(char));
strcpy(PPLBackupLocation, basePath);
strcat(PPLBackupLocation, fileSuffix);
PPLBackup = fopen(PPLBackupLocation, "w");
fwrite(fileContent, fsize, 1, PPLBackup);
fclose(PPLBackup);
free(PPLBackupLocation);
}

Answer 4

Multiple issues
As mentioned by #Klas Lindbäck & #Medinoc, do not use fprintf(). fwrite() is much better.
#Klas Lindbäck says, insure that you open both the file read and write in binary mode. as in fopen(PPLBackupLocation, "wb").
The return value from fread() should be assessed and if good, used for your fwrite().
calloc(fsize + 1, sizeof(char)) does not need to add 1.