Function for freeing array of strings

From what I see, besides the brittleness of the code in general (there is MUCH I would change), the biggest problem is by-value arrays you're passing in to your reader function.

You initially size them here in main():

charPntrArr = malloc(iniArrSize * sizeof(char*));
intPntrArr = malloc(iniArrSize * sizeof(int)); // note: fixed this. also fix in your resize fn

Then their values (the addresses held by each of those pointers) are passed into your reader here:

recCnt = readFx(charPntrArr, intPntrArr);

At various times the reader can (and does) resize those buffers, including relocating data if needed. There is no guarantee the base address stays the same. Thus when readFX returns, the pointers still hold the original values, but the resize efforts have long-since made those locations no longer defined as accessible.

A quick way to address this is to do the following:

• Change your readFX function to take its pointer parameters by address (pointers to pointers).
• Rename the input parameters in the actual function (it will make sense when you see the code below).
• Declare local vars that have the same original names, and are initialized with the dereferenced initial values of your params.
• Save the locals back to the dereferenced parameters when the function finishes.

Something like this:

int readFx(char*** ppCharArr, int** ppIntArr)
{
    char **charArr = *ppCharArr;
    int *intArr = *ppIntArr;

    /*
     input: csv file of string arrays
     output: count of records received
     purpose: read file, store values in array and populate pointer array
     */

    char buffer[350];
    char temp[350];
    char* token;
    int counter;
    int subLoc = 4;
    int enrLoc = 9;
    int arrSize = 10;


    counter = 0;

    /* Clear headers */
    fgets(buffer, sizeof(buffer), stdin);

    /* While file stream is not null */
    while (fgets(buffer, sizeof(buffer), stdin) != NULL)
    {

        /* Populate array within array if pntr arr has room */
        if (counter >= arrSize)
        {
            /* Reallocate memory due to necessary expansion */
            arrSize = makeRoom(&charArr, &intArr, arrSize);

            /* Realloc was successful */
            if (charArr == NULL || intArr == NULL)
            {
                printf("unable to reallocate\n");
                exit(1);
            }
        }

        /* buffer copy*/
        strcpy(temp, buffer);

        /* Get first token */
        token = getToken(buffer, subLoc);
        if (token != NULL)
            charArr[subLoc] = strdup(token);

        /* Get second token */
        token = getToken(temp, enrLoc);
        intArr[counter] = atoi(token);

        counter++;

    }

    *ppCharArr = charArr;
    *ppIntArr = intArr;
    return counter;
}

Invoked from main() like this:

charPntrArr = malloc(iniArrSize * sizeof *charPntrArr);
intPntrArr = malloc(iniArrSize * sizeof *intPntrArr);
recCnt = readFx(&charPntrArr, &intPntrArr);

The freeFX call can stay as it is. That's about the quickest way I can see for you to resolve this specific issue. Note: I did some hacking up on this code, so some things will not work with a simple cut/paste back to your code base (I have makeRoom returning the new size, for example), but you can hopefully still see what the root problem was.

Hope it helps.

Update

A dumbed down version with integrated allocation in the read-array and bubble-sorting of the content. I hope the OP finds it useful. This is considerably cleaner, imho, than the original version.

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

/* ---- PROTOTYPES ---- */
int readFx(char*** ppCharArr, int** ppIntArr);
int freeFx(char** charArr, int* intArr, int cnt);
void sortFx(char** const charArr, int* const intArr, int cnt);

/* ---- MAIN ---- */
int main(void)
{
    char** charPntrArr = NULL;
    int* intPntrArr = NULL;
    int recCnt = 0;

    /* array to store addresses of arrays forming the rows */

    /* read file and get record count */
    recCnt = readFx(&charPntrArr, &intPntrArr);
    sortFx(charPntrArr, intPntrArr, recCnt);
    freeFx(charPntrArr, intPntrArr, recCnt);
}

/* ---- FUNCTIONS ---- */

