/*******************************************************************
*
* _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);
}
