主页 / 问题 / 1596669
Accepted
LolPopGames
Asked:2024-10-14 17:48:55 +0000 UTC2024-10-14 17:48:55 +0000 UTC

C 中的内存分配错误中止（核心转储）[关闭]

  • 772

我想制作一个 Base64 编码器和解码器。我们得到了 3 个文件：

  1. base64.c:
#include "base64.h"

// ------- hidden header
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <limits.h>
#include <stdlib.h>

typedef bool bin;
// -------

// ------- hidden logic
unsigned short power(unsigned short base, unsigned short exponent)
{
    if (exponent == 0)
        return 1;

    int out = base;
    for (int i=0; i<exponent-1; i++)
    {
        out *= base;
    }

    return out;
}

// place bits pointer to first bit
void decToBin(unsigned short dec, bin *bits, short bits_count)
{
    short i=bits_count;
    while (dec != 0)
    {
        i--;

        bits[i] = dec % 2;
        dec /= 2;
    }
}

// place bits pointer to first bit
unsigned short binToDec(bin *bits, short bits_count)
{
    unsigned short dec=0;

    for (short i=bits_count-1, j=0; i >= 0; i--, j++)
    {
        dec += bits[i] * power(2, j);
    }

    return dec;
}

unsigned short strfind(const char *str, char sub)
{
    char *str_pos = strchr(str, sub);
    return str_pos - str;
}
// -------

void b64_encode(const char *str, char *base64)
{
    // ------- part 0: preparation
    const size_t            BYTES_COUNT = strlen(str),
                            BITS_COUNT = BYTES_COUNT * 8,
                            BASE_BYTES_COUNT = BITS_COUNT / 6;
    const unsigned short BASE_BYTES_MOD_COUNT = 6 - BITS_COUNT % 6;

    bin *bits = calloc(BITS_COUNT, sizeof(bin));
    if (bits == NULL)
    {
        printf("Failed memory allocation\n");
        return;
    }

    // ------- part 1: converting bytes to bits
    for (size_t i=0, j=0; i<BYTES_COUNT; i++, j+=8)
    {
        decToBin(str[i], &bits[j], 8);
    }

    // ------- part 2: dividing bits to base-bytes & encoding to base64
    size_t i=0, j=0;
    for (; j<BASE_BYTES_COUNT; i+=6, j++)
    {
        const unsigned short dec = binToDec(&bits[i], 6);
        base64[j] = BASE64_ALPHABET[dec];
    }

    if (BASE_BYTES_MOD_COUNT == 6)
    {
        free(bits);
        return;
    }

    // ------- part X: encoding mod bits to base64
    bin mod_base_byte[6] = {};

    for (unsigned short k=0; k< BASE_BYTES_MOD_COUNT/2; k++, i++)
        mod_base_byte[k] = bits[i];

    unsigned short dec = binToDec(&mod_base_byte[0], 6);
    base64[j] = BASE64_ALPHABET[dec];

    j++;
    for (unsigned short k=0; k< BASE_BYTES_MOD_COUNT/2; k++, j++)
    {
        base64[j] = '=';
    }

    free(bits);
}

void b64_decode(const char *base64, char *str)
{
    // ------- part 0: preparation
    const size_t            BASE64_LEN = strlen(base64);
    unsigned short          BASE64_MOD_COUNT = 6;
    if (base64[BASE64_LEN-1] == '=') BASE64_MOD_COUNT -= 2;
    if (base64[BASE64_LEN-2] == '=') BASE64_MOD_COUNT -= 2;
    if (BASE64_MOD_COUNT == 6)       BASE64_MOD_COUNT  = 0;

    const size_t BASE64_LEN_NO_MOD = BASE64_LEN - (6-BASE64_MOD_COUNT)/2,
                    BITS_COUNT = BASE64_LEN_NO_MOD * 6 - (6-BASE64_MOD_COUNT),
                    BYTES_COUNT = BITS_COUNT / 8;

    bin *bits = calloc(BITS_COUNT, sizeof(bin));
    if (bits == NULL)
    {
        printf("Failed memory allocation\n");
        return;
    }

    // ------- part 1: decoding base64 to bits
    for (size_t i=0, j=0; i<BASE64_LEN_NO_MOD; i++, j+=6)
    {
        unsigned short dec = strfind(BASE64_ALPHABET, base64[i]);
        if ((j > BITS_COUNT) && (BASE64_MOD_COUNT == 2))
        {
            decToBin(
                dec & 0b110000,
                &bits[j-4],
                2
            );
            continue;
        }

        else if ((j > BITS_COUNT) && (BASE64_MOD_COUNT == 4))
        {
            decToBin(
                dec & 0b111100,
                &bits[j-2],
                4
            );
            continue;
        }

        decToBin(dec, &bits[j], 6);
    }

    // ------- part 2: dividing bits to bytes
    for (size_t i=0, j=0; i<BYTES_COUNT; i++, j+=8)
    {
        str[i] = (char) binToDec(&bits[j], 8);
    }

    free(bits);
}
  1. base64.h:
