Replace a string within a C char string (strreplace, no sprintf)

Hello and sorry if this questions is already answered (in the way I want to :-) ) but I think I have a memory problem.
Assuming the following C function (yes, this one is very dirty and not optimized):

char *strreplace(char **str, char *dst, char *replace) {
    int replacestart = stringcompare(*str, dst), replaceend = strlen(dst), replacelen = strlen(replace);
    char *tmp1 = (char *)malloc(sizeof(char) * (replacestart + 1)), *tmp2 = (char *)malloc(sizeof(char) * ((strlen(*str) - replaceend) + 1));

    memset(tmp1, 0, sizeof(char) * (replacestart + 1));
    memset(tmp2, 0, sizeof(char) * ((strlen(*str) - replaceend) + 1));
    strncpy(tmp1, *str, replacestart);
    strncpy(tmp2, *str + replacestart + replaceend, (strlen(*str) - (replaceend + replacestart)));

    *str = realloc(*str, strlen(tmp1) + replacelen + strlen(tmp2));
    memset(*str, 0, strlen(tmp1) + replacelen + strlen(tmp2));

    strncpy(*str, tmp1, strlen(tmp1));
    strncpy(*str + strlen(tmp1), replace, replacelen);
    strncpy(*str + strlen(tmp1) + replacelen, tmp2, strlen(tmp2));
    return *str;
}

As seen, it should replace *dst with *replace whithin **str.
This works basically as expected. Here's the problem:

The output (*str) is not cleard out with zeros after memsetting it and has still the wrong length, even after reallocating.
Means, if the string is longer after replacing, the last chars are cutted of *str.
In turn, if the string is shorter, old chars are at the end of the char string are found.

What did I wrong. Mentioned that I don't want to use sprintf and no C++-STL, just want to do this with pointers in C.

Other words, what would be the right way to replace a string in an c char string with pointers.

Thanks alot.

EDIT after reqeuest for more information

I use this function as following:

...open a textfile via FILE type, determining file lengts (fseek)...

char *filecontent = (char *)malloc(sizeof(char) * filesize);
if(filesize != fread(filecontent, sizeof(char), filesize, fd)) {
    free(filecontent);
    return -1;
}

streplace(&filecontent, "[#TOBEREPLACED#]", "replaced");

...doing other stuff with filecontent...

EDIT 2, adding stringcompare()

int stringcompare(const char *string, const char *substr) {
    int i, j, firstOcc;
    i = 0, j = 0;

    while(string[i] != '\0') {
        while(string[i] != substr[0] && string[i] != '\0') {
            i++;
        }
        if(string[i] == '\0') {
            return -1;
        }

        firstOcc = i;

        while(string[i] == substr[j] && string[i] != '\0' && substr[j] != '\0') {
            i++;
            j++;
        }
        if(substr[j] == '\0') {
            return firstOcc;
        }
        if(string[i] == '\0') {
            return -1;
        }

        i = firstOcc + 1;
        j = 0;
    }
}

Solution

The logic of the function is not simple as it seems at the first glance.

You should decide what action to execute 1) if the source string is empty and 2) if the destination string is empty.

For example if the destination string is empty then the standard function strstr will return the address of the first character of the source string. However logically if dst is an empty string then the source string should not be changed except the case when it is in turn an empty string. In this case the function should just create a new string equal to the string replace.

Take into account that as the strings dst and replace are not changed within the function they should be declared with the qualifier const.

char * strreplace( char **str, const char *dst, const char *replace );

Also the function should report whether a new memory allocation was successful within the function by returning a null pointer in case when the allocation failed.

Taking all this into account the function can look the following way as it is shown in the demonstrative program.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * strreplace( char **str, const char *dst, const char *replace )
{
    char *result = *str;

    if ( *str[0] == '\0' )
    {
        if ( dst[0] == '\0' && replace[0] != '\0' )
        {
            char *result = malloc( strlen( replace ) + 1 );

            if ( result )
            {
                strcpy( result, replace );
                free( *str );
                *str = result;
            }
        }
    }
    else if ( dst[0] != '\0' )
    {
        char *pos = strstr( *str, dst );

        if ( pos != NULL )
        {
            size_t dst_n = strlen( dst );
            size_t replace_n = strlen( replace );

            result = ( char * )malloc( strlen( *str ) - dst_n + replace_n + 1 );

            if ( result )
            {
                size_t n = pos - *str;

                strncpy( result, *str, n );
                strcpy( result + n, replace );
                strcpy( result + n + replace_n, *str + n + dst_n );
            }

            free( *str );
            *str = result;
        }
    }


    return result;
}

int main(void) 
{
    const char *hello = "Hello everybody here";
    char *str = malloc( sizeof( char ) );
    str[0] = '\0';

    if ( strreplace( &str, "", hello ) )
    {
        puts( str );
    }

    if ( strreplace( &str, "everybody", "Eurobertics" ) )
    {
        puts( str );
    }

    if ( strreplace( &str, "Hello", "Bye" ) )
    {
        puts( str );
    }

    if ( strreplace( &str, " here", "" ) )
    {
        puts( str );
    }

    if ( strreplace( &str, "Bye ", "" ) )
    {
        puts( str );
    }

    free( str );

    return 0;
}

The program output is

Hello everybody here
Hello Eurobertics here
Bye Eurobertics here
Bye Eurobertics
Eurobertics