"aborted (core dumped)" in all programs

Question

yesterday, during programming time everything was okay, but today I get weird error. I do not know why but after running my programs, in terminal i get this error "aborted (core dumped)", also I run programs which are already done and the problem is the same. Example of the program:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define CHUNK 12

char *getWord(FILE *infile);

int main(int argc, char *argv[])
{
    char *word;
    FILE *infile, *outfile;
    int n = 0;

    if(argc != 2) 
    {
        printf("Error! Type:./file_name input_file output_file\n");
        abort();
    }

    infile = fopen(argv[1], "r");
    if(infile != NULL)
    {
        outfile = fopen(argv[2], "w");
        if(outfile == NULL)
        {
            printf("Error! Cannot open the output_file\n");
            abort();
        }
        else
        {
            while(!feof(infile))
            {
                word = getWord(infile);
                if(word == NULL)
                {
                    free(word);
                    abort();
                }

                n++;
                if(n % 2 == 0)
                {
                    fputs(word, outfile);
                    fputs(" ", outfile);
                }
                else 
                {
                    fputs(word, outfile);
                    fputs("(", outfile);
                    fputs(word, outfile);
                    fputs(")", outfile);
                    fputs(" ", outfile);
                }
                    free(word);
            }
        }
    }
    else
    {
        printf("Error! Cannot open the input_file\n");
        abort();
    }

    fclose(infile);
    fclose(outfile);
    return 0;
}

char *getWord(FILE *infile)
{
    char *word, *word2;
    int length, cursor, c;

    word = malloc(sizeof(char)*CHUNK);
    if(word == NULL)
    {
        return NULL;
    }

    length = CHUNK;
    cursor = 0;

    while(isalpha(c = getc(infile)) && !feof(infile))
    {
        word[cursor] = c;
        cursor++;

        if(cursor >= length)
        {
            length += CHUNK;
            word2 = realloc(word, length*sizeof(char));
            if(word2 == NULL)
            {
                free(word2);
                return NULL;
            }
            else word2 = word;
        }
    }

    ungetc(c, infile);
    word[cursor] = '\0';
    return word;
}

and the error:

Error! Type:./file_name input_file output_file
Aborted (core dumped)

Answer 1

If your command requires 2 parameters, you need to check for argc != 3 since the command name itself is considered an argument. If you are giving it 2 parameters, then your check on argc != 2 is failing and you're getting your error message, and the core dump due to the abort call.

Rather than abort, you should call exit with a non-zero parameter. E.g.,

if(argc != 3) 
{
    printf("Error! Type: %s input_file output_file\n", argv[0]);
    exit(1);
}

Answer 2

The logic in your realloc is wrong.

word2 = realloc(word, length*sizeof(char));
if(word2 == NULL)
{
    free(word2);
    return NULL;
}
else word2 = word;

should be

word2 = realloc(word, cursor);
if(word2 == NULL)
{
    free(word);
    return NULL;
}
word = word2;

There are a few changes here

• word starts out having length bytes allocated so there is no point in reallocating it to the same size. The variable which tracks string size is cursor so you need to reallocate to match its size.
• (minor) There is no need to use sizeof(char) to help calculate the size of an allocation - this is guaranteed to be 1
• If realloc fails, you need to free the original pointer, not the new one (which you know is NULL).
• If the reallocation succeeds, your heap cell may have been moved, leaving word pointing to memory you don't own. The rest of the function operates on word so you need to update it to point to your new buffer (word2)

As for why this worked for you previously, the above code results in undefined behaviour in a number of places. Sometimes you're unlucky and this appears to work correctly.