How to store the contents of a CSV file in a Linked List?

Question

I am trying to insert the contents from a csv file into a linklist using C. However, I am getting quite a few garbage outputs. The source code is given below.

#include
#include
#include
struct product *customer_head;

struct customer
{
    long long int c_id;//first 6 characters=date & next 6 characters=time & next characters=counter no & city code

    /*Compulsory Fields (Cannot be Skipped)*/
    char name[57];
    long long int ph_no;//10 digit phone number

    /*Non Compulsory Fields (Can be Skipped)*/
    char address[58];
    char city[25];
    char state_code[2];
    char pin[6];
    char email[60];

    struct customer *next;
};
struct customer * load()
{
    FILE * cust=fopen("customer_db.csv","r");
    struct customer *temp,*ptr;
    customer_head=NULL;
    char str[208];
    char *token,*eptr1,*eptr2;
    int line_cnt=0,i=0;

    while(fgets(str,234,cust)!=NULL)
    {
        line_cnt=0;
        i=0;
        ptr=(struct customer *)malloc(sizeof(struct customer));
        for(;str[i];i++)
        {
            if(str[i]=='
')
            {
                str[i]='\0';
                i=0;
                break;
            }
        }
        token=strtok(str,",");

        while(token!=NULL)
        {

            if(line_cnt==0)
            ptr->c_id=strtoll(token,&eptr1,10);

            else if(line_cnt==1)
            ptr->ph_no=strtoll(token,&eptr2,10);

            else if(line_cnt==2)
            sprintf(ptr->name,"%s",token);

            else if(line_cnt==3)
            sprintf(ptr->address,"%s",token);

            else if(line_cnt==4)
            sprintf(ptr->city,"%s",token);

            else if(line_cnt==5)
            sprintf(ptr->state_code,"%s",token);

            else if(line_cnt==6)
            sprintf(ptr->pin,"%s",token);

            else
            sprintf(ptr->email,"%s",token);

            line_cnt++;

            token=strtok(NULL,",");

        }
        if(customer_head==NULL)
        customer_head=ptr;
        else
        temp->next=ptr;
        temp=ptr;


    }
}
int print(struct customer *h)
{

    while(h->next!=NULL)
    {
        printf("
Customer ID: ");
        printf("%lld",h->c_id);
        printf("
Name: ");
        puts(h->name);
        printf("Phone Number: ");
        printf("%lld",h->ph_no);
        printf("
Address: ");
        puts(h->address);
        printf("City: ");
        puts(h->city);
        printf("State Code: ");
        puts(h->state_code);
        printf("PIN: ");
        puts(h->pin);
        printf("Email: ");
        puts(h->email);
        h=h->next;
    }
        printf("
Customer ID: ");
        printf("%lld",h->c_id);
        printf("
Name: ");
        puts(h->name);
        printf("Phone Number: ");
        printf("%ld",h->ph_no);
        printf("
Address: ");
        puts(h->address);
        printf("City: ");
        puts(h->city);
        printf("State Code: ");
        puts(h->state_code);
        printf("PIN: ");
        puts(h->pin);
        printf("Email: ");
        puts(h->email);

    return 1;
}
int main()
{
    load();
    print(customer_head);
}

I am also attaching the csv file here. In order for the program to be less complicated I have removed the headings from my csv file. They are in the order

Customer_ID,Phone_Number,Name,Address,City,State_Code,PIN,Email

1403201156540201,2226179183,Katherine_Hamilton,87_Thompson_St.,Fremont,IA,502645,k_hamilton@gmail.com
2204201532220103,8023631298,Marc_Knight,-,-,-,-,-
0305201423120305,8025595163,Albie_Rowland,-,Hamburg,NY,140752,-
0607201232220901,4055218053,Grant_Phelps,-,-,-,-,-

The dashes(-) indicate that those fields should remain empty.

The output is as follows:

Customer ID: 1403201156540201
Name: Katherine_Hamilton
Phone Number: 2226179183
Address: 87_Thompson_St.
City: Fremont
State Code: IA502645k_hamilton@gmail.com
PIN: 502645k_hamilton@gmail.com
Email: k_hamilton@gmail.com

Customer ID: 2204201532220103
Name: Marc_Knight
Phone Number: 8023631298
Address: -
City: -
State Code: -
PIN: -
Email: -

Customer ID: 305201423120305
Name: Albie_Rowland
Phone Number: 8025595163
Address: -
City: Hamburg
State Code: NY140752-
PIN: 140752-
Email: -

Customer ID: 607201232220901
Name: Grant_Phelps
Phone Number: 4055218053
Address: -
City: -
State Code: -
PIN: -
Email: -

As you can see, the contents are getting merged in quite a few places. I don't understand why.

David C. Rankin · Accepted Answer

Since from the comments you know that your declaration of your character arrays suffer from one-too-few character, at least in the case of char state_code[2]; leaving your array without a nul-terminating character leading to Undefined Behavior, you should ensure you have valid storage for all your input. (don't skimp on buffer size)

In general, you are making things a bit harder on yourself than it needs to be. Rather than attempting to use strtok() and count field and handle each field in a 8-part chain of if, else if ..., you have fixed input fields, so just parse the data with sscanf() and validate the number of conversions to confirm a successful parse, e.g.

/** fill list from csv file */
list_t *list_from_csv (list_t *list, FILE *fp)
{
    char buf[MAXC];
    node_t data = { .c_id = 0, .next = NULL };

    while (fgets (buf, MAXC, fp)) { /* read each line in file */
        /* parse and VALIDATE values from line */
        if (sscanf (buf, "%lld,%lld,%63[^,],%63[^,],%31[^,],%7[^,],%7[^,],%63[^,
]",
                    &data.c_id, &data.ph_no, data.name, data.address, data.city,
                    data.state_code, data.pin, data.email) == 8) {
            if (!add (list, &data)) /* validate add to list or break */
                break;
        }
    }

    return list;
}

Here, list_t is just an additional "wrapper" struct that holds a head and tail pointer for your linked list. This allows you to declare multiple lists in the scope needed and allows the same O(1) insertion by having the tail pointer always point to the last node in your list (your temp). Here, head and tail are just part of the wrapper and passed as a parameter rather than having to declare the list-pointer as global (bad practice). Each of the nodes in your list and the wrapper struct can be written as:

#define BYTE8   8           /* if you need a constant, #define one (or more) */
#define BYTE32 32
#define BYTE64 64
#define MAXC 1024

typedef struct node_t {     /* list node */
    /* 6 characters=date & 6 characters=time & counter no & city code */
    long long int c_id;

    /*Compulsory Fields (Cannot be Skipped)*/
    char name[BYTE64];
    long long int ph_no;    //10 digit phone number

    /*Non Compulsory Fields (Can be Skipped)*/
    char address[BYTE64];
    char city[BYTE32];
    char state_code[BYTE8];
    char pin[BYTE8];
    char email[BYTE64];

    struct node_t *next;
} node_t;

typedef struct {            /* list wrapper with head & tail pointers */
    node_t *head, *tail;
} list_t;

Then rather than writing your load() to contain both the FILE and list operations, keep your list operations separate. Simply create an add() function to add a node to your list, e.g.

/** add node at end of list, update tail to end */
node_t *add (list_t *l, node_t *data)
{
    node_t *node = malloc (sizeof *node);   /* allocate node */
    if (!node) {                            /* validate allocation */
        perror ("malloc-node");
        return NULL;
    }

    *node = *data;                      /* initialize members values */

    if (!l->head)                       /* if 1st node, node is head/tail */
        l->head = l->tail = node;
    else {                              /* otherwise */
        l->tail->next = node;           /* add at end, update tail pointer */
        l->tail = node;
    }

    return node;    /* return new node */
}

Now your load function need only read each line from the file and parse the line before calling add() passing a pointer to a struct of data along with the list pointer as parameters. Your load() function reduces to:

/** fill list from csv file */
list_t *list_from_csv (list_t *list, FILE *fp)
{
    char buf[MAXC];
    node_t data = { .c_id = 0, .next = NULL };

    while (fgets (buf, MAXC, fp)) { /* read each line in file */
        /* parse and VALIDATE values from line */
        if (sscanf (buf, "%lld,%lld,%63[^,],%63[^,],%31[^,],%7[^,],%7[^,],%63[^,
]",
                    &data.c_id, &data.ph_no, data.name, data.address, data.city,
                    data.state_code, data.pin, data.email) == 8) {
            if (!add (list, &data)) /* validate add to list or break */
                break;
        }
    }

    return list;
}

(note: when using strtok() or sscanf(), there is no need to strip the trailing ' ' from your input string -- simply include that as a delimiter for strtok() or exclude it from the conversion with sscanf())

Further, you don't need multiple calls to puts() and printf() to print each node's worth of data in your list. Look at how many function calls you make to print your data. You only need ONE call to printf(), e.g.

/** print all nodes in list */
void prn_list (list_t *l)
{
    if (!l->head) {
        puts ("list-empty");
        return;
    }

    for (node_t *n = l->head; n; n = n->next)
        printf ("
Customer ID: %lld
"
                "Name: %s
"
                "Phone Number: %lld
"
                "Address: %s
"
                "City: %s
"
                "State Code: %s
"
                "PIN: %s
"
                "Email: %s
", n->c_id, n->name, n->ph_no, n->address, n->city,
                                n->state_code, n->pin, n->email);
}

In main() simply declare an instance of your list_t wrapper, open/validate your FILE and then pass a pointer to the list and file-stream to your list_from_csv() (your load()) and then print the list and finally free all memory you have allocated and you are done. (yes, the memory will be freed on exit, but develop good habits early -- it won't be long before you are using allocate memory in function where a failure to free before return results in a memory-leak)

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

    list_t list = { .head = NULL, .tail = NULL };
    /* use filename provided as 1st argument (stdin by default) */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        perror ("file open failed");
        return 1;
    }

    if (!list_from_csv (&list, fp))
        return 1;

    if (fp != stdin)   /* close file if not stdin */
        fclose (fp);

    prn_list (&list);
    del_list (&list);
}

Putting it altogether, you would have something similar to the following:

#include 
#include 
#include 

#define BYTE8   8           /* if you need a constant, #define one (or more) */
#define BYTE32 32
#define BYTE64 64
#define MAXC 1024

typedef struct node_t {     /* list node */
    /* 6 characters=date & 6 characters=time & counter no & city code */
    long long int c_id;

    /*Compulsory Fields (Cannot be Skipped)*/
    char name[BYTE64];
    long long int ph_no;    //10 digit phone number

    /*Non Compulsory Fields (Can be Skipped)*/
    char address[BYTE64];
    char city[BYTE32];
    char state_code[BYTE8];
    char pin[BYTE8];
    char email[BYTE64];

    struct node_t *next;
} node_t;

typedef struct {            /* list wrapper with head & tail pointers */
    node_t *head, *tail;
} list_t;


/** add node at end of list, update tail to end */
node_t *add (list_t *l, node_t *data)
{
    node_t *node = malloc (sizeof *node);   /* allocate node */
    if (!node) {                            /* validate allocation */
        perror ("malloc-node");
        return NULL;
    }

    *node = *data;                      /* initialize members values */

    if (!l->head)                       /* if 1st node, node is head/tail */
        l->head = l->tail = node;
    else {                              /* otherwise */
        l->tail->next = node;           /* add at end, update tail pointer */
        l->tail = node;
    }

    return node;    /* return new node */
}

/** print all nodes in list */
void prn_list (list_t *l)
{
    if (!l->head) {
        puts ("list-empty");
        return;
    }

    for (node_t *n = l->head; n; n = n->next)
        printf ("
Customer ID: %lld
"
                "Name: %s
"
                "Phone Number: %lld
"
                "Address: %s
"
                "City: %s
"
                "State Code: %s
"
                "PIN: %s
"
                "Email: %s
", n->c_id, n->name, n->ph_no, n->address, n->city,
                                n->state_code, n->pin, n->email);
}

/** delete all nodes in list */
void del_list (list_t *l)
{
    node_t *n = l->head;

    while (n) {
        node_t *victim = n;
        n = n->next;
        free (victim);
    }
}

/** fill list from csv file */
list_t *list_from_csv (list_t *list, FILE *fp)
{
    char buf[MAXC];
    node_t data = { .c_id = 0, .next = NULL };

    while (fgets (buf, MAXC, fp)) { /* read each line in file */
        /* parse and VALIDATE values from line */
        if (sscanf (buf, "%lld,%lld,%63[^,],%63[^,],%31[^,],%7[^,],%7[^,],%63[^,
]",
                    &data.c_id, &data.ph_no, data.name, data.address, data.city,
                    data.state_code, data.pin, data.email) == 8) {
            if (!add (list, &data)) /* validate add to list or break */
                break;
        }
    }

    return list;
}

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

    list_t list = { .head = NULL, .tail = NULL };
    /* use filename provided as 1st argument (stdin by default) */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        perror ("file open failed");
        return 1;
    }

    if (!list_from_csv (&list, fp))
        return 1;

    if (fp != stdin)   /* close file if not stdin */
        fclose (fp);

    prn_list (&list);
    del_list (&list);
}

Example Use/Output

With your input file in dat/customer_list.txt, running the program you would receive:

$ ./bin/customer_list dat/customer_list.txt

Customer ID: 1403201156540201
Name: Katherine_Hamilton
Phone Number: 2226179183
Address: 87_Thompson_St.
City: Fremont
State Code: IA
PIN: 502645
Email: k_hamilton@gmail.com

Customer ID: 2204201532220103
Name: Marc_Knight
Phone Number: 8023631298
Address: -
City: -
State Code: -
PIN: -
Email: -

Customer ID: 305201423120305
Name: Albie_Rowland
Phone Number: 8025595163
Address: -
City: Hamburg
State Code: NY
PIN: 140752
Email: -

Customer ID: 607201232220901
Name: Grant_Phelps
Phone Number: 4055218053
Address: -
City: -
State Code: -
PIN: -
Email: -

Memory Use/Error Check

In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.

It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.

For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.

$ valgrind ./bin/customer_list dat/customer_list.txt
==14823== Memcheck, a memory error detector
==14823== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==14823== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==14823== Command: ./bin/customer_list dat/customer_list.txt
==14823==

Customer ID: 1403201156540201
Name: Katherine_Hamilton
Phone Number: 2226179183
Address: 87_Thompson_St.
City: Fremont
State Code: IA
PIN: 502645
Email: k_hamilton@gmail.com



==14823==
==14823== HEAP SUMMARY:
==14823==     in use at exit: 0 bytes in 0 blocks
==14823==   total heap usage: 7 allocs, 7 frees, 6,728 bytes allocated
==14823==
==14823== All heap blocks were freed -- no leaks are possible
==14823==
==14823== For counts of detected and suppressed errors, rerun with: -v
==14823== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Always confirm that you have freed all memory you have allocated and that there are no memory errors.

While you could cure a significant part of your problem just by ensuring you have adequate storage for each string, take the time to think through approaching the parse of values with sscanf() and since you control the conversion, there is no need to remove the trailing ' ' from the line read from the file. (just don't include the newline in the value parsed from your input string) If you did want to parse the ' ' from the end, you should be using, e.g.

    str[strcspn (str, "
")] = 0;

Lastly with both the format-string used with sscanf() and with strcspn() above, make sure you understand exactly how they work, see man 3 scanf and man 3 strspn

Let me know if you have further questions.

How to store the contents of a CSV file in a Linked List?

Answers (2)

Related Questions