Segmentation fault at free()

I'm getting a segmentation fault when I do free() in the delete function of the following linked list implementation. Please take a look and tell me where I am going wrong.

Code:

---

typedef struct node {
    char name[100];
    int id;
    struct node* next;
} Node;


void insert(Node** p, char* _name, int _id)
{
    Node *temp, *prev;
    temp = malloc(sizeof(struct node));
    temp->next = NULL;
    strcpy(temp->name,_name);
    temp->id = _id;


    if(*p == NULL) {
            *p = temp;
    }
    else {
            for(prev = *p; prev->next!=NULL; prev=prev->next);
            prev->next=temp;
    }
}


/* Delete entry
  @params p    first element
      _id    ID to delete
*/
void delete_by_id(Node** p, int _id) {
    Node *temp, *prev;
    prev = NULL;
    for(temp = *p; temp!= NULL; prev = temp, temp=temp->next) {
            if(temp->id == _id) {
                printf("Deleting entry with id: %d\n", temp->id);
                if(prev == NULL)
                    *p = temp->next;
                else
                    prev->next= temp->next;
                free(temp);
                return;
            }
    }   
}

---

When I run the program with valgrind, there is no seg. fault. It runs fine. So I am not able to figure out the problem.

Your code looks fine to me, and seems to run fine as well with the little wrapper program I wrote. Could you provide the smallest compilable set of code that exhibits the problem and the exact input you give to cause the seg fault?

segfaults on free are often double-free's (where you've tried to "free" something that's already been free'd) or where something was NEVER malloc'd in the first place. You're going to need to trace it in a debugger for a specific answer, unless you post the FULL code so that someone else can have a look in a debugger for you. Chances are, you never initialise something, you run off the end of your list of nodes and try to free memory that was never meant to be used, or you've somehow freed the same node twice.