Memory leaks in linked lists - memory

Question

I have recently tried to implement concurrent sorted linked list in C. Only problem is that I have not used C in a long time and despite my code working fine I discovered via valgrind that my code has a memory leak in the insertion function which adds a node to the linked list. My problem is that I allocated the new node for insertion at the beginning of the function and followed carefully all uses of the new node yet I have not found where does the memory leak occurs. Any help finding where it is appreciated. I will post the insertion function. I will post more code if someone asks for more.
Code :
struct node {
int value;
node* next;
pthread_mutex_t lock; // hand over hand implies a lock for every
// node
};
struct list {
node* head;
};
// insert function for a new value if a value already exists then do
nothing
void insert_value(list* list, int value)
{
if(list == NULL) return; // if list pointer is NULL then do nothing`
node* new_node = malloc(sizeof(node)); // create new node
if(new_node == NULL) return; // check if allocation fails
new_node->value = value;
pthread_mutex_init(&(new_node->lock),NULL); // initialize mutex lock
// for the new node
pthread_mutex_lock(&(new_node->lock)); // lock the new node
if(list->head == NULL) // new node is the first element in the list
{
new_node->next = NULL;
list->head = new_node;
pthread_mutex_unlock(&(new_node->lock));
return;
}
pthread_mutex_lock(&(list->head->lock)); // lock the head of the list
node* temp;
if(list->head->value == new_node->value) // do nothing if the head of
// list is equal to new node
{
pthread_mutex_unlock(&(list->head->lock));
pthread_mutex_unlock(&(new_node->lock));
pthread_mutex_destroy(&(new_node->lock));
free(new_node);
return;
}
else if(list->head->value > new_node->value) // new node comes before
// the list head
{
new_node->next = list->head;
temp = list->head;
list->head = new_node;
pthread_mutex_unlock(&(list->head->lock));
pthread_mutex_unlock(&(temp->lock));
return;
}
else
{
// Locate the node before the point of insertion //
node* dummy;
node* current = list->head;
temp = current->next;
if(temp == NULL) // new node comes after
// the list head
{
new_node->next = current->next;
current->next = new_node;
pthread_mutex_unlock(&(new_node->lock));
pthread_mutex_unlock(&(current->lock));
return;
}
pthread_mutex_lock(&(temp->lock)); // lock the successor of the head
// perform hand over hand traversal of the list
// and check if temp reaches the end of the list (NULL)
while (temp->value < new_node->value)
{
pthread_mutex_unlock(&(current->lock));
current = temp;
temp = temp->next;
if(temp == NULL) break;
pthread_mutex_lock(&(temp->lock));
}
if(temp == NULL) // new node will be the last element in this case
{
current->next = new_node;
new_node->next = NULL;
pthread_mutex_unlock(&(current->lock));
pthread_mutex_unlock(&(new_node->lock));
return;
}
else if(temp->value == new_node->value) //new node already exists
{
pthread_mutex_unlock(&(temp->lock));
pthread_mutex_unlock(&(current->lock));
pthread_mutex_unlock(&(new_node->lock));
pthread_mutex_destroy(&(new_node->lock));
free(new_node);
return;
}
else // new node should be inserted inside the list
{
dummy = temp;
new_node->next = current->next;
current->next = new_node;
pthread_mutex_unlock(&(dummy->lock));
pthread_mutex_unlock(&(current->lock));
pthread_mutex_unlock(&(new_node->lock));
return;
}
}
} `