Bonjour à toutes et à tous.

Voici mon problème, je veux incorporer du code dans mon application et pour cela je le convertis en base64.
Pour ce faire, je lis caractère par caractère puis je mets le tout dans un char*, sauf qu'avant j'utilisais une bibliothèque qui s'occuper du "buffer" et donc de l'ajout de caractère mais comme je veux être indépendant de cette bibliothèque, j'ai développé ma propre fonction.
C'est là que des problèmes (allocation mémoire ?) sont apparus...

Voici un exemple "tout bête", si je veux convertir:
c'est un test ! <- ça fonctionne
qu'en pensez-vous ? <- ça ne fonctionne pas
qu'en pensez-vous <- ça fonctionne
c'est un test <- ça ne fonctionne pas

Auriez-vous une idée ?
Ps: désolé pour le titre je n'ai pas trouvé mieux !

main.c
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>
#include "base64.h"
 
// Compilation: gcc -std=gnu99 main.c -o b64 -lm
 
int main(int argc, char *files[])
{
    size_t size_out;
    char* tmp_code = NULL;
    tmp_code = malloc(1); // Correcte ?
    strcpy (tmp_code, "");
    for (int i = 1; files[i]; i++)
    {
        printf("Ouverture du fichier: %s\n", files[i]);
        FILE *file;
        int c;
        if((file = fopen(files[i], "r")) != NULL)
        {
            c = fgetc(file);
            while (c != EOF)
            {
                /* Ma fonction qui pose problème ??? */
                char* test = malloc(1);
                sprintf(test, "%c", (char)c);
                tmp_code = realloc(tmp_code, strlen(tmp_code) + strlen(test) + 1);
                strcat (tmp_code, test);
                free(test);
                /*                                    */
		c = fgetc(file);
            }
            fclose(file);
        } else {
            printf("Impossible d'ouvrir le fichier: %s !\n", files[i]);
        }
    }
    printf("Le texte est:\n%s\n", tmp_code);
    char* encoded = base64_encode(tmp_code, &size_out);
    free(tmp_code);
    if (encoded == NULL)
    {
        printf("Impossible d'encoder !\n");
    } else {
        printf("Codage:\n%s\n", encoded);
        char* decoded = base64_decode(encoded, &size_out);
        printf("Decodage:\n%s\n", decoded);
        free(encoded);
        free(decoded);
    }
}
base64.h
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
                                'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
                                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
                                'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
                                'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
                                'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
                                'w', 'x', 'y', 'z', '0', '1', '2', '3',
                                '4', '5', '6', '7', '8', '9', '+', '/'};
 
static char *decoding_table = NULL;
static int mod_table[] = {0, 2, 1};
 
static void build_decoding_table()
{
    decoding_table = malloc(256);
    for (int i = 0; i < 0x40; i++)
    {
        decoding_table[encoding_table[i]] = i;
    }
}
 
static char *base64_encode(const char *data, size_t *output_length)
{
    size_t input_length = strlen(data);
    *output_length = (size_t) (4.0 * ceil((double) input_length / 3.0));
    char *encoded_data = malloc(*output_length);
    if (encoded_data == NULL)
    {
        return NULL;
    }
    for (int i = 0, j = 0; i < input_length;)
    {
 
        uint32_t octet_a = i < input_length ? data[i++] : 0;
        uint32_t octet_b = i < input_length ? data[i++] : 0;
        uint32_t octet_c = i < input_length ? data[i++] : 0;
        uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
        encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
        encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
        encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
        encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
    }
    for (int i = 0; i < mod_table[input_length % 3]; i++)
    {
        encoded_data[*output_length - 1 - i] = '=';
    }
    return encoded_data;
}
 
static char *base64_decode(const char *data, size_t *output_length)
{
    size_t input_length = strlen(data);
    if (decoding_table == NULL)
    {
        build_decoding_table();
    }
    if (input_length % 4 != 0)
    {
        return NULL;
    }
    *output_length = input_length / 4 * 3;
    if (data[input_length - 1] == '=')
    {
        (*output_length)--;
    }
    if (data[input_length - 2] == '=')
    {
        (*output_length)--;
    }
    char *decoded_data = malloc(*output_length);
    if (decoded_data == NULL)
    {
        return NULL;
    }
    for (int i = 0, j = 0; i < input_length;)
    {
        uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t triple = (sextet_a << 3 * 6) + (sextet_b << 2 * 6) + (sextet_c << 1 * 6) + (sextet_d << 0 * 6);
        if (j < *output_length)
        {
            decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
            decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
            decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
        }
    }
    return decoded_data;
}
Merci d'avance pour vos réponses.
Cordialement,
Nicolas.