Parser generating segfaults in C - c

Question

I've been trying to get this to work for the past 2 weeks to no avail.
I have a project to create a shell that implements parsing and built-in commands. The issue I'm having is when I pass a char* to my parse function and it returns, when i try to access any part of it, I get a segfault. I've tried different methods including a struct holding a char** all with the same problems, so i'm guessing it's an issue with my parser. I would appreciate any help.
code for parser.c:
#define BUFSIZE 1024
#define TOK_BUFSIZE 64
#define TOK_DELIM " \t\r\n\a"
char*** Parse(char *line0){
char* null_ptr = 0;
char*** cmd = malloc(MAX_SIZE * sizeof(char**));
/*
char arg[] = argument
char* argv[] = argument array
char** cmd[] = array of argument arrays
*/
int bufsize = MAX_SIZE, cmdp = 0, argp = 0, com = FALSE, redir = FALSE;
char *token;
char* line = malloc(100*sizeof(char));
strcpy(line,line0);
token = strtok(line, TOK_DELIM);
while (token){
if (*token == ';'){ // new command string
char* tmp1 = malloc(BUFSIZE * sizeof(char));
char** tmpa = malloc(BUFSIZE * sizeof(char*));
strcpy(tmp1, token);
tmp1[sizeof(token)] = null_ptr;
tmpa[0]=tmp1;
cmd[cmdp] = tmpa;
argp = 0;
cmdp++;
com = FALSE;
redir = FALSE;
}
else if (*token == '>' || *token == '<' || token == ">>"){ // redirects
argp = 0;
char* tmp1 = malloc(BUFSIZE * sizeof(char));
char** tmpa = malloc(BUFSIZE * sizeof(char*));
strcpy(tmp1, token);
tmp1[sizeof(token)] = null_ptr;
tmpa[argp]=tmp1;
argp++;
printf("Redirect: %s\n",tmp1);
com = FALSE;
redir = TRUE;
}
else if (*token == '|'){ // pipe
printf("PIPE\n");
cmdp++;
argp = 0;
com = FALSE;
}
else if (redir){ // redirect file name
// redirect token stored in arg[]
char* tmp1 = malloc(BUFSIZE * sizeof(char));
char** tmpa = malloc(BUFSIZE * sizeof(char*));
strcpy(tmp1, token);
tmp1[sizeof(token)] = null_ptr;
tmpa[argp]=tmp1;
cmd[cmdp]=tmpa;
argp = 0;
cmdp++;
redir = FALSE;
com = FALSE;
printf("File: %s\n", token);
}
else if (token == "&") // background
{
cmdp++;
argp = 0;
char* tmp1 = malloc(BUFSIZE * sizeof(char));
char** tmpa = malloc(BUFSIZE * sizeof(char*));
strcpy(tmp1, token);
tmp1[sizeof(token)] = null_ptr;
tmpa[0]=tmp1;
cmd[cmdp]=tmpa;
printf("Background");
}
else if (!com && !redir){ // command entered
argp = 0;
char* tmp1 = malloc(BUFSIZE * sizeof(char));
char** tmpa = malloc(BUFSIZE * sizeof(char*));
strcpy(tmp1, token);
tmp1[sizeof(token)] = null_ptr;
tmpa[argp] = tmp1;
argp++;
printf("Command %s\n", token);
com = TRUE;
}
else if (com){ // argument to command, all other redirects and pipes taken care of
char* tmp1 = malloc(BUFSIZE * sizeof(char));
char** tmpa = malloc(BUFSIZE * sizeof(char*));
strcpy(tmp1, token);
tmp1[sizeof(token)] = null_ptr;
tmpa[argp] = tmp1;
argp++;
printf("Argument: %s\n", token);
//cmd[cmdp] = argv; // save current working argument array
//cmdp++;
}
// end of if else statements
token = strtok(NULL, TOK_DELIM);
} // end of while
cmdp++;
cmd[cmdp] = NULL;
return &cmd;
}

Answer 1

When I compiled your code on the command-line by typing in:
gcc /path/to/yourcodefilename.c -Wall -Wextra
But replacing /path/to/yourcodefilename.c with the actual filename of the code containing the main function that eventually calls your function (my file is test2.c), I received warnings. The first being:
./test2.c:21: error: 'aaa' undeclared (first use in this function)
./test2.c:21: error: (Each undeclared identifier is reported only once
./test2.c:21: error: for each function it appears in.)
And I received a few of those. "aaa" is replaced by the named of something you used inside your function that has not been previously defined. This includes the word TRUE and FALSE. To correct this, you can use at the top of your program:
#define FALSE n
#define TRUE y
where n and y are numbers representing false and true respectively. Another way to correct it is to include the header files containing definitions for "TRUE" and "FALSE".
The second thing I noticed on a few lines is:
warning: assignment makes integer from pointer without a cast
Make sure you don't convert data over from one type to another. For example, don't set a character variable to a pointer value.
For example, change:
tmp1[sizeof(token)] = null_ptr;
to:
tmp1[sizeof(token)] = '\0';
Because specifying an index to a char* means specifying a char, and null_ptr is of type char* and char* and char are not the same. What i did was assigned a null value that is a char.
I hope that helps you with some troubleshooting

