UINT CConChecker::ThreadProc(LPVOID pProcParam)
{
CConChecker* pThis = reinterpret_cast<CConChecker*>(pProcParam);
AddLogLine(false,_T("CConChecker (ID: 0x%x) started..."),::GetCurrentThreadId());
pThis->Init();
DWORD dwResult = 0;
//Loop
#pragma warning(disable:4127) //condition is constant by IONIX-Team [cyrex2001]
while (true)
#pragma warning(default:4127) //condition is constant by IONIX-Team [cyrex2001]
{
dwResult = ::WaitForMultipleObjects(cmd_num,pThis->m_hEvent,FALSE,500);// - WAIT_OBJECT_0;
dwResult-=WAIT_OBJECT_0;
if (dwResult == CConChecker::cmd_exit)
break;
if (dwResult == CConChecker::cmd_step)
pThis->Check();
}
pThis->Exit();
::SetEvent(pThis->m_hKilled);
AddLogLine(false,_T("CConChecker (ID: 0x%x) stopped..."),::GetCurrentThreadId());
return 0;
}
void CLogActions::AddMsgLogLineRaw(const char* szTargetLog,const char *sBuffer, const char *sBuffer2)
{
if(objSettings.SaveMesNotesByDef){
AddLogLine(GetLogFileName(DEFAULT_GENERALLOG), sBuffer, objSettings.dwMaxLogFileSize, sBuffer2);
if(objSettings.SaveMesNotesByDefForUser && strcmp(szTargetLog,DEFAULT_GENERALLOG)!=0){
AddLogLine(GetLogFileName(szTargetLog), sBuffer, objSettings.dwMaxLogFileSize, sBuffer2);
}
}
}
void CMMServer::Init(){
if (thePrefs.IsMMServerEnabled() && !m_pSocket){
m_pSocket = new CListenMMSocket(this);
if (!m_pSocket->Create()){
StopServer();
AddLogLine(false, GetResString(IDS_MMFAILED) );
}
else{
AddLogLine(false, GetResString(IDS_MMSTARTED), thePrefs.GetMMPort(), _T(MM_STRVERSION));
}
}
}
bool CFriendList::AddEmfriendsMetToList(const CString& strFile)
{
CSafeBufferedFile file;
CFileException fexp;
if ( !file.Open(strFile, CFile::modeRead|CFile::osSequentialScan|CFile::typeBinary, &fexp) )
{
if ( fexp.m_cause != CFileException::fileNotFound )
{
CString strError(GetResString(IDS_ERR_READEMFRIENDS));
TCHAR szError[MAX_CFEXP_ERRORMSG];
if ( fexp.GetErrorMessage(szError,MAX_CFEXP_ERRORMSG) )
{
strError += _T(" - ");
strError += szError;
}
AddLogLine(true, _T("%s"), strError);
}
return false;
}
try
{
uint8 header = file.ReadUInt8();
if ( header != MET_HEADER )
{
file.Close();
return false;
}
UINT nRecordsNumber = file.ReadUInt32();
for (UINT i = 0; i < nRecordsNumber; i++)
{
CFriend* Record = new CFriend();
Record->LoadFromFile(&file);
if ( !IsAlreadyFriend(Record->m_abyUserhash) )
m_listFriends.AddTail(Record);
}
file.Close();
}
catch ( CFileException* error )
{
if ( error->m_cause == CFileException::endOfFile )
AddLogLine(true,GetResString(IDS_ERR_EMFRIENDSINVALID));
else
{
TCHAR buffer[MAX_CFEXP_ERRORMSG];
error->GetErrorMessage(buffer, MAX_CFEXP_ERRORMSG);
AddLogLine(true, GetResString(IDS_ERR_READEMFRIENDS), buffer);
}
error->Delete();
return false;
}
return true;
}// MORPH END - Added by Commander, Friendlinks [emulEspaña]
void CLogActions::AddMsgLogLine(const char* szTargetLog,const char *szFormat, ...)
{
if(objSettings.SaveMesNotesByDef){
va_list vaList;
va_start(vaList,szFormat);
CString sBuffer;
sBuffer.FormatV(szFormat,vaList);
va_end (vaList);
AddLogLine(GetLogFileName(DEFAULT_GENERALLOG), sBuffer, objSettings.dwMaxLogFileSize);
if(objSettings.SaveMesNotesByDefForUser && strcmp(szTargetLog,DEFAULT_GENERALLOG)!=0){
AddLogLine(GetLogFileName(szTargetLog), sBuffer, objSettings.dwMaxLogFileSize);
}
}
}
void CMMServer::ProcessHelloPacket(CMMData* data, CMMSocket* sender){
CMMPacket* packet = new CMMPacket(MMP_HELLOANS);
if (data->ReadByte() != MM_VERSION){
packet->WriteByte(MMT_WRONGVERSION);
sender->SendPacket(packet);
return;
}
else{
if(m_dwBlocked && m_dwBlocked > ::GetTickCount()){
packet->WriteByte(MMT_WRONGPASSWORD);
sender->SendPacket(packet);
return;
}
CString plainPW = data->ReadString();
CString testValue =MD5Sum(plainPW).GetHash();
if (testValue != thePrefs.GetMMPass() || plainPW.GetLength() == 0 ){
m_dwBlocked = 0;
packet->WriteByte(MMT_WRONGPASSWORD);
sender->SendPacket(packet);
m_cPWFailed++;
if (m_cPWFailed == 3){
AddLogLine(false, GetResString(IDS_MM_BLOCK));
m_cPWFailed = 0;
m_dwBlocked = ::GetTickCount() + MMS_BLOCKTIME;
}
return;
}
else{
m_bUseFakeContent = (data->ReadByte() != 0);
m_nMaxDownloads = data->ReadShort();
m_nMaxBufDownloads = data->ReadShort();
m_bGrabListLogin = (data->ReadByte() != 0);
// everything ok, new sessionid
AddLogLine(false, GetResString(IDS_MM_NEWUSER));
packet->WriteByte(MMT_OK);
m_nSessionID = (uint16)rand();
packet->WriteShort(m_nSessionID);
packet->WriteString(thePrefs.GetUserNick());
packet->WriteShort((uint16)((thePrefs.GetMaxUpload() >= UNLIMITED) ? 0 : thePrefs.GetMaxUpload()));
packet->WriteShort((uint16)((thePrefs.GetMaxDownload() >= UNLIMITED) ? 0 : (uint16)thePrefs.GetMaxDownload()));
ProcessStatusRequest(sender,packet);
//sender->SendPacket(packet);
}
}
}
void CHardLimit::DeleteFile(CPartFile* file)
{
CString datafilepath;
datafilepath.Format(_T("%s\\%s\\%s.ahl"), thePrefs.GetTempDir(),_T("Extra Lists"),file->GetPartMetFileName());
if (_tremove(datafilepath)) if (errno != ENOENT)
/*theApp.emuledlg->*/AddLogLine(true, _T("Failed to delete %s, you will need to do this by hand"), datafilepath);
}
//You can add a friend without a IP to allow the IRC to trade links with lowID users.
bool CFriendList::AddFriend(const uchar* abyUserhash, uint32 dwLastSeen, uint32 dwLastUsedIP, uint16 nLastUsedPort,
uint32 dwLastChatted, LPCTSTR pszName, uint32 dwHasHash){
// client must have an IP (HighID) or a hash
// TODO: check if this can be switched to a hybridID so clients with *.*.*.0 can be added..
if (IsLowID(dwLastUsedIP) && dwHasHash==0)
return false;
if (SearchFriend(abyUserhash, dwLastUsedIP, nLastUsedPort) != NULL)
return false;
CFriend* Record = new CFriend( abyUserhash, dwLastSeen, dwLastUsedIP, nLastUsedPort, dwLastChatted, pszName, dwHasHash );
m_listFriends.AddTail(Record);
ShowFriends();
SaveList();
// Mighty Knife: log friend activities
if (thePrefs.GetLogFriendlistActivities ()) {
#ifdef MIGHTY_TWEAKS
AddLogLine(false, GetResString(IDS_NEWFRIEND)+_T(" '%s', ip %i.%i.%i.%i:%i, ")+GetResString(IDS_CD_UHASH)+_T(" %s"),
Record->m_strName, (uint8)Record->m_dwLastUsedIP, (uint8)(Record->m_dwLastUsedIP>>8),
(uint8)(Record->m_dwLastUsedIP>>16),(uint8)(Record->m_dwLastUsedIP>>24),
Record->m_nLastUsedPort, md4str(Record->m_abyUserhash));
#else
AddLogLine(false, GetResString(IDS_NEWFRIEND)+_T(" '%s', ")+GetResString(IDS_CD_UHASH)+_T(" %s"),
Record->m_strName, md4str(Record->m_abyUserhash));
#endif
}
bool CServerListCtrl::StaticServerFileAppend(CServer *server)
{
try
{
// Remove any entry before writing to avoid duplicates
StaticServerFileRemove(server);
FILE* staticservers = _tfsopen(thePrefs.GetConfigDir() + _T("staticservers.dat"), _T("a"), _SH_DENYWR);
if (staticservers==NULL)
{
LogError(LOG_STATUSBAR, GetResString(IDS_ERROR_SSF));
return false;
}
if (_ftprintf(staticservers,
_T("%s:%i,%i,%s\n"),
server->GetAddress(),
server->GetPort(),
server->GetPreferences(),
server->GetListName()) != EOF)
{
AddLogLine(false, _T("'%s:%i,%s' %s"), server->GetAddress(), server->GetPort(), server->GetListName(), GetResString(IDS_ADDED2SSF));
server->SetIsStaticMember(true);
theApp.emuledlg->serverwnd->serverlistctrl.RefreshServer(server);
}
fclose(staticservers);
}
catch (...)
{
ASSERT(0);
return false;
}
return true;
}
void CServerWnd::OnBnClickedUpdateServerMetFromUrl()
{
CString strURL;
GetDlgItem(IDC_SERVERMETURL)->GetWindowText(strURL);
strURL.Trim();
if (strURL.IsEmpty())
{
if (thePrefs.addresses_list.IsEmpty())
{
AddLogLine(true, GetResString(IDS_SRV_NOURLAV));
}
else
{
bool bDownloaded = false;
POSITION pos = thePrefs.addresses_list.GetHeadPosition();
while (!bDownloaded && pos != NULL)
{
strURL = thePrefs.addresses_list.GetNext(pos);
bDownloaded = UpdateServerMetFromURL(strURL);
}
}
}
else
UpdateServerMetFromURL(strURL);
}
void CSourceSaver::DeleteFile(CPartFile* file)
{
TCHAR szslsfilepath[_MAX_PATH];
// khaos::kmod+ Source Lists directory
_tmakepath(szslsfilepath,NULL,(CString)file->GetTempPath()+_T("\\Source Lists"), file->GetPartMetFileName(),_T(".txtsrc"));
if (_tremove(szslsfilepath)) if (errno != ENOENT)
AddLogLine(true, _T("Failed to delete 'Temp\\Source Lists\\%s.txtsrc', you will need to do this by hand."), file->GetPartMetFileName());
}
void CSettingsSaver::DeleteOldSettings(CPartFile* file)
{
CString datafilepath;
datafilepath.Format(_T("%s\\%s\\%s.sivka"), file->GetTempPath(), _T("Extra Lists"), file->GetPartMetFileName());
if (_tremove(datafilepath)) if (errno != ENOENT)
AddLogLine(true, _T("Failed to delete %s, you will need to do this manually"), datafilepath);
}
void CLogger::AddLogLine(
const wxString &file,
int line,
bool critical,
const std::ostringstream &msg)
{
AddLogLine(file, line, critical, static_cast<DebugType>(0), msg);
}
void CLogActions::AddMailLogLine(const char *szFormat, ...)
{
va_list vaList;
va_start(vaList,szFormat);
CString sBuffer;
sBuffer.FormatV(szFormat,vaList);
va_end (vaList);
AddLogLine(GetLogFileName(DEFAULT_ANTISPAMLOG), sBuffer, objSettings.dwMaxMailLogFileSize);
}
bool CServerListCtrl::StaticServerFileAppend(CServer *server)
{
bool bResult;
AddLogLine(false, _T("'%s:%i,%s' %s"), server->GetAddress(), server->GetPort(), server->GetListName(), GetResString(IDS_ADDED2SSF));
server->SetIsStaticMember(true);
bResult = theApp.serverlist->SaveStaticServers();
RefreshServer(server);
return bResult;
}
void AddLogCurrentDT(char *fileName) {
char buff[20];
struct tm *curTime;
time_t now = time(0);
curTime = gmtime(&now);
strftime (buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", curTime);
AddLogLine(fileName, "\nanticollision: ", buff);
}
int CEMSocket::OnLayerCallback(const CAsyncSocketExLayer *pLayer, int nType, int nCode, WPARAM wParam, LPARAM lParam)
{
ASSERT(pLayer);
/*if (nType == LAYERCALLBACK_STATECHANGE)
{
CString logline;
if (pLayer==m_pProxyLayer)
{
logline.Format(_T("ProxyLayer changed state from %d to %d"), nParam2, nParam1);
AddLogLine(0, logline);
}
else
logline.Format(_T("Layer @ %d changed state from %d to %d"), pLayer, nParam2, nParam1);
AddLogLine(0, logline);
return 1;
}
else */if (nType == LAYERCALLBACK_LAYERSPECIFIC)
{
if (pLayer == m_pProxyLayer)
{
CString strError(GetProxyError(nCode));
switch (nCode)
{
case PROXYERROR_NOCONN:
// We failed to connect to the proxy
m_bProxyConnectFailed = true;
case PROXYERROR_REQUESTFAILED:
if (lParam && ((LPCSTR)lParam)[0] != '\0')
{
strError += _T(" - ");
strError += (LPCSTR)lParam;
}
if (wParam)
{
CString strErrInf;
if (GetErrorMessage(wParam, strErrInf, 1))
{
strError += _T(" - ");
strError += strErrInf;
}
}
default:
AddLogLine(0, _T("Proxy error - %s"), strError);
}
}
}
return 1;
}
void CLogger::AddLogLine(
const wxString &file,
int line,
bool critical,
DebugType type,
const std::ostringstream &msg)
{
int index = (int)type;
if ( index >= 0 && index < categoryCount ) {
const CDebugCategory& cat = g_debugcats[ index ];
wxASSERT(type == cat.GetType());
AddLogLine(file, line, critical, logStandard,
cat.GetName() + wxT(": ") + char2unicode(msg.str().c_str()));
}
}
UINT AFX_CDECL CPartFileConvert::run(LPVOID /*lpParam*/)
{
DbgSetThreadName("Partfile-Converter");
InitThreadLocale();
//Xman
// BEGIN SLUGFILLER: SafeHash
CReadWriteLock lock(&theApp.m_threadlock);
if (!lock.ReadLock(0))
return 0;
// END SLUGFILLER: SafeHash
int imported=0;
for (;;)
{
// search next queued job and start it
pfconverting=NULL;
for(POSITION pos = m_jobs.GetHeadPosition(); pos != NULL; m_jobs.GetNext(pos)){
pfconverting=m_jobs.GetAt(pos);
if (pfconverting->state==CONV_QUEUE) break; else pfconverting=NULL;
}
if (pfconverting!=NULL) {
pfconverting->state=CONV_INPROGRESS;
UpdateGUI(pfconverting);
pfconverting->state=performConvertToeMule(pfconverting->folder);
if (pfconverting->state==CONV_OK)
++imported;
UpdateGUI(pfconverting);
AddLogLine(true,GetResString(IDS_IMP_STATUS),pfconverting->folder,GetReturncodeText(pfconverting->state));
} else
break;// nothing more to do now
}
// clean up
UpdateGUI(NULL);
if (imported)
theApp.sharedfiles->PublishNextTurn();
convertPfThread=NULL;
return 0;
}
void CNatThread::RegisterMe(DWORD sip, WORD sport)
{
// modified by robert, 2010-07-30 加锁
CSingleLock locker(&m_Mutex, TRUE);
if(!CGlobalVariable::clientudp) return;
_AddDebugLogLine(false, _T("CNatThread::RegisterMe"));
if(!m_bRegister)
AddLogLine(false, _T("Registering to NAT traversal server [%s]\n"),ipstr(sip,ntohs(sport)));
m_dwSvrKeepalive = m_RegisterTime = time(NULL);
// VC-SearchDream[2007-06-08]: new way statics Begin
if (m_RegisterTime - m_dwSendStaticsTime > 60 * 10)
{
uchar pack[22];
GetMyUserHash(pack);
WORD counter1 = m_wTraverseBySvr, counter2 = m_wTraverseBySvr, counter3 = m_wTraverseBySE;
counter1 = htons(counter1);
counter2 = htons(counter2);
counter3 = htons(counter3);
memcpy(pack+16, &counter1, 2);
memcpy(pack+18, &counter2, 2);
memcpy(pack+20, &counter3, 2);
CNatSocket::SendPacket(sip, sport, OP_NAT_REGISTER, pack, 22);
m_dwSendStaticsTime = m_RegisterTime;
m_wTraverseBySvr = m_wTraverseBySE = 0;
}
else
{
uchar pack[16];
GetMyUserHash(pack);
CNatSocket::SendPacket(sip, sport, OP_NAT_REGISTER, pack, 16);
}
}
BOOL CXCatalogWnd::OnInitDialog()
{
CResizableDialog::OnInitDialog();
RECT rc;
GetClientRect(&rc);
m_catalog = new CXCatalogClientWnd;
if ( !m_catalog->Create(NULL, _T("xcatalog"), WS_VISIBLE|WS_CHILD, rc, this, IDC_CONTAINER) )
{
CWaitCursor waitCursor;
emActiveX::registerServer(L"xcatalog.dll");
if ( !m_catalog->Create(NULL, _T("xcatalog"), WS_VISIBLE|WS_CHILD, rc, this, IDC_CONTAINER) ) {
AddLogLine(true, _T("Unable create xCatalog control"));
delete m_catalog;
m_catalog = NULL;
}
}
return TRUE;
}
bool CServerWnd::AddServer(uint16 nPort, CString strAddress, CString strName, bool bShowErrorMB)
{
CServer* toadd = new CServer(nPort, strAddress);
// Barry - Default all manually added servers to high priority
if (thePrefs.GetManualAddedServersHighPriority())
toadd->SetPreference(SRV_PR_HIGH);
if (strName.IsEmpty())
strName = strAddress;
toadd->SetListName(strName);
if (!serverlistctrl.AddServer(toadd, true))
{
CServer* pFoundServer = theApp.serverlist->GetServerByAddress(toadd->GetAddress(), toadd->GetPort());
if (pFoundServer == NULL && toadd->GetIP() != 0)
pFoundServer = theApp.serverlist->GetServerByIPTCP(toadd->GetIP(), toadd->GetPort());
if (pFoundServer)
{
static const TCHAR _aszServerPrefix[] = _T("Server");
if (_tcsnicmp(toadd->GetListName(), _aszServerPrefix, ARRSIZE(_aszServerPrefix)-1) != 0)
{
pFoundServer->SetListName(toadd->GetListName());
serverlistctrl.RefreshServer(pFoundServer);
}
}
else
{
if (bShowErrorMB)
AfxMessageBox(GetResString(IDS_SRV_NOTADDED));
}
delete toadd;
return false;
}
else
{
AddLogLine(true, GetResString(IDS_SERVERADDED), toadd->GetListName());
return true;
}
}
void CChatSelector::ProcessMessage(CUpDownClient* sender, const CString& message)
{
sender->IncMessagesReceived();
CChatItem* ci = GetItemByClient(sender);
AddLogLine(true, GetResString(IDS_NEWMSG), sender->GetUserName(), ipstr(sender->GetConnectIP()));
bool isNewChatWindow = false;
if (!ci)
{
if ((UINT)GetItemCount() >= thePrefs.GetMsgSessionsMax())
return;
ci = StartSession(sender, false);
isNewChatWindow = true;
}
if (thePrefs.GetIRCAddTimeStamp())
AddTimeStamp(ci);
ci->log->AppendKeyWord(sender->GetUserName(), RECV_SOURCE_MSG_COLOR);
ci->log->AppendText(_T(": "));
ci->log->AppendText(message + _T("\n"));
int iTabItem = GetTabByClient(sender);
if (GetCurSel() == iTabItem && GetParent()->IsWindowVisible())
{
// chat window is already visible
;
}
else if (GetCurSel() != iTabItem)
{
// chat window is already visible, but tab is not selected
ci->notify = true;
}
else
{
ci->notify = true;
if (isNewChatWindow || thePrefs.GetNotifierOnEveryChatMsg())
theApp.emuledlg->ShowNotifier(GetResString(IDS_TBN_NEWCHATMSG) + _T(" ") + CString(sender->GetUserName()) + _T(":'") + message + _T("'\n"), TBN_CHAT);
isNewChatWindow = false;
}
}
void CServerConnect::TryAnotherConnectionRequest()
{
if (connectionattemps.GetCount() < (thePrefs.IsSafeServerConnectEnabled() ? 1 : 2))
{
CServer* next_server = theApp.serverlist->GetNextServer(m_bTryObfuscated);
if (next_server == NULL)
{
if (connectionattemps.GetCount() == 0)
{
if (m_bTryObfuscated && !thePrefs.IsClientCryptLayerRequired()){
// try all servers on the non-obfuscated port next
m_bTryObfuscated = false;
ConnectToAnyServer(0, true, true, true);
}
else if (m_idRetryTimer == 0)
{
// 05-Nov-2003: If we have a very short server list, we could put serious load on those few servers
// if we start the next connection tries without waiting.
LogWarning(LOG_STATUSBAR, GetResString(IDS_OUTOFSERVERS));
AddLogLine(false, GetResString(IDS_RECONNECT), CS_RETRYCONNECTTIME);
m_uStartAutoConnectPos = 0; // default: start at 0
VERIFY( (m_idRetryTimer = SetTimer(NULL, 0, 1000*CS_RETRYCONNECTTIME, RetryConnectTimer)) != NULL );
if (thePrefs.GetVerbose() && !m_idRetryTimer)
DebugLogError(_T("Failed to create 'server connect retry' timer - %s"), GetErrorMessage(GetLastError()));
}
}
return;
}
// Barry - Only auto-connect to static server option
if (thePrefs.GetAutoConnectToStaticServersOnly())
{
if (next_server->IsStaticMember())
ConnectToServer(next_server, true, !m_bTryObfuscated);
}
else
ConnectToServer(next_server, true, !m_bTryObfuscated);
}
}
void CFulEditCtrl::CheckAction(ColorSettings* cs, const tstring& line) {
if(cs->getPopup() && !matchedPopup && isSet(POPUP)) {
matchedPopup = true;
PopupManager::getInstance()->ShowMC(line, ::GetParent(m_hWnd));
}
if(cs->getTab() && isSet(TAB))
matchedTab = true;
if(cs->getLog() && !logged && !skipLog){
logged = true;
AddLogLine(line);
}
if(cs->getPlaySound() && !matchedSound && isSet(SOUND)){
if(!(BOOLSETTING(MUTE_ON_AWAY) && Util::getAway())) {
matchedSound = true;
PlaySound(cs->getSoundFile().c_str(), NULL, SND_ASYNC | SND_FILENAME | SND_NOWAIT);
}
}
if(cs->getFlashWindow())
WinUtil::flashWindow();
}
void CServerSocket::ConnectToServer(CServer* server) {
if (cur_server) {
ASSERT(0);
delete cur_server;
cur_server = NULL;
}
cur_server = new CServer(server);
Log(GetResString(IDS_CONNECTINGTO), cur_server->GetListName(), cur_server->GetFullIP(), cur_server->GetPort());
//==> remove PROXY [shadow2004]
#if defined(PROXY)
if (thePrefs.IsProxyASCWOP() )
{
if (thePrefs.GetProxy().UseProxy == true)
{
thePrefs.SetProxyASCWOP(true);
thePrefs.SetUseProxy(false);
AddLogLine(false, GetResString(IDS_ASCWOP_PROXYSUPPORT) + GetResString(IDS_DISABLED));
}
else
thePrefs.SetProxyASCWOP(false);
}
#endif //PROXY
//<== remove PROXY [shadow2004]
SetConnectionState(CS_CONNECTING);
if (!Connect(server->GetAddress(),server->GetPort())) {
DWORD dwError = GetLastError();
if (dwError != WSAEWOULDBLOCK) {
LogError(GetResString(IDS_ERR_CONNECTIONERROR), cur_server->GetListName(), cur_server->GetFullIP(), cur_server->GetPort(), GetErrorMessage(dwError, 1));
SetConnectionState(CS_FATALERROR);
return;
}
}
SetConnectionState(CS_CONNECTING);
}
void AddLogUint64(char *fileName, char *extData, const uint64_t data) {
char buf[100] = {0};
sprintf(buf, "%x%x", (unsigned int)((data & 0xFFFFFFFF00000000) >> 32), (unsigned int)(data & 0xFFFFFFFF));
AddLogLine(fileName, extData, buf);
}
void AddLogHex(char *fileName, char *extData, const uint8_t * data, const size_t len){
AddLogLine(fileName, extData, sprint_hex(data, len));
}
int CIPFilter::AddFromFile(LPCTSTR pszFilePath, bool bShowResponse)
{
DWORD dwStart = GetTickCount();
FILE* readFile = _tfsopen(pszFilePath, _T("r"), _SH_DENYWR);
if (readFile != NULL)
{
enum EIPFilterFileType
{
Unknown = 0,
FilterDat = 1, // ipfilter.dat/ip.prefix format
PeerGuardian = 2, // PeerGuardian text format
PeerGuardian2 = 3 // PeerGuardian binary format
} eFileType = Unknown;
setvbuf(readFile, NULL, _IOFBF, 32768);
TCHAR szNam[_MAX_FNAME];
TCHAR szExt[_MAX_EXT];
_tsplitpath(pszFilePath, NULL, NULL, szNam, szExt);
if (_tcsicmp(szExt, _T(".p2p")) == 0 || (_tcsicmp(szNam, _T("guarding.p2p")) == 0 && _tcsicmp(szExt, _T(".txt")) == 0))
eFileType = PeerGuardian;
else if (_tcsicmp(szExt, _T(".prefix")) == 0)
eFileType = FilterDat;
else
{
VERIFY( _setmode(fileno(readFile), _O_BINARY) != -1 );
static const BYTE _aucP2Bheader[] = "\xFF\xFF\xFF\xFFP2B";
BYTE aucHeader[sizeof _aucP2Bheader - 1];
if (fread(aucHeader, sizeof aucHeader, 1, readFile) == 1)
{
if (memcmp(aucHeader, _aucP2Bheader, sizeof _aucP2Bheader - 1)==0)
eFileType = PeerGuardian2;
else
{
(void)fseek(readFile, 0, SEEK_SET);
VERIFY( _setmode(fileno(readFile), _O_TEXT) != -1 ); // ugly!
}
}
}
int iFoundRanges = 0;
int iLine = 0;
if (eFileType == PeerGuardian2)
{
// Version 1: strings are ISO-8859-1 encoded
// Version 2: strings are UTF-8 encoded
uint8 nVersion;
if (fread(&nVersion, sizeof nVersion, 1, readFile)==1 && (nVersion==1 || nVersion==2))
{
while (!feof(readFile))
{
CHAR szName[256];
int iLen = 0;
for (;;) // read until NUL or EOF
{
int iChar = getc(readFile);
if (iChar == EOF)
break;
if (iLen < sizeof szName - 1)
szName[iLen++] = (CHAR)iChar;
if (iChar == '\0')
break;
}
szName[iLen] = '\0';
uint32 uStart;
if (fread(&uStart, sizeof uStart, 1, readFile) != 1)
break;
uStart = ntohl(uStart);
uint32 uEnd;
if (fread(&uEnd, sizeof uEnd, 1, readFile) != 1)
break;
uEnd = ntohl(uEnd);
iLine++;
// (nVersion == 2) ? OptUtf8ToStr(szName, iLen) :
AddIPRange(uStart, uEnd, DFLT_FILTER_LEVEL, CStringA(szName, iLen));
iFoundRanges++;
}
}
}
else
{
CStringA sbuffer;
CHAR szBuffer[1024];
while (fgets(szBuffer, _countof(szBuffer), readFile) != NULL)
{
iLine++;
sbuffer = szBuffer;
// ignore comments & too short lines
if (sbuffer.GetAt(0) == '#' || sbuffer.GetAt(0) == '/' || sbuffer.GetLength() < 5) {
sbuffer.Trim(" \t\r\n");
DEBUG_ONLY( (!sbuffer.IsEmpty()) ? TRACE("IP filter: ignored line %u\n", iLine) : 0 );
continue;
}
if (eFileType == Unknown)
{
// looks like html
if (sbuffer.Find('>') > -1 && sbuffer.Find('<') > -1)
sbuffer.Delete(0, sbuffer.ReverseFind('>') + 1);
// check for <IP> - <IP> at start of line
UINT u1, u2, u3, u4, u5, u6, u7, u8;
if (sscanf(sbuffer, "%u.%u.%u.%u - %u.%u.%u.%u", &u1, &u2, &u3, &u4, &u5, &u6, &u7, &u8) == 8)
{
eFileType = FilterDat;
}
else
{
// check for <description> ':' <IP> '-' <IP>
int iColon = sbuffer.Find(':');
if (iColon > -1)
{
CStringA strIPRange = sbuffer.Mid(iColon + 1);
UINT u1, u2, u3, u4, u5, u6, u7, u8;
if (sscanf(strIPRange, "%u.%u.%u.%u - %u.%u.%u.%u", &u1, &u2, &u3, &u4, &u5, &u6, &u7, &u8) == 8)
{
eFileType = PeerGuardian;
}
}
}
}
bool bValid = false;
uint32 start = 0;
uint32 end = 0;
UINT level = 0;
CStringA desc;
if (eFileType == FilterDat)
bValid = ParseFilterLine1(sbuffer, start, end, level, desc);
else if (eFileType == PeerGuardian)
bValid = ParseFilterLine2(sbuffer, start, end, level, desc);
// add a filter
if (bValid)
{
AddIPRange(start, end, level, desc);
iFoundRanges++;
}
else
{
sbuffer.Trim(" \t\r\n");
DEBUG_ONLY( (!sbuffer.IsEmpty()) ? TRACE("IP filter: ignored line %u\n", iLine) : 0 );
}
}
}
fclose(readFile);
// sort the IP filter list by IP range start addresses
qsort(m_iplist.GetData(), m_iplist.GetCount(), sizeof(m_iplist[0]), CmpSIPFilterByStartAddr);
// merge overlapping and adjacent filter ranges
int iDuplicate = 0;
int iMerged = 0;
if (m_iplist.GetCount() >= 2)
{
// On large IP-filter lists there is a noticeable performance problem when merging the list.
// The 'CIPFilterArray::RemoveAt' call is way too expensive to get called during the merging,
// thus we use temporary helper arrays to copy only the entries into the final list which
// are not get deleted.
// Reserve a byte array (its used as a boolean array actually) as large as the current
// IP-filter list, so we can set a 'to delete' flag for each entry in the current IP-filter list.
char* pcToDelete = new char[m_iplist.GetCount()];
memset(pcToDelete, 0, m_iplist.GetCount());
int iNumToDelete = 0;
SIPFilter* pPrv = m_iplist[0];
int i = 1;
while (i < m_iplist.GetCount())
{
SIPFilter* pCur = m_iplist[i];
if ( pCur->start >= pPrv->start && pCur->start <= pPrv->end // overlapping
|| pCur->start == pPrv->end+1 && pCur->level == pPrv->level) // adjacent
{
if (pCur->start != pPrv->start || pCur->end != pPrv->end) // don't merge identical entries
{
//TODO: not yet handled, overlapping entries with different 'level'
if (pCur->end > pPrv->end)
pPrv->end = pCur->end;
//pPrv->desc += _T("; ") + pCur->desc; // this may create a very very long description string...
iMerged++;
}
else
{
// if we have identical entries, use the lowest 'level'
if (pCur->level < pPrv->level)
pPrv->level = pCur->level;
iDuplicate++;
}
delete pCur;
//m_iplist.RemoveAt(i); // way too expensive (read above)
pcToDelete[i] = 1; // mark this entry as 'to delete'
iNumToDelete++;
i++;
continue;
}
pPrv = pCur;
i++;
}
// Create new IP-filter list which contains only the entries from the original IP-filter list
// which are not to be deleted.
if (iNumToDelete > 0)
{
CIPFilterArray newList;
newList.SetSize(m_iplist.GetCount() - iNumToDelete);
int iNewListIndex = 0;
for (int i = 0; i < m_iplist.GetCount(); i++) {
if (!pcToDelete[i])
newList[iNewListIndex++] = m_iplist[i];
}
ASSERT( iNewListIndex == newList.GetSize() );
// Replace current list with new list. Dump, but still fast enough (only 1 memcpy)
m_iplist.RemoveAll();
m_iplist.Append(newList);
newList.RemoveAll();
m_bModified = true;
}
delete[] pcToDelete;
}
if (thePrefs.GetVerbose())
{
DWORD dwEnd = GetTickCount();
AddDebugLogLine(false, _T("Loaded IP filters from \"%s\""), pszFilePath);
AddDebugLogLine(false, _T("Parsed lines/entries:%u Found IP ranges:%u Duplicate:%u Merged:%u Time:%s"), iLine, iFoundRanges, iDuplicate, iMerged, CastSecondsToHM((dwEnd-dwStart+500)/1000));
}
AddLogLine(bShowResponse, GetResString(IDS_IPFILTERLOADED), m_iplist.GetCount());
}
return m_iplist.GetCount();
}
int mfTraceDecode(uint8_t *data_src, int len, bool wantSaveToEmlFile) {
uint8_t data[64];
if (traceState == TRACE_ERROR) return 1;
if (len > 64) {
traceState = TRACE_ERROR;
return 1;
}
memcpy(data, data_src, len);
if ((traceCrypto1) && ((traceState == TRACE_IDLE) || (traceState > TRACE_AUTH_OK))) {
mf_crypto1_decrypt(traceCrypto1, data, len, 0);
PrintAndLog("dec> %s", sprint_hex(data, len));
AddLogHex(logHexFileName, "dec> ", data, len);
}
switch (traceState) {
case TRACE_IDLE:
// check packet crc16!
if ((len >= 4) && (!CheckCrc14443(CRC_14443_A, data, len))) {
PrintAndLog("dec> CRC ERROR!!!");
AddLogLine(logHexFileName, "dec> ", "CRC ERROR!!!");
traceState = TRACE_ERROR; // do not decrypt the next commands
return 1;
}
// AUTHENTICATION
if ((len == 4) && ((data[0] == 0x60) || (data[0] == 0x61))) {
traceState = TRACE_AUTH1;
traceCurBlock = data[1];
traceCurKey = data[0] == 60 ? 1:0;
return 0;
}
// READ
if ((len ==4) && ((data[0] == 0x30))) {
traceState = TRACE_READ_DATA;
traceCurBlock = data[1];
return 0;
}
// WRITE
if ((len ==4) && ((data[0] == 0xA0))) {
traceState = TRACE_WRITE_OK;
traceCurBlock = data[1];
return 0;
}
// HALT
if ((len ==4) && ((data[0] == 0x50) && (data[1] == 0x00))) {
traceState = TRACE_ERROR; // do not decrypt the next commands
return 0;
}
return 0;
break;
case TRACE_READ_DATA:
if (len == 18) {
traceState = TRACE_IDLE;
if (isBlockTrailer(traceCurBlock)) {
memcpy(traceCard + traceCurBlock * 16 + 6, data + 6, 4);
} else {
memcpy(traceCard + traceCurBlock * 16, data, 16);
}
if (wantSaveToEmlFile) saveTraceCard();
return 0;
} else {
traceState = TRACE_ERROR;
return 1;
}
break;
case TRACE_WRITE_OK:
if ((len == 1) && (data[0] == 0x0a)) {
traceState = TRACE_WRITE_DATA;
return 0;
} else {
traceState = TRACE_ERROR;
return 1;
}
break;
case TRACE_WRITE_DATA:
if (len == 18) {
traceState = TRACE_IDLE;
memcpy(traceCard + traceCurBlock * 16, data, 16);
if (wantSaveToEmlFile) saveTraceCard();
return 0;
} else {
traceState = TRACE_ERROR;
return 1;
}
break;
case TRACE_AUTH1:
if (len == 4) {
traceState = TRACE_AUTH2;
nt = bytes_to_num(data, 4);
return 0;
} else {
traceState = TRACE_ERROR;
return 1;
}
break;
case TRACE_AUTH2:
if (len == 8) {
traceState = TRACE_AUTH_OK;
nr_enc = bytes_to_num(data, 4);
ar_enc = bytes_to_num(data + 4, 4);
return 0;
} else {
traceState = TRACE_ERROR;
return 1;
}
break;
case TRACE_AUTH_OK:
if (len ==4) {
traceState = TRACE_IDLE;
at_enc = bytes_to_num(data, 4);
// decode key here)
ks2 = ar_enc ^ prng_successor(nt, 64);
ks3 = at_enc ^ prng_successor(nt, 96);
revstate = lfsr_recovery64(ks2, ks3);
lfsr_rollback_word(revstate, 0, 0);
lfsr_rollback_word(revstate, 0, 0);
lfsr_rollback_word(revstate, nr_enc, 1);
lfsr_rollback_word(revstate, uid ^ nt, 0);
crypto1_get_lfsr(revstate, &key);
printf("Key: %012"llx"\n",key);
AddLogUint64(logHexFileName, "key: ", key);
int blockShift = ((traceCurBlock & 0xFC) + 3) * 16;
if (isBlockEmpty((traceCurBlock & 0xFC) + 3)) memcpy(traceCard + blockShift + 6, trailerAccessBytes, 4);
if (traceCurKey) {
num_to_bytes(key, 6, traceCard + blockShift + 10);
} else {
num_to_bytes(key, 6, traceCard + blockShift);
}
if (wantSaveToEmlFile) saveTraceCard();
if (traceCrypto1) {
crypto1_destroy(traceCrypto1);
}
// set cryptosystem state
traceCrypto1 = lfsr_recovery64(ks2, ks3);
// nt = crypto1_word(traceCrypto1, nt ^ uid, 1) ^ nt;
/* traceCrypto1 = crypto1_create(key); // key in lfsr
crypto1_word(traceCrypto1, nt ^ uid, 0);
crypto1_word(traceCrypto1, ar, 1);
crypto1_word(traceCrypto1, 0, 0);
crypto1_word(traceCrypto1, 0, 0);*/
return 0;
} else {
traceState = TRACE_ERROR;
return 1;
}
break;
default:
traceState = TRACE_ERROR;
return 1;
}
return 0;
}