Extraño problema con free()

[curambar]

Link al codigo en cuestión: https://github.com/INGCOM-UNRN-P1/tp5-2024-curambar/blob/7fe9a6b851de3e5ca6263e1757ad15e397ca5fb5/ejercicio3/prueba.c#L263

Me encontré con un error muy extraño. Ocurre en dos lugares. El primer lugar es en las pruebas para la funcion de conversion de enteros a cadenas, donde tengo el siguiente codigo:

void nac_test(char mensaje[], int numero, int capacidad_esperada, char* cadena_esperada)
{
	printf("\n%s\n", mensaje);
	int capacidad_test = 0;
	char* cadena_test = numero_a_cadena(numero, &capacidad_test);
	if(coincide(capacidad_esperada, cadena_esperada, capacidad_esperada, cadena_test))
	{
		printf("OK\n");
	}
	else
	{
		printf("FAIL\n");
	}
	printf("Numero (%d)\n", numero);
	printf("Cadena esperada (%s)\n", cadena_esperada);
	printf("Cadena convertida (%s)\n", cadena_test);
	my_free(cadena_test);
	//WTF por qué falla al liberar en la ultima prueba???
}

La función de conversión en sí es la siguiente:

char* numero_a_cadena(int numero, int* capacidad)
{
	bool negativo = (numero < 0);
	char* cadena = NULL;
	if(negativo)
	{
		numero = -numero;
	}
	if(numero > 0)
	{
		int* vector = NULL;
		int cantidad = 0;
		//ej num = 345
		while(numero > 0)
		{
			int digito = numero % 10;
			numero = numero / 10;
			vector = (int*) my_realloc(vector, (cantidad + 1) * sizeof(int));
			vector[cantidad] = digito;
			cantidad++;
		}
		cadena = malloc_char(cantidad + 2);
		cadena[0] = ' ';
		if(negativo)
		{
			cadena[0] = '-';
		}
		for(int i = 1; i <= cantidad; i++)
		{
			cadena[i] = '0' + vector[cantidad - i];
		}
		cadena[cantidad + 1] = '\0';
		my_free(vector);
		cantidad = cantidad + 2;
		cadena = limpia_espacios(&cantidad, cadena);
		*capacidad = cantidad;
	}
	else
	{
		cadena = malloc_char(2);
		cadena = "0";
		*capacidad = 2;
	}
	return cadena;
}

Y las pruebas que estoy ejecutando son estas:

printf("\nProbando numero_a_cadena\n");
	{
		//test 1
		int numero = 12345;
		int capacidad_esperada = 6;
		char* cadena_esperada = malloc_char(capacidad_esperada);
		cadena_esperada = "12345";
		nac_test("Test 1", numero, capacidad_esperada, cadena_esperada);
	}
	{
		//test 2
		int numero = -200;
		int capacidad_esperada = 5;
		char* cadena_esperada = malloc_char(capacidad_esperada);
		cadena_esperada = "-200";
		nac_test("Test 2", numero, capacidad_esperada, cadena_esperada);
	}
	{
		//test 3
		int numero = 0;
		int capacidad_esperada = 2;
		char* cadena_esperada = malloc_char(capacidad_esperada);
		cadena_esperada = "0";
		nac_test("Test 3", numero, capacidad_esperada, cadena_esperada);
	}

Dado el contexto, el error que me encuentro es al ejecutar la 3er prueba, el my_free repentinamente falla.

Por cierto, este es my_free:

void my_free(void* ptr)
{
	free(ptr);
}

Este es el resultado en consola de las pruebas:

Probando numero_a_cadena

Test 1
OK
Numero (12345)
Cadena esperada (12345)
Cadena convertida (12345)

Test 2
OK
Numero (-200)
Cadena esperada (-200)
Cadena convertida (-200)

Test 3
OK
Numero (0)
Cadena esperada (0)
Cadena convertida (0)
make: *** [makefile:46: test] Error -1073740940

Debugueando con printf, encontré que el punto de falla es my_free. Por qué falla justo en esa prueba, no lo sé. Las cadenas estan bien formadas, verificado el terminador con la funcion "rayos-X" y todo.

Este my_free está en TODAS las funciones de prueba que hice, pero solo en esta ultima instancia de prueba falla.

No es el unico lugar donde hay error de este tipo. En otras pruebas falla el my_free si lo quiero usar en el main. En el siguiente caso, las lineas de my_free están comentadas porque en otro caso fallan.

