Trying to make linked list, getting seg fault - c

Question

New to C, but I'm trying to write this Linked List program, and I keep getting Segmentation fault: 11. I think I've narrowed it down to the problem being just in the linked list creation -- I marked it as the problem area. When I comment this section out, the seg fault doesn't happen.
I keep going over what is happening on paper and I can't understand why it won't work. Perhaps I just misunderstand the use of pointers or malloc since I'm inexperienced.
example text file that this program should work with:
>984932:39284 mus musculus okodvcxvmkw2e2p \n
ATCTCAATCGCACTATCTAGCATGTCGTATGCTTGCATGTCGTAGTCGT\n
ATGCTATGCTTACTCTATTTACGGCGCATCGTGATCGTAGGAGCGAGCT\n
>984932:39284 mus huumoros okodvcxvmkw2e2p \n
ATCTCAATCGCACTATCTAGCATGTCGTATGCTTGCATGTCGTAGTCGT\n
ATGCTATGCTTACTCTATTTACGGCGCATCGTGATCGTAGGAGCGAGCT\n
>984932:39284 mus pisces okodvcxvmkw2e2p \n
ATCTCAATCGCACTATCTAGCATGTCGTATGCTTGCATGTCGTAGTCGT\n
ATGCTATGCTTACTCTATTTACGGCGCATCGTGATCGTAGGAGCGAGCT\n
What I'm trying to do:
Create a linked list, where each node is one block of the text above. That is, each node contains the header which starts with '>', and the sequence data that is all of the ACTG. In the above example text file, there would be 3 nodes in addition to the head/tail nodes in the list.
How I'm trying to do it (the problem section):
Char is scanned. If char is '>', then we know we're at the header, and we read all following chars into the new node's header field until we reach the newline char. At this point, we know we're going to read in sequence data. Continue to do so until we reach another '>', and when we do, repeat.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int list_header_size = 200;
int list_data_size = 2000;
struct list{
char *header;
char *data;
struct list *next;
struct list *prev;
};
//append char onto a string
void append(char *s, char c){
int len = strlen(s);
s[len] = c;
s[len + 1] = '\0';
}
int create_list(char *filename){
FILE *fp = fopen(filename, "r");
if(fp == NULL){
printf("File could not be opened. Exiting..");
exit(1);
}
//setup head - doesn't hold a char
struct list *head = malloc(sizeof(struct list));
head->next = NULL;
head->header = NULL;
head->data = NULL;
head->prev = NULL;
//setup tail - doesn't hold a char
struct list *tail = malloc(sizeof(struct list));
tail->next = NULL;
tail->header = NULL;
tail->data = NULL;
tail->prev = NULL;
/***scan the .fasta file, populate list***/
//char holder
char c;
int list_size = 0;
int i = 1;
//pull single char from file until end of file is reached
do{
c = getc(fp);
//******PROBLEM IS IN THIS SECTION********//
//if header text is found
if(c == '>'){
//create a node
struct list *temp = malloc(sizeof(struct list));
//first case to setup head
if(i == 1){
head->next = temp;
temp->prev = head;
i = 0;
}
tail->next = temp;
tail->prev = temp;
//create space for header/sequence data in the new node
temp->header = (char*) malloc(sizeof(list_header_size));
temp->data = (char*) malloc(sizeof(list_sequence_size));
//add current char to header
append(temp->header, c);
c = getc(fp);
//put file's header data into node's header data
while(c != '\n'){
append(temp->header, c);
c = getc(fp);
}
//put file's sequence data into node's sequence data
while(c != '>' && c != EOF){
append(temp->data, c);
}
}
//*******END OF PROBLEM SECTION********//
}while(c != EOF);
/***end of scanning .fasta file and creating linked list***/
return 1;
}
int main(int argc, char * argv[]){
char *filename = (char*) malloc(80);
//check options
int i;
for(i = 1; i < argc; i++){
if(argv[i][0] == '-'){
switch(argv[i][1]){
default:;
}
}else{
//arg is filename
filename = argv[i];
}
}
create_list(filename);
return 1;
}

Answer 1

The most immediate thing is this:
//create space for header/sequence data in the new node
temp->header = (char*) malloc(sizeof(list_header_size));
temp->data = (char*) malloc(sizeof(list_sequence_size));
Which I believe should be this:
//create space for header/sequence data in the new node
temp->header = malloc(list_header_size);
temp->data = malloc(list_sequence_size);
if you're super - new to C there are probably other things here too, but mallocs and their sizes are always the first things I check, and this one isn't right.
EDIT Another Problem:
Your buffers are now allocated, but your append() function expects them to be zero-terminated from inception. They are not. Add this:
temp->header = malloc(list_header_size);
temp->data = malloc(list_sequence_size);
temp->header[0] = temp->data[0] = 0; // <=== this
To be honest, since these sizes are fixed I would have rather you just declare the actual node structure like this:
struct list{
char header[200];
char data[2000];
struct list *next;
struct list *prev;
};
and avoid all the extra allocations entirely, just allocating nodes and not their fields. If the field sizes ever become dynamic, this would need to change, but until then, keep it simple.

Answer 2

I would have a look at your append(...) function, and the data you feed into it.
Your first call to the function is
append(temp->header, c);
and temp->header is not guaranteed to be zeroed. It could point to anything, though most compilers will zero it (or attempt to do so). Use calloc instead of malloc.