как работать с памятью там в каком формате хранится mtdinfot mtdinfo; int keylen = 0;…
- 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); // дальнейший код }
- 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.
- User
не я вот выделил буфер размером mtd, так вот там долждно быть unsigned char или char
- 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— правильный выбор. -
- 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; } } } - Assistant
В вашей ситуации у вас данные инсайда (
read_bufиdata) — это бинарный буффер, прочитанный какunsigned char*, а в целевой структуре (struct crypted_keychan) поля — массивыchar.
Основная проблема:
- Вы используете
unsigned char*для чтения и хранения сырых байт. - А потом копируете эти данные в поля структуры, которые объявлены как
char[]. - При этом
charна большинстве платформ — это знаковый тип, но это обычно не мешает хранить бинарные данные. - В
memcpyбайты копируются "как есть", знаковость здесь не важна.
Ваш вопрос: как совместить?
Решение:
-
Читать из MTD в
unsigned char*— это правильно, чтобы избежать проблем со знаковостью. -
В структуре оставьте поля как
char[], это норма, двоичные данные можно хранить и вchar[]. -
Для копирования используйте
memcpy, это безопасно и не зависит от знаковости. -
Если нужно работать с этими полями как с байтами — используйте каст
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*)при обращении. - Вы используете
- User
только я не понял что будет в итоге.. из памяти копируется 254 потом memcpy переносится в char - и что там??
- Assistant
Давайте разберём подробнее, что происходит при копировании бинарных данных из буфера типа
unsigned char*в массивы типаchar[].
1. Что именно хранят
unsigned charиchar?unsigned char— целое число 0..255 (8 бит без знака).char— 8-битный тип данных, может быть или знаковым, или беззнаковым в зависимости от компилятора и платформы.- Например, на большинстве x86-систем
char=signed charпо умолчанию. - Тогда диапазон значений -128..127.
- Например, на большинстве x86-систем
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. - Если будете использовать эти данные в крипто/шифровальных алгоритмах — просто работайте с байтами, а знаковость не имеет значения.
Если нужна помощь с конкретным примером — могу помочь написать код с выводом байтов для проверки.
- 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) {
- 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), то без такого "использования" параметра код не скомпилируется. - 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);
- 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) вы получите строку без завершающего нуля — это и вызывает предупреждение и потенциально ошибки. - Если