[C] funzione string replace iterativa: consigli?

[Gimli[2BV!2B]]

Salve a tutti!
Principalmente programmo in C++, quindi ho solitamente a disposizione funzioni adatte per svolgere attività mediamente comuni.
Ora sto facendo qualcosa in C liscio, con poche possibilità di aggiungere dipendenze al progetto: ho quindi la necessità di implementare alcune funzioni di livello piuttosto basso.

Quella di più basso livello con cui mi sono scontrato è una funzione per replace globale all'interno di un array di char (primo dubbio: non esiste proprio un'implementazione standard già disponibile?).
Per non inventare nuovamente la ruota ho cercato un po' in giro, ma non ho trovato implementazioni che mi convincessero al 100% e si adattassero al mio scopo.

Questa è la mia implementazione.
Sono ovviamente dubbioso sulla sua qualità e sicurezza, curioso di imparare dai miei errori.
Consigli? Offese? Derisioni?#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
String replace.

SYNOPSIS
replace_str( &pHaystack, &pHaystack_size, "needle", "replace" )

DESCRIPTION
Sostituisce ricorsivamente una stringa all'interno di un'altra.
-> pHaystack: array di char in elaborazione, passato per riferimento.
Reallocato se necessario.
-> pHaystack_size: massima lunghezza diponibile per haystack (meno il
terminatore di stringa), passato per riferimento. Aggiornato in caso
di reallocazione.
-> needle: stringa che sarà sostituita.
-> replace: stringa che andrà a sostituire needle.

RETURN VALUE
N numero di needle sostituiti
-1 errore, fallita allocazione memoria
*/

int replace_str( char **pHaystack, size_t *pHaystack_size, const char *needle, const char *replace )
{
(*pHaystack)[ *pHaystack_size ] = '\0' ; //precauzione
int nFound = 0 ;
size_t strlen_needle = strlen( needle ) ;

//Prima ricerca per calcolare dimensione finale della stringa
char *current = *pHaystack ;
while( ( current = strstr( current, needle ) ) != NULL )
{
++ nFound ;
current += strlen_needle ;
}
if( nFound == 0 )
return nFound ;

char *buffer = NULL, *str_tmp ;
size_t strlen_with_needle, strlen_post_needle ;
size_t strlen_haystack = strlen( *pHaystack ) ;
size_t strlen_replace = strlen( replace ) ;
size_t strlen_final = strlen_haystack + nFound * ( strlen_replace - strlen_needle ) ;

//Eventuale riallocazione array di char in ingresso se troppo piccolo
if( *pHaystack_size <= strlen_final )
{
if( ( str_tmp = (char*)realloc( *pHaystack, strlen_final + 1 ) ) == NULL )
return -1 ;

(*pHaystack) = str_tmp ;
(*pHaystack_size) = strlen_final ;
}

//Buffer destinato ad ospitare la parte superiore della stringa
//durante la sostituzione
if( ( str_tmp = (char*)malloc( strlen_final + 1 ) ) == NULL )
return -1 ;
buffer = str_tmp ;

//Ricerca ricorrenze per sostituzione
current = *pHaystack ;
while( ( current = strstr( current, needle ) ) != NULL )
{
//Salvataggio porzione successiva ad occorrenza trovata
strlen_with_needle = ( current - *pHaystack ) + strlen_needle ;
strlen_post_needle = strlen_haystack - strlen_with_needle ;
strncpy( buffer, current + strlen_needle, strlen_post_needle + 1 ) ;

//Sostituzione
strncpy( current, replace, strlen_replace ) ;
current += strlen_replace ;

//Ripristino porzione successiva nell'array di origine
strncpy( current, buffer, strlen_post_needle + 1 ) ;
strlen_haystack += ( strlen_replace - strlen_needle ) ;
}

free( buffer ) ;
return nFound ;
}

int main()
{
size_t size = 20 ;
char *test = (char*)malloc( size + 1 ) ;
strcpy( test, "Hello, \\'world\\'!" ) ;
printf( "%s\n", test ) ;
replace_str( &test, &size, "world", "Orlando") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "world", "Orlando") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "'", "''") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "\\", "\\\\") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "\\\'", "\"") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "Hello, ", "") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "\\\"'Orlando\\\"'!", "") ;
printf( "\"%s\"\n", test ) ;
free( test ) ;

size = 5 ;
test = (char*)malloc( size + 1 ) ;
strcpy( test, "00000" ) ;
printf( "%s\n", test ) ;
replace_str( &test, &size, "0", "1") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "1", "22") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "2", "333") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "3", "4444") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "4", "55555") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "5", "666666") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "6", "7777777") ;
printf( "\"%s\"\n", test ) ;
replace_str( &test, &size, "7", "88888888") ;
printf( "\"%s\"\n", test ) ;
/*
replace_str( &test, &size, "8", "999999999") ;
printf( "\"%s\"\n", test ) ;
*/
free( test ) ;

return 0 ;
}

[Gimli[2BV!2B]]

Nessuno?

Ho pensato un po' per cercare di far fuori il buffer che uso per conservare la porzione da ripristinare dopo la sostituzione, ma non credo che sia fattibile in modo non troppo contorto o poco efficiente.
Sono anche dubbioso sulla comodità/eleganza del passaggio per riferimento di buffer e sua dimensione.
Qualche test che possa evidenziare casi particolari?