fgetc causes a segfault after running the second time

Question

I have an application that tries to read a specific key file and this can happen multiple times during the program's lifespan. Here is the function for reading the file:

__status 
_read_key_file(const char * file, char ** buffer)
{
    FILE * pFile = NULL;
    long fsize = 0;

    pFile = fopen(file, "rb");
    if (pFile == NULL) {
        _set_error("Could not open file: ", 1);
        return _ERROR;
    }

    // Get the filesize
    while(fgetc(pFile) != EOF) {
        ++fsize;
    }

    *buffer = (char *) malloc(sizeof(char) * (fsize + 1));

    // Read the file and write it to the buffer
    rewind(pFile);

    size_t result = fread(*buffer, sizeof(char), fsize, pFile);

    if (result != fsize) {
        _set_error("Reading error", 0);
        fclose(pFile);
        return _ERROR;
    }

    fclose(pFile);
    pFile = NULL;

    return _OK;
}

Now the problem is that for a single open/read/close it works just fine, except when I run the function the second time - it will always segfault at this line: while(fgetc(pFile) != EOF)

Tracing with gdb, it shows that the segfault occurs deeper within the fgetc function itself. I am a bit lost, but obviously am doing something wrong, since if I try to tell the size with fseek/ftell, I always get a 0.

Some context:

• Language: C
• System: Linux (Ubuntu 16 64bit)
• Please ignore functions and names with underscores as they are defined somewhere else in the code.
• Program is designed to run as a dynamic library to load in Python via ctypes

EDIT Right, it seems there's more than meets the eye. Jean-François Fabre spawned an idea that I tested and it worked, however I am still confused to why.

Some additional context:

Suppose there's a function in C that looks something like this:

_status 
init(_conn_params cp) {

    _status status = _NONE;

    if (!cp.pkey_data) {
        _set_error("No data, open the file", 0);

        if(!cp.pkey_file) {
            _set_error("No public key set", 0);
            return _ERROR;
        }

        status = _read_key_file(cp.pkey_file, &cp.pkey_data);
        if (status != _OK) return status;
    }

    /* SOME ADDITIONAL WORK AND CHECKING DONE HERE */

    return status;
}

Now in Python (using 3.5 for testing), we generate those conn_params and then call the init function:

from ctypes import *

libCtest = CDLL('./lib/lib.so')

class _conn_params(Structure):
    _fields_ = [
        # Some params

        ('pkey_file', c_char_p),
        ('pkey_data', c_char_p),

        # Some additonal params
    ]

#################### PART START #################
cp = _conn_params()
cp.pkey_file = "public_key.pem".encode('utf-8')

status = libCtest.init(cp)
status = libCtest.init(cp) # Will cause a segfault
##################### PART END ###################

# However if we do

#################### PART START #################
cp = _conn_params()
cp.pkey_file = "public_key.pem".encode('utf-8')
status = libCtest.init(cp)

# And then

cp = _conn_params()
cp.pkey_file = "public_key.pem".encode('utf-8')
status = libCtest.init(cp)

##################### PART END ###################

The second PART START / PART END will not cause the segfault in this context.

Would anyone know a reason to why?