Odd behaviour when using malloc

Question

I am new to C and facing an odd behavior when using malloc.

I read a input text from stdin (fgets) and pass it to a function myfunction.

void myfunction(char* src) {

     printf("src: |%s|\n", src);

     int srcLength = strlen(src);
     printf("src length: %d\n", srcLength);

     // CAUSES ODD BEHAVIOR IN MY SITUATION
     // char* output = malloc(200);
     //
     // if (output == NULL) {
     //   exit(EXIT_FAILURE);
     // }

     for (int i=0; i < srcLength; ++i) {
       char currChar = src[i];
       printf("|%c| ", currChar);
     }
}

When executing the function without malloc (see comment), I am getting this:

src: |asdf|
src length: 4
|a| |s| |d| |f|

But with malloc, I am getting this awkward behaviour. As if there were no chars in the char*:

src: |asdf|
src length: 4
|| || || || 

There might be an issue with the char* src (from stdin). But I am unsure because the input string is printed correctly (src: |asdf|).

Can anybody support me, how to analyze the source of the problem?

UPDATE 1:

Here is the code for reading from stdin and invoking myfunction.

int main(int argc, char **argv) {

  char *input = NULL;
  input = readStdin();
  myfunction(input);
  return EXIT_SUCCESS;
}

char* readStdin(void) {
    char buffer[400];
    char *text = fgets(buffer, sizeof(buffer), stdin);
    return text;
}

The myfunction and readStdin are in different files, but I hope it does not matter.

UPDATE 2:

As proposed by the supporters in the comments, I did a resolution of the scope issue.

I changed the function prototype of readStdin to:

 char* readStdin(char* input);

And I invoke readStdin with the allocated input.

 char* input = malloc(400);

In readStdin I replaced buffer with the function parameter.

Answer 1

Odd behaviour when using malloc

Yes, it's odd.... or perhaps not. You code has undefined behavior so everything may happen.

The problem is that text will end up as a pointer to buffer if fgets is succesful. But buffer is a local variable in the function so as soon as readStdin returns the variable buffer doesn't exist anymore. Therefore you pass myfunction an invalid pointer and when you use it (i.e. for read/write), you have undefined behavior.

Once you have undefined behavior it makes no sense to reason about what is going on.... but if we try to do that anyway, a likely explanation for most systems is:

buffer was located on the stack. When readStdin returns, the stack pointer is decrement (or incremented) so that buffer is now on the unused part of the stack. When you call a new function, the new function will also need some stack space. How much depends on the number of variables used by the function. In other words - the more variables, the more stack space will be needed. Since the new variables will overwrite some part of the stack - and thereby overwrite parts of the memory holding the obsolete buffer variable - the amount of destruction of buffer may change with the number of variables in the function call. That is probably what you see.

But notice that the above explanation is system specific. It is not something specified by the C standard. Still, that is how most systems work.

What to do?

Instead of

char buffer[400];

do

char* buffer = malloc(400);

Answer 2

As many have stated in the comments, you have scope issues. To avoid this, you need to allocate memory inside readStdin(). Quoting @MOehm from comments

Once you've left readStdin, buffer becomes invalid. Accessing it is undefined behaviour, which you should avoid. (I guess that the problem is not the malloc, but the additional variable output, which happens to occupy part of the space that was previously occupied by buffer, thus corrupting it.)

#define SIZE 400

char* readStdin(void) {
    char buffer[SIZE];
    char *text = NULL

    fgets(buffer, sizeof(buffer), stdin);
    text = malloc(sizeof(char) * (strlen(buffer) + 1));//allocate memory
    strcpy(text, buffer);//and copy the buffer into it.

    int length = strlen(text);
    if (text[length - 1] == '\n') {
        text[length - 1] = '\0';
    }
    return text;
}

And your main function should now look like this:

int main(int argc, char *argv[]) 
{
    char *input = NULL;
    input = readStdin();
    myfunction(input);
    free(input);//must now free it.
    input = NULL;
    return EXIT_SUCCESS;
}

Try making these changes and you will see that all your problems will go away. Now MyFunction will work as expected.

Answer 3

I don't understand why you don't get compile errors when doing char* output = malloc(200);: you MUST cast into char*, like char* output = (char*) malloc(200);