Adding very big numbers

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

char *sumar(char *n1, char *n2);
void compactar(char *numero);

int main() {
    char *ns1 = malloc(101);
    char *ns2 = malloc(101);
    char *res;

    printf("Introduce n1: ");
    scanf("%100s", ns1);

    printf("Introduce n2: ");
    scanf("%100s", ns2);

    res = sumar(ns1, ns2);

    free(ns1);
    free(ns2);

    printf("\nEl resultado: %s", res);

    free(res);
}

// Elimina los '0' de la izquierda.
void compactar(char *numero) {
    int i;

    // Busca el índice donde el número no tenga '0'
    for(i = 0; numero && numero[i] == '0'; ++i);

    // Copia al inicio de la cadena a partir de la posición con
    //   dígitos relevantes
    if(i) {
        memcpy(numero, numero + i, (strlen(numero) + 1 - i) * sizeof(char));
    }

    return numero;
}

char *sumar(char *n1, char *n2) {
    int n1_ind, n2_ind, res_ind, res_len;
    int digit_1, digit_2, digit_res;
    int carry = 0;
    char *res, *aux;

    compactar(n1);
    compactar(n2);

    // Índices apuntan al último carácter.
    n1_ind = strlen(n1) - 1;
    n2_ind = strlen(n2) - 1;

    // La longitud del resultado sera un carácter mas grande que el
    //   mayor numero, por si hay acarreo fina.l
    res_len = (n1_ind > n2_ind? n1_ind : n2_ind) + 2;

    // Se aloja la cadena resultado.
    res = malloc((res_len + 1) * sizeof(char));

    // Hacer la cadena imprimible.
    res[res_len] = '\0';

    // Índice apunta al ultimo carácter.
    res_ind = res_len - 1;

    // Suma los dos números desde el final hasta el principio. Si
    //   uno de ellos se queda demasido corto con el otro su
    //   dígito será 0.
    while(n1_ind >= 0 || n2_ind >= 0) {
        digit_1 = n1_ind >= 0? n1[n1_ind] - '0' : 0;
        digit_2 = n2_ind >= 0? n2[n2_ind] - '0' : 0;
        digit_res = digit_1 + digit_2 + carry;

        // Control del acarreo.
        if(digit_res > 9) {
            carry = 1;
            digit_res %= 10;
        } else {
            carry = 0;
        }

        // Posicionado del dígito resultado.
        res[res_ind] = digit_res + '0';

        // Actualización de los índices.
        --n1_ind;
        --n2_ind;
        --res_ind;
    }

    // El primer dígito del resultado es el valor de acarreo.
    res[res_ind] = carry + '0';

    compactar(res);


    return res;
}