Array of strings linked list - Segmentation fault - c

Question

I have a function that takes an array of strings. It separates all those strings by the presence of a particular character, in this case '|'. See my previous question for a better idea Split an array of strings based on character
So, I have an array of strings that looks like this:
char ** args = {"ls", "-l", "|", "cd", "."}
My parseCmnds function is supposed to go through each string in the array and create a new array of strings with all the strings before the '|' character. Then it creates a linked list where each node points to each of the array of strings I created, essentially separating the original array of strings into separate arrays of strings linked to each other.
So, my parse loop should create something like this for example:
On the first iteration:
char ** command = {"ls", "-l", NULL}
On the second iteration
char ** command = {"cd", ".", NULL}
After each iteration my function creates a new linked list node and populates it. I built code based on some of the answers I got on my previous question (thanks a million). But for some reason I'm getting a segmentation fault that I can't figure out. Can someone check out my code and let me know what I'm doing wrong?
typedef struct node {
char ** cmnd;
struct node * next;
} node_cmnds;
node_cmnds * parseCmnds(char **args) {
int i;
int j=0;
int numArgs = 0;
node_cmnds * head = NULL; //head of the linked list
head = malloc(sizeof(node_cmnds));
if (head == NULL) { //allocation failed
return NULL;
}
else {
head->next = NULL;
}
node_cmnds * currNode = head; //point current node to head
for(i = 0; args[i] != NULL; i++) { //loop that traverses through arguments
char ** command = (char**)malloc(maxArgs * sizeof(char*)); //allocate an array of strings for the command
if(command == NULL) { //allocation failed
return NULL;
}
while(strcmp(args[i],"|") != 0) { //loop through arguments until a | is found
command[i] = (char*)malloc(sizeof(args[i])); //allocate a string to copy argument
if(command[i] == NULL) { //allocation failed
return NULL;
}
else {
strcpy(command[i],args[i]); //add argument to our array of strings
i++;
numArgs++;
}
}
command[i] = NULL; //once we find | we set the array element to NULL to specify the end
while(command[j] != NULL) {
strcpy(currNode->cmnd[j], command[j]);
j++;
}
currNode->next = malloc(sizeof(node_cmnds));
if(currNode->next == NULL) {
return NULL;
}
currNode = currNode->next; //
numArgs = 0;
}
return head;
}

Answer 1

You're never allocating any memory for the cmnd member of node_cmds. So the line strcpy(currNode->cmnd[j], command[j]); is writing to...somewhere. Likely to memory you don't own. And when you do add those mallocs, your indexing (using j) is going to be very incorrect on the second pass through the outside for loop.
Also, you're leaking memory like a sieve. Try throwing some frees in there.

Answer 2

while(command[j] != NULL) {
strcpy(currNode->cmnd[j], command[j]);
j++;
}
At this statement you haven't allocated memory for the cmnd pointer(string). I believe this may be causing part of your problem. You have allocated memory for the struct, but you need to allocate memory for each pointer in the struct as well.