780 lines
19 KiB
C
780 lines
19 KiB
C
//
|
||
// Created by cfif on 30.01.23.
|
||
//
|
||
#include "fs_base_func.h"
|
||
#include "stdlib.h"
|
||
#include "httpd_types.h"
|
||
#include "GonetsCrcs.h"
|
||
|
||
|
||
unsigned char crc8(unsigned char *pcBlock, unsigned char len) {
|
||
unsigned char crc = 0xFF;
|
||
unsigned char i;
|
||
|
||
while (len--) {
|
||
crc ^= *pcBlock++;
|
||
|
||
for (i = 0; i < 8; i++)
|
||
crc = crc & 0x80 ? (crc << 1) ^ 0x31 : crc << 1;
|
||
}
|
||
|
||
return crc;
|
||
}
|
||
|
||
//CRC
|
||
#define POLYNOMIAL 0x131 //P(x)=x^8+x^5+x^4+1 = 100110001
|
||
|
||
//============================================================
|
||
uint8_t SF04_CheckCrc(const uint8_t data[], uint8_t nbrOfBytes)
|
||
//============================================================
|
||
//calculates checksum for n bytes of data
|
||
//and compares it with expected checksum
|
||
//input: data[] checksum is built based on this data
|
||
// nbrOfBytes checksum is built for n bytes of data
|
||
// checksum expected checksum
|
||
//return: error: CHECKSUM_ERROR = checksum does not match
|
||
// 0 = checksum matches
|
||
//============================================================
|
||
{
|
||
uint8_t crc = 0;
|
||
uint8_t byteCtr;
|
||
//calculates 8-Bit checksum with given polynomial
|
||
for (byteCtr = 0; byteCtr < nbrOfBytes; ++byteCtr) {
|
||
crc ^= (data[byteCtr]);
|
||
for (uint8_t bit = 8; bit > 0; --bit) {
|
||
if (crc & 0x80) {
|
||
crc = (crc << 1) ^ POLYNOMIAL;
|
||
} else { crc = (crc << 1); }
|
||
}
|
||
}
|
||
|
||
return crc;
|
||
}
|
||
|
||
FRESULT scan_files(char *path, uint32_t *globDirCount, uint32_t *globFileCount) {
|
||
FRESULT res;
|
||
DIR dir;
|
||
UINT i;
|
||
static FILINFO fno;
|
||
|
||
|
||
res = f_opendir(&dir, path); // Open the directory
|
||
if (res == FR_OK) {
|
||
for (;;) {
|
||
res = f_readdir(&dir, &fno); // Read a directory item
|
||
if (res != FR_OK || fno.fname[0] == 0) break; // Break on error or end of dir
|
||
if (fno.fattrib & AM_DIR) { // It is a directory
|
||
i = strlen(path);
|
||
strcat(path, "/");
|
||
strcat(path, fno.fname);
|
||
++*globDirCount;
|
||
res = scan_files(path, globDirCount, globFileCount); // Enter the directory
|
||
if (res != FR_OK) break;
|
||
path[i] = 0;
|
||
} else { // It is a file.
|
||
++*globFileCount;
|
||
}
|
||
}
|
||
f_closedir(&dir);
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
void reportScan(char *str, uint32_t AT) {
|
||
char buf[12];
|
||
|
||
char buff[256];
|
||
buff[0] = '\0';
|
||
strcat(buff, "1:/");
|
||
|
||
uint32_t globDirCount = 0;
|
||
uint32_t globFileCount = 0;
|
||
scan_files(buff, &globDirCount, &globFileCount);
|
||
|
||
str[0] = '\0';
|
||
|
||
strcat(str, "АТ-");
|
||
utoa(AT, buf, 10);
|
||
strcat(str, buf);
|
||
strcat(str, "\n");
|
||
|
||
strcat(str, "Проверка диска \n");
|
||
|
||
strcat(str, "Директорий ");
|
||
utoa(globDirCount, buf, 10);
|
||
strcat(str, buf);
|
||
strcat(str, "\n");
|
||
|
||
strcat(str, "Файлов ");
|
||
utoa(globFileCount, buf, 10);
|
||
strcat(str, buf);
|
||
strcat(str, "\n");
|
||
|
||
strcat(str, "Ошибок 0 \n");
|
||
|
||
}
|
||
|
||
|
||
void toAddPrefixStr(char *out, char *in, size_t len) {
|
||
|
||
if (len <= strlen(in)) {
|
||
out[0] = '\0';
|
||
strcat(out, in);
|
||
return;
|
||
}
|
||
|
||
size_t countPrefix = len - strlen(in);
|
||
|
||
for (size_t i = 0; i < countPrefix; ++i)
|
||
out[i] = '0';
|
||
|
||
out[countPrefix] = '\0';
|
||
|
||
strcat(out, in);
|
||
}
|
||
|
||
void getDelFileDir(tFs *fs, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS + MAX_LEN_PATH_FS];
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
pathTmp[0] = '\0';
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
|
||
fr = f_unlink_i(fs, pathTmp);
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
}
|
||
|
||
void getDelFilesDir(tFs *fs, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS + MAX_LEN_PATH_FS];
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
if (fno.fattrib & AM_DIR) {
|
||
pathTmp[0] = '\0';
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
strcat(pathTmp, "/");
|
||
|
||
getDelFileDir(fs, pathTmp);
|
||
}
|
||
|
||
pathTmp[0] = '\0';
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
|
||
fr = f_unlink_i(fs, pathTmp);
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
|
||
}
|
||
|
||
|
||
bool getDelFileDirClean(tFs *fs, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS + 32];
|
||
bool isClean = true;
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*");
|
||
|
||
if (fr == FR_OK && fno.fname[0]) {
|
||
isClean = false;
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
return isClean;
|
||
}
|
||
|
||
|
||
void getDelFilesDirClean(tFs *fs, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS + 32];
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
if (fno.fattrib & AM_DIR) {
|
||
pathTmp[0] = '\0';
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
strcat(pathTmp, "/");
|
||
|
||
if (getDelFileDirClean(fs, pathTmp)) {
|
||
fr = f_unlink_i(fs, pathTmp);
|
||
}
|
||
}
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
|
||
}
|
||
|
||
void getDelFileDirDatTracert(tFs *fs, char *path) {
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS];
|
||
bool isClean = true;
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*.DAT");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
pathTmp[0] = 0;
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
pathTmp[strlen(pathTmp) - 3] = 'O';
|
||
pathTmp[strlen(pathTmp) - 2] = 'T';
|
||
pathTmp[strlen(pathTmp) - 1] = 'M';
|
||
|
||
frInf = f_stat(pathTmp, &fnoInf);
|
||
if (frInf == FR_NO_FILE) {
|
||
pathTmp[0] = 0;
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
|
||
fr = f_unlink_i(fs, pathTmp);
|
||
}
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
}
|
||
|
||
|
||
void getDelFileDirDatInbox(tFs *fs, char *path, char *ext) {
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS];
|
||
bool isClean = true;
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*.DAT");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
pathTmp[0] = 0;
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
pathTmp[strlen(pathTmp) - 3] = ext[0];//'I';
|
||
pathTmp[strlen(pathTmp) - 2] = ext[1];//'T';
|
||
pathTmp[strlen(pathTmp) - 1] = ext[2];//'M';
|
||
|
||
frInf = f_stat(pathTmp, &fnoInf);
|
||
if (frInf == FR_NO_FILE) {
|
||
pathTmp[0] = 0;
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
|
||
fr = f_unlink_i(fs, pathTmp);
|
||
}
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
}
|
||
|
||
void getDelFilesDirDat(tFs *fs, char *path, char *ext) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char pathTmp[MAX_LEN_PATH_FS];
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
if (fno.fattrib & AM_DIR) {
|
||
pathTmp[0] = '\0';
|
||
strcat(pathTmp, path);
|
||
strcat(pathTmp, fno.fname);
|
||
strcat(pathTmp, "/");
|
||
|
||
getDelFileDirDatInbox(fs, pathTmp, ext);
|
||
}
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
|
||
}
|
||
|
||
|
||
void getPath(char *pathIn, char *pathOut, int count_dir) {
|
||
|
||
char tmp[2];
|
||
|
||
int step_dir = 0;
|
||
pathOut[0] = 0;
|
||
|
||
for (uint32_t i = 0; i < strlen(pathIn); ++i) {
|
||
|
||
if (pathIn[i] == '/')
|
||
++step_dir;
|
||
|
||
tmp[0] = toupper(pathIn[i]);
|
||
tmp[1] = 0;
|
||
|
||
strcat(pathOut, tmp);
|
||
|
||
if (step_dir == count_dir)
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
// Получение указателя на расширение файла
|
||
char *getVoidExt(char *buf) {
|
||
char *p = buf;
|
||
|
||
for (size_t i = 0; i < strlen(buf); ++i) {
|
||
if (*p == '.')
|
||
return p;
|
||
++p;
|
||
}
|
||
|
||
return p;
|
||
}
|
||
|
||
|
||
// Получение имени файла лога
|
||
size_t getFileNameLog(tRtcIO *rtc, char *buf, size_t len) {
|
||
struct tm dateTime;
|
||
rtc->getTM(rtc, &dateTime);
|
||
return strftime(buf, len, "%d-%m-%y.LOG", &dateTime);
|
||
}
|
||
|
||
|
||
// Получение строки дата
|
||
size_t getDateStr(tRtcIO *rtc, char *buf, size_t len) {
|
||
struct tm dateTime;
|
||
rtc->getTM(rtc, &dateTime);
|
||
return strftime(buf, len, "%Y%m%d", &dateTime);
|
||
}
|
||
|
||
// Получение строки дата время в UTC
|
||
size_t getDataTimeUTC(time_t *timestamp, char *buf, size_t len) {
|
||
struct tm dateTime;
|
||
localtime_r(timestamp, &dateTime);
|
||
|
||
// return strftime(buf, len, "%FT%T+03:00", dateTime);
|
||
return strftime(buf, len, "%FT%T", &dateTime);
|
||
}
|
||
|
||
// Получение строки дата время в UTC
|
||
size_t getDataTimeUTC_Ex(struct tm *dateTime, char *buf, size_t len) {
|
||
|
||
// return strftime(buf, len, "%FT%T+03:00", dateTime);
|
||
return strftime(buf, len, "%FT%T", dateTime);
|
||
}
|
||
|
||
// Получение строки дата/время
|
||
size_t getDataTime(time_t *timestamp, char *buf, size_t len) {
|
||
struct tm dateTime;
|
||
localtime_r(timestamp, &dateTime);
|
||
|
||
return strftime(buf, len, "%d-%m-%g %T", &dateTime);
|
||
}
|
||
|
||
|
||
// Удаление всех файлов в директории
|
||
bool delDirFileFs(tFs *fs, char *dir) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
|
||
char dirScan[MAX_LEN_PATH_FS];
|
||
dirScan[0] = '\0';
|
||
strcat(dirScan, dir);
|
||
|
||
char dirFileScan[MAX_LEN_PATH_FS];
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, dirScan, "*");
|
||
|
||
if (fr)
|
||
return false;
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
dirFileScan[0] = '\0';
|
||
strcat(dirFileScan, dirScan);
|
||
strcat(dirFileScan, fno.fname);
|
||
|
||
fr = f_unlink_i(fs, dirFileScan);
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
|
||
if (fr) {
|
||
fr = f_closedir_i(fs, &dj);
|
||
return Post_FS_ERR;
|
||
}
|
||
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
FRESULT deleteAllDir(tFs *fs, char *path) {
|
||
FRESULT res;
|
||
FILINFO fno;
|
||
DIR dir;
|
||
int i;
|
||
char *fn;
|
||
|
||
res = f_opendir_i(fs, &dir, path); // Открытие директории
|
||
if (res == FR_OK) {
|
||
i = strlen(path);
|
||
for (;;) {
|
||
res = f_readdir(&dir, &fno); // Чтение объекта директории
|
||
if (res != FR_OK || fno.fname[0] == 0)
|
||
break; // Останов цикла при ошибке или при достижении конца списка директории
|
||
|
||
fn = fno.fname;
|
||
if (fno.fattrib & AM_DIR) { // Это директория
|
||
//strcat(path, "/");
|
||
//strcat(path, fn);
|
||
|
||
strcat(&path[i], "/");
|
||
strcat(&path[i + 1], fn);
|
||
res = deleteAllDir(fs, path);
|
||
|
||
f_unlink_i(fs, path);
|
||
|
||
if (res != FR_OK) break;
|
||
path[i] = 0;
|
||
} else { // Это файл
|
||
|
||
char pathFile[MAX_LEN_PATH_FS];
|
||
pathFile[0] = '\0';
|
||
strcat(pathFile, path);
|
||
strcat(pathFile, "/");
|
||
strcat(pathFile, fn);
|
||
f_unlink_i(fs, pathFile);
|
||
|
||
}
|
||
}
|
||
f_closedir_i(fs, &dir);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
bool CopyFileFs_crc_md5(tFs *fs, uint32_t typeCrc, md5a_context *md5ctx, char *filenameTo, char *filenameFrom,
|
||
uint32_t offset, uint32_t initCrc32) {
|
||
FIL fsrc, fdst; // File objects
|
||
BYTE buffer[512]; // File copy buffer
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br, bw; // File read/write count
|
||
uint32_t crc32 = 0;
|
||
uint32_t crc32_update = 0;
|
||
uint32_t init = initCrc32;
|
||
|
||
fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
|
||
if (fr) return false;
|
||
|
||
fr = f_lseek_i(fs, &fsrc, offset);
|
||
if (fr) return false;
|
||
|
||
fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
|
||
if (fr) return false;
|
||
|
||
for (;;) {
|
||
f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);
|
||
if (br == 0) break;
|
||
|
||
// crc32
|
||
if (typeCrc == 1) {
|
||
crc32_update = GonetsCrc32_update(buffer, br, init);
|
||
init = crc32_update;
|
||
}
|
||
|
||
// md5
|
||
if (typeCrc == 2) {
|
||
md5a_update(md5ctx, buffer, (int) br);
|
||
}
|
||
|
||
f_write_i(fs, &fdst, buffer, br, &bw);
|
||
if (bw < br) break;
|
||
}
|
||
|
||
// crc32
|
||
if (typeCrc == 1) {
|
||
crc32 = GonetsCrc32_finish(crc32_update);
|
||
|
||
fr = f_write_i(fs, &fdst, &crc32, 4, &bw);
|
||
}
|
||
|
||
// md5
|
||
if (typeCrc == 2) {
|
||
uint8_t md5sum[16];
|
||
md5a_finish(md5ctx, md5sum);
|
||
|
||
f_write_i(fs, &fdst, md5sum, sizeof(md5sum), &bw);
|
||
}
|
||
|
||
f_close_i(fs, &fsrc);
|
||
f_close_i(fs, &fdst);
|
||
|
||
return true;
|
||
}
|
||
|
||
//BYTE buffer_crc[512 * 20];
|
||
|
||
uint32_t CrcFileFs(tFs *fs, char *filename) {
|
||
FIL fsrc; // File objects
|
||
// BYTE buffer_crc[512 * 2];
|
||
|
||
// BYTE buffer[512]; // File copy buffer
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br; // File read/write count
|
||
|
||
BYTE buffer_crc[512];
|
||
|
||
uint32_t init = 0xFFFFFFFF;
|
||
|
||
fr = f_open_i(fs, &fsrc, filename, FA_READ);
|
||
|
||
for (;;) {
|
||
f_read_i(fs, &fsrc, buffer_crc, sizeof(buffer_crc), &br);
|
||
if (br == 0) break;
|
||
|
||
init = GonetsCrc32_noreverse_update(buffer_crc, br, init);
|
||
|
||
}
|
||
|
||
f_close_i(fs, &fsrc);
|
||
|
||
init = GonetsCrc32_noreverse_finish(init);
|
||
|
||
return init;
|
||
}
|
||
|
||
bool CopyFileFs(tFs *fs, char *filenameTo, char *filenameFrom, uint32_t offset) {
|
||
FIL fsrc, fdst; // File objects
|
||
BYTE buffer[512]; // File copy buffer
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br, bw; // File read/write count
|
||
|
||
fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
|
||
if (fr) return false;
|
||
|
||
fr = f_lseek_i(fs, &fsrc, offset);
|
||
if (fr) return false;
|
||
|
||
fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
|
||
if (fr) return false;
|
||
|
||
for (;;) {
|
||
f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);
|
||
if (br == 0) break;
|
||
f_write_i(fs, &fdst, buffer, br, &bw);
|
||
if (bw < br) break;
|
||
}
|
||
|
||
f_close_i(fs, &fsrc);
|
||
f_close_i(fs, &fdst);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool
|
||
CopyFileTrucSizeFs(tFs *fs, uint32_t typeCrc, md5a_context *md5ctx,
|
||
uint32_t *crc32sum, uint8_t *md5sum,
|
||
uint32_t *crc32sumFile, uint8_t *md5sumFile,
|
||
char *filenameTo, char *filenameFrom,
|
||
uint32_t offset, uint32_t truncBytes, uint32_t size) {
|
||
FIL fsrc, fdst; // File objects
|
||
BYTE buffer[512]; // File copy buffer
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br, bw; // File read/write count
|
||
|
||
uint32_t crc32_update;
|
||
uint32_t init = 0xFFFFFFFF;
|
||
|
||
uint32_t count = (size - offset - truncBytes) / sizeof(buffer);
|
||
uint32_t tail = (size - offset - truncBytes) % sizeof(buffer);
|
||
|
||
fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
|
||
if (fr) return false;
|
||
|
||
fr = f_lseek_i(fs, &fsrc, offset);
|
||
if (fr) return false;
|
||
|
||
fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
|
||
if (fr) return false;
|
||
|
||
for (uint32_t i = 0; i < count; ++i) {
|
||
f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);
|
||
|
||
// crc32
|
||
if (typeCrc == 1) {
|
||
crc32_update = GonetsCrc32_update(buffer, br, init);
|
||
init = crc32_update;
|
||
}
|
||
|
||
// md5
|
||
if (typeCrc == 2) {
|
||
md5a_update(md5ctx, buffer, (int) br);
|
||
}
|
||
|
||
if (br == 0) break;
|
||
f_write_i(fs, &fdst, buffer, br, &bw);
|
||
if (bw < br) break;
|
||
}
|
||
|
||
f_read_i(fs, &fsrc, buffer, tail, &br);
|
||
|
||
// crc32
|
||
if (typeCrc == 1) {
|
||
crc32_update = GonetsCrc32_update(buffer, br, init);
|
||
init = crc32_update;
|
||
}
|
||
|
||
// md5
|
||
if (typeCrc == 2) {
|
||
md5a_update(md5ctx, buffer, (int) br);
|
||
}
|
||
|
||
f_write_i(fs, &fdst, buffer, br, &bw);
|
||
|
||
|
||
// crc32
|
||
if (typeCrc == 1) {
|
||
f_read_i(fs, &fsrc, crc32sumFile, 4, &br);
|
||
*crc32sum = GonetsCrc32_finish(crc32_update);
|
||
}
|
||
|
||
// md5
|
||
if (typeCrc == 2) {
|
||
f_read_i(fs, &fsrc, md5sumFile, 16, &br);
|
||
md5a_finish(md5ctx, md5sum);
|
||
}
|
||
|
||
|
||
f_close_i(fs, &fsrc);
|
||
f_close_i(fs, &fdst);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// Получене crc
|
||
uint32_t GetCrcFileisOpenFs(tFs *fs, FIL *fsrc, uint32_t offset) {
|
||
BYTE buffer[512]; // File copy buffer
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br; // File read/write count
|
||
uint32_t crc = 0;
|
||
|
||
fr = f_lseek_i(fs, fsrc, offset);
|
||
if (fr) return false;
|
||
|
||
for (;;) {
|
||
f_read_i(fs, fsrc, buffer, sizeof(buffer), &br);
|
||
|
||
for (size_t i = 0; i < br; ++i) {
|
||
crc += buffer[i];
|
||
}
|
||
|
||
if (br == 0) break;
|
||
}
|
||
|
||
return crc;
|
||
}
|
||
|
||
|
||
// Получене crc
|
||
uint32_t GetCrcFileFs(tFs *fs, char *filename, uint32_t offset) {
|
||
FIL fsrc; // File objects
|
||
BYTE buffer[512]; // File copy buffer
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br; // File read/write count
|
||
uint32_t crc = 0;
|
||
|
||
fr = f_open_i(fs, &fsrc, filename, FA_READ);
|
||
if (fr) return 0;
|
||
|
||
fr = f_lseek_i(fs, &fsrc, offset);
|
||
if (fr) return false;
|
||
|
||
for (;;) {
|
||
fr = f_read_i(fs, &fsrc, buffer, sizeof(buffer), &br);
|
||
|
||
for (size_t i = 0; i < br; ++i) {
|
||
crc += buffer[i];
|
||
}
|
||
|
||
if (fr) {
|
||
return 0;
|
||
}
|
||
|
||
if (br == 0)
|
||
break;
|
||
}
|
||
|
||
f_close_i(fs, &fsrc);
|
||
|
||
return crc;
|
||
}
|
||
|
||
/*
|
||
BYTE bufferSizeMaxCopy[1300]; // File copy buffer
|
||
|
||
bool CopyFileFsSize(tFs *fs, char *filenameTo, char *filenameFrom, uint32_t offset, uint32_t max) {
|
||
FIL fsrc, fdst; // File objects
|
||
FRESULT fr; // FatFs function common result code
|
||
UINT br, bw; // File read/write count
|
||
|
||
fr = f_open_i(fs, &fsrc, filenameFrom, FA_READ);
|
||
if (fr) return false;
|
||
|
||
fr = f_lseek_i(fs, &fsrc, offset);
|
||
if (fr) return false;
|
||
|
||
fr = f_open_i(fs, &fdst, filenameTo, FA_OPEN_APPEND | FA_WRITE);
|
||
if (fr) return false;
|
||
|
||
// for (;;) {
|
||
f_read_i(fs, &fsrc, bufferSizeMaxCopy, max, &br);
|
||
// if (br == 0) break;
|
||
f_write_i(fs, &fdst, bufferSizeMaxCopy, br, &bw);
|
||
// if (bw < br) break;
|
||
// }
|
||
|
||
f_close_i(fs, &fsrc);
|
||
f_close_i(fs, &fdst);
|
||
|
||
return true;
|
||
}
|
||
*/
|
||
|
||
|