Refine the way I do malloc and free - c

Question

I wrote this code that compiles on Solaris gcc
it works fine too for smaller inputs and I get the output I intend.
However, with larger inputs, I get segmentation faults, sometimes at places I do malloc and sometimes at places I do free. I am not asking for you to debug, could you take a look and possibly tell me if there is something royally wrong with the way I do malloc and free on items? I believe the code is corrputing the heap, but I am having a hard time figuring where. This is for my academic assignment and I cannot run tools like valgrind on the university machine.
I am new to C, so the code can be much better, I know.I still have to refine a lot of stuff, like re-use variables etc etc, which I haven't done yet.
We have a limit on a message size, so I am posting just the main and the two structures used.
struct QueueElement
{
char *path_Name;
char fileType;
int index;
struct QueueElement* next;
};
struct Queue
{
struct QueueElement* head;
struct QueueElement* tail;
};
struct DirNameSlotNumberMapping
{
char *AbsoluteDirPath;
char *AbsoluteParentDirPath;
char *DirName;
int nSlotNumberOfDir;
int nSlotNumberofDot;
};
struct Stage3ADisplay
{
int nSlot;
char *Item;
char *Type;
char *AbsoluteDirPath;
char *AttributesMDHex;
char *ContentsMDHex;
int nIndex;
unsigned char attributesMD[16];
unsigned char contentsMD[16];
};
struct DirNameSlotNumberMapping **DirDataForIndex = NULL; //create structure.
struct Stage3ADisplay **Stage3ADisplayVar = NULL; //create structure.
int nDirectoriesCounter = 0;
int nStage3ARowsCounter = 0;
int main(void)
{
char *pathName,*pathName2,*pathName3;
int nMatchesFound = 0;
char *oldPathName;
char *newPathNameStore;
struct Queue* bfsQueue = NULL;
struct QueueElement* givenPath = NULL;
enum skbool boolHelper1 = skfalse;
int exit = 0;
struct Stage3ADisplay **oldSnapshot = NULL; //create structure.
struct Stage3ADisplay **newSnapshot = NULL;
struct Stage3ADisplay **TableT1FromPDF = NULL;
struct Stage3ADisplay **TableT2FromPDF = NULL;
int nTableT1FromPDFCounter = 0;
int nTableT2FromPDFCounter = 0;
int nOldSnapshotCounter = 0;
int nNewSnapshotCounter = 0;
int *Table1ArrayChangeTracker = NULL;
int *Table2ArrayChangeTracker = NULL;
struct DirNameSlotNumberMapping **DirDataForOldIndex = NULL; //create structure.
struct DirNameSlotNumberMapping **DirDataForNewIndex = NULL; //create structure.
int nDirectoriesCounterOld = 0;
int nDirectoriesCounterNew = 0;
int nIterator1 = 0,nIterator2 = 0, nIterator3 = 0,nIterator4 = 0;
int nIterator5 = 0,nIterator6 = 0,nIterator7 = 0;
int nIterator8 = 0,nIterator9 = 0,nIterator10 = 0,nIterator11 = 0;
int nIterator15 = 0, nIterator16 = 0, nIterator17 = 0;
do
{
switch (menu())
{
case 2:
printf ( "Please enter the path under which the directory is present\n" );
pathName = malloc(300*sizeof(char));
scanf("%s",pathName);
printf ( "Please enter the name of the directory\n" );
pathName2 = malloc(300*sizeof(char));
scanf("%s",pathName2);
pathName3 = malloc(strlen(pathName) + strlen(pathName2) + 1 + 1);
strcpy(pathName3,pathName);
strcat(pathName3,"/");
strcat(pathName3,pathName2);
printf ( "Please enter the filename of the earlier snap shot file\n" );
oldPathName = malloc(300*sizeof(char));
scanf("%s",oldPathName);
boolHelper1 = CheckMD5FileAndDirectoryNameSame(pathName3,oldPathName);
if(boolHelper1 == skfalse)
{
printf("\n");
printf("The snapshot file is not for this directory\n");
printf("\n");
break;
}
else
{
printf("\n");
printf("Snapshot file and Directory Name Match\n");
printf("\n");
//write code to generate snapshot for the directory given here.
bfsQueue = Queue_New();
givenPath = malloc(1*sizeof(*givenPath));
givenPath->path_Name = pathName3;
Queue_Add_Element(bfsQueue, givenPath);
//make bfsTraverse return the name of the log file created.
//this file name can be passed on as a parameter to the
//function that compares the given log file and the newly generated log file
char * newPathName = bfsTraverse(bfsQueue);
newPathNameStore = strdup(newPathName);
Queue_Free(bfsQueue);
free(bfsQueue);
printf("\n");
bfsQueue = NULL;
free(pathName);
pathName = NULL;
//get the data of the two files into two structures.
//we'll compare the two structures.
//reading data of old snapshot into structure 1
FILE* p = NULL;
p = fopen(oldPathName, "r");
if (p != NULL )
{
fscanf(p, "%*[^\n]%*c"); //the first line is the directory name, ignore it.
char text[200];
while(fgets(text, sizeof text, p))
{
//found new item in the file
oldSnapshot = (struct Stage3ADisplay **)realloc(oldSnapshot, (nOldSnapshotCounter + 1) * sizeof(struct Stage3ADisplay *)); //add one record to the structure.
oldSnapshot[nOldSnapshotCounter] = (struct Stage3ADisplay *)malloc(sizeof(struct Stage3ADisplay)); //allocate memory for the new record added.
oldSnapshot[nOldSnapshotCounter]->Item = malloc(500);
oldSnapshot[nOldSnapshotCounter]->Type = malloc(500);
oldSnapshot[nOldSnapshotCounter]->AttributesMDHex = malloc(500);
oldSnapshot[nOldSnapshotCounter]->ContentsMDHex = malloc(500);
char *tempoutput = RemoveExtraSpaces(text,' ');
char * output = Trim_Right( tempoutput,' ');
sscanf(output,"%d %s %s %d %s %s\n",&oldSnapshot[nOldSnapshotCounter]->nSlot, oldSnapshot[nOldSnapshotCounter]->Item,oldSnapshot[nOldSnapshotCounter]->Type,&oldSnapshot[nOldSnapshotCounter]->nIndex,oldSnapshot[nOldSnapshotCounter]->AttributesMDHex,oldSnapshot[nOldSnapshotCounter]->ContentsMDHex);
nOldSnapshotCounter = nOldSnapshotCounter + 1;
}
fclose(p);
}
/*logic to reverse build DirDataForOldIndex */
int nPreviousDot = 0;
for(nIterator1 = 0; nIterator1 < nOldSnapshotCounter; nIterator1++)
{
if(strcmp(oldSnapshot[nIterator1]->Item,".") == 0)
{
nPreviousDot = oldSnapshot[nIterator1]->nSlot;
nPreviousDot = nPreviousDot - 1;
}
if(strcmp(oldSnapshot[nIterator1]->Item,".") != 0 && strcmp(oldSnapshot[nIterator1]->Item,"..") != 0 && strcmp(oldSnapshot[nIterator1]->Type,"d") ==0)
{
//found a directory, add it to the directory mapper structure.
DirDataForOldIndex = (struct DirNameSlotNumberMapping **)realloc(DirDataForOldIndex, (nDirectoriesCounterOld + 1) * sizeof(struct DirDataForIndex *)); //add one student to the structure.
DirDataForOldIndex[nDirectoriesCounterOld] = (struct DirNameSlotNumberMapping *)malloc(sizeof(struct DirNameSlotNumberMapping)); //allocate memory for the new student added.
if(oldSnapshot[nIterator1]->nIndex == 0)
{
DirDataForOldIndex[nDirectoriesCounterOld]->DirName = strdup(oldSnapshot[nIterator1]->Item);
DirDataForOldIndex[nDirectoriesCounterOld]->AbsoluteDirPath = strdup(pathName3);
DirDataForOldIndex[nDirectoriesCounterOld]->AbsoluteParentDirPath = "NOPARENT";
DirDataForOldIndex[nDirectoriesCounterOld]->nSlotNumberOfDir = oldSnapshot[nIterator1]->nSlot;
DirDataForOldIndex[nDirectoriesCounterOld]->nSlotNumberofDot = oldSnapshot[nIterator1]->nSlot + 1;
}
else
{
DirDataForOldIndex[nDirectoriesCounterOld]->DirName = strdup(oldSnapshot[nIterator1]->Item);
DirDataForOldIndex[nDirectoriesCounterOld]->nSlotNumberofDot = oldSnapshot[nIterator1]->nIndex;
DirDataForOldIndex[nDirectoriesCounterOld]->nSlotNumberOfDir = oldSnapshot[nIterator1]->nSlot;
//now build the absolute and the parent dir path names.
//using the previous dot variable,get the directory under which we are located.
//get the index number of the previous dot position.
int IndexVar = oldSnapshot[nPreviousDot]->nIndex;
IndexVar = IndexVar - 1;
//get that row's item and slot number, we'll match it
char *ItemName = oldSnapshot[IndexVar]->Item;
int nSlotNumber = oldSnapshot[IndexVar]->nSlot;
//now search in the DirDataForIndex
for(nIterator2 = 0; nIterator2 < nDirectoriesCounterOld; nIterator2++)
{
if(strcmp(DirDataForOldIndex[nIterator2]->DirName,ItemName) == 0 && DirDataForOldIndex[nIterator2]->nSlotNumberOfDir == nSlotNumber)
{
//that row's absolute path is the parent of this.
DirDataForOldIndex[nDirectoriesCounterOld]->AbsoluteParentDirPath = strdup(DirDataForOldIndex[nIterator2]->AbsoluteDirPath);
char* temp = malloc(strlen(DirDataForOldIndex[nDirectoriesCounterOld]->AbsoluteParentDirPath) + strlen(DirDataForOldIndex[nDirectoriesCounterOld]->DirName) + 1 + 1);
strcpy(temp,DirDataForOldIndex[nDirectoriesCounterOld]->AbsoluteParentDirPath);
strcat(temp,"/");
strcat(temp,DirDataForOldIndex[nDirectoriesCounterOld]->DirName);
DirDataForOldIndex[nDirectoriesCounterOld]->AbsoluteDirPath = strdup(temp);
free(temp);
temp = NULL;
}
}
}
nDirectoriesCounterOld = nDirectoriesCounterOld + 1;
}
}
//reading data of new snapshot into structure 2
p = fopen(newPathName, "r");
if (p != NULL )
{
fscanf(p, "%*[^\n]%*c"); //the first line is the directory name, ignore it.
char text[200];
while(fgets(text, sizeof text, p))
{
//found new item in the file
newSnapshot = (struct Stage3ADisplay **)realloc(newSnapshot, (nNewSnapshotCounter + 1) * sizeof(struct Stage3ADisplay *)); //add one record to the structure.
newSnapshot[nNewSnapshotCounter] = (struct Stage3ADisplay *)malloc(sizeof(struct Stage3ADisplay)); //allocate memory for the new record added.
newSnapshot[nNewSnapshotCounter]->Item = malloc(500);
newSnapshot[nNewSnapshotCounter]->Type = malloc(500);
newSnapshot[nNewSnapshotCounter]->AttributesMDHex = malloc(500);
newSnapshot[nNewSnapshotCounter]->ContentsMDHex = malloc(500);
char * output = Trim_Right(RemoveExtraSpaces(text,' '),' ');
sscanf(output,"%d %s %s %d %s %s\n",&newSnapshot[nNewSnapshotCounter]->nSlot, newSnapshot[nNewSnapshotCounter]->Item,newSnapshot[nNewSnapshotCounter]->Type,&newSnapshot[nNewSnapshotCounter]->nIndex,newSnapshot[nNewSnapshotCounter]->AttributesMDHex,newSnapshot[nNewSnapshotCounter]->ContentsMDHex);
nNewSnapshotCounter = nNewSnapshotCounter + 1;
}
fclose(p);
}
/*logic to reverse build DirDataForNewIndex */
nPreviousDot = 0;
for(nIterator1 = 0; nIterator1 < nNewSnapshotCounter; nIterator1++)
{
if(strcmp(newSnapshot[nIterator1]->Item,".") == 0)
{
nPreviousDot = newSnapshot[nIterator1]->nSlot;
nPreviousDot = nPreviousDot - 1;
}
if(strcmp(newSnapshot[nIterator1]->Item,".") != 0 && strcmp(newSnapshot[nIterator1]->Item,"..") != 0 && strcmp(newSnapshot[nIterator1]->Type,"d") ==0)
{
//found a directory, add it to the directory mapper structure.
DirDataForNewIndex = (struct DirNameSlotNumberMapping **)realloc(DirDataForNewIndex, (nDirectoriesCounterNew + 1) * sizeof(struct DirDataForIndex *)); //add one student to the structure.
DirDataForNewIndex[nDirectoriesCounterNew] = (struct DirNameSlotNumberMapping *)malloc(sizeof(struct DirNameSlotNumberMapping)); //allocate memory for the new student added.
if(newSnapshot[nIterator1]->nIndex == 0)
{
DirDataForNewIndex[nDirectoriesCounterNew]->DirName = strdup(newSnapshot[nIterator1]->Item);
DirDataForNewIndex[nDirectoriesCounterNew]->AbsoluteDirPath = strdup(pathName3);
DirDataForNewIndex[nDirectoriesCounterNew]->AbsoluteParentDirPath = "NOPARENT";
DirDataForNewIndex[nDirectoriesCounterNew]->nSlotNumberOfDir = newSnapshot[nIterator1]->nSlot;
DirDataForNewIndex[nDirectoriesCounterNew]->nSlotNumberofDot = newSnapshot[nIterator1]->nSlot + 1;
}
else
{
DirDataForNewIndex[nDirectoriesCounterNew]->DirName = strdup(newSnapshot[nIterator1]->Item);
DirDataForNewIndex[nDirectoriesCounterNew]->nSlotNumberofDot = newSnapshot[nIterator1]->nIndex;
DirDataForNewIndex[nDirectoriesCounterNew]->nSlotNumberOfDir = newSnapshot[nIterator1]->nSlot;
//now build the absolute and the parent dir path names.
//using the previous dot variable,get the directory under which we are located.
//get the index number of the previous dot position.
int IndexVar = newSnapshot[nPreviousDot]->nIndex;
IndexVar = IndexVar - 1;
//get that row's item and slot number, we'll match it
char *ItemName = newSnapshot[IndexVar]->Item;
int nSlotNumber = newSnapshot[IndexVar]->nSlot;
//now search in the DirDataFornewIndex
for(nIterator2 = 0; nIterator2 < nDirectoriesCounterNew; nIterator2++)
{
if(strcmp(DirDataForNewIndex[nIterator2]->DirName,ItemName) == 0 && DirDataForNewIndex[nIterator2]->nSlotNumberOfDir == nSlotNumber)
{
//that row's absolute path is the parent of this.
DirDataForNewIndex[nDirectoriesCounterNew]->AbsoluteParentDirPath = strdup(DirDataForNewIndex[nIterator2]->AbsoluteDirPath);
char* temp = malloc(strlen(DirDataForNewIndex[nDirectoriesCounterNew]->AbsoluteParentDirPath) + strlen(DirDataForNewIndex[nDirectoriesCounterNew]->DirName) + 1 + 1);
strcpy(temp,DirDataForNewIndex[nDirectoriesCounterNew]->AbsoluteParentDirPath);
strcat(temp,"/");
strcat(temp,DirDataForNewIndex[nDirectoriesCounterNew]->DirName);
DirDataForNewIndex[nDirectoriesCounterNew]->AbsoluteDirPath = strdup(temp);
free(temp);
temp = NULL;
}
}
}
nDirectoriesCounterNew = nDirectoriesCounterNew + 1;
}
}
//now we have reverse built DirDataForOldIndex and DirDataForNewIndex.
Table1ArrayChangeTracker = realloc(Table1ArrayChangeTracker,(nDirectoriesCounterOld + 1)*sizeof(int));
Table2ArrayChangeTracker = realloc(Table2ArrayChangeTracker,(nDirectoriesCounterNew + 1)*sizeof(int));
for(nIterator4 = 0; nIterator4 < nDirectoriesCounterOld; nIterator4++)
{
Table1ArrayChangeTracker[nIterator4] = -1; //initialize to -1
}
for(nIterator4 = 0; nIterator4 < nDirectoriesCounterNew; nIterator4++)
{
Table2ArrayChangeTracker[nIterator4] = -1; //initialize to -1
}
//get blocks one by one from the nDirectoriesCounterOld
for(nIterator4 = 0; nIterator4 < nDirectoriesCounterOld; nIterator4++)
{
char *absoluteDirectoryPath = DirDataForOldIndex[nIterator4]->AbsoluteDirPath;
int dot = DirDataForOldIndex[nIterator4]->nSlotNumberofDot;
int nexthighestdot = 0;
if(nIterator4 == nDirectoriesCounterOld - 1)
{
nexthighestdot = nOldSnapshotCounter;
nexthighestdot = nexthighestdot - 1;
}
else
{
nexthighestdot = DirDataForOldIndex[nIterator4 + 1]->nSlotNumberofDot;
nexthighestdot = nexthighestdot - 1;
nexthighestdot = nexthighestdot - 1;
}
//now, we have a block from dot to nexthighestdot.
//for referenceing the oldSnapshot
dot = dot - 1;
for(nIterator7 = dot; nIterator7 <= nexthighestdot;nIterator7++)
{
TableT1FromPDF = (struct Stage3ADisplay **)realloc(TableT1FromPDF, (nTableT1FromPDFCounter + 1) * sizeof(struct Stage3ADisplay *)); //add one record to the structure.
TableT1FromPDF[nTableT1FromPDFCounter] = (struct Stage3ADisplay *)malloc(sizeof(struct Stage3ADisplay)); //allocate memory for the new record added.
TableT1FromPDF[nTableT1FromPDFCounter]->nSlot = oldSnapshot[nIterator7]->nSlot;
TableT1FromPDF[nTableT1FromPDFCounter]->Item = malloc(strlen(oldSnapshot[nIterator7]->Item) + 1);
strcpy(TableT1FromPDF[nTableT1FromPDFCounter]->Item,oldSnapshot[nIterator7]->Item);
TableT1FromPDF[nTableT1FromPDFCounter]->Type = malloc(strlen(oldSnapshot[nIterator7]->Type) + 1);
strcpy(TableT1FromPDF[nTableT1FromPDFCounter]->Type,oldSnapshot[nIterator7]->Type);
TableT1FromPDF[nTableT1FromPDFCounter]->nIndex = oldSnapshot[nIterator7]->nIndex;
TableT1FromPDF[nTableT1FromPDFCounter]->AttributesMDHex = malloc(strlen(oldSnapshot[nIterator7]->AttributesMDHex) + 1);
strcpy(TableT1FromPDF[nTableT1FromPDFCounter]->AttributesMDHex,oldSnapshot[nIterator7]->AttributesMDHex);
TableT1FromPDF[nTableT1FromPDFCounter]->ContentsMDHex = malloc(strlen(oldSnapshot[nIterator7]->ContentsMDHex) + 1);
strcpy(TableT1FromPDF[nTableT1FromPDFCounter]->ContentsMDHex,oldSnapshot[nIterator7]->ContentsMDHex);
nTableT1FromPDFCounter = nTableT1FromPDFCounter + 1;
}
//now search for the same block in the newSnapshot
for(nIterator6 = 0; nIterator6 < nDirectoriesCounterNew; nIterator6++)
{
if(strcmp(absoluteDirectoryPath,DirDataForNewIndex[nIterator6]->AbsoluteDirPath) == 0)
{
//found the corresponding directory in the second block.
int dot2 = DirDataForNewIndex[nIterator6]->nSlotNumberofDot;
int nexthighestdot2 = 0;
if(nIterator6 == nDirectoriesCounterNew - 1)
{
nexthighestdot2 = nOldSnapshotCounter;
nexthighestdot2 = nexthighestdot2 - 1;
}
else
{
nexthighestdot2 = DirDataForNewIndex[nIterator6 + 1]->nSlotNumberofDot;
nexthighestdot2 = nexthighestdot2 - 1;
nexthighestdot2 = nexthighestdot2 - 1;
}
dot2 = dot2 - 1;
for(nIterator9 = dot2;nIterator9 <= nexthighestdot2; nIterator9++)
{
TableT2FromPDF = (struct Stage3ADisplay **)realloc(TableT2FromPDF, (nTableT2FromPDFCounter + 1) * sizeof(struct Stage3ADisplay *)); //add one record to the structure.
TableT2FromPDF[nTableT2FromPDFCounter] = (struct Stage3ADisplay *)malloc(sizeof(struct Stage3ADisplay)); //allocate memory for the new record added.
TableT2FromPDF[nTableT2FromPDFCounter]->nSlot = newSnapshot[nIterator9]->nSlot;
TableT2FromPDF[nTableT2FromPDFCounter]->Item = malloc(strlen(newSnapshot[nIterator9]->Item) + 1);
strcpy(TableT2FromPDF[nTableT2FromPDFCounter]->Item,newSnapshot[nIterator9]->Item);
TableT2FromPDF[nTableT2FromPDFCounter]->Type = malloc(strlen(newSnapshot[nIterator9]->Type) + 1);
strcpy(TableT2FromPDF[nTableT2FromPDFCounter]->Type,newSnapshot[nIterator9]->Type);
TableT2FromPDF[nTableT2FromPDFCounter]->nIndex = newSnapshot[nIterator9]->nIndex;
TableT2FromPDF[nTableT2FromPDFCounter]->AttributesMDHex = malloc(strlen(newSnapshot[nIterator9]->AttributesMDHex) + 1);
strcpy(TableT2FromPDF[nTableT2FromPDFCounter]->AttributesMDHex,newSnapshot[nIterator9]->AttributesMDHex);
TableT2FromPDF[nTableT2FromPDFCounter]->ContentsMDHex = malloc(strlen(newSnapshot[nIterator9]->ContentsMDHex) + 1);
strcpy(TableT2FromPDF[nTableT2FromPDFCounter]->ContentsMDHex,newSnapshot[nIterator9]->ContentsMDHex);
nTableT2FromPDFCounter = nTableT2FromPDFCounter + 1;
}
break;
}
}
//now we have the matching blocks, start comparing
for(nIterator10 = 0; nIterator10 < nTableT1FromPDFCounter; nIterator10++)
{
for(nIterator11 = 0; nIterator11 < nTableT2FromPDFCounter; nIterator11++)
{
enum skbool bAttributesChanged = skfalse;
enum skbool bContentsChanged = skfalse;
if(strcmp(TableT1FromPDF[nIterator10]->Item,TableT2FromPDF[nIterator11]->Item) == 0)
{
//matching element found in both arrays.
//compare attribute digest and message digests.
if(strcmp(TableT1FromPDF[nIterator10]->AttributesMDHex,TableT2FromPDF[nIterator11]->AttributesMDHex) == 0 && strcmp(TableT1FromPDF[nIterator10]->ContentsMDHex,TableT2FromPDF[nIterator11]->ContentsMDHex) == 0)
{
Table1ArrayChangeTracker[TableT1FromPDF[nIterator10]->nSlot - 1] = 1;
Table2ArrayChangeTracker[TableT2FromPDF[nIterator11]->nSlot - 1] = 1;
nMatchesFound++;
}
else
{
Table1ArrayChangeTracker[TableT1FromPDF[nIterator10]->nSlot - 1] = 2;
Table2ArrayChangeTracker[TableT2FromPDF[nIterator11]->nSlot - 1] = 2;
}
}
}
}
//after comparing clear temporary tables.
int nIterator99;
for(nIterator99 = 0; nIterator99 < nTableT1FromPDFCounter; nIterator99++)
{
free(TableT1FromPDF[nIterator99]->Item);
(TableT1FromPDF[nIterator99]->Item) = NULL;
free(TableT1FromPDF[nIterator99]->Type);
TableT1FromPDF[nIterator99]->Type = NULL;
free(TableT1FromPDF[nIterator99]->AttributesMDHex);
TableT1FromPDF[nIterator99]->AttributesMDHex = NULL;
free(TableT1FromPDF[nIterator99]->ContentsMDHex);
TableT1FromPDF[nIterator99]->ContentsMDHex = NULL;
free(TableT1FromPDF[nIterator99]);
TableT1FromPDF[nIterator99] = NULL;
}
for(nIterator99 = 0; nIterator99 < nTableT2FromPDFCounter; nIterator99++)
{
free(TableT2FromPDF[nIterator99]->Item);
TableT2FromPDF[nIterator99]->Item = NULL;
free(TableT2FromPDF[nIterator99]->Type);
TableT2FromPDF[nIterator99]->Type = NULL;
free(TableT2FromPDF[nIterator99]->AttributesMDHex);
TableT2FromPDF[nIterator99]->AttributesMDHex = NULL;
free(TableT2FromPDF[nIterator99]->ContentsMDHex);
TableT2FromPDF[nIterator99]->ContentsMDHex = NULL;
free(TableT2FromPDF[nIterator99]);
TableT2FromPDF[nIterator99] = NULL;
}
free(TableT1FromPDF);
free(TableT2FromPDF);
nTableT1FromPDFCounter = 0;
nTableT2FromPDFCounter = 0;
TableT1FromPDF = NULL;
TableT2FromPDF = NULL;
}
}
nMatchesFound++;
printf("Total matches found is %d\n",nMatchesFound);
nMatchesFound = 0;
free(oldSnapshot);
free(newSnapshot);
free(DirDataForOldIndex);
free(DirDataForNewIndex);
free(pathName3);
free(oldPathName);
free(Table1ArrayChangeTracker);
free(Table2ArrayChangeTracker);
nOldSnapshotCounter = 0;
nNewSnapshotCounter = 0;
nDirectoriesCounterOld = 0;
nDirectoriesCounterNew = 0;
Table1ArrayChangeTracker = NULL;
Table2ArrayChangeTracker = NULL;
oldSnapshot = NULL;
newSnapshot = NULL;
DirDataForOldIndex = NULL;
DirDataForNewIndex = NULL;
pathName3 = NULL;
oldPathName = NULL;
if(newPathNameStore != NULL)
{
printf("Snapshot file with name %s created\n",newPathNameStore);
free(newPathNameStore);
newPathNameStore = NULL;
}
int nIterator66;
for(nIterator66 = 0; nIterator66 < nDirectoriesCounter; nIterator66++)
{
free(DirDataForIndex[nIterator66]);
DirDataForIndex[nIterator66] = NULL;
}
free(DirDataForIndex);
for(nIterator66 = 0; nIterator66 < nStage3ARowsCounter; nIterator66++)
{
free(Stage3ADisplayVar[nIterator66]);
Stage3ADisplayVar[nIterator66]= NULL;
}
free(Stage3ADisplayVar);
nDirectoriesCounter = 0;
nStage3ARowsCounter = 0;
DirDataForIndex = NULL;
Stage3ADisplayVar = NULL;
break;
case 3:
printf ( "Exiting!\n" );
exit = 1;
break;
}
}while(exit == 0);
return 0;
}

Answer 1

One thing I would recommend is checking the status after malloc and before free as in
char *temp = malloc(10);
if(temp == NULL) {
//Malloc failed handle it
}
and
EDIT: This is unnecessary as oath pointed out free(NULL); is a no-op
if(temp != NULL) {
free(temp);
temp = NULL;
}

Answer 2

There are a few malloc(#) places. You should always use a #*sizeof(type) depending on the type you plan to put in. Then always check to make sure you aren't putting more than # of type into the location.
Unrelated, but it is helpful for readability to typedef structs. Usually something like:
typedef struct dataStructure_t {
int a;
int b;
} dataStructure;

Answer 3

If you have dbx available on your machine, it should quickly find where your code is corrupting its memory with its rtc (run time checking) capability. If not, you might use libumem and/or whatchmalloc to do the same.