Programming

    FILE *file_pointer; char output[512];     file_pointer = popen_new("ls; ls", "r");     size_t bytes = read(fileno(file_pointer), output, 512);      printf(output);     printf("%d\n", pclose_new(file_pointer));

fread(buf, 1, 512, fp);

int *x[2]; // Doesn't crash
x[0]=NULL; // doesn't crash.
x[0]=0; // same as NULL, but generates compiler warning.  NULL is better.
x[0]=0xdeadbeef; // Doesn't crash, but generates compiler warning.
printf("contents of pointer are %d\n", *(x[0])); // CRASH!

#define MAX 1000
int main(int argc, char **argv) {
    int i; char comm[MAX]; 
    for (i = 1; i<argc; i++) {
        strcat(comm,argv[i]);
        strcat(comm," ");
    }
    printf("%d\n",system_new(comm));
    FILE *file_pointer; char output[MAX];
    file_pointer = popen_new(comm, "r");
    fread(output, 1, MAX, file_pointer); 
    printf(output);
    printf("%d\n",pclose_new(file_pointer));
    file_pointer = popen_new(comm, "w");
    fwrite(output, 1, MAX, file_pointer); 
    printf("%d\n",pclose_new(file_pointer));
    return 0;
}

#define MAX 1000
int main(int argc, char **argv) {
    int i; char comm[MAX]; 

    // As described before, arrays on the stack are undefined until
    // you put something in them.  so strcat might find something in there
    // already.  Put a null terminator at the beginning to inform it that it's
    // empty.
    comm[0]='\0';

    for (i = 1; i<argc; i++) {
        strcat(comm,argv[i]);
        strcat(comm," ");
    }
    // This is OK because you're using a string.
    printf("%d\n",system_new(comm));

    FILE *file_pointer; char output[MAX];
    file_pointer = popen_new(comm, "r");
    size_t size=fread(output, 1, MAX, file_pointer); 
    // THIS IS WRONG for many reasons!
    // 1) Never use printf without a format string!  If 'output' contains %s or
    // something, that will cause printf to try and read from the stack, which
    // will crash, because there's nothing there!
    // 2) 'output' isn't a proper character string anyway.  PRINTF CANNOT
    // PRINT IT.  It can't know where it ends, it'll either end too soon or
    // too late.
    // printf(output);
    fwrite(output, 1, size, stdout);
    printf("%d\n",pclose_new(file_pointer));
    file_pointer = popen_new(comm, "w");
    // You're writing MAX bytes even though we may have read far less than MAX bytes.
    // That ends up printing bytes we never set to anything before, which
    // are undefined -- meaning could be anything.  In your case you get 
    // garbage.
    // Only write as many bytes as you actually read!
    // fwrite(output, 1, MAX, file_pointer); 
    fwrite(output, 1, size, file_pointer);
    printf("%d\n",pclose_new(file_pointer));
    return 0;
}