Memory leak caused by realloc in valgrind C

Question

I have a my_string object made that contains a char pointer, a size, and a capacity. I am trying to read words from a dictionary text file into the my_string object and print them to the screen. The default capacity is 7, so when I read a word that is longer than 7 characters, I need to reallocate some space at the end of the string. I haven't been able to implement this functionality correctly yet. It seems to work correctly, but when I run it in valgrind, there is apparently a memory leak somewhere in my code. Not sure where this is coming from, because I free the entire string after the program runs. If someone could help me with this you'd be a lifesaver. Here is my driver code, and my my_string.c file: main.c

#include <stdio.h>
#include <stdlib.h>
#include "my_string.h"

int main(int argc, char* argv[]) {

  MY_STRING hMy_String = NULL;
  FILE* fp;

  hMy_String = my_string_init_default();
  fp = fopen("dictionary.txt", "r");

  int len;

  while(my_string_extraction(hMy_String, fp)) {

        len = my_string_get_size(hMy_String);

        if(len == 8){
                my_string_insertion(hMy_String, stdout);


                printf("\n");

                if(fgetc(fp) == ' '){
                        printf("Found a space after the string\n");
                }
        }

  }

  my_string_destroy(&hMy_String);
  fclose(fp);

  return 0;

}

my_string.c

#include <stdio.h>
#include <stdlib.h>
#include "my_string.h"

struct my_string {

        int size;
        int capacity;
        char* data;

};

typedef struct my_string My_String;

MY_STRING my_string_init_default(void){
        //default capacity of string is 7

        //initializes pointer to My_String, set to NULL for good practice
        My_String* pMy_String = NULL;

        //allocates memory for default string
        pMy_String = (My_String*)malloc(sizeof(My_String));

        if(pMy_String != NULL) {
                pMy_String->size = 0;
                pMy_String->capacity = 7;
                pMy_String->data = (char*)malloc(sizeof(char) * pMy_String->capacity);
                if(pMy_String->data == NULL) {
                        free(pMy_String);
                        pMy_String = NULL;
                }
        }
        //returns copy of address to default string
        return pMy_String;
}


MY_STRING my_string_init_c_string(char* c_string) {
        int i = 0;
        //initializes a pointer to a My_String
        My_String* theString = NULL;

        //loops through string, for every character, i increases 1
        while((*c_string) != '\0'){
                c_string++;
                i++;
        }

        //resets c_strings value from before the loop
        c_string = c_string - i;
        i++; //i needs to be 1 greater than the length of the string

        //allocation
        theString = malloc(sizeof(My_String) + i);

        //if there was an error, return NULL
        if(theString == NULL)
                return NULL;
        else {
                //sets the values of the object to the given values
                (*theString).size = (i - 1);
                (*theString).capacity = i;
                (*theString).data = c_string;
        }

        //returns address of the initialized string
        return theString;
}


int my_string_get_capacity(MY_STRING hMy_string){

        return sizeof(hMy_string);
}

int my_string_get_size(MY_STRING hMy_string) {

        char* str = (char*) hMy_string;
        int size = 0;

        while(str[size] != '\0')
                size++;

        return size;
}

int my_string_compare(MY_STRING hLeft_string, MY_STRING  hRight_string) {

        // sets the strings to pointers to the My_String data type
        My_String* Left = hLeft_string;
        My_String* Right = hRight_string;
        //variables for lexicographical value of each string
        int left_lex = 0;
        int right_lex = 0;

        //loops through left string, adds up left_lex value
        while((*Left->data) != '\0') {
                left_lex += (*Left->data);
                (*Left).data++;
        }

        //loops through right string, adds up right_lex value
        while((*Right->data) != '\0') {
                right_lex += (*Right->data);
                (*Right).data++;
        }


        //does the comparison and returns the corrosponding value
        if(left_lex < right_lex){
                return -1;
        }else if (left_lex == right_lex) {
                return 0;
        }else {
                return 1;
        }

}

Status my_string_extraction(MY_STRING hMy_string, FILE* fp) {
        My_String* pMy_string = hMy_string;

        int start = 0, end = 0;
        char ch;
        int strLength, capacity, i;

        while(!feof(fp)){

                ch = fgetc(fp);


                if(ch == ' ' || ch == '\t' || ch == '\n' ||ch == '\r') {
                        continue;
                }
                else {
                        start = ftell(fp) - 1;
                        end = start + 1;
                        break;
                }
        }


        if(end == 0){
                return FAILURE;
        }


        while(!feof(fp)) {

                ch = fgetc(fp);
                end++;

                if(ch == ' ' || ch == '\t' || ch == '\n' ||ch == '\r'){
                        break;
                }

        }

        strLength = end - start - 1;
        (*pMy_string).size = strLength;

        if(strLength == 0){
                return FAILURE;
        }

        capacity = my_string_get_capacity(hMy_string);

        if(strLength >= capacity){
                hMy_string = realloc(hMy_string, strLength + 1);

        }

        fseek(fp, start, SEEK_SET);

        char* str = (char*)hMy_string;

        for(i = 0; i < strLength; i++) {
                str[i] = fgetc(fp);
        }

        str[i] = '\0';

        return SUCCESS;

}

Status my_string_insertion(MY_STRING hMy_string, FILE* fp) {
        char* str = (char*)hMy_string;


        if(fprintf(fp, "%s", str))
                return SUCCESS;
        else
                return FAILURE;
}

void my_string_destroy(MY_STRING* phMy_string){

        free(*phMy_string);
        *phMy_string = NULL;

}