Answer 2

There are several issues here:
You allocate cmd and its subarrays. You return an address to that array at the end of the function. The address has type char ****, which is not the correct return type. What's worse: That address is the address of a local variable, which goes out of scope immediately after returning. Return the handle you got from malloc instead:
char ***Parse(char *line0)
{
char ***cmd = malloc(MAX_SIZE * sizeof(*cmd));
// fill cmd
return cmd;
}
Your code is needlessly long, mostly because you code the steps to allocate memory, copy a string and null-terminate it explicitly. (Others have pointed out that you don't do the null termination properly. You also allocate a fixed size of 1024 bytes regardles of the actual string length, which is quite wasteful.) You could write a function to duplicate strings or use the non-standard, but widely available strdup; this would make your code easier to read.
All the temporary allocations are hard to follow. For example, in the branch if (!com && !redir), you allocate to tmpa, but you never store that value in cmd. The same goes for the redirection branch.
It's also not clear when you start a new command. There should be a new command just before parsing the first token, after encountering a pipe or after encountering a semicolon. You also start new commands for redirections and the background ampersand.
The comparison token == ">>" will always be false: token is an address in line and ">>" is a string literal stored n static memory. You should use strcmp to compare two strings.
In general, you want to allocate a new list when cmdp increases. In that case, argp is reset to zero. Otherwise, you just append to the current command.
I think that you complicate things by treating everything as special. I recommend to simplify the code and leave redirection and the background for the moment. They can easily be resolved when the command is called. (Your code sets the state with redir and com, but it never enforces file names after redirection, for example. You can do that easily when all the tokens are in place.)
The code below treats only pipes and semicolons as command separators. When the command is a pipe, the pipe token is prepended to the following command:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MAX_SIZE 32
#define TOK_DELIM " \t\r\n\a"
char *sdup(const char *str)
{
size_t len = strlen(str);
char *dup = malloc(len + 1);
if (dup) {
memcpy(dup, str, len);
dup[len] = '\0';
}
return dup;
}
char ***parse(char *line0)
{
char *token;
char *line = sdup(line0);
token = strtok(line, TOK_DELIM);
if (token == NULL) return NULL;
char ***cmd = malloc(MAX_SIZE * sizeof(char **));
int cmdp = 0;
int argp = 0;
cmd[0] = malloc(MAX_SIZE * sizeof(*cmd[0]));
while (token) {
if (strcmp(token, ";") == 0 || strcmp(token, "|") == 0) {
// begin new command
cmd[cmdp][argp++] = NULL;
cmdp++;
if (cmdp + 1 == MAX_SIZE) break;
argp = 0;
cmd[cmdp] = malloc(MAX_SIZE * sizeof(*cmd[0]));
// prepend pipe token
if (*token == '|') {
cmd[cmdp][argp++] = sdup(token);
}
} else {
// append to current command
if (argp + 1 < MAX_SIZE) {
cmd[cmdp][argp++] = sdup(token);
}
}
token = strtok(NULL, TOK_DELIM);
}
// null-terminate arg and cmd lists
cmd[cmdp][argp] = NULL;
cmdp++;
cmd[cmdp] = NULL;
return cmd;
}
int main()
{
char ***cmd = parse("echo start ; ls -l | wc > output ; echo stop");
char ***p = cmd;
while (*p) {
char **q = *p;
while (*q) {
printf("'%s' ", *q);
free(*q);
q++;
}
puts("");
free(*p);
p++;
}
free(cmd);
return 0;
}
Further remarks:
I'm not sure whether the current format is suited to the task. It might be better to have a tree structure that takes care of pipes, semicolons and maybe as well &&and || and then have leaf nodes with the commands where the arguments are linked lists.
Tokenisation with strtok requires white-space between all tokens, but punctuation can usually be written without explicit space, e.g.: "./a.out>kk&". So you will need a better method of parsing.
At the moment, you allocate space for each string, which you must free later. If you create a token struct that describes a token as read-only view into the original string you can do without the allocations. The views are not null-terminated, though, so you will need comparison methis that work on starting pointer plus length, for example.