Segmentation fault error while freeing the memory - c

Question

I tried to make a self-made program for lists. So, I created some basic stuff like creating the list, adding new nodes, showing them, and deleting all the existing nodes in the list.
However, when I put in my list more than 27 elements, it throws me a segmentation fault error while freeing the memory. By the way, when I add like 26 or smaller number of them, it works great. Maybe stack is overflowed or something like that, I really have no idea.
P.S don't tell me that I`m developing a bike, in this way, making something by myself first, I understand things better:)
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct node{
struct node * next;
int value;
} node;
int addNode(int position,int value, node ** head,int * size){
int i = 2;
node * curNode = *head;
if(position > *size) return;
while(i <= *size){
if(position == 1){
node * adress = *head;
*head = (node*) malloc(sizeof(node*));
(*head)->next = adress;
(*head)->value = value;
break;
}
else if(i == position){
node * adress = curNode->next;
curNode->next = (node*) malloc(sizeof(node*));
curNode = curNode->next;
curNode->next = adress;
curNode->value = value;
break;
}
else{
curNode = curNode->next;
++i;
}
}
++(*size);
return;
}
void showList(node * head, int size){
int i; node * currentNode = head;
for(i = 0; i < size; ++i){
printf(" %d , next adress: %p |\n", currentNode->value, currentNode->next);
currentNode = currentNode->next;
}
printf("\n");
}
void cleanList(node * head, int size){
int i;
node * curNode = head; node * nextToDelete = NULL;
for(i = 0; i < size; ++i){
nextToDelete = curNode->next;
free(curNode);
curNode = nextToDelete;
}
}
int main() {
node * head = (node*) malloc(sizeof(node*)); //saving head adress to know where the list starts
head->value = 1; //set head value as "1"
int i, size;
node * currentNode = head; //pointer which points to a current node
for(i = 0; i < 5; ++i){
node * adress = (node*) malloc(sizeof(node*)); //variable which saves new node`s adress
currentNode->next = adress; //set this new nod`s adress to previous node`s "next" parametr
currentNode = adress; //set new node`s adress to a current node
currentNode->value = i+2; ///set value for this node
}
size = 6;
addNode(2, 15, &head, &size);
showList(head, size);
showList(head, size);
cleanList(head, size);
return 0;
}

Answer 1

You are allocating memory incorrectly.
Notice these lines:
*head = (node*) malloc(sizeof(node*));
and
curNode->next = (node*) malloc(sizeof(node*));
You are allocating memory for a pointer to struct node instead of the actual struct.
Notice the sizeof function - you pass it the wrong parameter!
Your structure contains an int and a pointer. Those are usually the same size.
But you only allocate memory for a pointer, so, you allocate half the structure.
This will cause you to call free on an invalid address at some point.
It is a miracle your program only crashed during free operation, it should have crashed much sooner.