1433 lines
44 KiB
C
1433 lines
44 KiB
C
//
|
||
// Created by cfif on 21.02.23.
|
||
//
|
||
#include "ModemSendFunc.h"
|
||
#include "GonetsCrcs.h"
|
||
#include "ModemBufCreateHeader.h"
|
||
|
||
extern uint8_t bufFreeOperation[1500];
|
||
extern uint8_t bufFreeOperationKV[1500];
|
||
extern uint8_t bufFillOperation[1500];
|
||
|
||
// Получение информации о исходящем файле
|
||
bool getInfoFromFileNameOutBox(tFs *fs, char *path, tFileSendInfo *fileSendInfo, uint32_t *cuteOffsetBegin) {
|
||
FRESULT fr;
|
||
char bufDumpFile[512];
|
||
int stepParam = 0;
|
||
|
||
struct {
|
||
int paramcount;
|
||
char *params_names[MAX_POST_GET_PARAMETERS];
|
||
char *params_vals[MAX_POST_GET_PARAMETERS];
|
||
} params_uri;
|
||
|
||
*cuteOffsetBegin = 0;
|
||
|
||
FIL file;
|
||
fr = f_open_i(fs, &file, (TCHAR *) path, FA_READ);
|
||
if (fr != FR_OK) return false;
|
||
|
||
UINT bytes_read;
|
||
fr = f_read_i(fs, &file, bufDumpFile, 512, &bytes_read);
|
||
if (fr != FR_OK) {
|
||
fr = f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
|
||
fr = f_close_i(fs, &file);
|
||
|
||
params_uri.paramcount = extract_uri_ex_parameters(bufDumpFile, params_uri.params_names,
|
||
params_uri.params_vals,
|
||
MAX_POST_GET_PARAMETERS);
|
||
|
||
for (int i = 0; i < params_uri.paramcount; ++i) {
|
||
|
||
if (strcmp(params_uri.params_names[i], "mnum") == 0) {
|
||
fileSendInfo->mnum = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "urgency") == 0) {
|
||
fileSendInfo->urgency = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
|
||
if (strcmp(params_uri.params_names[i], "kvt_num") == 0) {
|
||
fileSendInfo->kvt_num = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "kvt_mon") == 0) {
|
||
fileSendInfo->kvt_mon = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "kvt_day") == 0) {
|
||
fileSendInfo->kvt_day = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
|
||
if (strcmp(params_uri.params_names[i], "type") == 0) {
|
||
fileSendInfo->typeFile = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
*cuteOffsetBegin = params_uri.params_vals[i] - bufDumpFile - 5;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "sos") == 0) {
|
||
|
||
fileSendInfo->sos = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "chSv") == 0) {
|
||
fileSendInfo->chSv = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "kvs") == 0) {
|
||
fileSendInfo->kvs = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "from") == 0) {
|
||
fileSendInfo->from = atoi(params_uri.params_vals[i]);
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "to") == 0) {
|
||
extract_utf8_parameters(params_uri.params_vals[i], fileSendInfo->to,
|
||
sizeof(fileSendInfo->to));
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "subj") == 0) {
|
||
extract_utf8_parameters(params_uri.params_vals[i], fileSendInfo->subj,
|
||
sizeof(fileSendInfo->subj));
|
||
++stepParam;
|
||
}
|
||
|
||
if (strcmp(params_uri.params_names[i], "msg") == 0) {
|
||
++stepParam;
|
||
|
||
//fileSendInfo->typeFile = TYPE_FILE_MESSAGE;
|
||
|
||
fileSendInfo->offsetMsg = params_uri.params_vals[i] - bufDumpFile;
|
||
fileSendInfo->fileName[0] = '\0';
|
||
|
||
if (strcmp(fileSendInfo->subj, "kvitin") == 0) {
|
||
fileSendInfo->typeFile = TYPE_FILE_KVITIN;
|
||
}
|
||
|
||
|
||
// if (strcmp(fileSendInfo->subj, "trace") == 0) {
|
||
// strcat(fileSendInfo->fileName, params_uri.params_vals[i]);
|
||
// fileSendInfo->typeFile = TYPE_FILE_TRACERT;
|
||
// }
|
||
|
||
if (strcmp(fileSendInfo->subj, "file") == 0) {
|
||
strcat(fileSendInfo->fileName, params_uri.params_vals[i]);
|
||
|
||
|
||
char dirFileNameOut[MAX_LEN_PATH_FS];
|
||
getPath(path, dirFileNameOut, 2);
|
||
|
||
if (strcmp(dirFileNameOut, dir_tracert) == 0) {
|
||
|
||
fileSendInfo->offsetMsg = 0;
|
||
|
||
fileSendInfo->typeFile = TYPE_FILE_TRACERT;
|
||
|
||
DIR dj;
|
||
FILINFO fnoInf;
|
||
char real_filename[MAX_LEN_PATH_FS];
|
||
createFileNameForId(real_filename, (char *) dir_tracert, fileSendInfo->mnum, "DAT");
|
||
|
||
fr = f_stat(real_filename, &fnoInf);
|
||
|
||
// Если не найден DAT
|
||
if (fr) {
|
||
f_unlink_i(fs, path);
|
||
return false;
|
||
}
|
||
|
||
}
|
||
|
||
/*
|
||
for (int j = params_uri.params_vals[i] - bufDumpFile; j < (int) sizeof(bufDumpFile); ++j) {
|
||
if (bufDumpFile[j] == '\0') {
|
||
++fileSendInfo->offsetMsg;
|
||
++fileSendInfo->offsetMsg;
|
||
break;
|
||
}
|
||
++fileSendInfo->offsetMsg;
|
||
}
|
||
*/
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
fileSendInfo->isSendAll = 0;
|
||
|
||
if (stepParam < 10)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool readSendFileInfo(tFs *fs, tFileSendInfo *fileSendInfo, char *path_inf_fileName) {
|
||
int result;
|
||
/*
|
||
fileSendInfo->typeFile = ini_getl("MAIN", "typeFile", 0, path_inf_fileName);
|
||
fileSendInfo->from = ini_getl("MAIN", "from", 0, path_inf_fileName);
|
||
fileSendInfo->mnum = ini_getl("MAIN", "mnum", 0, path_inf_fileName);
|
||
result = ini_gets("MAIN", "to", "0", fileSendInfo->to, MAX_LEN_PATH_FS, path_inf_fileName);
|
||
fileSendInfo->urgency = ini_getl("MAIN", "urgency", 0, path_inf_fileName);
|
||
fileSendInfo->chSv = ini_getl("MAIN", "chSv", 0, path_inf_fileName);
|
||
result = ini_gets("MAIN", "subj", "", fileSendInfo->subj, MAX_LEN_PATH_FS, path_inf_fileName);
|
||
fileSendInfo->kvs = ini_getl("MAIN", "kvs", 0, path_inf_fileName);
|
||
result = ini_gets("MAIN", "fileName", "", fileSendInfo->fileName, MAX_LEN_PATH_FS, path_inf_fileName);
|
||
fileSendInfo->dateDay = ini_getl("MAIN", "dateDay", 0, path_inf_fileName);
|
||
fileSendInfo->dateMon = ini_getl("MAIN", "dateMon", 0, path_inf_fileName);
|
||
fileSendInfo->sizeFileRep = ini_getl("MAIN", "sizeFileRep", 0, path_inf_fileName);
|
||
fileSendInfo->isSendAll = ini_getl("MAIN", "isSendAll", 0, path_inf_fileName);
|
||
fileSendInfo->bytes_sending = ini_getl("MAIN", "bytes_sending", 0, path_inf_fileName);
|
||
fileSendInfo->bytes_no_sending = ini_getl("MAIN", "bytes_no_sending", 0, path_inf_fileName);
|
||
|
||
fileSendInfo->routing = ini_getl("MAIN", "routing", 0, path_inf_fileName);
|
||
fileSendInfo->sos = ini_getl("MAIN", "sos", 0, path_inf_fileName);
|
||
|
||
fileSendInfo->crc32_MSK = ini_getl("MAIN", "crc32_MSK", 0, path_inf_fileName);
|
||
fileSendInfo->crc32_REP = ini_getl("MAIN", "crc32_REP", 0, path_inf_fileName);
|
||
*/
|
||
|
||
FRESULT fr;
|
||
FIL file;
|
||
UINT br;
|
||
|
||
fr = f_open_i(fs, &file, (TCHAR *) path_inf_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_read_i(fs, &file, fileSendInfo, sizeof(tFileSendInfo), &br);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
|
||
fr = f_close_i(fs, &file);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool writeSendFileInfo(tFs *fs, tFileSendInfo *fileSendInfo, char *path_inf_fileName) {
|
||
int result;
|
||
/*
|
||
result = ini_putl("MAIN", "typeFile", fileSendInfo->typeFile, path_inf_fileName);
|
||
result = ini_putl("MAIN", "from", fileSendInfo->from, path_inf_fileName);
|
||
result = ini_putl("MAIN", "mnum", fileSendInfo->mnum, path_inf_fileName);
|
||
result = ini_puts("MAIN", "to", fileSendInfo->to, path_inf_fileName);
|
||
result = ini_putl("MAIN", "urgency", fileSendInfo->urgency, path_inf_fileName);
|
||
result = ini_putl("MAIN", "chSv", fileSendInfo->chSv, path_inf_fileName);
|
||
result = ini_puts("MAIN", "subj", fileSendInfo->subj, path_inf_fileName);
|
||
result = ini_putl("MAIN", "kvs", fileSendInfo->kvs, path_inf_fileName);
|
||
result = ini_puts("MAIN", "fileName", fileSendInfo->fileName, path_inf_fileName);
|
||
result = ini_putl("MAIN", "dateDay", fileSendInfo->dateDay, path_inf_fileName);
|
||
result = ini_putl("MAIN", "dateMon", fileSendInfo->dateMon, path_inf_fileName);
|
||
result = ini_putl("MAIN", "sizeFileRep", fileSendInfo->sizeFileRep, path_inf_fileName);
|
||
result = ini_putl("MAIN", "isSendAll", fileSendInfo->isSendAll, path_inf_fileName);
|
||
result = ini_putl("MAIN", "bytes_sending", fileSendInfo->bytes_sending, path_inf_fileName);
|
||
result = ini_putl("MAIN", "bytes_no_sending", fileSendInfo->bytes_no_sending, path_inf_fileName);
|
||
result = ini_putl("MAIN", "routing", fileSendInfo->routing, path_inf_fileName);
|
||
result = ini_putl("MAIN", "sos", fileSendInfo->sos, path_inf_fileName);
|
||
result = ini_putl("MAIN", "crc32_MSK", fileSendInfo->crc32_MSK, path_inf_fileName);
|
||
result = ini_putl("MAIN", "crc32_REP", fileSendInfo->crc32_REP, path_inf_fileName);
|
||
*/
|
||
|
||
|
||
FRESULT fr;
|
||
FIL file;
|
||
UINT bw;
|
||
|
||
fr = f_open_i(fs, &file, (TCHAR *) path_inf_fileName, FA_WRITE | FA_CREATE_ALWAYS);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_write_i(fs, &file, fileSendInfo, sizeof(tFileSendInfo), &bw);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
|
||
fr = f_close_i(fs, &file);
|
||
|
||
return true;
|
||
}
|
||
|
||
uint32_t getCountTracertInRepoutCute(tFs *fs, uint32_t max) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
tFileSendInfo fileSendInfo;
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
uint32_t count = 0;
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(&fno.fname[0]);
|
||
createFileNameForId(path_dir_info_fileName, (char *) dir_rep_out, idFile, "INF");
|
||
|
||
bool resultFileInfo = readSendFileInfo(fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
if (fileSendInfo.typeFile == TYPE_FILE_TRACERT) {
|
||
++count;
|
||
if (count > max + 1)
|
||
break;
|
||
}
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
return count;
|
||
}
|
||
|
||
uint32_t getCountTypeFileInRepout(tFs *fs, tTypeFile typeFile, uint32_t *idInRepout) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
tFileSendInfo fileSendInfo;
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
uint32_t count = 0;
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(&fno.fname[0]);
|
||
createFileNameForId(path_dir_info_fileName, (char *) dir_rep_out, idFile, "INF");
|
||
|
||
bool resultFileInfo = readSendFileInfo(fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
if (fileSendInfo.typeFile == typeFile) {
|
||
idInRepout[count] = idFile;
|
||
++count;
|
||
|
||
if (count >= 16)
|
||
return count;
|
||
|
||
}
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
return count;
|
||
}
|
||
|
||
uint32_t getOldOut(tFs *fs, char *path, uint32_t *idInRepout, uint32_t countIdInRepout) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
|
||
uint32_t minNum = 0xFFFFFFFF;
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*.OTM");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t Num = atoi(&fno.fname[0]);
|
||
|
||
if (Num < minNum) {
|
||
bool isFind = false;
|
||
for (uint32_t i = 0; i < countIdInRepout; ++i) {
|
||
if (idInRepout[i] == Num) {
|
||
isFind = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isFind == false)
|
||
minNum = Num;
|
||
}
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
if (minNum == 0xFFFFFFFF)
|
||
minNum = 0;
|
||
|
||
return minNum;
|
||
}
|
||
|
||
|
||
/*
|
||
// Создание пакета транспортного уровня
|
||
bool
|
||
createPacketKvitin(tFs *fs, uint32_t offset, uint8_t *bufSendPacket, bool *isFrom, uint32_t *from,
|
||
uint32_t *lenTransPaket,
|
||
tFileSendInfo *fileSendInfo,
|
||
tRtcIO *rtcIo, char *path_rep_fileName, char *path_mask_fileName) {
|
||
uint8_t bufRead[512];
|
||
FIL fileRep;
|
||
FIL fileMask;
|
||
FRESULT fr;
|
||
UINT brRep, brMask; // File read/write count
|
||
|
||
// Создание заголовка транспортного пакета
|
||
tStructTransportKvitPacket *structTransportKvitPacket = (tStructTransportKvitPacket *) bufSendPacket;
|
||
|
||
structTransportKvitPacket->versionProtocol = 1;
|
||
|
||
structTransportKvitPacket->dataType = 8; // Квитанция на сообщение
|
||
|
||
structTransportKvitPacket->numberSender = fileSendInfo->from;
|
||
|
||
structTransportKvitPacket->dateCreateTransportPacketDay = fileSendInfo->dateDay;
|
||
structTransportKvitPacket->dateCreateTransportPacketMon = fileSendInfo->dateMon;
|
||
|
||
structTransportKvitPacket->numberMessage = fileSendInfo->mnum;
|
||
|
||
*isFrom = false;
|
||
bool isTo = false;
|
||
uint32_t stepFromOrTo = 0;
|
||
uint32_t stepFromOrTo_MaxLen = 0;
|
||
*from = 0;
|
||
uint32_t to = 0;
|
||
|
||
// Открытие файла маски
|
||
fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileMask, offset);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
for (;;) {
|
||
|
||
fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
|
||
for (uint32_t i = 0; i < brMask; ++i) {
|
||
|
||
// Поиск неотправленного начала
|
||
if (*isFrom == false) {
|
||
if ((bufRead[i] == 0) || (bufRead[i] == 1)) {
|
||
*from = stepFromOrTo + offset;
|
||
|
||
*isFrom = true;
|
||
}
|
||
} else {
|
||
// Поиск неотправленного конца
|
||
if (bufRead[i] == 0x55) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
++stepFromOrTo;
|
||
|
||
if (*isFrom) {
|
||
++stepFromOrTo_MaxLen;
|
||
}
|
||
}
|
||
|
||
|
||
// Нашли начало и конец
|
||
if ((*isFrom) && (isTo))
|
||
break;
|
||
|
||
// Нашли данные для полного пакета
|
||
if (stepFromOrTo_MaxLen > LEN_TRANS_PACKET) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
|
||
// Нашли конец файла
|
||
if (brMask == 0) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
}
|
||
fr = f_close_i(fs, &fileMask);
|
||
|
||
|
||
uint32_t dl = fileSendInfo->sizeFileRep - stepFromOrTo + *from;
|
||
|
||
*lenTransPaket = 0;
|
||
if (*isFrom) {
|
||
|
||
uint32_t leftFileSize = to - *from;
|
||
*lenTransPaket = TRANS_MIN(leftFileSize, LEN_TRANS_PACKET - sizeof(tStructTransportKvitPacket));
|
||
// *lenTransPaket = TRANS_MIN(leftFileSize, 13);
|
||
|
||
uint8_t *dataSendPacket = &bufSendPacket[sizeof(tStructTransportKvitPacket)];
|
||
|
||
// Открытие файла представления
|
||
fr = f_open_i(fs, &fileRep, (TCHAR *) path_rep_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileRep, *from);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_read_i(fs, &fileRep, dataSendPacket, *lenTransPaket, &brRep);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileRep);
|
||
return false;
|
||
}
|
||
|
||
fr = f_close_i(fs, &fileRep);
|
||
|
||
*lenTransPaket += sizeof(tStructTransportKvitPacket);
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
*/
|
||
|
||
// Создание пакета квитанции
|
||
bool
|
||
createPacketKvitin(tFs *fs, uint32_t offset, uint8_t *bufSendPacket, bool *isFrom, uint32_t *from,
|
||
uint32_t *lenTransPaket,
|
||
tFileSendInfo *fileSendInfo,
|
||
tRtcIO *rtcIo, char *path_rep_fileName, char *path_mask_fileName) {
|
||
uint8_t bufRead[512];
|
||
FIL fileRep;
|
||
FIL fileMask;
|
||
FRESULT fr;
|
||
UINT brRep, brMask; // File read/write count
|
||
|
||
// Создание заголовка транспортного пакета
|
||
tStructTransportKvitPacket *structTransportKvitPacket = (tStructTransportKvitPacket *) bufSendPacket;
|
||
|
||
structTransportKvitPacket->versionProtocol = 1;
|
||
|
||
structTransportKvitPacket->dataType = 8; // Квитанция на сообщение
|
||
|
||
structTransportKvitPacket->numberSender = fileSendInfo->from;
|
||
|
||
structTransportKvitPacket->dateCreateTransportPacketDay = fileSendInfo->kvt_day;
|
||
structTransportKvitPacket->dateCreateTransportPacketMon = fileSendInfo->kvt_mon;
|
||
|
||
structTransportKvitPacket->numberMessage = fileSendInfo->kvt_num;
|
||
|
||
*isFrom = false;
|
||
bool isTo = false;
|
||
uint32_t stepFromOrTo = 0;
|
||
*from = 0;
|
||
uint32_t to = 0;
|
||
|
||
// Открытие файла маски
|
||
fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileMask, offset);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
for (;;) {
|
||
|
||
fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
|
||
for (uint32_t i = 0; i < brMask; ++i) {
|
||
|
||
if (*isFrom == false) {
|
||
if ((bufRead[i] == 0) || (bufRead[i] == 0x56)) {
|
||
*from = stepFromOrTo + offset;
|
||
*isFrom = true;
|
||
}
|
||
} else {
|
||
if (bufRead[i] == 0x55) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
++stepFromOrTo;
|
||
}
|
||
|
||
if ((*isFrom) && (isTo))
|
||
break;
|
||
|
||
if (brMask == 0) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
}
|
||
fr = f_close_i(fs, &fileMask);
|
||
|
||
|
||
*lenTransPaket = 0;
|
||
if (*isFrom) {
|
||
|
||
uint32_t leftFileSize = to - *from;
|
||
*lenTransPaket = TRANS_MIN(leftFileSize, LEN_TRANS_PACKET - sizeof(tStructTransportKvitPacket));
|
||
// *lenTransPaket = TRANS_MIN(leftFileSize, 13);
|
||
|
||
uint8_t *dataSendPacket = &bufSendPacket[sizeof(tStructTransportKvitPacket)];
|
||
|
||
// Открытие файла представления
|
||
fr = f_open_i(fs, &fileRep, (TCHAR *) path_rep_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileRep, offset);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_read_i(fs, &fileRep, dataSendPacket, *lenTransPaket, &brRep);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileRep);
|
||
return false;
|
||
}
|
||
|
||
fr = f_close_i(fs, &fileRep);
|
||
|
||
*lenTransPaket += sizeof(tStructTransportKvitPacket);
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// Создание пакета транспортного уровня
|
||
bool
|
||
createPacketTransport(tFs *fs, uint32_t offset, uint8_t *bufSendPacket, bool *isFrom, uint32_t *from,
|
||
uint32_t *lenTransPaket,
|
||
tFileSendInfo *fileSendInfo,
|
||
tRtcIO *rtcIo, char *path_rep_fileName, char *path_mask_fileName) {
|
||
uint8_t bufRead[512];
|
||
FIL fileRep;
|
||
FIL fileMask;
|
||
FRESULT fr;
|
||
UINT brRep, brMask; // File read/write count
|
||
|
||
// Создание заголовка транспортного пакета
|
||
tStructTransportPacket *structTransportPacket = (tStructTransportPacket *) bufSendPacket;
|
||
|
||
structTransportPacket->versionProtocol = 1;
|
||
|
||
structTransportPacket->dataType = 12; // Пакет не квитируемого сообщения
|
||
if (fileSendInfo->kvs)
|
||
structTransportPacket->dataType = 0; // Пакет квитируемого сообщения
|
||
|
||
structTransportPacket->numberSender = fileSendInfo->from; // НС отправителя;
|
||
structTransportPacket->dateCreateTransportPacketDay = fileSendInfo->dateDay;
|
||
structTransportPacket->dateCreateTransportPacketMon = fileSendInfo->dateMon;
|
||
structTransportPacket->numberMessage = fileSendInfo->mnum;
|
||
|
||
//structTransportPacket->offsetPacket = offsetPacket;
|
||
//structTransportPacket->isEnd = isEnd;
|
||
|
||
*isFrom = false;
|
||
bool isTo = false;
|
||
uint32_t stepFromOrTo = 0;
|
||
uint32_t stepFromOrTo_MaxLen = 0;
|
||
*from = 0;
|
||
uint32_t to = 0;
|
||
|
||
// Открытие файла маски
|
||
fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileMask, offset);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
for (;;) {
|
||
|
||
fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
|
||
for (uint32_t i = 0; i < brMask; ++i) {
|
||
|
||
// Поиск неотправленного начала
|
||
if (*isFrom == false) {
|
||
if ((bufRead[i] == 0) || (bufRead[i] == 0x56)) {
|
||
*from = stepFromOrTo + offset;
|
||
|
||
*isFrom = true;
|
||
}
|
||
} else {
|
||
// Поиск неотправленного конца
|
||
if (bufRead[i] == 0x55) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
++stepFromOrTo;
|
||
|
||
if (*isFrom) {
|
||
++stepFromOrTo_MaxLen;
|
||
}
|
||
}
|
||
|
||
|
||
// Нашли начало и конец
|
||
if ((*isFrom) && (isTo))
|
||
break;
|
||
|
||
// Нашли данные для полного пакета
|
||
if (stepFromOrTo_MaxLen > LEN_TRANS_PACKET) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
|
||
// Нашли конец файла
|
||
if (brMask == 0) {
|
||
to = stepFromOrTo + offset;
|
||
isTo = true;
|
||
break;
|
||
}
|
||
}
|
||
fr = f_close_i(fs, &fileMask);
|
||
|
||
|
||
uint32_t dl = fileSendInfo->sizeFileRep - stepFromOrTo + *from;
|
||
|
||
*lenTransPaket = 0;
|
||
if (*isFrom) {
|
||
|
||
uint32_t leftFileSize = to - *from;
|
||
*lenTransPaket = TRANS_MIN(leftFileSize, LEN_TRANS_PACKET - sizeof(tStructTransportPacket));
|
||
// *lenTransPaket = TRANS_MIN(leftFileSize, 13);
|
||
|
||
structTransportPacket->offsetPacket = *from;
|
||
structTransportPacket->isEnd = 0;
|
||
|
||
if ((*from + *lenTransPaket) == fileSendInfo->sizeFileRep) {
|
||
structTransportPacket->isEnd = 1;
|
||
}
|
||
|
||
uint8_t *dataSendPacket = &bufSendPacket[sizeof(tStructTransportPacket)];
|
||
|
||
// Открытие файла представления
|
||
fr = f_open_i(fs, &fileRep, (TCHAR *) path_rep_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileRep, *from);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_read_i(fs, &fileRep, dataSendPacket, *lenTransPaket, &brRep);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileRep);
|
||
return false;
|
||
}
|
||
|
||
fr = f_close_i(fs, &fileRep);
|
||
|
||
*lenTransPaket += sizeof(tStructTransportPacket);
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
// Редактирование файла маски пакета транспортного уровня
|
||
bool editMaskPacketTransport(tFs *fs, uint32_t from, uint32_t lenTransPaket, char *path_mask_fileName,
|
||
tBufFreeFillState isFill) {
|
||
FIL fileMask;
|
||
FRESULT fr;
|
||
UINT bwMask; // File read/write count
|
||
|
||
// Открытие файла маски
|
||
fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_WRITE);
|
||
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
fr = f_lseek_i(fs, &fileMask, from);
|
||
|
||
const uint8_t *pBuf = bufFillOperation;
|
||
|
||
if (isFill == BUF_NO_RECEIVE)
|
||
pBuf = bufFreeOperation;
|
||
|
||
if (isFill == BUF_NO_RECEIVE_KV)
|
||
pBuf = bufFreeOperationKV;
|
||
|
||
|
||
uint32_t lenMaskInteger = lenTransPaket / sizeof(bufFreeOperation);
|
||
uint32_t lenMaskTail = lenTransPaket % sizeof(bufFreeOperation);
|
||
|
||
for (uint32_t i = 0; i < lenMaskInteger; ++i) {
|
||
fr = f_write_i(fs, &fileMask, pBuf, sizeof(bufFreeOperation), &bwMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (lenMaskTail > 0) {
|
||
fr = f_write_i(fs, &fileMask, pBuf, lenMaskTail, &bwMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
fr = f_close_i(fs, &fileMask);
|
||
|
||
return true;
|
||
}
|
||
|
||
// Поиск неотправленных блоков в файле маски
|
||
bool isFindMaskPacketTransport(tFs *fs, bool *isFind, char *path_mask_fileName, tFileSendInfo *fileSendInfo) {
|
||
uint8_t bufRead[512];
|
||
|
||
FIL fileMask;
|
||
FRESULT fr;
|
||
UINT brMask; // File read/write count
|
||
|
||
*isFind = false;
|
||
uint32_t step_len_mask_file = 0;
|
||
|
||
fileSendInfo->bytes_sending = 0;
|
||
fileSendInfo->bytes_no_sending = 0;
|
||
|
||
// Открытие файла маски
|
||
fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
for (;;) {
|
||
|
||
fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
|
||
for (uint32_t i = 0; i < brMask; ++i) {
|
||
if ((bufRead[i] == 0x00) || (bufRead[i] == 0x56)) {
|
||
*isFind = true;
|
||
++fileSendInfo->bytes_no_sending;
|
||
// return true;
|
||
} else {
|
||
++fileSendInfo->bytes_sending;
|
||
}
|
||
++step_len_mask_file;
|
||
}
|
||
|
||
if ((step_len_mask_file == fileSendInfo->sizeFileRep) || (brMask == 0))
|
||
break;
|
||
|
||
}
|
||
fr = f_close_i(fs, &fileMask);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// Поиск неотправленных блоков в файле маски
|
||
bool isFindMaskPacketTransportIsNotProc(tFs *fs, bool *isFind, char *path_mask_fileName) {
|
||
uint8_t bufRead[512];
|
||
|
||
FIL fileMask;
|
||
FRESULT fr;
|
||
UINT brMask; // File read/write count
|
||
|
||
*isFind = false;
|
||
|
||
// Открытие файла маски
|
||
fr = f_open_i(fs, &fileMask, (TCHAR *) path_mask_fileName, FA_READ);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
for (;;) {
|
||
|
||
fr = f_read_i(fs, &fileMask, bufRead, sizeof(bufRead), &brMask);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &fileMask);
|
||
return false;
|
||
}
|
||
|
||
for (uint32_t i = 0; i < brMask; ++i) {
|
||
if ((bufRead[i] == 0x00) || (bufRead[i] == 0x56)) {
|
||
*isFind = true;
|
||
fr = f_close_i(fs, &fileMask);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
if (brMask == 0)
|
||
break;
|
||
|
||
}
|
||
fr = f_close_i(fs, &fileMask);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool isAlreadyAdded(tFs *fs, uint32_t mnum) {
|
||
// uint32_t mnum = atoi(fname);
|
||
|
||
// Получение имени файла по ид
|
||
char fileNameRep[24];
|
||
// Создание имени файла
|
||
createFileNameForId(fileNameRep, "", mnum, "REP");
|
||
|
||
FRESULT fr;
|
||
FILINFO fno;
|
||
DIR dj;
|
||
|
||
bool result = false;
|
||
fr = f_findfirst_i(fs, &dj, &fno, dir_rep_out, fileNameRep);
|
||
|
||
if (fr == FR_OK && fno.fname[0])
|
||
result = true;
|
||
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
uint32_t
|
||
getMaxUrgencyOutbox(tFs *fs, tGonetsReedSalmon *gonetsReedSalmon, md5a_context *md5ctx, tRtcIO *rtcIo, char *path,
|
||
char *out_fileName, char *path_out_fileName, tTypeFile typeFile, tDeviceStorageIni *store,
|
||
uint32_t gr) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char bufDumpFile[512];
|
||
char dirFileName[MAX_LEN_PATH_FS];
|
||
// Структура содержащая информацию по исходящему сообщению
|
||
tFileSendInfo fileSendInfo;
|
||
uint32_t idFilesArray[16];
|
||
|
||
uint32_t cuteOffsetBegin = 0;
|
||
|
||
if (typeFile == TYPE_FILE_TRACERT) {
|
||
uint32_t count = getCountTypeFileInRepout(fs, TYPE_FILE_TRACERT, idFilesArray);
|
||
uint32_t countStep = count;
|
||
|
||
while (countStep < store->nvm.Settings_Tracert.MaxBuf_v) {
|
||
|
||
uint32_t idFileOld = getOldOut(fs, (char *) dir_tracert, idFilesArray, countStep);
|
||
|
||
if (idFileOld == 0)
|
||
break;
|
||
|
||
// Создание файла с полным путем
|
||
createFileNameForId(path_out_fileName, path, idFileOld, "OTM");
|
||
|
||
// Получение информации о файле
|
||
bool resultInfo = getInfoFromFileNameOutBox(fs, path_out_fileName, &fileSendInfo, &cuteOffsetBegin);
|
||
|
||
// Создание файла уровня представления
|
||
bool resultCreateRep = createFileRepresentation(fs, gonetsReedSalmon, md5ctx, rtcIo, path_out_fileName,
|
||
&fileSendInfo, gr, cuteOffsetBegin);
|
||
|
||
idFilesArray[countStep] = idFileOld;
|
||
++countStep;
|
||
}
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, "*.OTM");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
// Если файл представления уже создан
|
||
bool isAlready = isAlreadyAdded(fs, idFile);
|
||
if (isAlready) {
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Создание файла с полным путем
|
||
createFileNameForId(path_out_fileName, path, idFile, "OTM");
|
||
|
||
// Получение информации о файле
|
||
bool resultInfo = getInfoFromFileNameOutBox(fs, path_out_fileName, &fileSendInfo, &cuteOffsetBegin);
|
||
|
||
if ((fileSendInfo.typeFile == TYPE_FILE_AMS_RADAR) || (fileSendInfo.typeFile == TYPE_FILE_LORA_WAN)) {
|
||
|
||
uint32_t count = getCountTypeFileInRepout(fs, fileSendInfo.typeFile, idFilesArray);
|
||
uint32_t countStep = count;
|
||
|
||
uint32_t countMax;
|
||
|
||
if (fileSendInfo.typeFile == TYPE_FILE_AMS_RADAR)
|
||
countMax = store->nvm.Settings_AmsRadar.AmsRadarMaxBuf;
|
||
|
||
if (fileSendInfo.typeFile == TYPE_FILE_LORA_WAN)
|
||
countMax = store->nvm.Settings_LoRaWan.LoRaWanMaxBuf;
|
||
|
||
while (countStep < countMax) {
|
||
|
||
uint32_t idFileOld = getOldOut(fs, (char *) dir_outbox, idFilesArray, countStep);
|
||
|
||
if (idFileOld == 0)
|
||
break;
|
||
|
||
// Создание файла с полным путем
|
||
createFileNameForId(path_out_fileName, path, idFileOld, "OTM");
|
||
|
||
// Создание файла уровня представления
|
||
bool resultCreateRep = createFileRepresentation(fs, gonetsReedSalmon, md5ctx, rtcIo, path_out_fileName,
|
||
&fileSendInfo, gr, cuteOffsetBegin);
|
||
|
||
idFilesArray[countStep] = idFileOld;
|
||
++countStep;
|
||
}
|
||
|
||
|
||
} else {
|
||
|
||
// Создание файла уровня представления
|
||
bool resultCreateRep = createFileRepresentation(fs, gonetsReedSalmon, md5ctx, rtcIo, path_out_fileName,
|
||
&fileSendInfo, gr, cuteOffsetBegin);
|
||
|
||
}
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
// Создание файла уровня представления
|
||
bool createFileRepresentation(tFs *fs, tGonetsReedSalmon *gonetsReedSalmon, md5a_context *md5ctx, tRtcIO *rtcIo,
|
||
char *path_out_fileName, tFileSendInfo *fileSendInfo, uint32_t gr,
|
||
uint32_t cuteOffsetBegin) {
|
||
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, fileSendInfo->mnum);
|
||
|
||
FRESULT fr;
|
||
FIL file;
|
||
|
||
fr = f_open_i(fs, &file, (TCHAR *) path_dir_rep_fileName, FA_WRITE | FA_CREATE_ALWAYS);
|
||
if (fr) {
|
||
return false;
|
||
}
|
||
|
||
tStructRepresentationPacket structRepresentationPacket;
|
||
memset(&structRepresentationPacket, 0, sizeof(structRepresentationPacket));
|
||
structRepresentationPacket.versionProtocol = 1;
|
||
|
||
uint32_t to = atoi(fileSendInfo->to);
|
||
|
||
if (to < 100) {
|
||
structRepresentationPacket.classMessage = 3; // Сообщения в шлюз
|
||
structRepresentationPacket.typeMessage = 1; // Электронная почта в сети Интернет
|
||
} else {
|
||
structRepresentationPacket.classMessage = 1; // Целевые сообщения
|
||
|
||
if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
|
||
structRepresentationPacket.typeMessage = 4; // сообщение о местоположении
|
||
} else {
|
||
|
||
if (strcmp(fileSendInfo->subj, "file") == 0) {
|
||
structRepresentationPacket.typeMessage = 2; // файл с простой структурой
|
||
} else {
|
||
structRepresentationPacket.typeMessage = 1; // Текстовые сообщения
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
if (fileSendInfo->typeFile != TYPE_FILE_KVITIN) {
|
||
FILINFO fnoOutInf;
|
||
FRESULT frOutInf;
|
||
|
||
if (fileSendInfo->typeFile != TYPE_FILE_TRACERT) {
|
||
|
||
frOutInf = f_stat(path_out_fileName, &fnoOutInf);
|
||
if (frOutInf) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
|
||
|
||
char path_dir_tracert_dat[MAX_LEN_PATH_FS];
|
||
createFileNameForId(path_dir_tracert_dat, (char *) dir_tracert, fileSendInfo->mnum, "DAT");
|
||
|
||
frOutInf = f_stat(path_dir_tracert_dat, &fnoOutInf);
|
||
if (frOutInf) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
structRepresentationPacket.typeCrc = 1;
|
||
|
||
if (fnoOutInf.fsize > 100 * 1024) {
|
||
structRepresentationPacket.typeCrc = 2;
|
||
}
|
||
}
|
||
|
||
uint8_t *head = (uint8_t *) &structRepresentationPacket;
|
||
uint8_t crc8 = GonetsCrc8(head, 9);
|
||
|
||
structRepresentationPacket.crc8 = crc8;
|
||
structRepresentationPacket.rc = 0;
|
||
vGonetsReedSalmonEncode_1410_3430(gonetsReedSalmon, (uint8_t *) &structRepresentationPacket);
|
||
|
||
uint32_t initCrc32 = 0xFFFFFFFF;
|
||
|
||
// Запись заголовка
|
||
if (fileSendInfo->typeFile != TYPE_FILE_KVITIN) {
|
||
UINT bytes_written;
|
||
fr = f_write_i(fs, &file, &structRepresentationPacket, sizeof(tStructRepresentationPacket), &bytes_written);
|
||
|
||
if (fr) {
|
||
f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
|
||
if (fileSendInfo->typeFile != TYPE_FILE_TRACERT) {
|
||
// Запись заголовка для сервера ГОНЦА
|
||
if (isTo(fileSendInfo->to, '@')) {
|
||
char bufDumpFileHead[512];
|
||
cuteOffset(fs, path_out_fileName, bufDumpFileHead, sizeof(bufDumpFileHead), cuteOffsetBegin);
|
||
|
||
// crc32
|
||
if (structRepresentationPacket.typeCrc == 1) {
|
||
initCrc32 = GonetsCrc32_update((uint8_t *) bufDumpFileHead, fileSendInfo->offsetMsg - 13,
|
||
initCrc32);
|
||
}
|
||
|
||
// md5
|
||
if (structRepresentationPacket.typeCrc == 2) {
|
||
md5a_update(md5ctx, (uint8_t *) bufDumpFileHead, (int) fileSendInfo->offsetMsg - 13);
|
||
}
|
||
|
||
fr = f_write_i(fs, &file, &bufDumpFileHead, fileSendInfo->offsetMsg - 13, &bytes_written);
|
||
|
||
if (fr) {
|
||
f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
fr = f_close_i(fs, &file);
|
||
|
||
if (fileSendInfo->typeFile != TYPE_FILE_TRACERT) {
|
||
|
||
bool res = CopyFileFs_crc_md5(fs, structRepresentationPacket.typeCrc, md5ctx, path_dir_rep_fileName,
|
||
path_out_fileName, fileSendInfo->offsetMsg, initCrc32);
|
||
if (res == false) {
|
||
return false;
|
||
}
|
||
|
||
}
|
||
|
||
if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
|
||
|
||
char path_dir_tracert_dat[MAX_LEN_PATH_FS];
|
||
createFileNameForId(path_dir_tracert_dat, (char *) dir_tracert, fileSendInfo->mnum, "DAT");
|
||
|
||
bool res = CopyFileFs_crc_md5(fs, structRepresentationPacket.typeCrc, md5ctx, path_dir_rep_fileName,
|
||
path_dir_tracert_dat, fileSendInfo->offsetMsg, 0xFFFFFFFF);
|
||
if (res == false) {
|
||
return false;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
// Добавление размера REP файла в info структуру
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
|
||
frInf = f_stat(path_dir_rep_fileName, &fnoInf);
|
||
if (frInf) {
|
||
return false;
|
||
} else {
|
||
fileSendInfo->sizeFileRep = fnoInf.fsize;
|
||
}
|
||
|
||
time_t timestamp;
|
||
rtcIo->get(rtcIo, ×tamp);
|
||
timestamp += gr * 3600;
|
||
|
||
struct tm timestampTM;
|
||
localtime_r(×tamp, ×tampTM);
|
||
|
||
|
||
fileSendInfo->bytes_sending = 0;
|
||
fileSendInfo->bytes_no_sending = fileSendInfo->sizeFileRep;
|
||
|
||
fileSendInfo->dateDay = timestampTM.tm_mday;
|
||
fileSendInfo->dateMon = timestampTM.tm_mon + 1;
|
||
|
||
// Создание файла маски
|
||
UINT bw;
|
||
|
||
uint32_t lenMaskInteger = fileSendInfo->sizeFileRep / sizeof(bufFreeOperation);
|
||
uint32_t lenMaskTail = fileSendInfo->sizeFileRep % sizeof(bufFreeOperation);
|
||
|
||
fr = f_open_i(fs, &file, (TCHAR *) path_dir_mask_fileName, FA_WRITE | FA_CREATE_ALWAYS);
|
||
if (fr) return false;
|
||
|
||
for (uint32_t i = 0; i < lenMaskInteger; ++i) {
|
||
fr = f_write_i(fs, &file, bufFreeOperation, sizeof(bufFreeOperation), &bw);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (lenMaskTail > 0) {
|
||
fr = f_write_i(fs, &file, bufFreeOperation, lenMaskTail, &bw);
|
||
if (fr) {
|
||
fr = f_close_i(fs, &file);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
fr = f_close_i(fs, &file);
|
||
|
||
fileSendInfo->crc32_MSK = CrcFileFs(fs, path_dir_mask_fileName);
|
||
fileSendInfo->crc32_REP = CrcFileFs(fs, path_dir_rep_fileName);
|
||
|
||
// Создание info файла
|
||
bool result = writeSendFileInfo(fs, fileSendInfo, path_dir_info_fileName);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// Перенос файла в хранилище отправленных сообщений sentbox
|
||
bool renameFromOutBoxToSentBox(tFs *fs, tRtcIO *rtc, tFileSendInfo *fileSendInfo) {
|
||
|
||
// Путь к каталогу с датой
|
||
char path_sent_dirDate[MAX_LEN_PATH_FS];
|
||
path_sent_dirDate[0] = '\0';
|
||
getDateStr(rtc, path_sent_dirDate, sizeof(path_sent_dirDate));
|
||
|
||
// Путь к файлу в SENTBOX
|
||
char path_sent_fileName[MAX_LEN_PATH_FS];
|
||
path_sent_fileName[0] = '\0';
|
||
strcat(path_sent_fileName, dir_sentbox);
|
||
strcat(path_sent_fileName, path_sent_dirDate);
|
||
strcat(path_sent_fileName, "/");
|
||
|
||
FRESULT fr;
|
||
fr = f_mkdir_i(fs, path_sent_fileName);
|
||
|
||
if (fr) {
|
||
if (fr != FR_EXIST)
|
||
return false;
|
||
}
|
||
|
||
|
||
// Путь к файлу в OUTBOX
|
||
char path_out_fileName[MAX_LEN_PATH_FS];
|
||
path_out_fileName[0] = '\0';
|
||
|
||
// Создание имени файла по id
|
||
char sent_fileName[MAX_LEN_PATH_FS];
|
||
sent_fileName[0] = '\0';
|
||
|
||
|
||
if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
|
||
createFileNameForId(path_out_fileName, (char *) dir_tracert, fileSendInfo->mnum, "OTM");
|
||
} else {
|
||
createFileNameForId(path_out_fileName, (char *) dir_outbox, fileSendInfo->mnum, "OTM");
|
||
}
|
||
|
||
createFileNameForId(sent_fileName, "", fileSendInfo->mnum, "STM");
|
||
strcat(path_sent_fileName, sent_fileName);
|
||
|
||
//fr = f_rename_i(fs, path_out_fileName, path_sent_fileName);
|
||
CopyFileFs(fs, path_sent_fileName, path_out_fileName, 0);
|
||
f_unlink_i(fs, path_out_fileName);
|
||
|
||
|
||
if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
|
||
path_out_fileName[0] = '\0';
|
||
sent_fileName[0] = '\0';
|
||
|
||
createFileNameForId(path_out_fileName, (char *) dir_tracert, fileSendInfo->mnum, "DAT");
|
||
|
||
createFileNameForId(sent_fileName, "", fileSendInfo->mnum, "DAT");
|
||
|
||
|
||
path_sent_fileName[0] = '\0';
|
||
strcat(path_sent_fileName, dir_sentbox);
|
||
strcat(path_sent_fileName, path_sent_dirDate);
|
||
strcat(path_sent_fileName, "/");
|
||
|
||
strcat(path_sent_fileName, sent_fileName);
|
||
|
||
//fr = f_rename_i(fs, path_out_fileName, path_sent_fileName);
|
||
CopyFileFs(fs, path_sent_fileName, path_out_fileName, 0);
|
||
f_unlink_i(fs, path_out_fileName);
|
||
|
||
}
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
bool createBufStateFileSend(tFs *fs) {
|
||
FIL file;
|
||
char temp_filename[MAX_LEN_PATH_FS];
|
||
UINT bytes_written;
|
||
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
tFileSendInfo fileSendInfo;
|
||
|
||
char buf_proc[120];
|
||
|
||
|
||
char dirScan[MAX_LEN_PATH_FS];
|
||
dirScan[0] = '\0';
|
||
strcat(dirScan, dir_rep_out);
|
||
|
||
char dirFileScan[MAX_LEN_PATH_FS];
|
||
|
||
// uint8_t bufMnum[maxFilesOutBox];
|
||
// memset(bufMnum, 0, sizeof(bufMnum));
|
||
// int countFileInfo = 0;
|
||
|
||
temp_filename[0] = '\0';
|
||
strcat(temp_filename, file_dir_proc);
|
||
fr = f_open_i(fs, &file, (TCHAR *) temp_filename, FA_CREATE_ALWAYS | FA_WRITE);
|
||
|
||
buf_proc[0] = '\0';
|
||
strcat(buf_proc, "{\"InfoSend\":[");
|
||
fr = f_write_i(fs, &file, buf_proc, strlen(buf_proc), &bytes_written);
|
||
|
||
buf_proc[0] = ' ';
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, dirScan, "*.INF");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
dirFileScan[0] = '\0';
|
||
strcat(dirFileScan, dirScan);
|
||
strcat(dirFileScan, fno.fname);
|
||
|
||
readSendFileInfo(fs, &fileSendInfo, dirFileScan);
|
||
|
||
struct to_json jsonResponse_State[] = {
|
||
{.name = "mnum", .value = &fileSendInfo.mnum, .vtype = t_to_uint32_t, .stype = t_to_object},
|
||
{.name = "kvs", .value = &fileSendInfo.kvs, .vtype = t_to_uint8_t},
|
||
{.name = "isSendAll", .value = &fileSendInfo.isSendAll, .vtype = t_to_uint8_t},
|
||
{.name = "bytes_sending", .value = &fileSendInfo.bytes_sending, .vtype = t_to_uint32_t},
|
||
{.name = "bytes_no_sending", .value = &fileSendInfo.bytes_no_sending, .vtype = t_to_uint32_t},
|
||
{NULL}
|
||
};
|
||
|
||
size_t len_json = json_generate(&buf_proc[1], jsonResponse_State, sizeof(buf_proc));
|
||
|
||
fr = f_write_i(fs, &file, buf_proc, len_json + 1, &bytes_written);
|
||
|
||
buf_proc[0] = ',';
|
||
|
||
|
||
// bufMnum[countFileInfo] = 1;
|
||
|
||
// bufStateFileSend[countFileInfo].valid = 1;
|
||
// bufStateFileSend[countFileInfo].kvs = fileSendInfo.kvs;
|
||
// bufStateFileSend[countFileInfo].isSendAll = fileSendInfo.isSendAll;
|
||
// bufStateFileSend[countFileInfo].mnum = fileSendInfo.mnum;
|
||
// bufStateFileSend[countFileInfo].bytes_sending = fileSendInfo.bytes_sending;
|
||
// bufStateFileSend[countFileInfo].bytes_no_sending = fileSendInfo.bytes_no_sending;
|
||
|
||
// ++countFileInfo;
|
||
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
buf_proc[0] = '\0';
|
||
strcat(buf_proc, "]}");
|
||
fr = f_write_i(fs, &file, buf_proc, strlen(buf_proc), &bytes_written);
|
||
fr = f_close_i(fs, &file);
|
||
|
||
|
||
// for (int i = 0; i < maxFilesOutBox; ++i) {
|
||
// if (bufMnum[i] == 0) {
|
||
// bufStateFileSend[i].valid = 0;
|
||
// }
|
||
// }
|
||
|
||
return true;
|
||
} |