printf("\nProbando duplicar\n");
{
	//test 1
	int capacidad = 12;
	char* cadena_duplicar_1 = malloc_char(capacidad);
	cadena_duplicar_1 = "Anda la osa";
	duplicar_test("Test 1", capacidad, cadena_duplicar_1);
	//my_free(cadena_duplicar_1);
}
{
	//test 2
	int capacidad = 2;
	char* cadena_duplicar_2 = malloc_char(capacidad);
	cadena_duplicar_2 = "_";
	duplicar_test("Test 2", capacidad, cadena_duplicar_2);
	//my_free(cadena_duplicar_2);
}
{
	//test 3
	int capacidad = 1;
	char* cadena_duplicar_3 = malloc_char(capacidad);
	cadena_duplicar_3 = "";
	duplicar_test("Test 3", capacidad, cadena_duplicar_3);
	//my_free(cadena_duplicar_3);
}

la funcion malloc_char es esta:

char* malloc_char(int num_caracteres)
{
	void* ptr = NULL;
	if(num_caracteres >= 0)
	{
		ptr = malloc((1 + num_caracteres) * sizeof(char));
	}
	return (char*)ptr;
}

[curambar]

Revisando el código de error que me daba el make (-1073740940), decidí transformarlo en un entero sin signo y me dió el valor 3221226356, o 0xC0000374. Googleando ese codigo de error encontré una pista. Es el codigo de error de "STATUS_HEAP_CORRUPTION", por lo que sospeché que algo raro le estaba pasando a la dirección del puntero. En el main de prueba.c agregué unos printf para verificar donde esta el error:

char* cadena = malloc_char(capacidad);
printf("Direccion del puntero antes de asignar valor %p\n", cadena);
cadena = "Anda la osa";
printf("Direccion del puntero luego de asignar valor %p\n", cadena);
duplicar_test("Test 1", capacidad, cadena);
printf("Direccion del puntero luego de la prueba %p\n", cadena);

Y descubrí, horrorizado, que el acto de asignar un valor "manualmente" (tipo cadena = "sarasa";) altera el puntero. Estos son los valores que imprimió la consola:

Direccion del puntero antes de asignar valor 000001DDBEDED920
Direccion del puntero luego de asignar valor 00007FF7373E72D7
Test 1
OK
Cadena duplicada (Anda la osa)
Cadena esperada (Anda la osa)
Direccion del puntero luego de la prueba 00007FF7373E72D7

¿Tal vez está realocando la memoria al asignarle un valor? El realloc altera la dirección de memoria de un puntero, tal vez esto esté haciendo algo similar. Dado el caso, y considerando que tengo que asignarles valores manualmente a esos punteros para hacer las pruebas, ¿cómo puedo liberar esos punteros? ¿O quizás alguna alternativa a la asignación manual de valor?

Para el caso de la función que puse al principio de mi primer pregunta, el error saltaba al pasar por esta parte del código:

cadena = malloc_char(2);
cadena = "0"; // ESTA LINEA EN PARTICULAR, LA DE ASIGNACION MANUAL DE VALOR
*capacidad = 2;

Alteré el algoritmo para que nunca le asigne un valor "manualmente" y dejó de dar error. Sin embargo, en el código de prueba no tengo esa opción.

La única solución que se me ocurre de momento es olvidarme del malloc y del free y asignar la cadena sin punteros, tipo cadena[] = "sarasa". Esto tiene el beneficio adicional de que puedo calcular la capacidad de la cadena con un simple sizeof(cadena).

[martinvilu]

Y descubrí, horrorizado, que el acto de asignar un valor "manualmente" (tipo cadena = "sarasa";) altera el puntero. Estos son los valores que imprimió la consola:

Es que si tenes una variable de tipo puntero, la asignación directa, modifica el puntero, no el contenido.

cadena = "Anda la osa";

Es una cadena del segmento de texto mezclada con una del heap; estás reemplazando direcciones, mezclando segmentos.

Y despues estas intentando liberar algo que esta fuera del segmento correcto

[martinvilu]

Me interesa el proyecto como lo tengas con este bug por dos cosas, va a ser un excelente ejemplo para mas adelante, y tambien para ver que me dicen las herramientas de verificación.

[martinvilu]

Casi se me pasa esto;

Alteré el algoritmo para que nunca le asigne un valor "manualmente" y dejó de dar error. Sin embargo, en el código de prueba no tengo esa opción.

Para 'cargar' algo en una cadena creada con malloc, tenés que copiar los caracteres, esto lo podés hacer con una función propia o con memcpy.