/******************************************************************* * * _DrawEye */ static void _DrawEye(int xPos0, int yPos0, int xPos1, int yPos1, int rx, int ry) { int Hyp; int dx; int dy; int x; int y; GUI_SetColor(GUI_WHITE); GUI_FillEllipse(xPos0, yPos0, rx, ry); GUI_SetColor(GUI_BLACK); GUI_DrawEllipse(xPos0, yPos0, rx, ry); // // Calculate the coordinates // dx = xPos1 - xPos0 + 1; dy = yPos1 - yPos0 + 1; Hyp = GUI__sqrt32(dx * dx + dy * dy); x = (dx * _Min(rx - 5, abs(dx)) * FACTOR / Hyp) + xPos0 * FACTOR; y = (dy * _Min(ry - 5, abs(dy)) * FACTOR / Hyp) + yPos0 * FACTOR; // // Draw the pupil // GUI_AA_SetFactor(FACTOR); GUI_AA_EnableHiRes(); GUI_SetColor(0xD00000); GUI_AA_FillCircle(x, y, (int)(5.75 * FACTOR)); GUI_SetColor(GUI_BLACK); GUI_AA_FillCircle(x, y, (int)(3.75 * FACTOR)); GUI_SetColor(GUI_GRAY); GUI_AA_FillCircle(x - (int)(1.25 * FACTOR), y - (int)(1.25 * FACTOR), (int)(1.25 * FACTOR)); GUI_AA_DisableHiRes(); }
/** @details GOST_Crypt_GF_Data Функция шифрования в режиме гаммирования с обратной связью. @param *Data - указатель на данные для шифрования/расшифрования. @param Size - Размер данных @param *Synchro - Указатель на синхопросылку, также сюда заносится текущее значение синхропосылки. @param Mode - Если _GOST_Mode_Encrypt будет выполнено шифрование данных, если _GOST_Mode_Decrypt расшифрование @param *GOST_Table - Указатель на таблицу замены ГОСТ(ДК) в 128 байтном формате (вместо старшого полубайта 0). @param *GOST_Key - Указатель на 256 битный массив ключа(СК). @attention Если используется режим совместимости с входами еталонного шифратора, то синхропосылка Synchro для первого вызова должна быть подготовлена функцией GOST_Crypt_GF_Prepare_S. */ void GOST_Crypt_GF_Data(uint8_t *Data, uint32_t Size, uint8_t *Synchro, bool Mode, uint8_t *GOST_Table, uint8_t *GOST_Key ) { GOST_Data_Part *S=(GOST_Data_Part *)Synchro; uint8_t i,Tmp; while(Size!=0) { GOST_Crypt_32_E_Cicle(S,GOST_Table,(uint32_t *)GOST_Key);//C32(S) #if _GOST_ROT==1 (*S).half[_GOST_Data_Part_N2_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N2_Half]); (*S).half[_GOST_Data_Part_N1_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N1_Half]); #endif for (i=0;i<_Min(_GOST_Part_Size,Size);i++)//Data XOR S; S=Data; { if (Mode==_GOST_Mode_Encrypt) { *Data^=(*S).parts[i]; (*S).parts[i]=*Data; } else { Tmp=*Data; *Data^=(*S).parts[i]; (*S).parts[i]=Tmp; } Data++; } #if _GOST_ROT==1 (*S).half[_GOST_Data_Part_N2_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N2_Half]); (*S).half[_GOST_Data_Part_N1_Half]=_SWAPW32((*S).half[_GOST_Data_Part_N1_Half]); #endif Size-=i; } }
/** @details GOST_Crypt_G_Data Шифрование\Расшифрования блока данных в режиме гаммирования. @param *Data - Указатель на данные для шифрования\расшифрования, также сюда заносится результат работы. @param Size - Размер данных @param *Synchro - Указатель на синхопросылку, также сюда заносится текущее значение синхропосылки. @param *GOST_Table - Указатель на таблицу замены ГОСТ(ДК) в 128 байтном формате(вместо старшого полубайта 0). @param *GOST_Key - Указатель на 256 битный массив ключа(СК). @attention Синхропосылка Synchro для первого вызова должна быть подготовлена функцией/макросом GOST_Crypt_G_PS. */ void GOST_Crypt_G_Data(uint8_t *Data, uint32_t Size, uint8_t *Synchro, uint8_t *GOST_Table, uint8_t *GOST_Key ) { GOST_Data_Part *S=(GOST_Data_Part *)Synchro; GOST_Data_Part Tmp; uint8_t i; while(Size!=0) { (*S).half[_GOST_Data_Part_N1_Half]+=_GOST_C0; _GOST_ADC32((*S).half[_GOST_Data_Part_N2_Half],_GOST_C1,(*S).half[_GOST_Data_Part_N2_Half]);//_GOST_Data_Part_HiHalf Tmp=*S; GOST_Crypt_32_E_Cicle(&Tmp,GOST_Table,(uint32_t *)GOST_Key); #if _GOST_ROT==1 Tmp.half[_GOST_Data_Part_N2_Half]=_SWAPW32(Tmp.half[_GOST_Data_Part_N2_Half]); Tmp.half[_GOST_Data_Part_N1_Half]=_SWAPW32(Tmp.half[_GOST_Data_Part_N1_Half]); #endif for (i=0;i<_Min(_GOST_Part_Size,Size);i++) { *Data^=Tmp.parts[i]; Data++; } Size-=i; } }
/** @details GOST_Encrypt_SR Функция шифрования/расшифрования в режиме простой замены. @param *Data - Указатель на данные для шифрования, также сюда заносится результат. @param Size - Размер данных @param Mode - Если _GOST_Mode_Encrypt шифрования, _GOST_Mode_Decrypt - расшифрование @param *GOST_Table - Указатель на таблицу замены ГОСТ(ДК) в 128 байтном формате (вместо старшого полубайта 0) @param *GOST_Key - Указатель на 256 битный массив ключа(СК). */ void GOST_Encrypt_SR(uint8_t *Data, uint32_t Size, bool Mode, uint8_t *GOST_Table, uint8_t *GOST_Key ) { uint8_t Cur_Part_Size; GOST_Data_Part Data_prep; uint32_t *GOST_Key_pt=(uint32_t *) GOST_Key; while (Size!=0) { Cur_Part_Size=_Min(_GOST_Part_Size,Size); memset(&Data_prep,_GOST_Def_Byte,sizeof(Data_prep)); memcpy(&Data_prep,Data,Cur_Part_Size); #if _GOST_ROT==1 Data_prep.half[_GOST_Data_Part_N2_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N2_Half]); Data_prep.half[_GOST_Data_Part_N1_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N1_Half]); #endif if (Mode==_GOST_Mode_Encrypt) { GOST_Crypt_32_E_Cicle(&Data_prep,GOST_Table,GOST_Key_pt); } else { GOST_Crypt_32_D_Cicle(&Data_prep,GOST_Table,GOST_Key_pt); } #if _GOST_ROT==1 Data_prep.half[_GOST_Data_Part_N2_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N2_Half]); Data_prep.half[_GOST_Data_Part_N1_Half]=_SWAPW32(Data_prep.half[_GOST_Data_Part_N1_Half]); #endif memcpy(Data,&Data_prep, Cur_Part_Size); Data+=Cur_Part_Size; Size-=Cur_Part_Size; } }
//exists gracefully void CApp::HandlerSIGTERM(int) { LOG("Signal to stop set: max %d sec", m_nStopTimeout ); SetStop(); int timeLeft = alarm(0); alarm( _Min(timeLeft,m_nStopTimeout-1) ); AlarmEx( SIGKILL, m_nStopTimeout ); //set watchdog }
BOOL KFileFormat::_DeleteCurrentLineComment(LPCTSTR lpOristr, CString& strDesStr, BOOL* pbDeleteMode) { if (!lpOristr || !pbDeleteMode) return FALSE; CString strLine = lpOristr; while (1) { int nIndexSingleComment = 0; while (1) { nIndexSingleComment = strLine.Find(SINGLE_LINE_COMMENT, nIndexSingleComment); if (-1 == nIndexSingleComment) break; if (FALSE == _IsCommentInvalid(strLine, nIndexSingleComment)) break; nIndexSingleComment++; } int nIndexLeftMultiComment = 0; while (1) { nIndexLeftMultiComment = strLine.Find(LEFT_MULTI_LINE_COMMENT, nIndexLeftMultiComment); if (-1 == nIndexLeftMultiComment) break; if (FALSE == _IsCommentInvalid(strLine, nIndexLeftMultiComment)) break; nIndexLeftMultiComment++; } if (-1 == nIndexSingleComment && -1 == nIndexLeftMultiComment) break; int nMin = _Min(nIndexSingleComment, nIndexLeftMultiComment); if (nMin == nIndexSingleComment) { strLine = strLine.Left(nIndexSingleComment); continue; } *pbDeleteMode = TRUE; int nIndexRightMultiComment = strLine.Find(RIGHT_MULTI_LINE_COMMENT, nIndexLeftMultiComment + 2); if (-1 != nIndexRightMultiComment) *pbDeleteMode = FALSE; strLine = *pbDeleteMode == TRUE ? strLine.Left(nIndexLeftMultiComment) : strLine.Left(nIndexLeftMultiComment) + strLine.Mid(nIndexRightMultiComment + 2); } strDesStr = strLine; return TRUE; }
//general func void Encrypt_SR(uint8_t *_Data, uint32_t Size, bool Mode, uint8_t *Table, uint8_t *Key){ uint8_t Cur_Part_Size; Data Data_prep; uint32_t *Key_pt = (uint32_t *)Key; while (Size != 0){ Cur_Part_Size = _Min(Part_Size, Size); //memset(&Data_prep, Def_Byte, sizeof(Data_prep)); memcpy(&Data_prep, _Data, Cur_Part_Size); if (Mode == Mode_Encrypt){ Crypt_32_E_Cicle(&Data_prep, Table, Key_pt); }else{ Crypt_32_D_Cicle(&Data_prep, Table, Key_pt); } memcpy(_Data, &Data_prep, Cur_Part_Size); _Data += Cur_Part_Size; Size -= Cur_Part_Size; } }
//for first round Imitta must set to _GOST_Def_Byte void GOST_Imitta(uint8_t *Open_Data, uint8_t *Imitta, uint32_t Size, uint8_t *GOST_Table, uint8_t *GOST_Key ) { uint8_t Cur_Part_Size; GOST_Data_Part *Imitta_Prep=(GOST_Data_Part *) Imitta; GOST_Data_Part Open_Data_Prep; while(Size!=0) { Cur_Part_Size=_Min(_GOST_Part_Size,Size); Open_Data_Prep.half[_GOST_Data_Part_N2_Half]=0; Open_Data_Prep.half[_GOST_Data_Part_N1_Half]=0; memcpy(&Open_Data_Prep,Open_Data,Cur_Part_Size); (*Imitta_Prep).half[_GOST_Data_Part_N1_Half]^=Open_Data_Prep.half[_GOST_Data_Part_N1_Half]; (*Imitta_Prep).half[_GOST_Data_Part_N2_Half]^=Open_Data_Prep.half[_GOST_Data_Part_N2_Half]; Size-=Cur_Part_Size; Open_Data+=Cur_Part_Size; GOST_Imitta_16_E_Cicle(Imitta_Prep,GOST_Table,(uint32_t *)GOST_Key); } #if _GOST_ROT==1 (*Imitta_Prep).half[_GOST_Data_Part_N1_Half]=_SWAPW32((*Imitta_Prep).half[_GOST_Data_Part_N1_Half]); (*Imitta_Prep).half[_GOST_Data_Part_N2_Half]=_SWAPW32((*Imitta_Prep).half[_GOST_Data_Part_N2_Half]); #endif }
/* cgiReadFile() * * Read and save a file from a multipart request * another case to look for, when 0x0D is seen as the last * character in the buffer, then the whole buffer should be * commited, and retry the search */ char *CGI::ReadFile (char *boundary, int& contentLength) { size_t boundaryLen; char tmpl[]= NIVIS_TMP"cgi_file_upload_XXXXXX"; FILE *tmpfile; int fd; boundaryLen = strlen(boundary); FLOG("BOUNDARY[%s]", boundary); int startContentLength = contentLength ; if ( -1 == (fd = mkstemp (tmpl)) ) { log2flash("CGI: cgiReadFile failed: Unable to mkstemp"); return NULL; } if ((tmpfile = fdopen (fd, "w")) == NULL) { unlink (tmpl); log2flash("CGI: cgiReadFile failed: Unable to fdopen tmpfile"); return NULL; } FLOG("contentLength[%d]", contentLength); log2flash("CGI: cgiReadFile expecting %u bytes", contentLength); while (contentLength > 0 && !feof (io.input)) { size_t boundaryOffset =0 ; char rdBuf[8*1024]; struct timeval timeout={5,0}; fd_set readfds, errfds; FD_ZERO(&readfds); FD_ZERO(&errfds); FD_SET( fileno(io.input), &readfds ); FD_SET( fileno(io.input), &errfds ); int rv=select(fileno(io.input)+1, &readfds, NULL, &errfds, &timeout); if ( -1 == rv || FD_ISSET(fileno(io.input), &errfds) ) { FPERR("select failed"); break ; } if ( 0== rv || ! FD_ISSET( fileno(io.input), &readfds) ) { LOG("FILE is not readable"); continue; } ssize_t ssize = peek( fileno(io.input), rdBuf, sizeof(rdBuf) ); if ( ssize <= 0 ) break ; size_t size = (size_t)ssize; LOG("Size:%i contentLength:%i", size, contentLength); if ( boundaryOffset ) { if ( ! strncmp( rdBuf, boundary+boundaryOffset, _Min( strlen(boundary)-boundaryOffset, size)) ) { boundaryOffset+=_Min( strlen(boundary)-boundaryOffset, size); if ( boundaryOffset==boundaryLen) { LOG("Rest of boundary found[%s] -> exit", rdBuf ); boundaryOffset = 0 ; break; } else { LOG("Still looking for boundary"); continue ; } } else { LOG("Rest of partial match not found -> commit all data. (rb:%i contentLength:%i)", size, contentLength); fcopy_s(tmpfile, fileno(io.input), size, contentLength); boundaryOffset = 0 ; } } int boundaryStart = searchodoa(rdBuf, size); if ( boundaryStart <0 ) { fcopy_s(tmpfile, fileno(io.input), size, contentLength); LOG("No 0x0D/0x0A seen -> commit all data (rb:%i contentLength:%i)", size, contentLength ); continue; } else { if ( ! strncmp( rdBuf+boundaryStart+2, boundary, _Min(size,boundaryLen)) ) { // read from socket until boundary begins // write the read data to disk so we can use // rdBuf to reconstruct the boundary boundaryOffset = _Min(size,boundaryLen) ; if ( boundaryOffset >= boundaryLen ) { size_t plus=0, finalsz=size; if ( ! strncmp("--\x0d\x0a",rdBuf+boundaryStart+2+boundaryLen,4) ) { LOG("Final boundary found -> commit all data and exit (contentLength:%i)", contentLength ); plus=4; finalsz=sizeof(rdBuf); } ssize_t rb = read( fileno(io.input), rdBuf, finalsz ); if ( rb <=0 ) { LOG_ERR("Smth went wrong"); break ; } for ( size_t wb=0; wb < rb-boundaryLen-2-plus/*0d0a*/; ) { wb += fwrite( rdBuf+wb, sizeof(char), (rb-boundaryLen-2-plus)-wb, tmpfile); } contentLength -= rb ; LOG("Boundary found comit data until boundaryStart (rb:%i contentLength:%i)", rb, contentLength); break ; } else { // needs testing, hard to hit branch LOG("Partial match -> need more data. comit data before boundaryStart (contentLength:%i)", contentLength ); //consume until boundary begins fcopy_s( tmpfile, fileno(io.input), boundaryStart-1, contentLength) ; continue ; } } else { fcopy_s(tmpfile, fileno(io.input), size, contentLength); LOG("Reached end of buffer-> commit all data. (rb:%i contentLength:%i)", size, contentLength); continue; } } } fclose_s (tmpfile); FLOG("cgiReadFile[%u]B tmpFile:[%s] contentLengthLeft[%d]B", startContentLength-contentLength, tmpl, contentLength); //log2flash("CGI: cgiReadFile[%u]B tmpFile[%s] contentLengthLeft[%d]", startContentLength-contentLength, tmpl, contentLength); if (contentLength) { ERR("cgiReadFile incomplete dl -> unlink(tmpFile:[%s])", tmpl); log2flash("ERR:cgiReadFile incomplete dl -> unlink(tmpFile:[%s])", tmpl); unlink(tmpl); return NULL; } return strdup (tmpl); }