seg fault for linked list in another linked list--help!!

hi
i have a linked list in another linked list

Code:

---

/* the branch linked list */
struct nodebranch{
        unsigned int offset;
        unsigned char data[130];
        struct nodebranch *next;
};

struct node{
        unsigned int id;
        struct nodebranch *branch;
        struct node *next;
};

---

I have a function insertToList(), in the function i have
struct node *current;
to point to the current node position of the list. in the function, i will call insertToBranch()

static void insertToBranch(struct node **bufferNode, L2_IDU l2idu);

to insert data into the branch linked list from the list node current. i call the function use:

insertToBranch(&(current->branch), l2idu);

current->branch is the node linked to branch(another linked list), the data will be inserted to that linked list.
l2idu is a data structure and is not important for this question.

in the insertToBranch() function, i have
void insertToBranch(struct node **bufferNode, L2_IDU l2idu){

struct nodebranch *currentbranch;
....
which i use to point to the current position of the *bufferNode.
but while i do that

currentbranch = *bufferNode;

i got a seg fault!??
i know if i pass a linked list reference, thats the rite way to do, but not sure about pass a linked list which is in another linked list.
anyone has any idea?
ps. im quit sure the seg fault is caused by pointing currentbranch to *bufferNode.

cheers
dave

i think i should post my code to make it easier(or harder???) for u guys to understand

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "bool.h"
#include "layer2.h"
#include "layer3.h"

/* The Layer 3 PDU length is the MTU of Layer 3. */
/* (even though we can't really put all that into one packet) */
#define L3_PDU_MAXLENGTH        L3_MTU

/* the fill in for other headers which need to be set to zero*/
#define ZERO 0x00;

/* a global varible for identification */
static int identificator = 0;


/* the branch linked list */
struct nodebranch{
        unsigned int offset;
        unsigned char data[130];
        struct nodebranch *next;
};

struct node{
        unsigned int id;
        struct nodebranch *branch;
        struct node *next;
};

/* the linked list we use to store different msgs before send them*/
static void insertToList(struct node **msgBuffer, L2_IDU l2idu);
static void insertToBranch(struct nodebranch **bufferNode, L2_IDU l2idu);
static int countLength(struct nodebranch **branch);

/* the function to check if all the packets have been stored, if is
 * sort and send the msg and return a 1, else return 0
 */
void StoreAndSendMessage(struct nodebranch * branch, int branchLength, int lastPacketDataLength);

void checkAndSend(struct nodebranch **branch, L2_IDU l2idu);

//void insert( NodePtr *sPtr, char value);
//void delete( NodePtr *sPtr, char value);

/* the packet is a Layer 3 protocol data unit */
typedef unsigned char L3_PDU[L3_PDU_MAXLENGTH];

int L3_connected=FALSE;

/* the function that Layer 2 calls */
static void L3_receiveL2_IDU(L2_IDU l2idu);

/* the pointer to a function, to call when giving a DU to Layer 4 */
static void (* receiveL3_IDU)(L3_IDU l3idu);


/**
 * Place your function header and description here.
 *  - describe how you implemented the reassembly
 *  - describe any data structures you used
 *  - etc.
 */
static void L3_receiveL2_IDU(L2_IDU l2idu)
{
        /* the linked list of linked list which store all the packets
        * before sending them
        */
        printf("show something before the seg fault!!\n");
        struct node *msgBuffer = NULL;
       
        insertToList(&msgBuffer, l2idu);
}

void insertToList(struct node **Buffer, L2_IDU l2idu){

        int id;                                                        /* identification */               
        /* check if the linked list already have node with the same
        * identificaton
        */
        struct node *currentList;                        /*currentListList pointer*/
        struct node *new;                                /*use to add new node*/
        struct node *preList;                                /*point to one before msgBuffer*/
       
        /*allocate memory to new*/
        new = malloc(sizeof(struct node));
       
        /* get id */
        id = ((l2idu.data[4]<<8) | l2idu.data[5]);
       
        /* if there s space, insert packet*/
        if(new != NULL){
               
                preList = NULL;
                currentList = *Buffer;
               
                /* loop to the last node in the list or the node which got
                * the same id no. with the packet*/
                while(currentList != NULL && currentList->id != id){
                        preList = currentList;
                        currentList = currentList->next;
                }
                /*case 1, there s a node in the list have same id */
                if(currentList != NULL && preList!=NULL){
                       
                        /* insert the packet into the node */
                        insertToBranch(&(currentList->branch), l2idu);
                        printf("out of insertToBranch function01");

                }
                /* otherwise, the list comes to the end, and we ll add the packet
                * on the end of the list*/
                else{       
                        new->id = id;
                        insertToBranch(&(currentList->branch), l2idu);
                        printf("out of insertToBranch function02");
                        new->next = NULL; /*node doesnt link to other node*/
                       
                        /* case 3, empty list */
                        if (preList == NULL){
                                new->next = *Buffer;
                                *Buffer = new;
                                /* point currentList to new */
                                currentList = new;
                        }
                        /* case 2, no id in the list, add to the end of list */
                        else {
                                preList->next = new;
                                new->next = currentList;
                                /* point currentList to new */
                                currentList = new;
                        }
                }
        }
        else {
                printf("%c not inserted. No memory available.\n", id );
        }
       
        /* after insert the packet, we need to check if the branch which
        * just insert the packet has a MF set to true. if its true, means
        * there s chance the whole msg has been recieved. if its so, store
        * and send the msg, and clear the branch free the memory.
        */
        checkAndSend(&currentList->branch, l2idu);
               
        if(currentList->branch == NULL){
                preList->next = currentList->next;
                free(currentList);
        }       
}

               

/*insert the packet into the node with same id, along
 * with data, a offset and a counter will be saved as well
 * for later use. after the packet has been saved onto branch,
 * check if all the packets has been recieved, by check if
 * the count equl to the offset/16. sort and send them and
 * make branch to NULL and free the memory.
 * the packet with MF = 0 (the last packet) will be inserted
 * on the end of the list while others will be inserted in the
 * front.
 */
void insertToBranch(struct nodebranch **bufferNode, L2_IDU l2idu){
       
        printf("in the insertToBranch function\n");
        int offset;                                            /* the offset of incoming packet l2idu*/
        int i;                                                        /* counter i */
        int length;                                                /* totle length of the packet */
        int lastPacketDataLength = 0;                /* the data length of the last packet(where MP=0)*/
        struct nodebranch * newNode;          /* newNode to add into branch */
        struct nodebranch * pre;            /* a linked list point one node before current*/
        struct nodebranch * current;         
       
        /* current point to bufferNode */
        current = *bufferNode;
               
        /* get the offset, while the MF is 1, need to change that bit
        * into 0 1st.
        */
       
        printf("the current is pointed to *bufferNode\n");
        if( (l2idu.data[6] ^ (1<<5)) > l2idu.data[6]){
                offset = ((l2idu.data[6]<<8) | l2idu.data[7]);
                printf("the offset is : %d \n", offset);
        }
        else {
                offset = ( ( (l2idu.data[6] ^ (1<<5)) <<8) | l2idu.data[7]);
                printf("the offset is : %d \n", offset);
        }
       
        /* get totle length of the packet */
        length = ((l2idu.data[2]<<8) | l2idu.data[3]);
       
        /* asign memory to the new node */
        newNode = malloc(sizeof(struct nodebranch));
       
        /*if the MF = 0, the bufferNode->MF will be set to TRUE
        */
        if((l2idu.data[6] ^ (1<<5)) > l2idu.data[6]) {
               
                /* the data length of packet which have MF=0 */
                lastPacketDataLength = length - 20;
        }
        /* for all the packets, will be inserted into a sorted list */
        /* loop to get the sorted position of the packet */
        while(current != NULL && offset > current->offset){
                pre = current;
                current = current->next;
        }
               
        /* put packet into a new node */       
        newNode->offset = offset;
        for(i=0; i<(length-20); i++){
                newNode->data[i] = l2idu.data[20+i];
        }
               
        /* for empty list */
        if(pre == NULL){
                newNode->next = *bufferNode;
                *bufferNode = newNode;
        }
        /* if list s not empty, insert new node */
        else{
                pre->next = newNode;
                newNode->next = current;
        }
}

---

Code:

---

if(currentList != NULL && preList!=NULL)
{
}
else
{       
  new->id = id;
  insertToBranch(&(currentList->branch), ...

---

When currentList is NULL (true in your case) you're still trying to access its members - so exception occures

this is the part of the code which might give u a problem.

Code:

---


new->id = id;
                        insertToBranch(&(currentList->branch), l2idu);
                        printf("out of insertToBranch function02");
                        new->next = NULL; /*node doesnt link to other node*/
                       
                        /* case 3, empty list */
                        if (preList == NULL){
                                new->next = *Buffer;
                                *Buffer = new;
                                /* point currentList to new */
                                currentList = new;
                        }
                        /* case 2, no id in the list, add to the end of list */
                        else {
                                preList->next = new;
                                new->next = currentList;
                                /* point currentList to new */
                                currentList = new;

---

u are trying to reference the branch when currentlist is NULL. There is no sign of currentList reference a node a the first run. Assign the new node to the cuurrentlist and then then try referencing the branch from the currentlist.

ssharish2005

but my code is :

Code:

---

if(currnetList != NULL .....){

}

---

so when currentList is not NULL, do insert....... isn't it?
i used '!='

You have this call also in the else statement I just skipped the if block of yours