Segfault when reading from update linked list - c

Question

So I'm working on an implementation of a hash table. I'm not very experienced with C and pointers and getting a bit stuck.
I've got hashtable definition that looks like this:
typedef struct KVnode {
int kv[2];
struct KVnode *next;
} KVnode;
typedef struct hashtable {
int size; // size of hash table
int entries; // number of slots allocated in table
KVnode *table; /* pointer to table. Each entry will point to linked list
of key-value nodes */
} hashtable;
Where the hash table struct contains a table of KVnode pointers. The KVnodes are essentially a linked list to store collisions.
My implementation of put looks like this:
void put(hashtable* ht, keyType key, valType value){
int index = hash_key(key, ht->size);
KVnode *new_node = malloc( sizeof(KVnode) );
new_node->kv[0] = key;
new_node->kv[1] = value;
new_node->next = NULL;
printf("Inserting at index: %i, key:%i, val:%i \n", index, key, value);
// If next val is 0, we can set the first node to key-value
if( ht->table[index].next == 0)
ht->table[index] = *new_node;
else{ // find last node in linked list and append new_node
KVnode cn = ht->table[index];
while( cn.next != NULL )
cn = *cn.next;
cn.next = new_node;
}
}
And here the overall code:
#include <stdio.h>
#include <stdlib.h>
#define SIZE 503
typedef struct KVnode {
int kv[2];
struct KVnode *next;
} KVnode;
typedef struct hashtable {
int size; // size of hash table
int entries; // number of slots allocated in table
KVnode *table; /* pointer to table. Each entry will point to linked list
of key-value nodes */
} hashtable;
typedef int keyType;
typedef int valType;
void init(hashtable**);
int hash_key(keyType key, int size);
void put(hashtable* ht, keyType key, valType value);
void init(hashtable** ht) {
*ht = (hashtable *) malloc( sizeof(hashtable) );
if(*ht == NULL){
printf( "Error: Unable to allocate memory for hashtable" );
exit(1);
}
else{
(*ht)->entries = 0;
(*ht)->size = SIZE;
(*ht)->table = calloc((*ht)->size , sizeof(KVnode *));
}
}
int hash_key(keyType key, int size){
return key % size;
}
void put(hashtable* ht, keyType key, valType value){
int index = hash_key(key, ht->size);
KVnode *new_node = malloc( sizeof(KVnode) );
new_node->kv[0] = key;
new_node->kv[1] = value;
new_node->next = NULL;
printf("Inserting at index: %i, key:%i, val:%i \n", index, key, value);
// If next val is 0, we can set the first node to key-value
if( ht->table[index].next == 0)
ht->table[index] = *new_node;
else{ // find last node in linked list and append new_node
KVnode cn = ht->table[index];
while( cn.next != NULL )
cn = *cn.next;
cn.next = new_node;
}
}
int main(){
hashtable *t = NULL;
init(&t);
put(t, 225, 100);
put(t, 55555, 100);
printf("node at 255, k:%i, v:%i\n", t->table[225].kv[0],t->table[225].kv[1] );
printf("node at 255, 2nd node, k:%i, v:%i\n",
t->table[225].next->kv[0],t->table[225].next->kv[1] );
free(t);
}
The program compiles fine but at runtime i get at segfault. Here's the output:
ds-MacBook-Pro:project0 d$ ./ll
Inserting at index: 225, key:225, val:100
Inserting at index: 225, key:55555, val:100
node at 255, k:55555, v:100
Segmentation fault: 11
I can't figure out if the issue is my print statement or if I'm actually not appending the linked list correctly in put.