void SDHandler::_closeFile() {
if(_sdBuffer.length() > 0) {
_log("_closeFile: buffer is not 0\n");
_saveData();
}
if(_fp != 0) {
_log("_closeFile: file is open\n");
fclose(_fp);
_fp = 0;
}
_log("_closeFile: file is now closed\n");
}
void CachedImage::download()
{
if (_url.isEmpty() || isDownloading())
return;
if (_available)
{
emit available();
return;
}
if (_headReply)
_headReply->abort();
_reply = _man->web()->get(QNetworkRequest(_url));
Q_TEST(connect(_reply, SIGNAL(finished()), this, SLOT(_saveData())));
Q_TEST(connect(_reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(_changeBytes(qint64,qint64))));
Q_TEST(connect(_reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(_printError(QNetworkReply::NetworkError))));
Q_TEST(connect(_reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(_printErrors(QList<QSslError>))));
emit downloadingChanged();
}
void SDHandler::_filterData(const std::string &data) {
#if SD_TESTING
if(!_active) {
#else
if(!_active || !_dateInitialized) {
#endif
return;
}
#if REDUCED_SD_LOGGING
if(data.compare(1, 5, "GPGGA", 0, 5) == 0 || data.compare(1, 5, "GPRMC", 0, 5) == 0) {
if(data.compare(13, 3, ".00", 0, 3) == 0 || data.compare(13, 3, ".99", 0, 3) == 0) {
//fprintf(_fp, data.c_str());
_sdBuffer += data;
}
}
#else
//fprintf(_fp, data.c_str());
_sdBuffer += data;
#endif
#if SD_TESTING
_log("_sdBuffer length: %i\n", _sdBuffer.length());
#endif
if(_sdBuffer.length() > 2000) {
_saveData();
}
}
void SDHandler::_saveData() {
_led->write(0);
#if DEBUG_LOGGING
int blockSize = 16;
int i = 1;
_log("Checking memory with blocksize %d char ...\n", blockSize);
while (true) {
char *p = (char *) malloc(i * blockSize);
if (p == NULL)
break;
free(p);
++i;
}
_log("Memory OK for %d char\n", (i - 1) * blockSize);
#endif
if(_fp != 0) {
_log("Saving data to SD\n");
int wroteBytes = fprintf(_fp, _sdBuffer.c_str());
BT.printf("Wrote %i bytes to SD\n", wroteBytes);
if(wroteBytes < 0) {
writeFailed = true;
}
}
_sdBuffer.clear();
#if DEBUG_LOGGING
//_log("Current Stack : 0x%08X\r\n", __current_sp());
//_log("Current Heap : 0x%08X\r\n", __current_pc());
blockSize = 16;
i = 1;
_log("Checking memory with blocksize %d char ...\n", blockSize);
while (true) {
char *p = (char *) malloc(i * blockSize);
if (p == NULL)
break;
free(p);
++i;
}
_log("Memory OK for %d char\n", (i - 1) * blockSize);
#endif
_led->write(1);
}
void SaveFileManager::createASaveFile(int i)
// public function that wraps the functionality of the class into one client call
{
_parseAndAddData();
_saveData(i);
}
// ======= FTP thread handler =========
static void _thread_ftp(void*inContext)
{
(void)inContext;
fd_set readset, wrset;
struct timeval_t t_val;
int k;
uint32_t timeout = 0;
uint8_t recv_tmo = 0;
t_val.tv_sec = 0;
t_val.tv_usec = 5000;
timeout = mico_get_time();
ftp_log("\r\n[FTP trd] FTP THREAD STARTED\r\n");
// *** First we have to get IP address and connect the cmd socket
char pIPstr[16]={0};
int err;
k = 3;
do {
err = gethostbyname((char *)pDomain4Dns, (uint8_t *)pIPstr, 16);
if (err != kNoErr) {
k--;
mico_thread_msleep(50);
}
}while ((err != kNoErr) && (k > 0));
if ((err == kNoErr) && (ftpCmdSocket != NULL)) {
ftpCmdSocket->addr.s_ip = inet_addr(pIPstr);
ftpCmdSocket->clientFlag = NO_ACTION;
free(pDomain4Dns);
pDomain4Dns=NULL;
// Connect socket!
char ip[17];
memset(ip, 0x00, 17);
inet_ntoa(ip, ftpCmdSocket->addr.s_ip);
ftp_log("[FTP cmd] Got IP: %s, connecting...\r\n", ip);
struct sockaddr_t *paddr = &(ftpCmdSocket->addr);
int slen = sizeof(ftpCmdSocket->addr);
// _micoNotify will be called if connected
connect(ftpCmdSocket->socket, paddr, slen);
}
else {
ftp_log("[FTP dns] Get IP error\r\n");
goto terminate;
}
if (recvBuf == NULL) {
recvBuf = malloc(MAX_RECV_LEN+4);
memset(recvBuf, 0, MAX_RECV_LEN+4);
}
recvLen = 0;
// ===========================================================================
// Main Thread loop
while (1) {
mico_thread_msleep(5);
if (ftpCmdSocket == NULL) goto terminate;
if ( ((mico_get_time() - timeout) > MAX_FTP_TIMEOUT) ||
(((mico_get_time() - timeout) > 8000) && (!(status & FTP_LOGGED))) ) {
// ** TIMEOUT **
ftp_log("[FTP trd] Timeout\r\n");
timeout = mico_get_time();
if ((status & FTP_LOGGED))
ftpCmdSocket->clientFlag = REQ_ACTION_QUIT;
else
ftpCmdSocket->clientFlag = REQ_ACTION_DISCONNECT;
}
// ========== stage #1, Check cmd socket action requests ===================
//REQ_ACTION_DISCONNECT
if (ftpCmdSocket->clientFlag == REQ_ACTION_DISCONNECT) {
ftpCmdSocket->clientFlag = NO_ACTION;
closeDataSocket();
ftp_log("[FTP cmd] Socket disconnected\r\n");
if (ftpCmdSocket->disconnect_cb != LUA_NOREF) {
queue_msg_t msg;
msg.L = gL;
msg.source = onFTP;
msg.para1 = 0;
msg.para2 = ftpCmdSocket->disconnect_cb;
mico_rtos_push_to_queue( &os_queue, &msg, 0);
}
closeCmdSocket(0);
continue;
}
//REQ_ACTION_QUIT
if (ftpCmdSocket->clientFlag == REQ_ACTION_QUIT) {
if ((status & FTP_LOGGED)) {
ftpCmdSocket->clientFlag = NO_ACTION;
ftp_log("[FTP cmd] Quit command\r\n");
if (_send("QUIT\r\n", 6) <= 0) {
ftpCmdSocket->clientFlag = REQ_ACTION_DISCONNECT;
}
}
else ftpCmdSocket->clientFlag = REQ_ACTION_DISCONNECT;
continue;
}
if (!(status & FTP_CONNECTED)) continue;
//--------------------------------------
//REQ_ACTION_LIST, REQ_ACTION_RECV, REQ_ACTION_SEND
else if ((ftpCmdSocket->clientFlag == REQ_ACTION_LIST) ||
(ftpCmdSocket->clientFlag == REQ_ACTION_RECV) ||
(ftpCmdSocket->clientFlag == REQ_ACTION_SEND)) {
ftpCmdSocket->clientLastFlag = ftpCmdSocket->clientFlag;
ftpCmdSocket->clientFlag = NO_ACTION;
_send("PASV\r\n", 6);
}
//REQ_ACTION_DOLIST
else if (ftpCmdSocket->clientFlag == REQ_ACTION_DOLIST) {
ftpCmdSocket->clientFlag = NO_ACTION;
int res;
if (ftpfile != NULL) {
char tmps[100];
if (list_type == 1) sprintf(tmps,"NLST %s\r\n", ftpfile);
else sprintf(tmps,"LIST %s\r\n", ftpfile);
res = _send(&tmps[0], strlen(ftpfile)+7);
free(ftpfile);
ftpfile = NULL;
}
else {
if (list_type == 1) res = _send("NLST\r\n", 6);
else res = _send("LIST\r\n", 6);
}
if (res > 0) status |= FTP_LISTING;
else {
ftp_log("[FTP cmd] LIST command failed.\r\n");
}
}
//REQ_ACTION_DORECV
else if (ftpCmdSocket->clientFlag == REQ_ACTION_DORECV) {
ftpCmdSocket->clientFlag = NO_ACTION;
char tmps[100];
sprintf(tmps,"RETR %s\r\n", ftpfile);
int res = _send(&tmps[0], strlen(ftpfile)+7);
if (res > 0) {
status |= FTP_RECEIVING;
file_status = 0;
}
else {
ftp_log("[FTP cmd] RETR command failed.\r\n");
file_status = -4;
}
}
//REQ_ACTION_DOSEND
else if (ftpCmdSocket->clientFlag == REQ_ACTION_DOSEND) {
ftpCmdSocket->clientFlag = NO_ACTION;
char tmps[100];
if ((send_type & SEND_APPEND)) sprintf(tmps,"APPE %s\r\n", ftpfile);
else sprintf(tmps,"STOR %s\r\n", ftpfile);
int res = _send(&tmps[0], strlen(ftpfile)+7);
if (res > 0) {
file_status = 0;
}
else {
ftp_log("[FTP cmd] STOR/APPE command failed.\r\n");
file_status = -4;
}
}
//REQ_ACTION_CHDIR
else if (ftpCmdSocket->clientFlag == REQ_ACTION_CHDIR) {
ftpCmdSocket->clientFlag = NO_ACTION;
if (ftpfile != NULL) {
char tmps[100];
sprintf(tmps,"CWD %s\r\n", ftpfile);
_send(&tmps[0], strlen(ftpfile)+6);
free(ftpfile);
ftpfile = NULL;
}
else {
_send("PWD\r\n", 5);
}
}
//REQ_ACTION_LOGGED
else if (ftpCmdSocket->clientFlag == REQ_ACTION_LOGGED) {
ftpCmdSocket->clientFlag=NO_ACTION;
if (ftpCmdSocket->logon_cb != LUA_NOREF) {
queue_msg_t msg;
msg.L = gL;
msg.source = onFTP;
msg.para1 = 1;
msg.para3 = NULL;
msg.para2 = ftpCmdSocket->logon_cb;
mico_rtos_push_to_queue( &os_queue, &msg, 0);
}
}
//REQ_ACTION_LIST_RECEIVED
else if (ftpCmdSocket->clientFlag == REQ_ACTION_LIST_RECEIVED) {
ftpCmdSocket->clientFlag=NO_ACTION;
if (ftpCmdSocket->list_cb != LUA_NOREF) {
queue_msg_t msg;
msg.L = gL;
msg.source = onFTP;
msg.para1 = recvDataLen;
msg.para2 = ftpCmdSocket->list_cb;
msg.para3 = (uint8_t*)malloc(recvDataLen+4);
if (msg.para3 != NULL) memcpy((char*)msg.para3, recvDataBuf, recvDataLen);
mico_rtos_push_to_queue( &os_queue, &msg, 0);
}
}
//REQ_ACTION_RECEIVED
else if (ftpCmdSocket->clientFlag == REQ_ACTION_RECEIVED) {
ftpCmdSocket->clientFlag=NO_ACTION;
if (ftpCmdSocket->received_cb != LUA_NOREF) {
queue_msg_t msg;
msg.L = gL;
msg.source = onFTP;
msg.para1 = file_status;
msg.para3 = NULL;
if (recv_type == RECV_TOSTRING) {
msg.para3 = (uint8_t*)malloc(recvDataLen+4);
if (msg.para3 != NULL) memcpy((char*)msg.para3, recvDataBuf, recvDataLen);
}
msg.para2 = ftpCmdSocket->received_cb;
mico_rtos_push_to_queue( &os_queue, &msg, 0);
}
}
//REQ_ACTION_SENT
else if (ftpCmdSocket->clientFlag == REQ_ACTION_SENT) {
ftpCmdSocket->clientFlag=NO_ACTION;
if (ftpCmdSocket->sent_cb != LUA_NOREF) {
queue_msg_t msg;
msg.L = gL;
msg.source = onFTP;
msg.para1 = file_status;
msg.para3 = NULL;
msg.para2 = ftpCmdSocket->sent_cb;
mico_rtos_push_to_queue( &os_queue, &msg, 0);
}
}
// ========== stage 2, check data send =====================================
if ((ftpDataSocket != NULL) && ((status & FTP_SENDING))) {
FD_ZERO(&wrset);
FD_SET(ftpDataSocket->socket, &wrset);
// check socket state
select(ftpDataSocket->socket+1, NULL, &wrset, NULL, &t_val);
if (FD_ISSET(ftpDataSocket->socket, &wrset)) {
int err;
if ((send_type & SEND_STRING)) err = _sendString();
else err = _sendFile();
if (err != 0) {
closeDataSocket();
// close file;
if (file_fd != FILE_NOT_OPENED) {
SPIFFS_close(&fs,file_fd);
file_fd = FILE_NOT_OPENED;
ftp_log("\r\n[FTP dta] Data file closed\r\n");
}
data_done = 1;
status &= ~FTP_SENDING;
ftpCmdSocket->clientFlag = REQ_ACTION_SENT;
}
continue;
}
}
// ========== stage 3, check receive&disconnect ============================
FD_ZERO(&readset);
// ** select sockets to monitor for receive or disconnect
int maxfd = ftpCmdSocket->socket;
FD_SET(ftpCmdSocket->socket, &readset);
if ( (ftpDataSocket != NULL) && ((status & FTP_DATACONNECTED)) ) {
if (ftpDataSocket->socket > maxfd) maxfd = ftpDataSocket->socket;
FD_SET(ftpDataSocket->socket, &readset);
}
// ** check sockets state
select(maxfd+1, &readset, NULL, NULL, &t_val);
// ** Check COMMAND socket
if (FD_ISSET(ftpCmdSocket->socket, &readset)) {
// read received data to buffer
int rcv_len;
if ((MAX_RECV_LEN-recvLen) > 1) {
rcv_len = recv(ftpCmdSocket->socket, (recvBuf+recvLen), MAX_RECV_LEN-recvLen-1, 0);
}
else { // buffer full, ignore received bytes
char tmpb[16];
rcv_len = recv(ftpCmdSocket->socket, &tmpb[0], 16, 0);
}
if (rcv_len <= 0) { // failed
ftp_log("\r\n[FTP cmd] Disconnect!\r\n");
ftpCmdSocket->clientFlag = REQ_ACTION_DISCONNECT;
continue;
}
recvLen += rcv_len;
_checkCmdResponse(); // leave only the last line in buffer
timeout = mico_get_time();
recv_tmo = 0;
}
// ** Check DATA socket
if ( (ftpDataSocket != NULL) && ((status & FTP_DATACONNECTED)) ) {
if (FD_ISSET(ftpDataSocket->socket, &readset)) {
// read received data to buffer
int rcv_len = recv(ftpDataSocket->socket, (recvDataBuf+recvDataLen), max_recv_datalen-recvDataLen-1, 0);
if (rcv_len <= 0) { // failed
if (!(status & (FTP_RECEIVING | FTP_LISTING))) {
ftp_log("\r\n[FTP dta] Disconnect!\r\n");
closeDataSocket();
file_status = -9;
data_done = 1;
}
continue;
}
else {
if ((status & FTP_RECEIVING) && (recv_type == RECV_TOFILE)) {
// === write received data to file ===
recvDataLen = rcv_len;
_saveData(0);
recvDataLen = 0;
}
else if ((status & FTP_LISTING) || ((status & FTP_RECEIVING) && (recv_type == RECV_TOSTRING))) {
if ((recvDataLen + rcv_len) < (max_recv_datalen-16)) recvDataLen += rcv_len;
else recvDataLen = max_recv_datalen-16;
*(recvDataBuf + recvDataLen) = '\0';
}
}
timeout = mico_get_time();
recv_tmo = 0;
}
}
// ===== nothing received ==================================================
recv_tmo++;
if (recv_tmo < 10) continue;
recv_tmo = 0;
// == Check if something was received from Command socket ==
if (recvLen > 0) {
// == Analize response ===
response();
recvLen = 0;
memset(recvBuf, 0, MAX_RECV_LEN);
}
// == Check if Data socket was receiving ==
if ((status & (FTP_RECEIVING | FTP_LISTING))) {
// Finish all operattions on data socket
if ((status & FTP_RECEIVING) && (recv_type == RECV_TOFILE)) {
_saveData(1);
recvDataLen = 0;
}
else {
if ((status & FTP_RECEIVING) && (recv_type == RECV_TOSTRING)) {
file_status = recvDataLen;
}
ftp_log("[FTP dta] Data received (%d)\r\n", recvDataLen);
}
if ((status & FTP_LISTING)) {
status &= ~FTP_LISTING;
ftpCmdSocket->clientFlag = REQ_ACTION_LIST_RECEIVED;
}
if ((status & FTP_RECEIVING)) {
status &= ~FTP_RECEIVING;
ftpCmdSocket->clientFlag = REQ_ACTION_RECEIVED;
}
// Close data socket
closeDataSocket();
data_done = 1;
}
} // while
terminate:
_ftp_deinit(0);
ftp_log("\r\n[FTP trd] FTP THREAD TERMINATED\r\n");
ftp_thread_is_started = false;
mico_rtos_delete_thread( NULL );
}
