Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

как работать с памятью там в каком формате хранится mtdinfot mtdinfo; int keylen = 0;…

  1. User

    как работать с памятью там в каком формате хранится mtd_info_t mtd_info; int key_len = 0; int fd = open("/dev/mtd0", O_RDONLY); if (fd > 0) { ioctl(fd, MEMGETINFO, &mtd_info);

    int mtd_len = (int)mtd_info.size; printf("mtd_len %d\r\n",mtd_len); lseek(fd, 0, SEEK_SET);

    char *read_buf = calloc(mtd_len, SIZE_CHAR); int len_read = read(fd, read_buf, mtd_len); // дальнейший код }

  2. Assistant

    Вы спрашиваете, как работать с памятью типа MTD (Memory Technology Device) в Linux, а также в каком формате хранится информация.

    MTD — это абстракция для работы с флеш-памятью (NOR, NAND и пр.) в Linux. Устройство /dev/mtdX предоставляет интерфейс низкого уровня для работы с этой флеш-памятью.


    Кратко по вашему коду и последующей работе с памятью:

    mtd_info_t mtd_info;
    int fd = open("/dev/mtd0", O_RDONLY);
    if (fd > 0) {
        ioctl(fd, MEMGETINFO, &mtd_info); // Получаем информацию о памяти
    
        int mtd_len = (int)mtd_info.size; // Размер всего MTD
        printf("mtd_len %d\r\n", mtd_len);
    
        lseek(fd, 0, SEEK_SET);
    
        char *read_buf = calloc(mtd_len, sizeof(char)); // Буфер для чтения всей памяти
        int len_read = read(fd, read_buf, mtd_len);    // Чтение содержимого
    
        // Здесь можно работать с полученными данными
        // После завершения:
        free(read_buf);
        close(fd);
    }
    

    1. В каком формате хранится память MTD?

    • MTD — это "сырая" флеш-память.
    • На устройстве /dev/mtdX хранится образ, разделенный на сектора (erase blocks).
    • Формат (содержимое) определяется тем, что записано в эту память:
      • Это может быть raw-файловая система (например, JFFS2, UBIFS).
      • Или кастомные данные (конфигурации, загрузчики, образы, бинарные данные и т.д.).

    Важно: без знания, что именно записано, прочитанный массив байт — это "сырые" данные.


    2. Особенности работы с MTD:

    • Чтение и запись: обычно работают только крупными блоками (erase blocks), минимальным выравниванием.
    • Erase (стирание): нельзя записать поверх данных без предварительного стирания сектора.
    • Ошибки ECC: NAND-память может требовать дополнительной обработки (ECC — коррекция ошибок), которая часто реализована драйвером.

    3. Пример формата и дальнейшей работы:

    Если в MTD хранится, например, файловая система (JFFS2 или UBIFS), то:

    • Прочитанные данные — это бинарный образ, который нужно монтировать через соответствующий драйвер (или использовать с tools типа ubinize, flash_erase, flashcp).
    • Для анализа можно использовать специальные инструменты (например, binwalk для поиска файловых систем в бинарном образе).

    Если же MTD используется для хранения собственного формата:

    • Нужно знать структуру данных (например, заголовки, оффсеты).
    • Тогда после чтения массива байт можно произвести парсинг вручную.

    4. Рекомендации при работе с MTD

    • Используйте стандартные ioctl для получения информации и управления памятью:
      • MEMGETINFO — получение информации о размере, erase block size и пр.
      • MEMERASE — стирание блоков перед записью (требуется для флеш).
    • Для записи используйте открытие с флагом O_SYNC и посекторное выравнивание.
    • Всегда проверяйте и обрабатывайте ошибки чтения/записи и стирания.
    • Имеет смысл использовать библиотеку mtdutils (ubuntu, openwrt) для упрощения.

    Пример расширенного кода для стирания и записи:

    #include <mtd/mtd-user.h>
    
    int erase_mtd(int fd, struct erase_info_user erase) {
        if(ioctl(fd, MEMERASE, &erase) != 0) {
            perror("erase error");
            return -1;
        }
        return 0;
    }
    
    int main() {
        int fd = open("/dev/mtd0", O_SYNC | O_RDWR);
        if (fd < 0) {
            perror("open");
            return -1;
        }
    
        mtd_info_t mtd_info;
        if(ioctl(fd, MEMGETINFO, &mtd_info) != 0) {
            perror("ioctl MEMGETINFO");
            close(fd);
            return -1;
        }
    
        printf("MTD size: %u bytes\n", mtd_info.size);
        printf("Erase block size: %u bytes\n", mtd_info.erasesize);
    
        // Пример стирания первого сектора
        struct erase_info_user erase;
        erase.start = 0;
        erase.length = mtd_info.erasesize;
    
        if(erase_mtd(fd, erase) != 0) {
            close(fd);
            return -1;
        }
    
        // Запись и чтение
    
        close(fd);
        return 0;
    }
    

    Итог

    • MTD — это интерфейс для работы с флеш-памятью, хранящейся в формате raw.
    • Нужно использовать специальные ioctl для управления (стирания, получение инфо).
    • Формат самих данных зависит от специфики устройства — файловые системы, загрузчики, данные и пр.
    • Перед записью блоки надо стирать.
    • Для чтения можно просто прочитать нужный диапазон, но интерпретировать данные нужно согласно их формату.

    Если нужно детальнее помочь с обработкой или форматами, укажите, что конкретно хранится в MTD.

  3. User

    не я вот выделил буфер размером mtd, так вот там долждно быть unsigned char или char

  4. Assistant

    В вашем случае:

    char *read_buf = calloc(mtd_len, sizeof(char));
    

    или

    unsigned char *read_buf = calloc(mtd_len, sizeof(unsigned char));
    

    Что лучше выбрать — char или unsigned char?

    • unsigned char обычно используется, когда вы работаете с «сырыми» данными, байтовыми потоками, бинарными буферами, особенно с низкоуровневой памятью и устройствами, чтобы избежать проблем с знаковостью.

    • char по стандарту языка C — это либо signed, либо unsigned (зависит от платформы и компилятора), но часто считается знаковым типом (signed char).


    Ваша ситуация:

    Поскольку вы читаете из флеш-памяти (MTD) бинарные данные, лучше использовать unsigned char.

    Причины:

    • unsigned char гарантирует, что все байты интерпретируются как значения от 0 до 255.
    • Использование char (знакового) может привести к проблемам при проверке значений и обработке байтов с самым старшим битом (например, негативные значения).
    • С unsigned char проще делать побитовые операции и сравнения.

    Как исправить:

    unsigned char *read_buf = calloc(mtd_len, sizeof(unsigned char));
    int len_read = read(fd, read_buf, mtd_len);
    

    И далее работать с read_buf как с массивом байтов.


    Резюме:

    • Для буфера, который содержит сырые данные из памяти/устройства — лучше unsigned char.
    • Если задача — работать с текстом, тогда подходит char.
    • Для защищённой и предсказуемой обработки бинарных данных всегда отлично подходит unsigned char.

    Если ваш код требует работать с байтами, то unsigned char — правильный выбор.

  5. User

    как тогда решить, мне в структуре надо char struct crypted_keychan { int timer_work; char iv[17]; char sha[129]; char key[33]; char hash[257]; char *encrypt; };

    mtd_info_t mtd_info;
    int key_len = 0;
    int fd = open("/dev/mtd0", O_RDONLY);
    if (fd > 0) {
        ioctl(fd, MEMGETINFO, &mtd_info);
    
        int mtd_len = (int)mtd_info.size;
        printf("mtd_len %d\r\n",mtd_len);
        lseek(fd, 0, SEEK_SET);
    
        unsigned char *read_buf = calloc(mtd_len, SIZE_CHAR);
    
        int len_read = read(fd, read_buf, mtd_len);
    
        unsigned char *data = calloc(len_read + 1, SIZE_CHAR);
        
        if (len_read >= 1) {
            int i;
            int j = 0;
    
            for (i = 0; i < 1024; i++) {
                if (read_buf[i] == 255) {
                    break;
                }
                data[j] = read_buf[i];
                j++;
            }
            if (j > 0) {
    
                len_read = j;
    
                int len = 128;
                memcpy(CRYPTED->sha, data, len);
                memcpy(CRYPTED->key, data + len, 32);
                len += 32;
                memcpy(CRYPTED->iv, data + len, 16);
                len += 16;
                memcpy(CRYPTED->hash, data + len, 256);
                len += 256;
    
            }
        }
    }
    
  6. Assistant

    В вашей ситуации у вас данные инсайда (read_buf и data) — это бинарный буффер, прочитанный как unsigned char*, а в целевой структуре (struct crypted_keychan) поля — массивы char.


    Основная проблема:

    • Вы используете unsigned char* для чтения и хранения сырых байт.
    • А потом копируете эти данные в поля структуры, которые объявлены как char[].
    • При этом char на большинстве платформ — это знаковый тип, но это обычно не мешает хранить бинарные данные.
    • В memcpy байты копируются "как есть", знаковость здесь не важна.

    Ваш вопрос: как совместить?


    Решение:

    1. Читать из MTD в unsigned char* — это правильно, чтобы избежать проблем со знаковостью.

    2. В структуре оставьте поля как char[], это норма, двоичные данные можно хранить и в char[].

    3. Для копирования используйте memcpy, это безопасно и не зависит от знаковости.

    4. Если нужно работать с этими полями как с байтами — используйте каст unsigned char* при доступе.


    Пример исправленного кода для копирования:

    memcpy(CRYPTED->sha, data, 128);
    memcpy(CRYPTED->key, data + 128, 32);
    memcpy(CRYPTED->iv, data + 160, 16);
    memcpy(CRYPTED->hash, data + 176, 256);
    

    Дополнительно:

    • Убедитесь, что CRYPTED — указатель на struct crypted_keychan, выделенный заранее.

    • Не забудьте про терминаторы в строках, если поле — строка с символами. В вашем случае, например:

      CRYPTED->iv[16] = '\0';
      CRYPTED->sha[128] = '\0';
      CRYPTED->key[32] = '\0';
      CRYPTED->hash[256] = '\0';
      

      — если вы собираетесь трактовать эти поля как C-строки.

    • Если поля — это именно бинарные данные (не строки с окончанием '\0'), то терминатор не нужен и поля должны быть именно такого размера.


    Кратко:

    • Читайте как unsigned char*.
    • Копируйте в char[] через memcpy.
    • В памяти они совпадают по байтам.
    • Не нужно менять типы в структуре ради совместимости.

    Итог

    unsigned char *read_buf = calloc(mtd_len, sizeof(unsigned char));
    int len_read = read(fd, read_buf, mtd_len);
    unsigned char *data = calloc(len_read + 1, sizeof(unsigned char));
    
    if (len_read >= 1) {
        int j = 0;
        for (int i = 0; i < 1024; i++) {
            if (read_buf[i] == 255) break;
            data[j++] = read_buf[i];
        }
    
        if (j > 0) {
            len_read = j;
            memcpy(CRYPTED->sha, data, 128);
            memcpy(CRYPTED->key, data + 128, 32);
            memcpy(CRYPTED->iv, data + 160, 16);
            memcpy(CRYPTED->hash, data + 176, 256);
            // При необходимости добавить нулевой терминатор:
            // CRYPTED->sha[128] = '\0';
            // CRYPTED->key[32] = '\0';
            // CRYPTED->iv[16] = '\0';
            // CRYPTED->hash[256] = '\0';
        }
    }
    

    Безопасно и стандартизировано.


    Если в дальнейшем понадобятся операции как со строками, просто приведите соответствующие поля к (unsigned char*) или (char*) при обращении.

  7. User

    только я не понял что будет в итоге.. из памяти копируется 254 потом memcpy переносится в char - и что там??

  8. Assistant

    Давайте разберём подробнее, что происходит при копировании бинарных данных из буфера типа unsigned char* в массивы типа char[].


    1. Что именно хранят unsigned char и char?

    • unsigned char — целое число 0..255 (8 бит без знака).
    • char — 8-битный тип данных, может быть или знаковым, или беззнаковым в зависимости от компилятора и платформы.
      • Например, на большинстве x86-систем char = signed char по умолчанию.
      • Тогда диапазон значений -128..127.

    2. Что происходит при memcpy?

    memcpy просто копирует последовательность байт в память, не смотря ни на какие типы, знаки, интерпретации.

    • Если у вас байт с числом 254 (0xFE) в unsigned char, он посимвольно, побитово скопируется в соответствующий элемент массива типа char.
    • В памяти байт станет 0xFE.
    • Внутреннее представление в памяти не поменяется.

    3. Что значит это с точки зрения интерпретации?

    • Если потом вы обратитесь к этому элементу как к char, и char знаковый:
      • Значение будет интерпретироваться как -2 (т.е. 254 как знаковое число —128–127 => 254 - 256 = -2).
    • Но если вы рассматриваете эти данные как бинарные, то знаковость значения не важна, вы работаете с байтами, а не с числами.

    4. Итог: «Что будет в char после memcpy?»

    • Побитовое представление байт будет абсолютно идентичным.
    • В памяти хранится тот же самый байт (например, 0xFE).
    • При работе с этими байтами вам нужно просто помнить, что при чтении как char может происходить интерпретация знака, но это никак не влияет на содержимое.
    • Если обработка идёт побайтно (сравнения, копирования, шифрование), то знаковость не важна.

    5. Когда нужна явная конверсия?

    • Если вы хотите вывести байты как числа 0..255, используйте приведение в unsigned char для вывода.

    Например:

    char c = read_buf[i];
    printf("%d ", (unsigned char)c);
    

    6. Резюме

    СтадияЧто происходит
    Чтение в unsigned char*Байты с 0..255 сохраняются без изменений
    Копирование в char[]Байты копируются побитово, содержимое не меняется
    Обращение к элементу как charЕсли char знаковый, значения могут быть интерпретированы как отрицательные при преобразовании в int, но в памяти байт тот же
    Работа с бинарными даннымиЗнаковость не важна, поскольку вы манипулируете байтами

    Практический совет:

    • Если храните бинарные данные в char[] — это нормально и безопасно.
    • Если будете их выводить как числа, явно приводите к unsigned char чтобы увидеть 0..255.
    • Если будете использовать эти данные в крипто/шифровальных алгоритмах — просто работайте с байтами, а знаковость не имеет значения.

    Если нужна помощь с конкретным примером — могу помочь написать код с выводом байтов для проверки.

  9. User

    смотри есть такая штука - ЗАГЛУШКА typedef void (*callback_webhook) (struct struct_app_core *core); void _wh_webhook_none_used(struct struct_app_core *core) {

    return ; }

    но In function ‘_wh_webhook_none_used’: src/apps/workers/webhook.c:44:47: error: unused parameter ‘core’ [-Werror=unused-parameter] _wh_webhook_none_used(struct struct_app_core *core) {

  10. Assistant

    Ошибка возникает из-за того, что параметр core у функции _wh_webhook_none_used не используется внутри функции, а компилятор с ключом -Werror=unused-parameter превращает предупреждение об "неиспользуемом параметре" в ошибку.

    То есть:

    void _wh_webhook_none_used(struct struct_app_core *core) {
      return;
    }
    

    — здесь core не используется, поэтому компилятор ругается.


    Как исправить?

    Есть несколько распространенных способов:


    Вариант 1: Явно "пользоваться" параметром, чтобы убрать предупреждение

    В теле функции добавьте это:

    (void)core;
    

    Это "псевдоиспользование" параметра — говорит компилятору, что параметр намеренно не используется.


    Полный пример:

    void _wh_webhook_none_used(struct struct_app_core *core) {
        (void)core;
        return;
    }
    

    Вариант 2: Убрать имя параметра в объявлении, если не нужен

    Если объявление параметра можно изменить, то так:

    void _wh_webhook_none_used(struct struct_app_core * /*core*/) {
        return;
    }
    

    Т.е. параметр есть, но имя не указывается, это тормозит предупрждения.


    Вариант 3: Использовать атрибут компилятора (GCC)

    Можно пометить параметр как «unused»:

    void _wh_webhook_none_used(struct struct_app_core *core __attribute__((unused))) {
        return;
    }
    

    Резюме

    Самый простой и часто используемый способ — вариант 1: (void)core; в теле функции.


    Если промежуточный warning превращается в ошибку (-Werror), то без такого "использования" параметра код не скомпилируется.

  11. User

    size_t len = strlen(URI_copy + i); //64 size_t n = (len < 254) ? len : 254;

    strncpy(path, URI_copy + i, n);
    

    error: ‘strncpy’ specified bound depends on the length of the source argument [-Werror=stringop-truncation] 687 | strncpy(path, URI_copy + i, n);

  12. Assistant

    Ошибка gcc stringop-truncation с -Werror появляется, когда strncpy вызывается с длиной копирования, которая меньше длины строки источника, и потенциально может привести к усечению (truncation) без гарантии нулевого терминатора.


    Ваша ситуация

    size_t len = strlen(URI_copy + i); // допустим, len = 64
    size_t n = (len < 254) ? len : 254;
    
    strncpy(path, URI_copy + i, n);
    
    • Если len < 254, то копируется вся строка длиной len, без проблем.
    • Если len >= 254, копируется ровно 254 байта (т.е. строка усекается — не копируется завершающий нулевой символ \0).

    Поэтому компилятор (gcc) предупреждает, что strncpy может скопировать строку без завершающего нуля, что — потенциально ошибка.


    В чём проблема?

    strncpy не гарантирует, что результат всегда будет нуль-терминирован, если длина копирования равна или меньше длине исходной строки. Если строка усечена, то path не будет иметь нуль-терминатора, что может привести к ошибкам при последующем использовании path.


    Как исправить?

    Вариант 1: Сделать явным, что path имеет размер минимум n + 1 и вручную добавить нулевой символ

    size_t len = strlen(URI_copy + i);
    size_t n = (len < 254) ? len : 254;
    
    strncpy(path, URI_copy + i, n);
    path[n] = '\0'; // обязательно, чтобы гарантировать нуль-терминатор
    

    Важно: path должен быть выделен минимум на n+1 байт!


    Вариант 2: Использовать memcpy + ручное добавление терминатора, если уверены в длине

    Если уверены, что path — массив нужного размера:

    memcpy(path, URI_copy + i, n);
    path[n] = '\0';
    

    Вариант 3: Использовать strlcpy (если доступна)

    strlcpy копирует строку с гарантией нулевого терминатора и ограничением.

    strlcpy(path, URI_copy + i, sizeof(path));
    

    Но в Linux strlcpy может отсутствовать, её надо реализовать или взять из BSD.


    Почему не стоит использовать просто strncpy без фикса?

    strncpy предназначена для копирования фиксированного количества байт, и если копируемая строка длиннее, она просто не ставит \0, что часто вызывает баги.


    Итог - простой безопасный код:

    size_t len = strlen(URI_copy + i);
    size_t n = (len < 254) ? len : 254;
    
    strncpy(path, URI_copy + i, n);
    path[n] = '\0'; // гарантируем, что path строка!   
    

    Пример определения path:

    char path[255]; // 254 + 1 для нулевого терминатора
    

    Если вы не добавите path[n] = '\0', то при усечении строки (len >= 254) вы получите строку без завершающего нуля — это и вызывает предупреждение и потенциально ошибки.