Valgrind is complaing about freed memory

[arortell]

hello, I got a clean bill of health from valgrind before I added the check function. Now valgrind is complaining about a pointer that was freed in unload and was fine before this function which I really don't understand.Here is the code and the valgrind error. Thank you.

  #include "hashTable.h"
#include <stdbool.h>


table_node hash_table[TABLE_LENGTH];

bool loaded = true;

//assigning letters a-z to table nodes for buckets
void key_hash_t( ) 
{
	char key = 'a';
	for ( int i = 0; i < TABLE_LENGTH; i++ )
	{
		hash_table[i].letter = (key + i);
	}
}

//TODO: return and error checking 
bool load_hash_t(const char *file_name)
{
	char word[WORD_LENGTH];
	char c;
	int index = 0, hash_val = 0, size = get_file_size(file_name);
	FILE *file = fopen(file_name, "r");
	
	if (file == NULL)
	{
		printf ("File not found...\n");
		return false;
	}

	for (int word_count = 0; word_count < size; word_count++) 
	{
		node *new_node = malloc( sizeof(*new_node) ); 

		// make sure malloc was successful
		if (new_node == NULL)
		{
			printf ("Failed to allocate memory...\n");
			return false;
		}

		new_node->next = NULL;
		
		while ((c = fgetc(file)) != '\n')
		{
			word[index] = c;
			index++;
		}

		hash_val = hash(word);

		for (int j = 0; j < index; j++)
		{
			new_node->word[j] = word[j];
		}

		index = 0;

		// if this bucket has no nodes yet add it here
		if (hash_table[hash_val].next == NULL)
		{
			hash_table[hash_val].next = new_node;
		}
		else
		{
			//add new  node to end of list
			new_node->next = hash_table[hash_val].next;
			hash_table[hash_val].next = new_node;
		}
	}
	fclose(file);
	return true;
}

// delete list nodes
bool unload_hash_t( )
{
	/**
	 * loop through array
	 * traverse each list and
	 * delete each node
	 **/
	for (int i = 0; i < TABLE_LENGTH; i++)
	{
		node *cursor = hash_table[i].next;

		while (cursor != NULL)
		{
			node *temp = cursor;
			cursor = cursor->next;
			free(temp);
		}
	}
	return true;
}

/**
 * get size of dictionary file 
 * for load function
 * */
int get_file_size(const char *file_name)
{
	char c;
	int line_count = 0;
	FILE *file = fopen(file_name, "r");
	
	if (file == NULL)
	{
		printf("File not found..\n");
		exit(EXIT_FAILURE);
	}

	while ((c = fgetc(file)) != EOF)
	{
		if (c == '\n')
		{
			line_count++;
		}
	}
	fclose(file);

	return line_count;
}

/**
 * convert first char to lowercase
 * subtract by 97 to give correct 
 * array index
 **/
int hash(const char *str)
{
	if (str == NULL)
	{
		printf("NULL pointer..\n");
		exit(EXIT_FAILURE);
	}
	return (tolower(str[0]) - 97);
}

/**
 * loop threw array to find bucket
 * traverse list to find word
 * return true if found false if not
 */
bool check(const char* word)
{
	//hash word
	int hash_val = hash(word); 
	
	//must reassign to make editable
	char *eword = strdup(word);

	//convert word to lower
	word_tolower(eword);

	node *cursor = NULL;
	
	//iterate table array to find bucket
	for(int i = 0; i  < TABLE_LENGTH; i ++)
	{
		cursor = hash_table[hash_val].next;
		//traverse list for bucket hash_val
		while (cursor != NULL)
		{
			if(strcmp(eword, cursor->word) == 0)
			{
                                free(eword);
				return true;
			}
			else
			{
				cursor = cursor->next;
			}
		}
		
	}
	free(eword);

	return false;
}

 /**
  * iterate through array and
  * traverse each list counting each node
  * as I go by
  **/
unsigned int size( )
{
	if (!loaded)
	{
		printf("Dictionary not loaded..\n");
		return 0;
	}
	node *cursor = NULL;
	int node_count = 0;
		
	for (int i = 0; i < TABLE_LENGTH; i++)
	{
		cursor = hash_table[i].next;
		while (cursor != NULL)
		{
			node_count++;
			cursor = cursor->next;
		}
	}
	return node_count;
}

void word_tolower(char* word)
{
	if (word == NULL)
	{
		printf("NULL pointer ...\n");
		exit(EXIT_FAILURE);
	}

	for (int i = 0, length = strlen(word); i  < length; i ++)
	{
		word[i] = tolower(word[i]);
	}
}

Valgrind Message:

arortell@gentoobox ~/Develpoment/Projects/C_Projects/Data_Structures/HashTable $ valgrind --leak-check=full --track-origins=yes ./hashTable
==7877== Memcheck, a memory error detector
==7877== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==7877== Using Valgrind-3.9.0 and LibVEX; rerun with -h for copyright info
==7877== Command: ./hashTable
==7877==
==7877== Conditional jump or move depends on uninitialised value(s)
==7877==    at 0x4C2C860: strcmp (mc_replace_strmem.c:730)
==7877==    by 0x400CA1: check (hashTable.c:179)
==7877==    by 0x400EBF: main (main.c:18)
==7877==  Uninitialised value was created by a heap allocation
==7877==    at 0x4C28730: malloc (vg_replace_malloc.c:291)
==7877==    by 0x40090C: load_hash_t (hashTable.c:40)
==7877==    by 0x400EB3: main (main.c:16)
==7877==
YESNumber of nodes = (3i)
==7877==
==7877== HEAP SUMMARY:
==7877==     in use at exit: 0 bytes in 0 blocks
==7877==   total heap usage: 6 allocs, 6 frees, 1,315 bytes allocated
==7877==
==7877== All heap blocks were freed -- no leaks are possible
==7877==
==7877== For counts of detected and suppressed errors, rerun with: -v
==7877== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 1 from 1)