Getting abort trap 6 after malloc() call - c

Question

I'm new to C from java and having a bit of trouble with memory management. I have this function whose purpose is to read x through y lines of a file. I am trying to write the function so that it can handle any size line in a file. Here is the function:
char** getRangeOfLinesFromFile(char* fileName, int startingLineNumber, int endingLineNumber, int BUFFER_SIZE) {
//set up an array to hold the range of lines we're going to return
//+1 because the range is inclusive
char** lineArray = malloc((endingLineNumber - startingLineNumber + 1) * sizeof(char*));
//get the file
FILE* file_ptr = fopen(fileName,"r");
//our buffer array will hold the lines as we read them
char *buffer = (char*) malloc(sizeof(char) * BUFFER_SIZE);
//this array will be used just in case a line is bigger than our buffer and we need to take multiple passes at it
char *temp = (char*) malloc(sizeof(char) * BUFFER_SIZE);
int lineCounter = 1;
while (fgets(buffer, BUFFER_SIZE, file_ptr) != NULL) {
strcat(temp, buffer);
size_t len = strlen(temp);
if (temp[len - 1] != '\n') {
realloc(temp,BUFFER_SIZE);
} else {
if (shouldKeepLine(lineCounter,startingLineNumber,endingLineNumber)) {
int index = lineCounter - startingLineNumber;
lineArray[index] = malloc(len * sizeof(char));
//ERROR HERE
strcpy(lineArray[index],temp);
}
*temp = *(char*) malloc(sizeof(char) * BUFFER_SIZE);
lineCounter++;
// we don't need to keep reading the file if we're not going to print anything else
if (lineCounter > endingLineNumber) {
break;
}
}
}
//clean up
free(buffer);
free(temp);
fclose(file_ptr);
return lineArray;
}
This is what the shouldKeepLine() function looks like:
bool shouldKeepLine(int lineNumber, int lowerBound, int upperBound) {
if (lineNumber >= lowerBound && lineNumber <= upperBound) {
return true;
}
return false;
}
During testing I'm using a Buffer Size of 10, so I can test that it 'grows' properly. This size will increase when the program is complete. The test file I'm using to read from currently has 2 lines. The first line of the file has like 15 characters. The second line has around 90 or so.
When I run this program, I get an Abort trap 6 error. After putting some debugging print statements in, I see that it throws that error on the strcpy call right below the ERROR HERE comment in my code, but only for line 2, not line 1. Line 1 is also larger than the buffer but a tenth or so the size of line 2. If I change this line:
lineArray[index] = malloc(len * sizeof(char));
to:
lineArray[index] = malloc(len * sizeof(char) * 1000);
It works fine. This just doesn't seem dynamic.
Not sure what I'm doing wrong. Any help is appreciated.

Answer 1

the following code should (not compiled/tested)
perform the activity you want to implement
char** getRangeOfLinesFromFile(
char* fileName,
int startingLineNumber, // note: first line in file is considered line 1, not 0
int endingLineNumber,
int BUFFER_SIZE )
{
//set up an array to hold the range of lines we're going to return
//+1 because the range is inclusive
char** lineArray = NULL;
// what about if endingLineNumber is < startingLine Number???
int lineCount = endingLineNumber - startingLineNumber + 1;
int i; // loop counter/index
// get array of pointers to point to each line that is kept
if( NULL == (lineArray = malloc( (lineCount) * sizeof(char*)) ) )
{ // then, malloc failed
perror( "malloc for array of pointers failed" );
exit( EXIT_FAILURE );
}
// implied else, malloc successful
// *I* would use the getline()) function, so the length of the
// input line would not matter.
// however, the following code uses the passed in value BUFFER_SIZE
// (which I would have made a #define and not passed it in)
// initialize the array of pointers to char
for( i=0; i<lineCount; i++)
{
if( NULL == (lineArray[i] = malloc(BUFFER_SIZE) ) )
{ // then malloc failed
perror( "malloc for each line storage area failed" );
// free all allocated memory
// suggest using the cleanup() function, below
exit( EXIT_FAILURE );
}
// implied else, malloc successful
// (optional, but good practice)
// clear each memory allocated area to NUL bytes
memset( lineArray[i], 0x00, BUFFER_SIZE );
} // end for
// if got here, then all memory allocations are completed
//get the file
FILE* file_ptr = NULL;
if( NULL == (file_ptr = fopen(fileName,"r") ) )
{ // then, fopen failed
perror( "fopen for input file failed" );
// free all allocated memory
// suggest using the cleanup() function, below
exit( EXIT_FAILURE );
}
// implied else, fopen successful
for(i=0; i < (startingLineNumber-1); i++)
{
unsigned int inputChar;
while( (inputChar = fgetc( file_ptr )) != EOF
{
if( EOF == inputChar )
{ // then, file does not contain nearly enough lines
// free all allocated memory
// suggest using cleanup() function, below
fclose( file_ptr );
return (NULL);
}
if( '\n' == inputChar ) { break;} // end of current line
} // end while
} // end for
// if got here, then ready to read first line of interest
// NOTE: be sure there is a newline at end of input file
int bufLength = BUFFER_SIZE;
for( i=0; i<lineCount; i++ )
{
// get a line, allowing for max input buffer length
if( fgets( &lineArray[i][strlen(lineArray[i])], BUFFER_SIZE, file_ptr ) )
{ // then got (more) line, up to BUFFER_SIZE -1
if( '\n' != lineArray[i][(strlen( lineArray[i] )-1) )
{ // then more char available for this line
char *tempPtr = NULL;
if( NULL == (tempPtr = realloc( lineArray[i], (bufLength*2) ) ) )
{ // then, realloc failed
perror( "realloc to increase buffer size failed" );
// add --free all the allocations--
// suggest sub function with passed parameters
fclose( file_ptr );
exit( EXIT_FAILURE );
}
// implied else, realloc successful
// update the pointer in the array
lineArray[i] = tempPtr;
// update buffer length indication
bufLength *= 2;
i--; // so will append to same entry in array for rest of line
}
else
{ // else, got all of line
bufLength = BUFFER_SIZE; // reset
} // end if
}
else
{ // else, fgets failed
perror( "fgets for line failed" );
// add --free all allocations--
// suggest sub function with passed parameters
fclose( file_ptr );
exit( EXIT_FAILURE );
} // end if
} // end for
// if got here, then all desired lines read successfully
fclose( file_ptr );
return lineArray;
} // end function: getRangeOfLinesFromFile
remember that the caller has to free all those memory allocations
first the allocation for each line
then the allocation for the lineArray
perhaps like this:
void cleanup( char**pArray, int entryCount )
{
int i; // loop counter/index
for( i=0; i<entryCount; i++ )
{
free(pArray[i]);
}
free(pArray);
} // end function: cleanup

Answer 2

This line of code is likely to be troublesome:
strcat (temp, buffer);
At the point it executes, temp has been malloced, but not initialized.
There really ought to be checks after every malloc() to make sure they succeeded.