int readFx(char*** ppCharArr, int** ppIntArr)
{
    const int subLoc = 4;
    const int enrLoc = 9;

    char **charArr = *ppCharArr;
    int *intArr = *ppIntArr;

    char line[350];
    char* token = NULL;
    int arrSize = 0;
    int counter = 0;
    int i=0;

    /* Clear headers */
    fgets(line, sizeof(line), stdin);
    while (fgets(line, sizeof(line), stdin) != NULL)
    {
        // check for reallocation prior to insertion
        if (counter == arrSize)
        {
            // need to expand
            int newSize = (arrSize ? (2*arrSize) : 1);
            void *tmp = realloc(charArr, newSize * sizeof *charArr);
            if (tmp == NULL)
            {
                fprintf(stderr, "Failed to expand charArr to %d elements", newSize);
                exit(1);
            }
            charArr = tmp;

            // expand intArr likewise
            tmp = realloc(intArr, newSize * sizeof(*intArr));
            if (tmp == NULL)
            {
                fprintf(stderr, "Failed to expand intArr to %d elements", newSize);
                exit(1);
            }
            intArr = tmp;
            arrSize = newSize;

            printf("Resized arrays to %d slots\n", newSize);
        }

        // get tokens
        for (token = strtok(line, ",\n"), i=1; token && (i<subLoc); ++i)
            token = strtok(NULL, ",\n");
        if (token)
        {
            charArr[counter] = strdup(token);

            // next token
            for (; token && i<enrLoc; ++i)
                token = strtok(NULL, ",\n");
            if (token)
            {
                intArr[counter] = atoi(token);
                printf("%s %d\n", charArr[counter], intArr[counter]);
                ++counter;
            }
            else
            {
                free(charArr[counter]);
            }
        }

    }

    *ppCharArr = charArr;
    *ppIntArr = intArr;

    return counter;
}

int freeFx(char** charArr, int* intArr, int cnt)
{
    while (cnt--)
        free(charArr[cnt]);
    free(charArr);
    free(intArr);
    return 0;
}


void sortFx(char** const charArr, int* const intArr, int cnt)
{
    int swapped = 1, i, j=cnt;

    // simple bubblesort algorithm. note there is no string copying cone here
    //  we compare strings, and if swapping is needed, swap *pointers* in the
    //  charArr pointer array (and intArr side by side, but that is unrelated)
    while (swapped && j--)
    {
        swapped = 0; // reset swap detection

        for (i = 0; i < j; ++i)
        {
            int cmp = strcmp(charArr[i], charArr[i+1]);
            if ( cmp > 0)
            {
                char *strTmp = charArr[i];
                int intTemp = intArr[i];

                // do the swaps
                charArr[i] = charArr[i+1];
                charArr[i+1] = strTmp;
                intArr[i] = intArr[i+1];
                intArr[i+1] = intTemp;

                // something swapped so set flag
                swapped = 1;
            }
            else if (cmp == 0 && intArr[i] > intArr[i+1])
            {
                int intTemp = intArr[i];
                intArr[i] = intArr[i+1];
                intArr[i+1] = intTemp;

                // something swapped so set flag
                swapped = 1;
            }
        }
    }

    printf("\nSORTED RESULTS\n");
    for (i=0; i<cnt; ++i)
        printf("%s %d\n", charArr[i], intArr[i]);
}

Output

The following output is from the pasted sample data.

Resized arrays to 1 slots
SOCW 0
Resized arrays to 2 slots
MUSI 0
Resized arrays to 4 slots
MAE 0
EE 11
Resized arrays to 8 slots
SOCW 1
ARCH 47
BIOL 0
BE 6
Resized arrays to 16 slots
BIOL 0
EDAD 2
BE 6
EDAD 0
BIOL 31
CHEM 118
ME 1
MUSI 1
Resized arrays to 32 slots
MUSI 0
EVSE 1

SORTED RESULTS
ARCH 47
BE 6
BE 6
BIOL 0
BIOL 0
BIOL 31
CHEM 118
EDAD 0
EDAD 2
EE 11
EVSE 1
MAE 0
ME 1
MUSI 0
MUSI 0
MUSI 1
SOCW 0
SOCW 1