bool
DCirfile::Find(const char **names, short count, bool ep)
{
if (!names
|| !count)
return false;
InElemPath = ep;
if (SecFile
&& SecSect
&& ((SecFound = SecFile->Find(names, count, ep)) == true))
return true;
if (SubSect
&& ((SubFound = FindStr(CurrSubSect, names, count)) == true))
return true;
// scan current section for line starting with name
// if not found in section, return false
if (CurrSect)
return FindStr(CurrSect, names, count);
return false;
}
int FindHDD_LG_Emul(void) //Поиск диска из рекордера LG эмулятором
{
#if !defined EMULATOR_HDD_AND_COPY //Режим эмулятора с эмуляцией копирования
EnableWindow(hCopy, FALSE);
#endif
if(Load_Dump() < 0) return -1; //Загрузка дампа
SEC_0 Sec0;
// if(FindStr("Sector 0") < 0) return -1;
// if(Read_Dump((BYTE*)&Sec0, 512) < 0) return -1;
if(Read_Sec_Emul(0, (BYTE*)&Sec0) < 0) return -1; //Чтение сектора по номеру эмулятором
#if defined OUT_TEST
Add_SpecSpis("Find HDD from LG emulator");
#endif
SEC_63 Sec63;
if(FindStr("Sector 63") < 0) return -1;
if(Read_Dump((BYTE*)&Sec63, 512) < 0) return -1;
if(strncmp(Sec63.Met, "LGEINC ", 8) != 0 ||
strncmp(Sec63.Name, "VOLUMELABE FAT32 ", 19) != 0)
return Error2("Содержимое сектора 63 не соответствует требованиям.", "Эмулятор.");
#if defined OUT_TEST
Add_SpecSpis("HDD from LG found");
Add_SpecSpis("Sector 63");
View_HEX_Any((BYTE *)&Sec63, 512);
#endif
if(Sec63.nf != 1 || Sec63.F8 != 0xF8 || Sec63.SecPerCl != sClSec)
return Error1((Lan+19)->msg); //return Error1("Найден жесткий диск только частично похожий на то, что он из рекордера LG.");
Start_SecFAT1 = 63 + Sec63.numRezSec; //Позиция начала таблицы FAT
Start_SecDir1 = Start_SecFAT1 + Sec63.nSecDir; //Позиция начала первого каталога
num_SecFAT1 = Sec63.numSecFAT; //Число секторов в FAT
Size_FAT1 = num_SecFAT1 * sSecB; //Число байт в FAT
// maxZapFAT1 = sSecB / 4 * num_SecFAT1; //Число записей в FAT (по 4 байта)
maxZapFAT1 = Sec63.numSecPart / sClSec; //Максимальное число записей в FAT (по 4 байта)
SEC_63 Sec64;
if(FindStr("Sector 64") < 0) return -1;
if(Read_Dump((BYTE*)&Sec64, 512) < 0) return -1;
#if defined OUT_TEST
Add_SpecSpis("Sector 64");
View_HEX_Any((BYTE *)&Sec64, 512);
#endif
if(strncmp(Sec64.Met, "LGEINC ", 8) != 0 ||
strncmp(Sec64.Name, "VOLUMELABE FAT32 ", 19) != 0)
return Error2("Содержимое сектора 64 не соответствует требованиям.", "Эмулятор.");
Start_SecDir2 = Sec63.numSecPart + 63 + Sec64.numRezSec + Sec64.nSecDir; //Номер сектора начала каталога во втором разделе
num_SecFAT2 = Sec64.numSecFAT; //Число секторов в FAT
Size_FAT2 = num_SecFAT2 * sSecB; //Число байт в FAT
maxZapFAT2 = sSecB / 4 * num_SecFAT2; //Число записей в FAT (по 4 байта)
Start_SecFAT2 = Start_SecFAT1 + Sec0.numClP1; //Позиция начала таблицы FAT2
return 0;
}
CSocket* Connect(CSocket* socket,CDlgMain* dlg,char* buffer,bool auth,CDlgSettings* dlg2)
{
if(socket)
{
dlg->console+=_T("\r\nDisconnecting...");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
Send(socket,dlg,"QUIT");
Receive(socket,dlg,buffer);
delete socket;
socket = NULL;
}
dlg->console+=_T("\r\nConnecting...");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
socket = new CSocket;
//dlg->socket = socket;
socket->Create();
if(socket->Connect(dlg2->set_serveraddress,25))
{
dlg->console+=_T("OK");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
Receive(socket,dlg,buffer);
int pos1 = FindStr(buffer," ",1);
int pos2 = FindStr(buffer," ",pos1+1);
if((pos1!=-1)&&(pos2!=-1))
dlg->res_domain = CharToString(MidStr(buffer,pos1+1,pos2));
else
dlg->res_domain = dlg2->set_serveraddress;
//dlg->MessageBox(dlg->res_domain);
}
else
{
dlg->console+=_T("ERROR!");
ShowError(socket,dlg);
delete socket;
socket = NULL;
}
return socket;
}
int Read_Sec_Emul(int Num, BYTE* Sec) //Чтение сектора по номеру эмулятором
{
char Ss[100];
sprintf (Ss, "Sector %d", Num);
if(FindStr(Ss) < 0) return -1;
if(Read_Dump(Sec, 512) < 0) return -1;
return 0;
}
//-----------------------------------------------------------------------------
bool WildCmp( const char *Buffer, const char *Mask, LPDWORD Start, LPDWORD End, LPDWORD Len )
{
int skip[256];
int lenBuffer = m_lstrlen(Buffer);
int lenMask = m_lstrlen(Mask);
if( lenMask == 0 ) //если маска пустая
if( lenBuffer == 0 )
return true;
else
return false;
else
if(lenBuffer == 0)
return false;
bool cmp = true; //результат сравнения
int pBuffer = 0; //позиция начала сравнения
int pMask = 0; //позиция начала символов в маске
*Start = WILD_CMP_POS_MAX;
while( pBuffer < lenBuffer )
{
while( pMask < lenMask && Mask[pMask] == '*' ) pMask++; //игнорируем начальные *
if( pMask >= lenMask ) break; //закончилась маска
int begMask = pMask;
while( pMask < lenMask && Mask[pMask] && Mask[pMask] != '*' ) ////ищем за символами символ * пока не дойдем до конца маски
{
pMask++;
}
const char* find;
int lenMask2 = pMask - begMask;
const char* end; //последний найденный символ в Buffer, необходим для дальнейшего поиска
InitTblSkip( Mask + begMask, pMask - begMask, skip );
find = FindStr( Buffer + pBuffer, lenBuffer - pBuffer, Mask + begMask, lenMask2, skip, &end );
if( find == 0 )
{
cmp = false;
break;
}
pBuffer = find - Buffer; //позиция найденной строки
if( *Start == WILD_CMP_POS_MAX ) *Start = pBuffer; //если еще ничего не находили, то запоминаем
pBuffer = end - Buffer + 1; //позиция с которой продолжим поиск
*End = pBuffer;
pMask++;
}
if( cmp )
{
if( *Start == WILD_CMP_POS_MAX ) //такое может быть если маска это одни *
{
*Start = 0;
*End = lenBuffer;
}
*Len = *End - *Start + 1;
return true;
}
return false;
}
int EBuffer::FindStr(const char *Data, int Len, int Options) {
SearchReplaceOptions opt;
memset(&opt, 0, sizeof(opt));
opt.Options = Options;
return FindStr(Data, Len, opt);
}
LRESULT CALLBACK DocWin::IdmFindNext(
HWND hwnd,
WPARAM wParam,
LPARAM lParam
) {
FindInfo & fi = theRubyWin.GetFindInfo();
FindStr(fi.LastFindStr(), fi.SearchFlg(), IDM_FIND_NEXT);
SetFocus(GetWindow(hwnd, GW_CHILD));
return 0;
}
int ReadClast2Emul(DWORDLONG Poz, BYTE *buff) //Чтение кластера эмулятором
{
DWORD nSector = DWORD(Poz / sSecB);
DWORD nClast = (nSector - Start_SecDir2) / sClSec2 + 1;
char Ss[300];
wsprintf(Ss, "Load Dir (claster2 %d, sector %d)", nClast, nSector);
if(FindStr(Ss) < 0)
// return Error2("Не найдена строка", Ss);
{ Error3("Не найдена строка", Ss, "Эмулятор."); return 0; }
if(Read_Dump(buff, sCl2_B) < 0) return -1;
return 0;
}
LRESULT CALLBACK DocWin::IdmFind(
HWND hwnd,
WPARAM wParam,
LPARAM lParam
) {
FINDDLG finddlg(theRubyWin.GetFindInfo(), "FINDDLG");
CHARFORMAT & cfm = theRubyWin.CharFormat();
if (cfm.cbSize) {
finddlg.SetFont(cfm.bCharSet, cfm.szFaceName);
}
if (finddlg.Open(hwnd, theRubyWin.hInstance()) == IDOK) {
FindStr(finddlg.FindStr(), finddlg.SearchFlg(), IDM_FIND_NEXT);
}
SetFocus(GetWindow(hwnd, GW_CHILD));
return 0;
}
int EBuffer::SearchWord(int SearchFlags) {
char word[MAXSEARCH + 1];
PELine L = VLine(CP.Row);
int P, len = 0;
int Case = BFI(this, BFI_MatchCase) ? 0 : SEARCH_NCASE;
P = CharOffset(L, CP.Col);
while ((P > 0) && ((ChClass(L->Chars[P - 1]) == 1) || (L->Chars[P - 1] == '_')))
P--;
while (len < int(sizeof(word)) && P < L->Count && (ChClass(L->Chars[P]) == 1 || L->Chars[P] == '_'))
word[len++] = L->Chars[P++];
word[len] = 0;
if (len == 0)
return 0;
return FindStr(word, len, Case | SearchFlags | SEARCH_WORD);
}
bool SpfTest(CDlgMain* dlg,CURL* curl,thread_status* this_struct)
{
dlg->console+=_T("\r\n*Retrieving SPF record.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
CURLcode result;
CString temp = _T("http://tools.bevhost.com/cgi-bin/dnslookup?data=");
CString domain = dlg->res_domain;//GetDomain(dlg->settings->server_address);
temp+=domain;
temp+=_T("&server=");
SetCurlUrl(curl,temp);
CleanData(this_struct);
result = curl_easy_perform(curl);
if((result!=CURLE_OK)||(this_struct->data==NULL))
{
//dlg->MessageBox(_T("Unable to retrieve spf record"));
dlg->result_spfbox = _T("");
dlg->result_spf = _T("?");
dlg->console+=_T("\r\nUnable to get SPF record.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
else
{
int pos = 0;
int pos_end = 0;
dlg->result_spfbox = _T("");
while(true)
{
pos = FindStr(this_struct->data,"descriptive text \"",pos);
pos_end = FindStr(this_struct->data,"\"",pos+19);
if(pos!=-1)
{
dlg->result_spfbox+=MidStr(this_struct->data,pos+18,pos_end);
dlg->result_spfbox+=_T("\r\n");
//dlg->result_spf_type = _T("TXT");
dlg->result_spf_domain = domain;
}
else
break;
pos+=1;
}
if(dlg->result_spfbox==_T(""))
{
dlg->console+=_T("\r\nNo SPF records found.");
dlg->result_spfbox = _T("[No SPF records found]");
dlg->result_spf = _T("NO");
}
else
{
dlg->console+=_T("\r\nSuccess.");
dlg->result_spf = _T("YES");
}
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
return true;
}
bool VerifyTest(CSocket* socket,CDlgMain* dlg,char* buffer,CDlgSettings* dlg2)
{
dlg->console+=_T("\r\n*Starting Verify Command Test.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
CString temp;
CString domain = dlg->res_domain;//GetDomain(dlg->settings->server_address);
char* msg;
Send(socket,dlg,"HELO mozilla");
Receive(socket,dlg,buffer);
temp = _T("VRFY ");
temp+=_T("frankblack");
temp+=_T("@");
temp+=domain;
msg = StringToChar(temp);
Send(socket,dlg,msg);
Receive(socket,dlg,buffer);
bool verify = ((strcmp((const char*)MidStr(buffer,0,3),"502")!=0)&&(strcmp((const char*)MidStr(buffer,0,3),"252")!=0));
bool from = true;
if(!verify)
{
Send(socket,dlg,"RSET");
Receive(socket,dlg,buffer);
temp = _T("MAIL FROM:<");
temp+=dlg2->set_fromabuseverify;
temp+=_T(">");
msg = StringToChar(temp);
Send(socket,dlg,msg);
Receive(socket,dlg,buffer);
if(strcmp((const char*)MidStr(buffer,0,3),"250")!=0)
from = false;
else
{
temp = _T("RCPT TO:<");
temp+=_T("userdhdrhanonexistafw");
temp+=_T("@");
temp+=domain;
temp+=_T(">");
msg = StringToChar(temp);
Send(socket,dlg,msg);
Receive(socket,dlg,buffer);
POSITION lpos = dlg->rcptto_list.GetHeadPosition();
verify = false;
CString rcp;
for(int k=0;k<dlg->rcptto_list.GetCount();k++)
{
rcp = dlg->rcptto_list.GetNext(lpos);
if(FindStr(buffer,StringToChar(rcp),0)!=-1)
{
verify = true;
break;
}
}
//verify = (FindStr(buffer,"5.3.0",0)!=-1);
}
}
if(!from)
{
dlg->MessageBox(_T("Couldn't test verify as FROM field is incorrect"));
dlg->result_veriify = _T("?");
}
else
dlg->result_veriify = verify?_T("YES"):_T("NO");
return verify;
}
DWORD WINAPI RunTests(LPVOID lpParam)
{
thread_data* data = (thread_data*)lpParam;
CDlgMain* dlg = data->Dlgmain;
CDlgSettings* dlg2 = data->Dlgsettings;
//CResultsDlg* dlg = data->result_dlg;
char buffer[SOCK_BUFFER+1];
CString msg;
dlg->console+=_T("\r\nTest started.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
AfxSocketInit();
CSocket* socket = NULL;
curl_global_init(CURL_GLOBAL_ALL);
CURL* curl = curl_easy_init();
thread_status* this_struct = new thread_status;
this_struct->bufferlen = 0;
this_struct->initialized = false;
this_struct->data = NULL;
this_struct->writepos = 0;
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl,
CURLOPT_WRITEFUNCTION, writefunction);
curl_easy_setopt(curl,CURLOPT_WRITEDATA, (void *) &this_struct);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT,25);
curl_easy_setopt(curl, CURLOPT_TIMEOUT,30);
CString cookie = _T("cookie/cookie");
CString cookie2;
CString cookie3 = _T(".txt");
int cookie4 = int(time(NULL));
cookie2.Format(_T("%d"),cookie4);
cookie = cookie+cookie2+cookie3;
char* cookie_file = StringToChar(cookie);
//MessageBox(cookie);
curl_easy_setopt(curl, CURLOPT_COOKIEJAR, cookie_file);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, cookie_file);
curl_easy_setopt(curl, CURLOPT_COOKIESESSION, true);
for(int GG=0;GG<1;GG++) // to make cancel possible
{
if(socket = Connect(socket,dlg,buffer,false,dlg2))
{
dlg->result_1ismailserver = _T("YES");
int pos1 = FindStr(buffer,"Version",0);
int pos2;
if(pos1!=-1)
{
pos2 = FindStr(buffer," ",pos1+7+2);
if(pos2==-1)
pos2 = FindStr(buffer,"\r",pos1+7+2);
dlg->result_2version = CharToString(MidStr(buffer,pos1+7+1,pos2));
}
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
if(CheckIfCancelled(dlg))
break;
// OPEN RELAY
if(dlg->test_openrelay)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Open Relay Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
RelayTest(socket,dlg,buffer,dlg2);
}
if(CheckIfCancelled(dlg))
break;
/// VERIFY COMMAND TEST
if(dlg->test_verify)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Verify Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
VerifyTest(socket,dlg,buffer,dlg2);
}
if(CheckIfCancelled(dlg))
break;
/// POSTMAN/ABUSE TEST
if(dlg->test_postmaster)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Postman Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
PostAbuseTest(socket,dlg,buffer,dlg2,0);
}
if(CheckIfCancelled(dlg))
break;
if(dlg->test_abuse)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Abuse Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
PostAbuseTest(socket,dlg,buffer,dlg2,1);
}
if(CheckIfCancelled(dlg))
break;
/// ATTACHMENT TEST // (with server change)
if(dlg->test_attachments)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Attachment Test ------------------");
CString temp = dlg2->set_serveraddress;
dlg2->set_serveraddress = dlg2->set_authserver;
socket = Connect(socket,dlg,buffer,false,dlg2);
dlg2->set_serveraddress = temp;
AttachmentTest(socket,dlg,buffer,dlg2);
}
if(CheckIfCancelled(dlg))
break;
/// SPOOFING TEST
if(dlg->test_spoofing1)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Spoofing 1 Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
SpoofingTest(socket,dlg,buffer,1,dlg2);
}
if(CheckIfCancelled(dlg))
break;
/// SPOOFING TEST 2 // (with server change)
if(dlg->test_spoofing2)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Spoofing 2 Test ------------------");
CString temp = dlg2->set_serveraddress;
dlg2->set_serveraddress = dlg2->set_authserver;
socket = Connect(socket,dlg,buffer,false,dlg2);
dlg2->set_serveraddress = temp;
SpoofingTest(socket,dlg,buffer,2,dlg2);
}
if(CheckIfCancelled(dlg))
break;
/// HELP TEST
if(dlg->test_help)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Help Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
HelpTest(socket,dlg,buffer);
}
if(CheckIfCancelled(dlg))
break;
/// ENCRYPTED AUTH
if(dlg->test_encauth)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Encry.Auth Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
EhloTest(socket,dlg,buffer,1);
}
if(CheckIfCancelled(dlg))
break;
/// CLEARTEXT
if(dlg->test_cleartext)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Cleartext Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
EhloTest(socket,dlg,buffer,2);
}
if(CheckIfCancelled(dlg))
break;
/// SASL
if(dlg->test_sasl)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ SASL Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
EhloTest(socket,dlg,buffer,3);
}
if(CheckIfCancelled(dlg))
break;
/// AUTH
if(dlg->test_auth)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Auth. Test ------------------");
socket = Connect(socket,dlg,buffer,false,dlg2);
EhloTest(socket,dlg,buffer,4);
}
if(CheckIfCancelled(dlg))
break;
}
else
{
dlg->result_1ismailserver = _T("NO");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
if(dlg->test_spf)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ SPF Test ------------------");
SpfTest(dlg,curl,this_struct);
}
if(dlg->test_blacklist)
{
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\n------------------ Blacklist Test ------------------");
BlacklistTest(dlg,curl,this_struct);
}
} // end GG
delete socket;
dlg->console+=_T("\r\n-----------------------------------------------------");
dlg->console+=_T("\r\nTEST COMPLETED.");
dlg->GetDlgItem(IDC_BUTTON7)->EnableWindow(TRUE);
dlg->GetDlgItem(IDC_BUTTON8)->EnableWindow(TRUE);
dlg->GetDlgItem(IDC_BUTTON3)->SetWindowTextW(_T("Run"));
dlg->GetDlgItem(IDC_BUTTON3)->EnableWindow(TRUE);
dlg->running = FALSE;
dlg->want_cancel = FALSE;
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
return 0;
}
bool EhloTest(CSocket* socket,CDlgMain* dlg,char* buffer,int subtype)
{
CString name[4];
name[0] = _T("Encrypted authentication");
name[1] = _T("Cleartext login");
name[2] = _T("SASL Login methods");
name[3] = _T("Authentication");
dlg->console+=(_T("\r\n*Starting ")+name[subtype-1]+_T(" Test."));
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
Send(socket,dlg,"EHLO mozilla");
Receive(socket,dlg,buffer);
bool result = false;
result = (strcmp((const char*)MidStr(buffer,0,3),"250")==0);
int pos1, pos2;
if(result)
{
switch(subtype)
{
case 1: // ENCR
result = FindStr(buffer,"STARTTLS",0)!=-1;
dlg->result_encauth = result?_T("YES"):_T("NO");
break;
case 2: // CLEARTEXT
result = FindStr(buffer,"PLAIN",0)!=-1;
dlg->result_cleartext = result?_T("YES"):_T("NO");
break;
case 3: // SASL
pos1 = FindStr(buffer,"AUTH",0);
if(pos1!=-1)
{
pos2 = FindStr(buffer,"\r",pos1);
dlg->result_sasl = CharToString(MidStr(buffer,pos1+5,pos2));
dlg->result_sasl.Replace(_T("LOGIN"),_T(""));
}
else
{
dlg->result_sasl = _T("-");
}
break;
case 4: // AUTH
result = ((FindStr(buffer,"AUTH",0)!=-1)||(FindStr(buffer,"STARTTLS",0)!=-1));
dlg->result_auth = result?_T("YES"):_T("NO");
break;
}
}
else
{
dlg->console+=_T("\r\n[ERROR] Server extensions not obtained.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
return true;
}
bool BlacklistTest(CDlgMain* dlg,CURL* curl,thread_status* this_struct)
{
dlg->console+=_T("\r\n*Retrieving Blacklist record.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
CURLcode result;
CString temp = _T("q=");
CString temp2;
temp+=dlg->res_domain;//GetDomain(dlg->settings->server_address);
//temp+=_T("&check=check");
SetCurlUrl(curl,"http://www.blacklistalert.org/");
CleanData(this_struct);
result = curl_easy_perform(curl);
//<input type=hidden name="PHPSESSID" value="1885fc88a84fee781f38ef97da59386f">
int af = FindStr(this_struct->data,"name=\"PHPSESSID\" value=\"",0);
int af2 = FindStr(this_struct->data,"\">",af);
CString sess = CharToString(MidStr(this_struct->data,af+24,af2));
temp+=_T("&PHPSESSID=")+sess;
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, StringToChar(temp));
SetCurlUrl(curl,"http://www.blacklistalert.org/");
CleanData(this_struct);
result = curl_easy_perform(curl);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
if((this_struct->data==NULL))
{
//dlg->MessageBox(_T("Unable to retrieve blacklist records"));
dlg->result_blacklistednum = _T("?");
dlg->console+=_T("\r\nUnable to get Blacklist record.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
else
{
int pos1 = FindStr(this_struct->data,"(Alphabetic order):</b><br>",0);
int pos1end = FindStr(this_struct->data,"<hr>",pos1+10);
int pos2 = FindStr(this_struct->data,"(Alphabetic order)</b><br>",pos1end);
int pos2end = FindStr(this_struct->data,"<hr>",pos2+10);
if((pos1==-1)||(pos1end==-1)||(pos2==-1)||(pos2end==-1))
{
dlg->result_blacklistednum = _T("?");
dlg->result_blacklist = _T("?");
dlg->console+=_T("\r\nUnable to get Blacklist record.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
else
{
int pos4 = 0, pos5 = 0, pos6 = pos1+26, pos7 = 0, pos8 = 0, pos9 = 0;
bool ok;
bool no_result;
int c_ok = 0;
int c_listed = 0;
int count = 0;
int index = 0;
while((pos4!=-1)&&(pos6<pos2end)) // < !!!!!!!!!!!!!!!!!!!
{
pos4 = FindStr(this_struct->data,"<br>",pos6);
if(pos4==pos1end-4)
pos4 = FindStr(this_struct->data,"<br>",pos2+26);
else if(pos4==pos2end-4)
break;
pos5 = FindStr(this_struct->data,"<font color=",pos4);
temp = MidStr(this_struct->data,pos4+4,pos5-1);
index = dlg->blacklist.InsertItem(dlg->blacklist.GetItemCount(),temp);
pos6 = FindStr(this_struct->data,">",pos5+5);
pos7 = FindStr(this_struct->data,"</em>",pos6);
pos8 = FindStr(this_struct->data,"href=\"",pos6);
pos9 = FindStr(this_struct->data,"\">",pos8);
// is blacklsited or not
ok = (strcmp((const char*)MidStr(this_struct->data,pos5+12,pos6),"green")==0);
no_result = (strcmp((const char*)MidStr(this_struct->data,pos5+12,pos6),"magenta")==0);
if(ok)
{
dlg->blacklist.SetItemText(index,1,_T("OK"));
c_ok++;
}
else if(no_result)
{
dlg->blacklist.SetItemText(index,1,_T("NO RESULT"));
}
else
{
dlg->blacklist.SetItemText(index,1,_T("LISTED"));
c_listed++;
if(pos8<pos7)
{
CString temp3(MidStr(this_struct->data,pos8+6,pos9));
dlg->blacklist.SetItemText(index,2,temp3);
}
}
count++;
temp.Format(_T("%d"),c_listed);
temp2.Format(_T("%d"),count);
temp+=_T("/");
temp+=temp2;
dlg->result_blacklistednum = temp;
dlg->UpdateData(FALSE);
}
if(c_listed)
dlg->result_blacklist = _T("YES");
else
dlg->result_blacklist = _T("NO");
dlg->console+=_T("\r\nSuccess.");
dlg->UpdateData(FALSE);
ScrollToBottom(dlg);
}
}
return true;
}
static struct header *
FieldList_to_fea(FieldList list,
struct fea_data **rec,
char **fnames,
int copy_sources)
{
struct header *hdr;
int i, j;
FieldSpec *fld;
char **codes;
FieldList subfields;
FieldSpec *subf;
char *name;
void *ptr;
int spstype;
long *dim;
struct fea_header *fea;
struct header *source;
if (list == NULL)
return NULL;
hdr = new_header(FT_FEA);
for (i = 0; (fld = list[i]) != NULL; i++)
{
codes = NULL;
if (fld->occurrence != VIRTUAL
&& (subfields = fld->subfields) != NULL)
{
for (j = 0; (subf = subfields[j]) != NULL; j++)
{
if (strcmp(subf->name, "enumStrings") != 0)
{
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: subfields "
"not supported in ESPS FEA files.\n");
}
else if (fld->type != SHORT)
{
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: Non-SHORT field "
"has subfield enumStrings.\n");
}
else if (subf->type != CHAR)
{
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: enumStrings not CHAR.\n");
}
else if (subf->rank != 2)
{
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: enumStrings "
"not of rank 2.\n");
}
else
codes = StrArrayFromRect(subf->dim, subf->data);
}
}
if (FieldIsTag(fld) && FindStr(ESPS_TAG, fnames))
hdr->common.tag = TRUE;
else if (FieldIsFeaSubtype(fld))
hdr->hd.fea->fea_type = *(short *) fld->data;
else
{
name = fld->name;
switch(fld->occurrence)
{
case GLOBAL:
{
int size = (int) FieldLength(fld);
ptr = fld->data;
if (debug_level >= 2)
fprintf(stderr,
"FieldList_to_fea: "
"global field[%d]: \"%s\".\n",
i, name);
if (fld->rank > 1)
{
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: rank %d globals "
"not supported in ESPS FEA files.\n",
fld->rank);
}
if (size == 0)
{
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: empty globals "
"not supported in ESPS FEA files.\n");
}
else if (codes != NULL)
(void) add_genhd_e(name,
(short *) ptr, size, codes, hdr);
else
switch (fld->type)
{
case DOUBLE:
(void) add_genhd_d(name,
(double *) ptr, size, hdr);
break;
case FLOAT:
(void) add_genhd_f(name,
(float *) ptr, size, hdr);
break;
case LONG:
(void) add_genhd_l(name,
(long *) ptr, size, hdr);
break;
case SHORT:
(void) add_genhd_s(name,
(short *) ptr, size, hdr);
break;
case SCHAR:
case UCHAR:
case CHAR:
(void) add_genhd_c(name,
(char *) ptr, size, hdr);
break;
default:
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: global type %d "
"not supported in ESPS FEA files.\n",
fld->type);
}
}
break;
case REQUIRED:
{
long size = FieldLength(fld);
if (debug_level >= 2)
fprintf(stderr,
"FieldList_to_fea: "
"required field[%d]: \"%s\".\n",
i, name);
if (FindStr(name, fnames))
{
spstype = (codes != NULL) ? CODED
: ElibTypeToEsps(fld->type);
if (spstype != UNDEF)
{
dim = (long *) malloc(fld->rank * sizeof(long));
for (j = 0; j < fld->rank; j++)
dim[j] = fld->dim[j];
add_fea_fld(name, size, fld->rank,
dim, spstype, codes, hdr);
}
}
}
break;
case OPTIONAL:
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: optional fields "
"not supported in ESPS FEA files.\n");
break;
case VIRTUAL:
if (copy_sources)
{
if (strncmp(name, "source_", 7) != 0)
{
if (debug_level)
fprintf(stderr, "Field_List_to_fea: VIRTUAL "
"field other than source_<n>.\n");
}
else if ((subfields = fld->subfields) != NULL
|| fld->type == CHAR)
{
size_t len;
char *data;
source = FieldList_to_fea(subfields,
NULL, NULL, TRUE);
len = FieldLength(fld);
data = (char *) malloc(len + 1);
strncpy(data, fld->data, len);
data[len] = '\0';
add_source_file(hdr, data, source);
}
}
break;
case INCLUDED:
if (debug_level)
fprintf(stderr,
"FieldList_to_fea: included fields "
"not supported in ESPS FEA files.\n");
break;
default:
spsassert(0, "FieldList_to_fea: "
"unrecognized occurrence code.\n");
break;
}
}
}
if (rec != NULL)
{
*rec = allo_fea_rec(hdr);
fea = hdr->hd.fea;
if (hdr->common.tag)
{
fld = FindField(list, ESPS_TAG);
fld->data = &(*rec)->tag;
}
for (i = 0; i < (int) fea->field_count; i++)
{
name = fea->names[i];
fld = FindField(list, name);
fld->data = get_fea_ptr(*rec, name, hdr);
}
}
return hdr;
}
void CCodeBlocksWorkspace::GenerateMakefileText(const CString& FileName,
CCodeBlocksBuildConfig& Config)
{
// generate individual makefiles for projects
//std::cout<<"Workspace: "<<FileName.GetCString()<<std::endl;
CString cwd = GetCurrentDir();
CString workspace_path = ExtractFilePath(FileName);
if (!workspace_path.IsEmpty())
{
ChangeDir(workspace_path);
}
//std::cout<<"Workspace path: "<<workspace_path.GetCString()<<std::endl;
m_TargetNames.Clear(); m_MakefileNames.Clear();
for (size_t i = 0; i < m_Units.size(); i++)
{
CString project_name = m_Units[i]->m_FileName;
CString makefile_path = JoinPaths(workspace_path,ExtractFilePath(project_name));
CString makefile_pathname = JoinPaths(workspace_path,project_name+".mak");
CString target_name = LowerCase(ChangeFileExt(project_name,""));
CString makefile_name = ExtractFileName(makefile_pathname);
//std::cout<<"Project name: "<<project_name.GetCString()<<std::endl;
//std::cout<<"Makefile path: "<<makefile_path.GetCString()<<std::endl;
//std::cout<<"Makefile pathname: "<<makefile_pathname.GetCString()<<std::endl;
target_name = CCodeBlocksProject::DecorateTargetName(target_name);
//std::cout<<"Target name: "<<target_name.GetCString()<<std::endl;
//std::cout<<"Makefile name: "<<makefile_name.GetCString()<<std::endl;
m_TargetNames.Insert(target_name);
m_MakefilePaths.Insert(makefile_path);
m_MakefileNames.Insert(makefile_name);
makefile_pathname = MakeNativePath(makefile_pathname);
//std::cout<<"Native makefile pathname: "<<makefile_pathname.GetCString()<<std::endl;
m_Units[i]->m_Project.GenerateMakefile(makefile_pathname,Config);
}
//CString cwd = GetCurrentDir();
// generate workspace makefile
int active_platforms = 0;
for (size_t pi = 0, pn = Config.Platforms().GetCount(); pi < pn; pi++)
{
if (Config.Platforms().Platform(pi)->Active()) active_platforms++;
}
bool single_platform = (1==active_platforms);
for (size_t pi = 0, pn = Config.Platforms().GetCount(); pi < pn; pi++)
{
CPlatform *pl = Config.Platforms().Platform(pi);
if (!pl->Active()) continue;
CString makefile_path = ExtractFilePath(FileName);
CString makefile_name = ExtractFileName(FileName);
CString platform_suffix;
if (!single_platform) platform_suffix = "."+LowerCase(pl->Name());
makefile_name += platform_suffix;
//ChangeDir(makefile_path);
//
m_MakefileText.Clear();
// head comment
m_MakefileText.Insert("#------------------------------------------------------------------------------#");
#ifdef REVISION_NUMBER
{
CString s = "# This makefile was generated by 'cbp2make' tool rev. #";
CString n = IntegerToString(REVISION_NUMBER);
int o = FindStr(s,"rev.") + 4;
for (int i = 0; i < n.GetLength(); i++) s.SetChar(i+o,n[i]);
m_MakefileText.Insert(s);
}
#else
m_MakefileText.Insert("# This makefile was generated by 'cbp2make' tool #");
#endif
m_MakefileText.Insert("#------------------------------------------------------------------------------#");
m_MakefileText.Insert("");
// macros
CString line = "WRKDIR = "+pl->EvalWorkDir();
m_MakefileText.Insert(line);
line = "MAKE = "+pl->Tool_Make();
m_MakefileText.Insert(line);
m_MakefileText.Insert("");
// targets
line = "all:";
for (int i = 0; i < m_TargetNames.GetCount(); i++)
{
line.Append(" ").Append(m_TargetNames[i]);
}
m_MakefileText.Insert(line); m_MakefileText.Insert("");
for (int i = 0; i < m_TargetNames.GetCount(); i++)
{
CString makefile_path = m_MakefilePaths[i];
line = m_TargetNames[i]+":";
m_MakefileText.Insert(line);
line = "\t$(MAKE)";
if (!makefile_path.IsEmpty())
{
line += " -C "+pl->ProtectPath(pl->Pd(makefile_path),Config.QuotePathMode());
}
line += " all -f "+pl->ProtectPath(pl->Pd(m_MakefileNames[i])+platform_suffix,Config.QuotePathMode());
m_MakefileText.Insert(line);
m_MakefileText.Insert("");
}
//
line = "clean:";
for (int i = 0; i < m_TargetNames.GetCount(); i++)
{
line.Append(" clean_").Append(m_TargetNames[i]);
}
m_MakefileText.Insert(line); m_MakefileText.Insert("");
for (int i = 0; i < m_TargetNames.GetCount(); i++)
{
CString makefile_path = m_MakefilePaths[i];
line = "clean_"+m_TargetNames[i]+":";
m_MakefileText.Insert(line);
line = "\t$(MAKE)";
if (!makefile_path.IsEmpty())
{
line += " -C "+pl->ProtectPath(pl->Pd(makefile_path),Config.QuotePathMode());
}
line += " clean -f "+pl->ProtectPath(pl->Pd(m_MakefileNames[i])+platform_suffix,Config.QuotePathMode());
m_MakefileText.Insert(line);
m_MakefileText.Insert("");
}
//
line = ".PHONY:";
for (int i = 0; i < m_TargetNames.GetCount(); i++)
{
line.Append(" ").Append(m_TargetNames[i]);
line.Append(" clean_").Append(m_TargetNames[i]);
}
m_MakefileText.Insert(line); m_MakefileText.Insert("");
m_MakefileText.SaveToFile(makefile_name);
m_MakefileText.Clear();
ChangeDir(cwd);
}
}
int EBuffer::Find(SearchReplaceOptions &opt) {
int slen = strlen(opt.strSearch);
int Options = opt.Options;
int rlen = strlen(opt.strReplace);
RxNode *R = NULL;
opt.resCount = -1;
opt.lastInsertLen = 0;
if (slen == 0) return 0;
if (Options & SEARCH_BLOCK) {
if (CheckBlock() == 0) return 0;
}
if (Options & SEARCH_RE) {
R = RxCompile(opt.strSearch);
if (R == 0) {
View->MView->Win->Choice(GPC_ERROR, "Find", 1, "O&K", "Invalid regular expression.");
return 0;
}
}
if (Options & SEARCH_GLOBAL) {
if (Options & SEARCH_BLOCK) {
if (Options & SEARCH_BACK) {
if (SetPosR(BE.Col, BE.Row) == 0) goto error;
} else {
if (SetPosR(BB.Col, BB.Row) == 0) goto error;
}
} else {
if (Options & SEARCH_BACK) {
if (RCount < 1) goto error;
if (SetPosR(LineLen(RCount - 1), RCount - 1) == 0) goto error;
} else {
if (SetPosR(0, 0) == 0) goto error;
}
}
}
opt.resCount = 0;
while (1) {
if (Options & SEARCH_RE) {
if (FindRx(R, opt) == 0) goto end;
} else {
if (FindStr(opt.strSearch, slen, opt) == 0) goto end;
}
opt.resCount++;
if (opt.Options & SEARCH_REPLACE) {
char ask = 'A';
if (!(Options & SEARCH_NASK)) {
char ch;
while (1) {
Draw(VToR(CP.Row), 1);
Redraw();
switch (View->MView->Win->Choice(0, "Replace",
5,
"&Yes",
"&All",
"&Once",
"&Skip",
"&Cancel",
"Replace with %s?", opt.strReplace)) {
case 0:
ch = 'Y';
break;
case 1:
ch = 'A';
break;
case 2:
ch = 'O';
break;
case 3:
ch = 'N';
break;
case 4:
case -1:
default:
ch = 'Q';
break;
}
if (ch == 'Y') {
ask = 'Y';
goto ok_rep;
}
if (ch == 'N') {
ask = 'N';
goto ok_rep;
}
if (ch == 'Q') {
ask = 'Q';
goto ok_rep;
}
if (ch == 'A') {
ask = 'A';
goto ok_rep;
}
if (ch == 'O') {
ask = 'O';
goto ok_rep;
}
}
ok_rep:
if (ask == 'N') goto try_join;
if (ask == 'Q') goto end;
if (ask == 'A') Options |= SEARCH_NASK;
}
if (Options & SEARCH_RE) {
PELine L = RLine(Match.Row);
int P, R;
char *PR = 0;
int LR = 0;
R = Match.Row;
P = Match.Col;
P = CharOffset(L, P);
if (0 == RxReplace(opt.strReplace, L->Chars, L->Count, MatchRes, &PR, &LR)) {
if (DelText(R, Match.Col, MatchLen) == 0) goto error;
if (PR && LR > 0)
if (InsText(R, Match.Col, LR, PR) == 0) goto error;
if (PR)
free(PR);
rlen = LR;
}
} else {
if (DelText(Match.Row, Match.Col, MatchLen) == 0) goto error;
if (InsText(Match.Row, Match.Col, rlen, opt.strReplace) == 0) goto error;
// Cursor remains at start of inserted string. If there is recursive
// replace pattern, fte can go it infinite loop.
// Workaround: Move cursor to end of inserted string
opt.lastInsertLen = strlen(opt.strReplace);
}
if (!(Options & SEARCH_BACK)) {
MatchLen = rlen;
MatchCount = rlen;
}
if (ask == 'O')
goto end;
}
try_join:
if (Options & SEARCH_JOIN) {
char ask = 'A';
if (!(Options & SEARCH_NASK)) {
char ch;
while (1) {
Draw(VToR(CP.Row), 1);
Redraw();
switch (View->MView->Win->Choice(0, "Join Line",
5,
"&Yes",
"&All",
"&Once",
"&Skip",
"&Cancel",
"Join lines %d and %d?", 1 + VToR(CP.Row), 1 + VToR(CP.Row) + 1)) {
case 0:
ch = 'Y';
break;
case 1:
ch = 'A';
break;
case 2:
ch = 'O';
break;
case 3:
ch = 'N';
break;
case 4:
case -1:
default:
ch = 'Q';
break;
}
if (ch == 'Y') {
ask = 'Y';
goto ok_join;
}
if (ch == 'N') {
ask = 'N';
goto ok_join;
}
if (ch == 'Q') {
ask = 'Q';
goto ok_join;
}
if (ch == 'A') {
ask = 'A';
goto ok_join;
}
if (ch == 'O') {
ask = 'O';
goto ok_join;
}
}
ok_join:
if (ask == 'N') goto try_split;
if (ask == 'Q') goto end;
if (ask == 'A') Options |= SEARCH_NASK;
}
if (JoinLine(Match.Row, Match.Col) == 0) goto error;
if (ask == 'O')
goto end;
}
try_split:
if (Options & SEARCH_SPLIT) {
char ask = 'A';
if (!(Options & SEARCH_NASK)) {
char ch;
while (1) {
Draw(VToR(CP.Row), 1);
Redraw();
switch(View->MView->Win->Choice(0, "Split Line",
5,
"&Yes",
"&All",
"&Once",
"&Skip",
"&Cancel",
"Split line %d?", VToR(CP.Row)))
{
case 0:
ch = 'Y';
break;
case 1:
ch = 'A';
break;
case 2:
ch = 'O';
break;
case 3:
ch = 'S';
break;
case 4:
case -1:
default:
ch = 'Q';
break;
}
if (ch == 'Y') {
ask = 'Y';
goto ok_split;
}
else if (ch == 'N') {
ask = 'N';
goto ok_split;
}
else if (ch == 'Q') {
ask = 'Q';
goto ok_split;
}
else if (ch == 'A') {
ask = 'A';
goto ok_split;
}
else if (ch == 'O') {
ask = 'O';
goto ok_split;
}
}
ok_split:
if (ask == 'N') goto try_delete;
if (ask == 'Q') goto end;
if (ask == 'A') Options |= SEARCH_NASK;
}
if (SplitLine(Match.Row, Match.Col + strlen(opt.strReplace)) == 0)
goto error;
if (ask == 'O')
goto end;
}
try_delete:
if (Options & SEARCH_DELETE) {
char ask = 'A';
if (!(Options & SEARCH_NASK)) {
char ch;
while (1) {
Draw(VToR(CP.Row), 1);
Redraw();
switch (View->MView->Win->Choice(0, "Delete Line",
5,
"&Yes",
"&All",
"&Once",
"&Skip",
"&Cancel",
"Delete line %d?", VToR(CP.Row))) {
case 0:
ch = 'Y';
break;
case 1:
ch = 'A';
break;
case 2:
ch = 'O';
break;
case 3:
ch = 'N';
break;
case 4:
case -1:
default:
ch = 'Q';
break;
}
if (ch == 'Y') {
ask = 'Y';
goto ok_delete;
}
if (ch == 'N') {
ask = 'N';
goto ok_delete;
}
if (ch == 'Q') {
ask = 'Q';
goto ok_delete;
}
if (ch == 'A') {
ask = 'A';
goto ok_delete;
}
if (ch == 'O') {
ask = 'O';
goto ok_delete;
}
}
ok_delete:
if (ask == 'N') goto next;
if (ask == 'Q') goto end;
if (ask == 'A') Options |= SEARCH_NASK;
}
if (Match.Row == RCount - 1) {
if (DelText(Match.Row, 0, LineLen()) == 0) goto error;
} else
if (DelLine(Match.Row) == 0) goto error;
if (ask == 'O')
goto end;
if (!(Options & SEARCH_ALL))
break;
goto last;
}
next:
if (!(Options & SEARCH_ALL))
break;
Options |= SEARCH_NEXT;
last:
;
}
end:
// end of search
if (R)
RxFree(R);
if (Options & SEARCH_ALL)
Msg(S_INFO, "%d match(es) found.", opt.resCount);
else {
if (opt.resCount == 0) {
Msg(S_INFO, "[%s] not found", opt.strSearch);
return 0;
}
}
return 1;
error:
if (R) {
RxFree(R);
}
View->MView->Win->Choice(GPC_ERROR, "Find", 1, "O&K", "Error in search/replace.");
return 0;
}
static FieldList
fea_to_FieldList(struct header *hdr,
struct fea_data *rec,
char **field_names,
int copy_sources)
{
struct fea_header *fea;
FieldList list;
int i, j;
FieldSpec *field, *subfield;
char *name;
int spstype;
long *dim;
int rank;
int type;
char **codes;
char **gnames;
int gnum;
struct varsize *var;
int nsrc;
FieldList source;
char *line;
long len;
if (hdr == NULL)
return NULL;
if (hdr->common.type != FT_FEA)
return NULL;
fea = hdr->hd.fea;
list = NULL;
if (hdr->common.tag && FindStr(ESPS_TAG, field_names))
{
field = NewFieldSpec(ELONG, 0);
field->name = savestring(ESPS_TAG);
field->occurrence = REQUIRED;
if (rec != NULL)
field->data = &rec->tag;
AddField(&list, field);
}
if (debug_level)
fprintf(stderr, "fea_to_FieldList: field count %d.\n",
fea->field_count);
for (i = 0; i < (int) fea->field_count; i++)
{
long size;
name = fea->names[i];
if (FindStr(name, field_names))
{
spstype = fea->types[i];
size = fea->sizes[i];
rank = fea->ranks[i];
dim = fea->dimens[i];
if (debug_level >= 2)
fprintf(stderr,
"fea_to_FieldList: field[%d]: \"%s\".\n",
i, name);
type = EspsTypeToElib(spstype);
field = NewFieldSpec(type, rank);
if (rank == 1)
field->dim[0] = size;
else
for (j = 0; j < rank; j++)
field->dim[j] = dim[j];
field->name = savestring(name);
field->occurrence = REQUIRED;
if (spstype == CODED)
{
codes = fea->enums[i];
subfield = NewFieldSpec(ECHAR, 2);
subfield->name = savestring("enumStrings");
subfield->occurrence = GLOBAL;
StrArrToRect(codes, &subfield->dim, &subfield->data);
AddSubfield(field, subfield);
}
if (rec != NULL)
field->data = get_fea_ptr(rec, name, hdr);
AddField(&list, field);
}
}
gnames = genhd_list(&gnum, hdr);
for (i = 0; i < gnum; i++)
{
int size;
name = gnames[i];
spstype = genhd_type(name, &size, hdr);
if (debug_level >= 2)
fprintf(stderr,
"fea_to_FieldList: global field[%d]: \"%s\".\n",
i, name);
type = EspsTypeToElib(spstype);
field = NewFieldSpec(type, 1);
field->dim[0] = size;
field->name = savestring(name);
field->occurrence = GLOBAL;
if (spstype == CODED)
{
codes = genhd_codes(name, hdr);
subfield = NewFieldSpec(ECHAR, 2);
subfield->name = savestring("enumStrings");
subfield->occurrence = GLOBAL;
StrArrToRect(codes, &subfield->dim, &subfield->data);
AddSubfield(field, subfield);
}
field->data = get_genhd(name, hdr);
AddField(&list, field);
}
if (fea->fea_type != NONE)
{
field = AddGlobalField(&list, "FeaSubtype",
0, NULL, ESHORT, NULL);
*(short *) field->data = fea->fea_type;
subfield = NewFieldSpec(ECHAR, 2);
subfield->name = savestring("enumStrings");
subfield->occurrence = GLOBAL;
StrArrToRect(fea_file_type, &subfield->dim, &subfield->data);
AddSubfield(field, subfield);
}
var = &hdr->variable;
if (copy_sources)
{
nsrc = MAX(var->nnames, var->nheads);
for (i = 0; i < nsrc; i++)
{
source = (i >= var->nheads) ? NULL
: fea_to_FieldList(var->srchead[i], NULL, NULL, TRUE);
name = (i >= var->nnames) ? NULL
: var->source[i];
(void) AddSource(&list, i, name, source);
}
}
if (var->comment != NULL)
{
line = savestring(var->comment);
len = strlen(line);
if (line[len-1] == '\n')
line[len-1] = '\0';
(void) AddCommandLine(&list, line);
}
return list;
}
// Formatting, Non MFC
LPCTSTR CHighTime::Format(LPSTR pBuffer, int iBufferLen, LPCTSTR pFormat) const
{
_HighTimeFormat tmHighTimeTemp;
tm tmTemp;
LPSTR szTemp = NULL;
int iPos;
// If null, return empty string
if (pBuffer == NULL || GetStatus() == null || iBufferLen <= 0)
return NULL;
// If invalid, return DateTime resource string
if (GetStatus() == invalid || !ConvertLongLongToTime(m_liTime, tmHighTimeTemp))
{
strncpy(pBuffer, INVALID_DATETIME, iBufferLen);
return pBuffer;
}
if (iBufferLen <= 10)
szTemp = new CHAR[10];
else
szTemp = new CHAR[iBufferLen+1];
// Add milli, micro & nano part!!!!!!
//%s for the millisecond part
//%u for the microsecond part
//%n for the nanosecond part
strncpy(pBuffer, pFormat, iBufferLen);
iPos = FindStr(pBuffer, "%s", 0);
if (iPos >= 0) {
wsprintf(szTemp,"%03d",tmHighTimeTemp.nMilli);
ReplaceStr(pBuffer, iBufferLen, "%s", szTemp);
}
iPos = FindStr(pBuffer, "%#s", 0);
if (iPos >= 0) {
wsprintf(szTemp,"%d",tmHighTimeTemp.nMilli);
ReplaceStr(pBuffer, iBufferLen, "%#s", szTemp);
}
iPos = FindStr(pBuffer, "%u", 0);
if (iPos >= 0) {
wsprintf(szTemp,"%03d",tmHighTimeTemp.nMicro);
ReplaceStr(pBuffer, iBufferLen, "%u", szTemp);
}
iPos = FindStr(pBuffer, "%#u", 0);
if (iPos >= 0) {
wsprintf(szTemp,"%d",tmHighTimeTemp.nMicro);
ReplaceStr(pBuffer, iBufferLen, "%#u", szTemp);
}
iPos = FindStr(pBuffer, "%n", 0);
if (iPos >= 0) {
wsprintf(szTemp,"%03d",tmHighTimeTemp.nNano);
ReplaceStr(pBuffer, iBufferLen, "%n", szTemp);
}
iPos = FindStr(pBuffer, "%#n", 0);
if (iPos >= 0) {
wsprintf(szTemp,"%d",tmHighTimeTemp.nNano);
ReplaceStr(pBuffer, iBufferLen, "%#n", szTemp);
}
// Convert tm from internal format to standard format
ConvertToStandardFormat(tmHighTimeTemp, tmTemp);
// Fill in the buffer, disregard return value as it's not necessary
strcpy(szTemp, pBuffer);
strftime(pBuffer, iBufferLen, szTemp, &tmTemp);
delete [] szTemp;
return pBuffer;
} // CHighTime::Format()
int ReadFAT2Emul(DWORDLONG Poz) //Чтение FAT эмулятором
{
if(FindStr("Load FAT 2") < 0) return -1;
if(Read_Dump((BYTE*)FAT2, Size_FAT2) < 0) return -1;
return 0;
}
int pinpad_get_pinblock(uchar pinindex, short type, char mode, char *amt,
char *price, char *pan, char *track2, char *pinblock, short *pinblklen) {
int iret;
short i;
int len;
char szBuffTemp[128];
char szBuff[128];
char szPAN[32], szAmtBuf[16] = { 0 }, szTrack2Buf[128] = { 0 };
char logbuf[2048] = { 0 };
int j;
if (NULL == amt || NULL == price || NULL == pan || NULL == track2
|| NULL == pinblock || NULL == pinblklen)
return EPP_INPUT_PARAM_ERROR;
memcpy(szAmtBuf, amt, 12);
strcpy(szTrack2Buf, track2);
iret = epp_beep(hPinPad, 1, 500);
if (iret)
return iret;
//清除屏幕
iret = epp_clear_screen(hPinPad);
if (iret)
return iret;
if (type == TRANS_VOID_SALE || type == TRANS_APP_PRE_AUTH) {
for (i = 0; i < 12; i++) {
if (szAmtBuf[i] != '0')
break;
}
memset(szBuff, 0, sizeof(szBuff));
memset(szBuffTemp, 0, sizeof(szBuffTemp));
memcpy(szBuffTemp, &szAmtBuf[i], 12 - i);
money2float(szBuff, szBuffTemp);
} else {
memset(szBuff, 0, sizeof(szBuff));
if (atoi(price) % 100 != 0)
sprintf(szBuff, "%d.%02d", atoi(price) / 100, atoi(price) % 100);
else
sprintf(szBuff, "%d.00", atoi(price) / 100);
}
iret = epp_display_string(hPinPad, 10, 0, 16, szBuff, strlen(szBuff));
if (iret)
return iret;
epp_set_pin_input_timeout(hPinPad, 60000);
memset(szBuffTemp, 0, sizeof(szBuffTemp));
memcpy(szBuffTemp, "0000000000000000", 16);
len = 0;
if (mode == CARD_MANUAL) {
len = strlen(pan);
memcpy(&szBuffTemp[4], &pan[len - 13], 12);
} else {
iret = FindStr(szTrack2Buf, 37, "=", 1);
memset(szPAN, 0, sizeof(szPAN));
memcpy(szPAN, &szTrack2Buf[iret - 1 - 12], 12);
memcpy(&szBuffTemp[4], szPAN, 12);
}
__android_log_print(ANDROID_LOG_INFO, "N20Epp",
"pinpad_get_pinblock---szBuffTemp:[%s]", szBuffTemp);
memset(szBuff, 0, sizeof(szBuff)); //gF.TermVar.MasterKeyIndex[0]
iret = epp_get_pin(hPinPad, KEY_TYPE_PIN, pinindex, 1, 0x00, szBuffTemp,
"0456789abc\0\0\0", szBuff);
if (iret) {
if (iret == -EPP_NO_PIN) {
*pinblklen = 0;
return EPP_SUCCESS;
}
return iret;
}
*pinblklen = 8;
memset(pinblock, 0, sizeof(pinblock));
memcpy(pinblock, szBuff, 8);
memset(logbuf, 0x00, sizeof(logbuf));
for (i = 0, j = 0; i < 8; i++, j = j + 2) {
sprintf(&logbuf[j], "%02x", pinblock[i]);
}
__android_log_print(ANDROID_LOG_INFO, "N20Epp",
"pinpad_get_pinblock---pin block:[%s]", logbuf);
return EPP_SUCCESS;
}
int GaussianMixture::Load(string nomfic)
{
int ddim,nbgauss;
ifstream fichier;
double* mm;
double* cc;
char pattern[256];
/* ouverture */
fichier.open(nomfic.c_str(), ios::in);
if(fichier.bad())
return 0;
/* Lecture du nombre de gaussiennes */
FindStr(fichier,"<nb>");
if(fichier.eof()) {cout << dispdec << "|ERROR|--> GaussianMixture (Load) \t:\t <nb> not found" << endl; return 0;}
fichier >> nbgauss;
/* Lecture de la dimension des gaussiennes */
FindStr(fichier,"<dim>");
if(fichier.eof()) {cout << dispdec << "|ERROR|--> GaussianMixture (Load) \t:\t <dim> not found" << endl; return 0;}
fichier >> ddim;
this->dim = ddim;
/* Allocations d'un melange de gaussiennes sans init */
Alloc(nbgauss,this->dim,NULL,NULL);
/* Allocation de moyenne et covariance temp */
mm = new double[this->dim];
cc = new double[this->dim*this->dim];
/*Lecture des gausiennes une par une */
for(int n=0;n<nbgauss;n++)
{
/* Lecture moyenne */
sprintf(pattern,"<mean_%d>",n);
FindStr(fichier,pattern);
if(fichier.eof()) {cout << dispdec << "|ERROR|--> GaussianMixture (Load) \t:\t " << pattern << " not found" << endl; return 0;}
for(int i=0;i<this->dim;i++)
fichier >> mm[i];
/* Lecture covariance */
sprintf(pattern,"<cov_%d>",n);
FindStr(fichier,pattern);
if(fichier.eof()) {cout << dispdec << "|ERROR|--> GaussianMixture (Load) \t:\t " << pattern << " not found" << endl; return 0;}
for(int i=0;i<this->dim*this->dim;i++)
fichier >> cc[i];
/* Lecture coefficient */
// sprintf(pattern,"<coeff_%d>",n);
// FindStr(fichier,pattern);
// if(fichier.eof()) {cout << "|ERROR|--> GaussianMixture (Load) \t:\t " << pattern << " not found" << endl; return 0;}
// fichier >> coeff[i];
/* Init de la gaussienne i */
glist[n]->Init(mm,cc);
}
fichier.close();
delete [] mm;
delete [] cc;
return 1;
}
int ColorBase::load(string nomfic)
{
string tmp;
string filename;
ifstream fichier;
/* ouverture du fichier */
filename = icuConfigPath + "/color/bases/" + nomfic;
fichier.open(filename.c_str(), ios::in);
if(!fichier) { cout << "|ERROR|--> ColorBase (Load) \t:\t Error loading " << nomfic << endl; return 0; }
/* recherche nom de la base */
FindStr(fichier,"<nm>");
if(fichier.eof()) { cout << "|ERROR|--> ColorBase (Load) \t:\t Error <nm> not found !" << endl; return 0; }
else fichier >> this->nm;
/* recup du numero de la base */
this->num = ColorBaseType.getIndex(this->nm);
/* recherche numero du plan contenant la luminance */
FindStr(fichier,"<pLum>");
if(fichier.eof()) { cout << "|ERROR|--> ColorBase (Load) \t:\t Error <pLum> not found !" << endl; return 0; }
else fichier >> this->pLum;
/* recherche nom de la bornes des plans */
FindStr(fichier,"<ranges>");
if(fichier.eof()) { cout << "|ERROR|--> ColorBase (Load) \t:\t Error <ranges> not found !" << endl; return 0; }
else
{
fichier >> this->rC1[0];
fichier >> this->rC1[1];
fichier >> this->rC2[0];
fichier >> this->rC2[1];
fichier >> this->rC3[0];
fichier >> this->rC3[1];
}
this->dimC1 = this->rC1[1]+1;
this->dimC2 = this->rC2[1]+1;
this->dimC3 = this->rC3[1]+1;
/* Connexion des plans luminance et chromatiques */
switch(this->pLum)
{
case 1:
{
this->LumR = this->rC1;
this->ChromR1 = this->rC2;
this->ChromR2 = this->rC3;
this->dimLum = &this->dimC1;
this->dimChrom1 = &this->dimC2;
this->dimChrom2 = &this->dimC3;
}
break;
case 2:
{
this->LumR = this->rC2;
this->ChromR1 = this->rC1;
this->ChromR2 = this->rC3;
this->dimLum = &this->dimC2;
this->dimChrom1 = &this->dimC1;
this->dimChrom2 = &this->dimC3;
}
break;
case 3:
{
this->LumR = this->rC3;
this->ChromR1 = this->rC1;
this->ChromR2 = this->rC2;
this->dimLum = &this->dimC3;
this->dimChrom1 = &this->dimC1;
this->dimChrom2 = &this->dimC2;
}
break;
}
return 1;
}