#ifndef BASE64_H_
#define BASE64_H_

#define BASE64_ALPHABET "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

void b64_encode(const char *str, char *base64);
void b64_decode(const char *base64, char *str);

#endif
  1. test.c:
#include <stdio.h>
#include "base64.h"

int main()
{
    char str[14] = "Hello, World!";
    char base64[100] = "";
    char str_out[14] = "";
    b64_encode(str, base64);
    printf("%s\n", base64);
    b64_decode(base64, str_out);
    printf("%s\n", str_out);

    char str2[14] = "Man";
    char base64_2[100] = "";
    char str2_out[14] = "";
    b64_encode(str2, base64_2);
    printf("%s\n", base64_2);
    b64_decode(base64_2, str2_out);
    printf("%s\n", str2_out);

    return 0;
}

运行时显示两个printf，并出现两行错误：

SGVsbG8sIFdvcmxkIQ==
Hello, World!
base64: malloc.c:2617: sysmalloc: Assertion `(old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)' failed.
Aborted (core dumped)

通过其他打印，我发现问题出在该行中的b64_encode ：

bin *bits = calloc(BITS_COUNT, sizeof(bin));

有趣的是，第一个函数调用工作正常，但第二个函数调用创建了一个错误而不返回 NULL（它只是创建了一个严重错误）。

我试图了解发生了什么，但无法通过调试来做到这一点。

谁知道问题出在哪里？

添加。信息

  1. 在Linux上编程
  2. 使用以下命令编译并启动：
#   ↓ Получилось без предупреждений
gcc -Wall base64.c test.c -o base64
./base64
  1. Base64 的工作原理
c

2 个回答

  1. 让我们看看你的：

    void decToBin(unsigned short dec, bin *bits, short bits_count)
{
    short i=bits_count;
    ...
    bits[i] = dec % 2;
    ...

    对于她的挑战：

    for (size_t i=0, j=0; i<BYTES_COUNT; i++, j+=8)
{
    decToBin(str[i], &bits[j], 8);
    ...

    为了防止超出数组的限制，您需要j+8less BITS_COUNT。

    我们添加：

    for (size_t i=0, j=0; i<BYTES_COUNT; i++, j+=8)
{
    assert(j+8 < BITS_COUNT);
    decToBin(str[i], &bits[j], 8);
}

    我们得到：

    断言失败：j+8 < BITS_COUNT

    这够了吗？

    我不太明白你是怎么想的——这很奇怪……而且感觉是你认为bool这是一点，而不是unsigned char……但我不明白这一点，所以我不坚持。但我至少在一个地方向你展示了离开阵列的方法......

    • 1
  2. Best Answer

    谢谢你，@user207200！

    最初我以为问题出在enocder上，但是评论中告诉我问题出在解码器decToBin(dec, &bits[j], 6);上。

    这是最重要的事情。我尝试注释掉解码器，并且代码运行没有错误。

    从同一条评论中，我意识到在初始化BITS_COUNT中，您应该简单地 将BASE64_LEN_NO_MOD乘以6。

    我还重命名了解码器中的几乎所有变量，以使代码至少更漂亮一些。

    这是解决我的问题的最终代码：

    1. base64.c:
    #include "base64.h"

// ------- hidden header
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <limits.h>
#include <stdlib.h>
#include <assert.h>

typedef bool bin;
// -------

// ------- hidden logic
unsigned short power(unsigned short base, unsigned short exponent)
{
    if (exponent == 0)
        return 1;

    int out = base;
    for (int i=0; i<exponent-1; i++)
    {
        out *= base;
    }

    return out;
}

// place bits pointer to first bit
void decToBin(unsigned short dec, bin *bits, short bits_count)
{
    short i=bits_count;
    while (dec != 0)
    {
        i--;

        bits[i] = dec % 2;
        dec /= 2;
    }
}

// place bits pointer to first bit
unsigned short binToDec(bin *bits, short bits_count)
{
    unsigned short dec=0;

    for (short i=bits_count-1, j=0; i >= 0; i--, j++)
    {
        dec += bits[i] * power(2, j);
    }

    return dec;
}

unsigned short strfind(const char *str, char sub)
{
    char *str_pos = strchr(str, sub);
    if (str_pos == NULL)
        return -1;
    return str_pos - str;
}
// -------

void b64_encode(const char *str, char *base64)
{
    // ------- part 0: preparation
    const size_t            BYTES_COUNT = strlen(str),
                            BITS_COUNT = BYTES_COUNT * 8,
                            BASE_BYTES_COUNT = BITS_COUNT / 6;
    const unsigned short BASE_BYTES_MOD_COUNT = 6 - BITS_COUNT % 6;

    bin *bits = calloc(BITS_COUNT, sizeof(bin));
    if (bits == NULL)
    {
        printf("Failed memory allocation\n");
        return;
    }

    // ------- part 1: converting bytes to bits
    for (size_t i=0, j=0; i<BYTES_COUNT; i++, j+=8)
    {
        assert(j+7<BITS_COUNT);
        decToBin(str[i], &bits[j], 8);
    }

    // ------- part 2: dividing bits to base-bytes & encoding to base64
    size_t i=0, j=0;
    for (; j<BASE_BYTES_COUNT; i+=6, j++)
    {
        const unsigned short dec = binToDec(&bits[i], 6);
        base64[j] = BASE64_ALPHABET[dec];
    }
    if (BASE_BYTES_MOD_COUNT == 6)
    {
        free(bits);
        return;
    }

    // ------- part X: encoding mod bits to base64
    bin mod_base_byte[6] = {};

    for (unsigned short k=0; k< BASE_BYTES_MOD_COUNT/2; k++, i++)
        mod_base_byte[k] = bits[i];

    unsigned short dec = binToDec(&mod_base_byte[0], 6);
    base64[j] = BASE64_ALPHABET[dec];

    j++;
    for (unsigned short k=0; k< BASE_BYTES_MOD_COUNT/2; k++, j++)
    {
        base64[j] = '=';
    }

    free(bits);
}

void b64_decode(const char *base64, char *str)
{
    // ------- part 0: preparation
    const size_t            B64_LEN = strlen(base64);
    unsigned short          B64_MOD_LEN = 6,
                            B64_EQUALS_COUNT = 0;
    if (base64[B64_LEN-1] == '=') {B64_MOD_LEN -= 2; B64_EQUALS_COUNT++;}
    if (base64[B64_LEN-2] == '=') {B64_MOD_LEN -= 2; B64_EQUALS_COUNT++;}
    if (B64_MOD_LEN == 6)          B64_MOD_LEN  = 0;

    const size_t B64_NO_MOD_LEN = B64_LEN - B64_EQUALS_COUNT,
                 BITS_COUNT = B64_NO_MOD_LEN * 6,
                 BYTES_COUNT = BITS_COUNT / 8;

    bin *bits = calloc(BITS_COUNT, sizeof(bin));
    if (bits == NULL)
    {
        printf("Failed memory allocation\n");
        return;
    }

    // ------- part 1: decoding base64 to bits
    for (size_t i=0, j=0; i<B64_NO_MOD_LEN; i++, j+=6) {
        unsigned short dec = strfind(BASE64_ALPHABET, base64[i]);
        if ((j > BITS_COUNT) && (B64_MOD_LEN == 2))
        {
            decToBin(
                dec & 0b110000,
                &bits[j-4],
                2
            );
            continue;
        }
        else if ((j > BITS_COUNT) && (B64_MOD_LEN == 4))
        {
            decToBin(
                dec & 0b111100,
                &bits[j-2],
                4
            );
            continue;
        }

        decToBin(dec, &bits[j], 6);
    }

    // ------- part 2: dividing bits to bytes
    for (size_t i=0, j=0; i<BYTES_COUNT; i++, j+=8)
    {
        str[i] = (char) binToDec(&bits[j], 8);
    }

    free(bits);
}
    1. base64.h:
    #ifndef BASE64_H_
#define BASE64_H_

#define BASE64_ALPHABET "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

void b64_encode(const char *str, char *base64);
void b64_decode(const char *base64, char *str);

#endif
    1. test.c:
    #include <stdio.h>
#include "base64.h"

int main()
{
    char str[14] = "Hello, World!";
    char base64[100] = "";
    char str_out[14] = "";
    b64_encode(str, base64);
    printf("%s\n", base64);
    b64_decode(base64, str_out);
    printf("%s\n", str_out);

    char str2[14] = "Man";
    char base64_2[100] = "";
    char str2_out[14] = "";
    b64_encode(str2, base64_2);
    printf("%s\n", base64_2);
    b64_decode(base64_2, str2_out);
    printf("%s\n", str2_out);

    return 0;
}
    • 0

相关问题