Unexpected output after the first iteration of this code

Question

I honestly have no idea how the following even happens. Here is the code:

while(1)
{
    char** line = read_command();
    char* command = line[0];
    char** parameters = malloc(100);
    int i;

    for(i = 0; i < pNum; i++) // pNum is a global var containing the number of words read from read_command()
    {
        parameters[i] = line[i];
        printf("%i: %s", i, parameters[i]);
    }

    printf("%s\n", parameters[0]);
    parameters[0] = "/usr/bin/";
    strcat(parameters[0], command);
    printf("%s\n", command);
    printf("%s\n", parameters[0]);

    if(fork() != 0)
        waitpid(1, &status, 0);
    else
        execve(parameters[0], parameters, NULL);
}

read_command() returns a char** that is basically an "array" to the string that was entered, and each char* contains a word. Like if I enter "hello people of earth" the result would be ["hello", "people", "of", "earth"]. This fucntion always works.

upon the first iteration everything works just as expected. example, when I type "date" the output is as follows:

0: date
date
date
/usr/bin/date
and then the date is displayed

but upon the second iteration if i use "date" as the input again the output is as follows:

0:date
edate 
/usr/bin/datedate 
and the date command is not issued

the second printf statement always prints "e" after the first iteration even if I print a constant string like "hello". and then the parameters[0] somehow has 2 "date" in it even though the command pointer has only 1 "date".

And after the third iteration the program does not wait for user input, it just loops non stop and displays "PM: warning, process table is full!"

What could possibly cause this?

I am working in MINIX 3.1.0 with the cc compiler for C

EDIT: the read_command():

char* line = malloc(), * linep = line;
size_t lenmax = 100, len = lenmax;
int c;
int currPos = 0;
int currParam = 0;
int i;
char** parameters = malloc(100);

if(line == NULL)
    return NULL;

while(1)
{
    c = fgetc(stdin);

    if(c == EOF) || c == '\n')
        break;

    if(--len == 0)
    {
        char* linen = realloc(linep, lenmax *= 2);
        len = lenmax;

        if(linen == NULL)
        {
            free(linep);
            return NULL;
        }

        line = linen + (line - linep);
        linep = linen;
    }

    if((*line++ = c) == '\n')
        break;
}

*line = '\0'; // everything up to this point i got from this link: http://stackoverflow.com/a/314422/509914

 parameters[currentParam] = malloc(100);

for(i = 0; i < strlen(linep); i++);
{
    if(isspace(linep[i]) || line[i] == EOF)
    {
        parameters[currParam][currPos] = '\0;
        currPos = 0;
        parameters[++currParam] = malloc(100);
    }
    else
        parameters[currParam][currPos++] = line[i];
}

parameters[currParam][currPos] = '\0';
pNum = currParam + 1;
return parameters;

Answer 1

It sure is interesting that those people who learn by reading reputable resources, such as the tried and tested for decades K&R tend to have these issues far less frequently than those who don't...

char** parameters = malloc(100); is attempting to allocate 100 bytes. realloc behaves similarly, so I won't mention this again. Perhaps you meant to allocate 100 lots of char *? It'd make even more sense to allocate pNum lots of char *: char **parameters = malloc(pNum * sizeof *parameters);... char* linen = realloc(linep, (lenmax *= 2) * sizeof *linep);...

strcat doesn't allocate memory; the only functions that allocate memory are malloc, calloc and realloc.

When you call strcat(foo, bar); you're asking strcat to append the string pointed to by bar onto the end of the string pointed to by foo. In your code, you're attempting to modify a string literal. Undefined behaviour, and typically a segfault.

Even your modified attempt is wrong. In parameters[0] = "/usr/bin/";, you're not copying a string into parameters[0]; you're assigning parameters[0] to point to the string (which is typically in immutable memory, as I mentioned earlier). You really need to narrow down the source of your undefined behaviour by creating an MCVE...

In the first line of your read_command() function, char* line = malloc(), * linep = line;, you have called malloc without providing an argument. That's a constraint violation. Your compiler should be issuing you with an error. Perhaps you've forgotten to #include <stdlib.h>, and so malloc is missing its prototype? Please provide an MCVE so we don't have to make guesses like this.

There's another constraint violation at if(c == EOF) || c == '\n')... Even if we were to fill in the blanks to produce an MCVE for you (which we shouldn't have to do, because it's your work and you're asking us for help), this code would not compile. Perhaps that's what's causing your crashes? Always check the messages that your compiler gives you. Don't ignore warnings... and definitely don't ignore error messages.

I compared the code that you claimed came from this answer, and it is quite different. The code at that answer compiles, for one. Nonetheless, is that your way to establish trust with the people who are trying to help you... by lying?

You don't need so much dynamic allocation, and normally I would go out of my way and explain how you can do this the best way possible, but the lies have put me off. I have one more point to make: Make sure parameters is terminated by a null pointer (similarly to how strings are terminated by a null character), as it is required to be by the manual.