//MailSlot of flush DNS cache sender
bool WINAPI FlushDNSMailSlotSender(
void)
{
//Create mailslot.
HANDLE hFile = CreateFileW(MAILSLOT_NAME, GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
if (hFile == INVALID_HANDLE_VALUE)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Create mailslot error, error code is %lu.\n", GetLastError());
return false;
}
//Write into mailslot.
DWORD cbWritten = 0;
if (!WriteFile(hFile, MAILSLOT_MESSAGE_FLUSH_DNS, (DWORD)(lstrlenW(MAILSLOT_MESSAGE_FLUSH_DNS) + 1U) * sizeof(wchar_t), &cbWritten, nullptr))
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"MailSlot write messages error, error code is %lu.\n", GetLastError());
CloseHandle(hFile);
return false;
}
CloseHandle(hFile);
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Flush DNS cache message was sent successfully.\n");
return true;
}
//Catch Control-C exception from keyboard.
BOOL WINAPI CtrlHandler(
const DWORD fdwCtrlType)
{
//Print to screen.
if (GlobalRunningStatus.Console)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
switch (fdwCtrlType)
{
case CTRL_C_EVENT: //Handle the CTRL-C signal.
{
fwprintf_s(stderr, L"Get Control-C.\n");
}break;
case CTRL_BREAK_EVENT: //Handle the CTRL-Break signal.
{
fwprintf_s(stderr, L"Get Control-Break.\n");
}break;
default: //Handle other signals.
{
fwprintf_s(stderr, L"Get closing signal.\n");
}break;
}
}
return FALSE;
}
void debug(const wchar_t* format, ...)
{
wchar_t tmpbuf[128];
time_t rawtime;
struct tm timeinfo;
va_list valist;
if (!DEBUG && EXECUTE_FROM_GPE)
return;
time(&rawtime);
localtime_s(&timeinfo, &rawtime);
wcsftime(tmpbuf, 128, L"%Y-%m-%d %H:%M:%S ", &timeinfo);
va_start(valist, format);
if (!EXECUTE_FROM_GPE){
fwprintf_s(stdout, L"%ls", tmpbuf);
vfwprintf_s(stdout, format, valist);
}
if (debugfh != NULL && DEBUG) {
fwprintf_s(debugfh, L"%ls", tmpbuf);
vfwprintf_s(debugfh, format, valist);
fflush(debugfh);
}
va_end(valist);
}
//SHA-1 hash function
bool __fastcall SHA1_Hash(
FILE *Input)
{
//Parameters check
if (HashFamilyID != HASH_ID_SHA1 || Input == nullptr)
{
fwprintf_s(stderr, L"Parameters error.\n");
return false;
}
//Initialization
std::shared_ptr<char> Buffer(new char[FILE_BUFFER_SIZE]()), StringBuffer(new char[FILE_BUFFER_SIZE]());
auto HashInstance = std::make_shared<SHA1_State>();
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
memset(StringBuffer.get(), 0, FILE_BUFFER_SIZE);
memset(HashInstance.get(), 0, sizeof(SHA1_State));
size_t ReadLength = 0;
//SHA-1 initialization
SHA1_Init(HashInstance.get());
//Hash process
while (!feof(Input))
{
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
ReadLength = fread_s(Buffer.get(), FILE_BUFFER_SIZE, sizeof(char), FILE_BUFFER_SIZE, Input);
if (ReadLength == 0 && errno == EINVAL)
{
fwprintf_s(stderr, L"Hash process error.\n");
return false;
}
else {
SHA1_Process(HashInstance.get(), (uint8_t *)Buffer.get(), (unsigned long)ReadLength);
}
}
//Binary to hex
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
SHA1_Done(HashInstance.get(), (uint8_t *)Buffer.get());
if (sodium_bin2hex(StringBuffer.get(), FILE_BUFFER_SIZE, (const unsigned char *)Buffer.get(), SHA1_SIZE_DIGEST) == nullptr)
{
fwprintf_s(stderr, L"Convert binary to hex error.\n");
return false;
}
else {
//Print to screen.
std::string HashResult = StringBuffer.get();
CaseConvert(true, HashResult);
for (size_t Index = 0;Index < HashResult.length();++Index)
fwprintf_s(stderr, L"%c", HashResult.c_str()[Index]);
fwprintf_s(stderr, L"\n");
}
return true;
}
void saveOptions()
{
FILE* optionsFile = getOptionsFile(L"w");
if (optionsFile)
{
fwprintf_s(optionsFile, L"%s,%hhu\n", reqFSOptionName, reqFullscreen);
fwprintf_s(optionsFile, L"%s,%i\n", soundOptionName, soundOption);
fclose(optionsFile);
}
}
//Catch system signal
BOOL WINAPI SignalHandler(
const DWORD SignalType)
{
//Print to screen.
switch (SignalType)
{
//Handle the CTRL-C signal.
case CTRL_C_EVENT:
{
fwprintf_s(stderr, L"[Notice] Get Control-C.\n");
PrintProcess(true, true);
}break;
//Handle the CTRL-Break signal.
case CTRL_BREAK_EVENT:
{
fwprintf_s(stderr, L"[Notice] Get Control-Break.\n");
PrintProcess(true, true);
//Exit process.
return TRUE;
}break;
//Handle other signals.
default:
{
fwprintf_s(stderr, L"[Notice] Get closing signal.\n");
PrintProcess(true, true);
}
}
//Close file handle.
if (ConfigurationParameter.OutputFile != nullptr)
{
fclose(ConfigurationParameter.OutputFile);
ConfigurationParameter.OutputFile = nullptr;
}
//Close all file handles and WinSock cleanup.
#if defined(PLATFORM_WIN)
if (ConfigurationParameter.IsInitialized_WinSock)
{
WSACleanup();
ConfigurationParameter.IsInitialized_WinSock = false;
}
_fcloseall();
#elif (defined(PLATFORM_FREEBSD) || (defined(PLATFORM_LINUX) && !defined(PLATFORM_OPENWRT)))
fcloseall();
#endif
//Exit process.
// exit(EXIT_SUCCESS);
return FALSE;
}
void left_print_string(FILE * fp, wchar_t * s, wchar_t * t) {
/* prints s then prints the last |t|-|s| characters of t.
if s is longer than t, it truncates s.
*/
int i, j, k;
j = wcslen(t);
k = wcslen(s);
for (i=0; i<j; i++) {
if (i<k) {
fwprintf_s(fp, L"%c", s[i]);
} else {
fwprintf_s(fp, L"%c", t[i]);
}
}
}
int logLoadResources()
{
int iReturnCode = DIAGLIB_OK;
if(g_pfile) return DIAGLIB_OK;
if(g_wsLogFile.empty()) logInit(NULL);
errno_t err = 0;
//Create the file (Erase previous file)
for(int i=0;i<LOG_OPEN_ATTEMPT_COUNT;i++)
{
err = _wfopen_s(&g_pfile, g_wsLogFile.c_str(), (g_logFirstOpen?L"w":L"a"));
if (g_pfile)
{
break;
}
else if( err == ENOENT ) //Folder does not exist
{
g_logAvailable = false;
return DIAGLIB_ERR_NOT_AVAILABLE;
}
else
{
Sleep(50);
}
}
if(g_pfile && g_logFirstOpen)
{
#ifdef WIN32
fwprintf_s(g_pfile,L"RUNNING DIAGLIB VERSION: %hs\n",diaglibVersion());
#elif __APPLE__
fwprintf_s(g_pfile,L"RUNNING DIAGLIB VERSION: %s\n",diaglibVersion());
#endif
}
g_logFirstOpen = false;
if (!g_pfile)
{
return DIAGLIB_ERR_FILE_CREATE_FAILED;
}
return iReturnCode;
}
//Flush DNS cache
void __fastcall FlushAllDNSCache(
void)
{
//Flush DNS cache in program.
std::unique_lock<std::mutex> DNSCacheListMutex(DNSCacheListLock);
DNSCacheList.clear();
DNSCacheList.shrink_to_fit();
DNSCacheListMutex.unlock();
//Flush DNS cache in system.
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
#if defined(PLATFORM_WIN)
system("ipconfig /flushdns 2>nul"); //All Windows version
fwprintf_s(stderr, L"\n");
#elif defined(PLATFORM_LINUX)
#if defined(PLATFORM_OPENWRT)
system("/etc/init.d/dnsmasq restart 2>/dev/null"); //Dnsmasq manage DNS cache on OpenWrt
#else
auto Result = system("service nscd restart 2>/dev/null"); //Name Service Cache Daemon service
Result = system("service dnsmasq restart 2>/dev/null"); //Dnsmasq service
Result = system("rndc restart 2>/dev/null"); //Name server control utility of BIND(9.1.3 and older version)
Result = system("rndc flush 2>/dev/null"); //Name server control utility of BIND(9.2.0 and newer version)
#endif
#elif defined(PLATFORM_MACX)
// system("lookupd -flushcache 2>/dev/null"); //Less than Mac OS X Tiger(10.4)
// system("dscacheutil -flushcache 2>/dev/null"); //Mac OS X Leopard(10.5) and Snow Leopard(10.6)
system("killall -HUP mDNSResponder 2>/dev/null"); //Mac OS X Lion(10.7), Mountain Lion(10.8) and Mavericks(10.9)
system("discoveryutil mdnsflushcache 2>/dev/null"); //Mac OS X Yosemite(10.10) and newer version
#endif
return;
}
int logWrite(bool time, const wchar_t *format, va_list argList)
{
int iReturnCode = DIAGLIB_OK;
if(!g_logAvailable)
return DIAGLIB_OK;
if(format==NULL)
return DIAGLIB_ERR_BAD_CALL;
if(!g_pfile)
{
if(DIAGLIB_OK != (iReturnCode = logLoadResources()))
{
return iReturnCode;
}
}
if(!g_pfile) return DIAGLIB_ERR_INTERNAL;
if(time)
{
std::wstring timestamp;
getLocalTime(timestamp);
fwprintf_s(g_pfile,L"%ls - ",timestamp.c_str());
}
vfwprintf_s(g_pfile, format, argList);
return DIAGLIB_OK;
}
UINT CALLBACK LogThread(void* param)
{
TCHAR fileName[MAX_PATH];
LogPath(fileName, _T("log"));
while ( m_bLoggerRunning || (m_logQueue.size() > 0) )
{
if ( m_logQueue.size() > 0 )
{
SYSTEMTIME systemTime;
GetLocalTime(&systemTime);
WIN32_FILE_ATTRIBUTE_DATA fileInformation;
GetFileAttributesEx(fileName, GetFileExInfoStandard, &fileInformation);
if(logFileParsed != systemTime.wDay || fileInformation.nFileSizeLow > 10485760)
{
LogRotate();
logFileParsed=systemTime.wDay;
LogPath(fileName, _T("log"));
}
CAutoLock lock(&m_logFileLock);
FILE* fp = _tfopen(fileName, _T("a+"));
if (fp!=NULL)
{
SYSTEMTIME systemTime;
GetLocalTime(&systemTime);
wstring line = GetLogLine();
while (!line.empty())
{
fwprintf_s(fp, L"%s", line.c_str());
line = GetLogLine();
}
fclose(fp);
}
else //discard data
{
wstring line = GetLogLine();
while (!line.empty())
{
line = GetLogLine();
}
}
}
if (m_bLoggerRunning)
{
m_EndLoggingEvent.Wait(1000); //Sleep for 1000ms, unless thread is ending
}
else
{
Sleep(1);
}
}
_endthreadex(0);
return 0;
}
void CLog::writeLineMessageW(const wchar_t *format, va_list argList)
{
if(!m_f) //Should not happend, as this method must only be called if the writeLineHeader succeed
throw CMWEXCEPTION(EIDMW_FILE_NOT_OPENED);
vfwprintf_s(m_f, format, argList);
fwprintf_s(m_f,L"%c",'\n');
close();
}
IDiaSymbol* PF_OpenAndFindGlobalScopeFromPdbFile(const wchar_t *szFilename)
{
IDiaSession *pSession = NULL;
IDiaSymbol *pGlobalScope = NULL;
IDiaDataSource *pSource;
HRESULT hr = CoCreateInstance(CLSID_DiaSource,
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IDiaDataSource),
(void **)&pSource);
if (FAILED(hr))
{
fwprintf_s(stdout, L"Could not CoCreate CLSID_DiaSource.\n");
return NULL;
}
if (FAILED(pSource->loadDataFromPdb(szFilename)))
{
fwprintf_s(stdout, L"loadDataFromPdb.\n");
return NULL;
}
if (FAILED(pSource->openSession(&pSession)))
{
fwprintf_s(stdout, L"openSession.\n");
pSession = 0;
return NULL;
}
if (FAILED(pSession->get_globalScope(&pGlobalScope)))
{
fwprintf_s(stdout, L"globalscope.\n");
pSession = 0;
pGlobalScope = 0;
return NULL;
}
pSession = 0;
return pGlobalScope;
}
//Flush DNS cache
void FlushDNSCache(
const uint8_t *Domain)
{
//Flush DNS cache in program.
std::unique_lock<std::mutex> DNSCacheListMutex(DNSCacheListLock);
if (Domain == nullptr) //Flush all DNS cache.
{
DNSCacheList.clear();
}
//Flush single domain cache.
else {
for (auto DNSCacheDataIter = DNSCacheList.begin();DNSCacheDataIter != DNSCacheList.end();)
{
if (DNSCacheDataIter->Domain == (const char *)Domain)
DNSCacheDataIter = DNSCacheList.erase(DNSCacheDataIter);
else
++DNSCacheDataIter;
}
}
DNSCacheListMutex.unlock();
//Flush DNS cache in system.
std::lock_guard<std::mutex> ScreenMutex(ScreenLock);
#if defined(PLATFORM_WIN)
system("ipconfig /flushdns 2>nul"); //All Windows version
fwprintf_s(stderr, L"\n");
#elif defined(PLATFORM_LINUX)
#if defined(PLATFORM_OPENWRT)
system("/etc/init.d/dnsmasq restart 2>/dev/null"); //Dnsmasq manage DNS cache on OpenWrt
#else
auto Result = system("service nscd restart 2>/dev/null"); //Name Service Cache Daemon service
Result = system("service dnsmasq restart 2>/dev/null"); //Dnsmasq service
Result = system("rndc restart 2>/dev/null"); //Name server control utility of BIND(9.1.3 and older version)
Result = system("rndc flush 2>/dev/null"); //Name server control utility of BIND(9.2.0 and newer version)
#endif
#elif defined(PLATFORM_MACX)
// system("lookupd -flushcache 2>/dev/null"); //Less than Mac OS X Tiger(10.4)
// system("dscacheutil -flushcache 2>/dev/null"); //Mac OS X Leopard(10.5) and Snow Leopard(10.6)
system("killall -HUP mDNSResponder 2>/dev/null"); //Mac OS X Lion(10.7), Mountain Lion(10.8) and Mavericks(10.9)
system("discoveryutil mdnsflushcache 2>/dev/null"); //Mac OS X Yosemite(10.10) and newer version
#endif
return;
}
void CALLBACK MyDllNotification(ULONG Reason, PLDR_DLL_NOTIFICATION_DATA NotificationData,
PVOID Context)
{
//Check for the reason
switch (Reason)
{
//LDR_DLL_NOTIFICATION_REASON_LOADED
case LDR_DLL_NOTIFICATION_REASON_LOADED:
break;
//LDR_DLL_NOTIFICATION_REASON_UNLOADED
case LDR_DLL_NOTIFICATION_REASON_UNLOADED:
{
wchar_t message[256] = { 0 };
swprintf(message, L"DLL was unloaded event for %wZ\n", (*NotificationData->Unloaded.FullDllName));
//MessageBoxW(0, message, L"Event", MB_OK);
fwprintf_s(fp, message);
}
default:
return;
}
}
static void Output(const char *fmt, ... )
{
va_list ap;
va_start(ap, fmt);
#ifndef XP_WIN
vfprintf(stderr, fmt, ap);
#ifdef XP_OS2
char msg[2048];
vsnprintf(msg, sizeof(msg), fmt, ap);
HAB hab = WinInitialize(0);
WinCreateMsgQueue(hab, 0);
WinMessageBox(HWND_DESKTOP, 0, msg, "Firefox", 0,
MB_OK | MB_ERROR | MB_MOVEABLE);
#endif
#else
char msg[2048];
vsnprintf_s(msg, _countof(msg), _TRUNCATE, fmt, ap);
wchar_t wide_msg[2048];
MultiByteToWideChar(CP_UTF8,
0,
msg,
-1,
wide_msg,
_countof(wide_msg));
#if MOZ_WINCONSOLE
fwprintf_s(stderr, wide_msg);
#else
MessageBoxW(NULL, wide_msg, L"Firefox", MB_OK
| MB_ICONERROR
| MB_SETFOREGROUND);
#endif
#endif
va_end(ap);
}
void addPtToKml( FILE* outKml, Item* pitem )
{
TCHAR* ptTchar = NULL;
TCHAR ptName[ MAX_PATH ] = { 0 };
// Set up point's name
wcscpy_s( ptName, _countof( ptName ), pitem->findInfo.cFileName );
ptTchar = wcsrchr( ptName, L'.' );
if ( ptTchar != NULL )
*ptTchar = L'\0';
// Output point placemark
fwprintf_s( outKml, TEXT( "<Placemark>\n" ) );
fwprintf_s( outKml, TEXT( " <name>%s</name>\n" ),
ptName );
fwprintf_s( outKml, TEXT( " <styleUrl>#mypushpin</styleUrl>\n" ) );
fwprintf_s( outKml, TEXT( " <Point>\n" ) );
fwprintf_s( outKml, TEXT( " <coordinates>%s</coordinates>\n" ),
pitem->coords );
fwprintf_s( outKml, TEXT( " </Point>\n" ) );
fwprintf_s( outKml, TEXT( "</Placemark>\n\n" ) );
}
//ATTENTION : Design for use with macro
// Must be follow by writeLineMessage to close the file
//Write to log the first part of the line
bool CLog::writeLineHeaderW(tLOG_Level level,const int line,const wchar_t *file)
{
if(level>m_maxlevel)
return false;
long lPreviousOpenFailed = getOpenFailed();
if(!open(true))
return false;
std::wstring timestamp;
getLocalTimeW(timestamp);
if(lPreviousOpenFailed > 0)
{
if(isFileMixingGroups())
{
fwprintf_s(m_f,L"%ls - %ld - %ls: ...ERROR: This file could not be opened. %ld logging line(s) are missing...\n",timestamp.c_str(),CThread::getCurrentPid(),m_group.c_str(),lPreviousOpenFailed);
}
else
{
fwprintf_s(m_f,L"%ls - %ld: ...ERROR: This file could not be opened. %ld logging line(s) are missing...\n",timestamp.c_str(),CThread::getCurrentPid(),lPreviousOpenFailed);
}
}
if(isFileMixingGroups())
{
if(line>0 && wcslen(file)>0)
fwprintf_s(m_f,L"%ls - %ld|%ld - %ls - %ls -'%ls'-line=%d: ",timestamp.c_str(),CThread::getCurrentPid(),CThread::getCurrentThreadId(),m_group.c_str(),getLevel(level),file,line);
else
fwprintf_s(m_f,L"%ls - %ld|%ld - %ls - %ls: ",timestamp.c_str(),CThread::getCurrentPid(),CThread::getCurrentThreadId(),m_group.c_str(),getLevel(level));
}
else
{
if(line>0 && wcslen(file)>0)
fwprintf_s(m_f,L"%ls - %ld|%ld - %ls -'%ls'-line=%d: ",timestamp.c_str(),CThread::getCurrentPid(),CThread::getCurrentThreadId(),getLevel(level),file,line);
else
fwprintf_s(m_f,L"%ls - %ld|%ld - %ls: ",timestamp.c_str(),CThread::getCurrentPid(),CThread::getCurrentThreadId(),getLevel(level));
}
return true;
}
//MD4 hash function
bool __fastcall MD4_Hash(
FILE *Input)
{
//Parameters check
if ((HashFamilyID != HASH_ID_MD4 && HashFamilyID != HASH_ID_ED2K) || Input == nullptr)
{
fwprintf_s(stderr, L"Parameters error.\n");
return false;
}
//Initialization
size_t ReadBlockSize = FILE_BUFFER_SIZE, ReadLength = 0, RoundCount = 0;
if (HashFamilyID == HASH_ID_ED2K)
ReadBlockSize = ED2K_SIZE_BLOCK;
std::shared_ptr<char> Buffer(new char[ReadBlockSize]()), StringBuffer(new char[FILE_BUFFER_SIZE]()), BufferED2K(new char[MD4_SIZE_DIGEST]());
memset(Buffer.get(), 0, ReadBlockSize);
memset(StringBuffer.get(), 0, FILE_BUFFER_SIZE);
memset(BufferED2K.get(), 0, MD4_SIZE_DIGEST);
MD4_CTX HashInstance, HashInstanceED2K;
memset(&HashInstance, 0, sizeof(MD4_CTX));
memset(&HashInstanceED2K, 0, sizeof(MD4_CTX));
//MD4 initialization
MD4_Init(&HashInstance);
if (HashFamilyID == HASH_ID_ED2K)
MD4_Init(&HashInstanceED2K);
//Hash process
while (!feof(Input))
{
memset(Buffer.get(), 0, ReadBlockSize);
_set_errno(0);
ReadLength = fread_s(Buffer.get(), ReadBlockSize, sizeof(char), ReadBlockSize, Input);
if (ReadLength == 0)
{
fwprintf_s(stderr, L"Hash process error");
if (errno > 0)
fwprintf_s(stderr, L", error code is %d.\n", errno);
else
fwprintf_s(stderr, L".\n");
return false;
}
else {
MD4_Update(&HashInstance, Buffer.get(), ReadLength);
if (HashFamilyID == HASH_ID_ED2K)
{
MD4_Final((unsigned char *)Buffer.get(), &HashInstance);
memcpy_s(BufferED2K.get(), MD4_SIZE_DIGEST, Buffer.get(), MD4_SIZE_DIGEST);
MD4_Update(&HashInstanceED2K, Buffer.get(), MD4_SIZE_DIGEST);
MD4_Init(&HashInstance);
}
++RoundCount;
}
}
//Binary to hex
memset(Buffer.get(), 0, ReadBlockSize);
if (HashFamilyID == HASH_ID_MD4)
{
MD4_Final((unsigned char *)Buffer.get(), &HashInstance);
}
else if (HashFamilyID == HASH_ID_ED2K)
{
if (RoundCount > 1U)
MD4_Final((unsigned char *)Buffer.get(), &HashInstanceED2K);
else
memcpy_s(Buffer.get(), MD4_SIZE_DIGEST, BufferED2K.get(), MD4_SIZE_DIGEST);
}
else {
return false;
}
if (sodium_bin2hex(StringBuffer.get(), FILE_BUFFER_SIZE, (const unsigned char *)Buffer.get(), MD4_SIZE_DIGEST) == nullptr)
{
fwprintf_s(stderr, L"Convert binary to hex error.\n");
return false;
}
else {
//Print to screen.
std::string HashResult = StringBuffer.get();
CaseConvert(true, HashResult);
for (size_t Index = 0;Index < HashResult.length();++Index)
fwprintf_s(stderr, L"%c", HashResult.c_str()[Index]);
fwprintf_s(stderr, L"\n");
}
return true;
}
int wmain(
_In_ int argc,
_In_ wchar_t* argv[])
{
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
int main(int argc, char *argv[])
{
#endif
#if defined(ENABLE_LIBSODIUM)
//Libsodium initialization
if (sodium_init() != EXIT_SUCCESS)
{
wprintf_s(L"Libsodium initialization error\n");
#if defined(PLATFORM_WIN)
system("Pause");
#endif
return EXIT_FAILURE;
}
FILE *Output = nullptr;
//Output.
#if defined(PLATFORM_WIN)
_wfopen_s(&Output, L"KeyPair.txt", L"w+,ccs=UTF-8");
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
Output = fopen("KeyPair.txt", "w+");
#endif
if (Output != nullptr)
{
//Initialization and make keypair.
size_t Index = 0;
std::shared_ptr<char> Buffer(new char[KEYPAIR_MESSAGE_LEN]());
std::shared_ptr<uint8_t> PublicKey(new uint8_t[crypto_box_PUBLICKEYBYTES]()), SecretKey(new uint8_t[crypto_box_SECRETKEYBYTES]());
memset(Buffer.get(), 0, KEYPAIR_MESSAGE_LEN);
memset(PublicKey.get(), 0, crypto_box_PUBLICKEYBYTES);
memset(SecretKey.get(), 0, crypto_box_SECRETKEYBYTES);
crypto_box_keypair(PublicKey.get(), SecretKey.get());
//Write public key.
memset(Buffer.get(), 0, KEYPAIR_MESSAGE_LEN);
if (sodium_bin2hex(Buffer.get(), KEYPAIR_MESSAGE_LEN, PublicKey.get(), crypto_box_PUBLICKEYBYTES) == nullptr)
wprintf_s(L"Create ramdom key pair failed, please try again.\n");
CaseConvert(true, Buffer.get(), KEYPAIR_MESSAGE_LEN);
fwprintf_s(Output, L"Client Public Key = ");
for (Index = 0;Index < strnlen_s(Buffer.get(), KEYPAIR_MESSAGE_LEN);++Index)
{
if (Index > 0 && Index % KEYPAIR_INTERVAL == 0 && Index + 1U < strnlen_s(Buffer.get(), KEYPAIR_MESSAGE_LEN))
fwprintf_s(Output, L":");
fwprintf_s(Output, L"%c", Buffer.get()[Index]);
}
memset(Buffer.get(), 0, KEYPAIR_MESSAGE_LEN);
fwprintf_s(Output, L"\n");
//Write secret key.
if (sodium_bin2hex(Buffer.get(), KEYPAIR_MESSAGE_LEN, SecretKey.get(), crypto_box_SECRETKEYBYTES) == nullptr)
wprintf_s(L"Create ramdom key pair failed, please try again.\n");
CaseConvert(true, Buffer.get(), KEYPAIR_MESSAGE_LEN);
fwprintf_s(Output, L"Client Secret Key = ");
for (Index = 0;Index < strnlen_s(Buffer.get(), KEYPAIR_MESSAGE_LEN);++Index)
{
if (Index > 0 && Index % KEYPAIR_INTERVAL == 0 && Index + 1U < strnlen_s(Buffer.get(), KEYPAIR_MESSAGE_LEN))
fwprintf_s(Output, L":");
fwprintf_s(Output, L"%c", Buffer.get()[Index]);
}
fwprintf_s(Output, L"\n");
//Close file.
fclose(Output);
}
else {
wprintf_s(L"Cannot create target file(KeyPair.txt)\n");
#if defined(PLATFORM_WIN)
system("Pause");
#endif
return EXIT_FAILURE;
}
wprintf_s(L"Create ramdom key pair success, please check KeyPair.txt.\n\n");
#if defined(PLATFORM_WIN)
system("Pause");
#endif
#else
#if defined(PLATFORM_WIN)
wprintf_s(L"LibSodium is disable.\n\n");
system("Pause");
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
wprintf(L"LibSodium is disable.\n\n");
#endif
#endif
return EXIT_SUCCESS;
}
//Convert lowercase/uppercase words to uppercase/lowercase words(Character version)
#if defined(ENABLE_LIBSODIUM)
void __fastcall CaseConvert(
_In_ const bool IsLowerToUpper,
_Inout_ char *Buffer,
_In_ const size_t Length)
{
for (size_t Index = 0;Index < Length;++Index)
{
//Lowercase to uppercase
if (IsLowerToUpper)
Buffer[Index] = (char)toupper(Buffer[Index]);
//Uppercase to lowercase
else
Buffer[Index] = (char)tolower(Buffer[Index]);
}
return;
}
//Print errors to log file
size_t __fastcall PrintError(const size_t Type, const PWSTR Message, const SSIZE_T Code, const PWSTR FileName, const size_t Line)
{
//Print Errors: ON/OFF.
if (!Parameter.PrintError || Message == nullptr)
return FALSE;
//Get current date&time.
tm Time = {0};
time_t tTime = 0;
time(&tTime);
localtime_s(&Time, &tTime);
/*
//Windows API
SYSTEMTIME Time = {0};
GetLocalTime(&Time);
fwprintf_s(Output, L"%u%u/%u %u:%u:%u -> %s.\n", Time.wYear, Time.wMonth, Time.wDay, Time.wHour, Time.wMinute, Time.wSecond, pBuffer); //Windows API
//Convert to ASCII.
char TimeBuf[ADDR_STRING_MAXSIZE] = {0};
asctime_s(TimeBuf, &Time);
fwprintf_s(Output, L"%s -> %s.\n", TimeBuf, pBuffer);
*/
FILE *Output = nullptr;
_wfopen_s(&Output, ErrorLogPath.c_str(), L"a,ccs=UTF-8");
if (Output != nullptr)
{
// Error Type
// 01: System Error
// 02: Parameter Error
// 03: IPFilter Error
// 04: Hosts Error
// 05: Winsock Error
// 06: WinPcap Error
// 07: DNSCurve Error
switch (Type)
{
//System Error
case SYSTEM_ERROR:
{
if (Code == NULL)
{
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> System Error: %ls.\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
}
else {
//About System Error Codes, see http://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx.
if (Code == ERROR_FAILED_SERVICE_CONTROLLER_CONNECT)
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> System Error: %ls, ERROR_FAILED_SERVICE_CONTROLLER_CONNECT(The service process could not connect to the service controller).\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
else
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> System Error: %ls, error code is %d.\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message, (int)Code);
}
}break;
//Parameter Error
case PARAMETER_ERROR:
{
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> Parameter Error: %ls", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
if (FileName != nullptr && Line != NULL)
{
//Delete double backslash.
std::wstring sFileName(FileName);
while (sFileName.find(L"\\\\") != std::wstring::npos)
sFileName.erase((size_t)sFileName.find(L"\\\\"), 1U);
//Write to file
fwprintf_s(Output, L" in line %d of %ls", (int)Line, sFileName.c_str());
}
//About Windows Sockets Error Codes, see http://msdn.microsoft.com/en-us/library/windows/desktop/ms740668(v=vs.85).aspx.
if (Code != NULL)
fwprintf_s(Output, L", error code is %d", (int)Code);
fwprintf_s(Output, L".\n");
}break;
//IPFilter Error
case IPFILTER_ERROR:
{
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> IPFilter Error: %ls", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
if (FileName != nullptr && Line != NULL)
{
//Delete double backslash.
std::wstring sFileName(FileName);
while (sFileName.find(L"\\\\") != std::wstring::npos)
sFileName.erase((size_t)sFileName.find(L"\\\\"), 1U);
//Write to file
fwprintf_s(Output, L" in line %d of %ls", (int)Line, sFileName.c_str());
}
//About Windows Sockets Error Codes, see http://msdn.microsoft.com/en-us/library/windows/desktop/ms740668(v=vs.85).aspx.
if (Code != NULL)
fwprintf_s(Output, L", error code is %d", (int)Code);
fwprintf_s(Output, L".\n");
}break;
//Hosts Error
case HOSTS_ERROR:
{
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> Hosts Error: %ls", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
if (FileName != nullptr && Line != NULL)
{
//Delete double backslash.
std::wstring sFileName(FileName);
while (sFileName.find(L"\\\\") != std::wstring::npos)
sFileName.erase((size_t)sFileName.find(L"\\\\"), 1U);
//Write to file
fwprintf_s(Output, L" in line %d of %ls", (int)Line, sFileName.c_str());
}
//About Windows Sockets Error Codes, see http://msdn.microsoft.com/en-us/library/windows/desktop/ms740668(v=vs.85).aspx.
if (Code != NULL)
fwprintf_s(Output, L", error code is %d", (int)Code);
fwprintf_s(Output, L".\n");
}break;
//Winsock Error
//About Windows Sockets Error Codes, see http://msdn.microsoft.com/en-us/library/windows/desktop/ms740668(v=vs.85).aspx.
case WINSOCK_ERROR:
{
if (Code == NULL)
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> Winsock Error: %ls.\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
else
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> Winsock Error: %ls, error code is %d.\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message, (int)Code);
}break;
//WinPcap Error
case WINPCAP_ERROR:
{
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> WinPcap Error: %ls.\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
}break;
//DNSCurve Error
case DNSCURVE_ERROR:
{
fwprintf_s(Output, L"%d-%02d-%02d %02d:%02d:%02d -> DNSCurve Error: %ls.\n", Time.tm_year + 1900, Time.tm_mon + 1, Time.tm_mday, Time.tm_hour, Time.tm_min, Time.tm_sec, Message);
}break;
default:
{
fclose(Output);
return EXIT_FAILURE;
}
}
fclose(Output);
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
void addCoordsToKml( FILE* outKml, Item* pitem )
{
fwprintf_s( outKml, TEXT( " %s\n" ), pitem->coords );
}
void outputKml( List* plist )
{
errno_t err;
FILE* outKml = NULL;
TCHAR fName[ MAX_PATH ] = { 0 };
// Set up kml file's name
wcscpy_s( fName, _countof( fName ), plist->measureName );
wcscat_s( fName, _countof( fName ), TEXT( ".kml" ) );
// Set up 'lati' output file
err = _wfopen_s( &outKml, fName, TEXT( "w" ) );
if ( err != 0 )
{
fwprintf_s( stderr, TEXT( "Can't create output file.\n" ) );
return;
}
// Output header
fwprintf_s( outKml,
TEXT( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" ) );
fwprintf_s( outKml,
TEXT( "<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n\n" ) );
fwprintf_s( outKml, TEXT( "<Document>\n\n" ) );
// Output styles
fwprintf_s( outKml, TEXT( "<Style id=\"mypushpin\">\n" ) );
fwprintf_s( outKml, TEXT( " <LabelStyle>\n" ) );
fwprintf_s( outKml, TEXT( " <scale>0.5</scale>\n" ) );
fwprintf_s( outKml, TEXT( " </LabelStyle>\n" ) );
fwprintf_s( outKml, TEXT( " <IconStyle>\n" ) );
fwprintf_s( outKml, TEXT( " <scale>0.5</scale>\n" ) );
fwprintf_s( outKml, TEXT( " <Icon>\n" ) );
fwprintf_s( outKml, TEXT( " <href>http://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png</href>\n" ) );
fwprintf_s( outKml, TEXT( " </Icon>\n" ) );
fwprintf_s( outKml, TEXT( " </IconStyle>\n" ) );
fwprintf_s( outKml, TEXT( "</Style>\n\n" ) );
fwprintf_s( outKml, TEXT( "<Style id=\"myline\">\n" ) );
fwprintf_s( outKml, TEXT( " <LineStyle>\n" ) );
fwprintf_s( outKml, TEXT( " <color>ff7fff55</color>\n" ) );
fwprintf_s( outKml, TEXT( " <colorMode>normal</colorMode>\n" ) );
fwprintf_s( outKml, TEXT( " <width>3</width>\n" ) );
fwprintf_s( outKml, TEXT( " </LineStyle>\n" ) );
fwprintf_s( outKml, TEXT( "</Style>\n\n" ) );
// Output measurement points (placemarks) to kml file
TraverseToFile( plist, outKml, addPtToKml );
// Output polygon joining measurement points
fwprintf_s( outKml, TEXT( "<Placemark>\n" ) );
fwprintf_s( outKml, TEXT( " <name>%s</name>\n" ), plist->measureName );
fwprintf_s( outKml, TEXT( " <styleUrl>#myline</styleUrl>\n" ) );
fwprintf_s( outKml, TEXT( " <LineString>\n" ) );
fwprintf_s( outKml, TEXT( " <coordinates>\n" ) );
// Add coods of all pts to kml
TraverseToFile( plist, outKml, addCoordsToKml );
// If needed, then close the polygon
// Output coords of first point again
if ( plist->iCount > 2 )
fwprintf_s( outKml, TEXT( " %s\n" ), plist->head->item.coords );
// Terminate polygon output
fwprintf_s( outKml, TEXT( " </coordinates>\n" ) );
fwprintf_s( outKml, TEXT( " </LineString>\n" ) );
fwprintf_s( outKml, TEXT( "</Placemark>\n\n" ) );
// Output footer
fwprintf_s( outKml, TEXT( "</Document>\n\n" ) );
fwprintf_s( outKml, TEXT( "</kml>" ) );
// Close kml file
if ( fclose( outKml ) != 0 )
fwprintf_s( stderr, TEXT( "Error closing kml file\n" ) );
}
int Test_print_wide( void )
/*************************/
{
wchar_t buf[128];
int n;
int violations = NumViolations;
VERIFY( wprintf_s( NULL ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( wprintf_s( L"%n", &n ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( wprintf_s( L"%s", NULL ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( fwprintf_s( NULL, L"hello" ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( fwprintf_s( stdout, NULL, 3 ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( fwprintf_s( stdout, L"%hhn", &n ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( my_wprintf_s( NULL, 3, 6 ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( my_fwprintf_s( NULL, L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( my_fwprintf_s( stdout, NULL ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( swprintf_s( buf, 2, L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( swprintf_s( buf, sizeof( buf ), L"%%n%d", 1 ) == 3 );
VERIFY( !wcscmp( buf, L"%n1" ) );
*buf = 'z';
VERIFY( swprintf_s( buf, sizeof( buf ), NULL ) == 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
*buf = 'z'; /* preinit output buffer ... */
VERIFY( swprintf_s( NULL, sizeof( buf ), L"hi" ) == 0 );
VERIFY( ++violations == NumViolations );
VERIFY( swprintf_s( buf, 0, L"hi" ) == 0 );
VERIFY( ++violations == NumViolations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( swprintf_s( buf, ~0, L"hi" ) == 0 );
VERIFY( ++violations == NumViolations );
#endif
VERIFY( my_swprintf_s( NULL, sizeof( buf ), L"hi" ) == 0 );
VERIFY( ++violations == NumViolations );
VERIFY( my_swprintf_s( buf, 0, L"hi" ) == 0 );
VERIFY( ++violations == NumViolations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( my_swprintf_s( buf, ~0, L"hi" ) == 0 );
VERIFY( ++violations == NumViolations );
#endif
VERIFY( *buf == 'z' ); /* ... and make sure no one touched it */
VERIFY( my_swprintf_s( buf, 5, NULL, 'z', "oo", 36 ) == 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( my_swprintf_s( buf, 6, L"%c%s%d", 'z', L"oo", 36 ) == 5 );
VERIFY( !wcscmp( buf, L"zoo36" ) );
VERIFY( my_swprintf_s( buf, 5, L"%c%s%d", 'z', L"oo", 36 ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( my_swprintf_s( buf, sizeof( buf ), L"hi%#6.3n", &n ) == 0 );
VERIFY( ++violations == NumViolations );
VERIFY( my_swprintf_s( buf, sizeof( buf ), L"%%n%s", L"Y" ) == 3 );
VERIFY( !wcscmp( buf, L"%nY" ) );
VERIFY( my_swprintf_s( buf, sizeof( buf ), L"hi%s", NULL ) == 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( my_snwprintf_s( buf, sizeof( buf ), L"hi%#6.3n", &n ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( my_snwprintf_s( buf, 1, L"hi%s", NULL ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
wmemset( buf, 'Q', 10 );
VERIFY( my_snwprintf_s( buf, 4, L"%c%s%d", 'z', L"oo", 3676 ) == 7 );
VERIFY( !wmemcmp( buf, L"zoo\0QQQQQQ", 10 ) );
VERIFY( my_snwprintf_s( buf, sizeof( buf ), L"%c%s%d", 'z', L"oo", 36 ) == 5 );
VERIFY( !wcscmp( buf, L"zoo36" ) );
VERIFY( my_snwprintf_s( NULL, sizeof( buf ), L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( my_snwprintf_s( buf, 0, L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( my_snwprintf_s( buf, ~0, L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
#endif
VERIFY( snwprintf_s( NULL, sizeof( buf ), L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( snwprintf_s( buf, 0, L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
#if RSIZE_MAX != SIZE_MAX
VERIFY( snwprintf_s( buf, ~0, L"hi" ) < 0 );
VERIFY( ++violations == NumViolations );
#endif
VERIFY( *buf == 'z' );
VERIFY( snwprintf_s( buf, sizeof( buf ), NULL, 3, 5 ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( snwprintf_s( buf, sizeof( buf ), L"hi%#3.55n", &n ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
VERIFY( snwprintf_s( buf, sizeof( buf ), L"hi%s", NULL ) < 0 );
VERIFY( ++violations == NumViolations );
VERIFY( *buf == '\0' );
return( 1 );
}
//----------------------------------------------------------------------------
// Function: SystemInfo
//
// Description:
// Returns the resource information about the machine
//
// Returns:
// EXIT_SUCCESS: On success
// EXIT_FAILURE: otherwise
int SystemInfo()
{
size_t vmemSize, vmemFree, memSize, memFree;
PERFORMANCE_INFORMATION memInfo;
SYSTEM_INFO sysInfo;
FILETIME idleTimeFt, kernelTimeFt, userTimeFt;
ULARGE_INTEGER idleTime, kernelTime, userTime;
ULONGLONG cpuTimeMs;
size_t size;
LPBYTE pBuffer;
PROCESSOR_POWER_INFORMATION const *ppi;
ULONGLONG cpuFrequencyKhz;
NTSTATUS status;
ZeroMemory(&memInfo, sizeof(PERFORMANCE_INFORMATION));
memInfo.cb = sizeof(PERFORMANCE_INFORMATION);
if(!GetPerformanceInfo(&memInfo, sizeof(PERFORMANCE_INFORMATION)))
{
ReportErrorCode(L"GetPerformanceInfo", GetLastError());
return EXIT_FAILURE;
}
vmemSize = memInfo.CommitLimit*memInfo.PageSize;
vmemFree = vmemSize - memInfo.CommitTotal*memInfo.PageSize;
memSize = memInfo.PhysicalTotal*memInfo.PageSize;
memFree = memInfo.PhysicalAvailable*memInfo.PageSize;
GetSystemInfo(&sysInfo);
if(!GetSystemTimes(&idleTimeFt, &kernelTimeFt, &userTimeFt))
{
ReportErrorCode(L"GetSystemTimes", GetLastError());
return EXIT_FAILURE;
}
idleTime.HighPart = idleTimeFt.dwHighDateTime;
idleTime.LowPart = idleTimeFt.dwLowDateTime;
kernelTime.HighPart = kernelTimeFt.dwHighDateTime;
kernelTime.LowPart = kernelTimeFt.dwLowDateTime;
userTime.HighPart = userTimeFt.dwHighDateTime;
userTime.LowPart = userTimeFt.dwLowDateTime;
cpuTimeMs = (kernelTime.QuadPart - idleTime.QuadPart + userTime.QuadPart)/10000;
// allocate buffer to get info for each processor
size = sysInfo.dwNumberOfProcessors * sizeof(PROCESSOR_POWER_INFORMATION);
pBuffer = (BYTE*) LocalAlloc(LPTR, size);
if(!pBuffer)
{
ReportErrorCode(L"LocalAlloc", GetLastError());
return EXIT_FAILURE;
}
status = CallNtPowerInformation(ProcessorInformation, NULL, 0, pBuffer, (long)size);
if(0 != status)
{
fwprintf_s(stderr, L"Error in CallNtPowerInformation. Err:%d\n", status);
LocalFree(pBuffer);
return EXIT_FAILURE;
}
ppi = (PROCESSOR_POWER_INFORMATION const *)pBuffer;
cpuFrequencyKhz = ppi->MaxMhz*1000;
LocalFree(pBuffer);
fwprintf_s(stdout, L"%Iu,%Iu,%Iu,%Iu,%u,%I64u,%I64u\n", vmemSize, memSize,
vmemFree, memFree, sysInfo.dwNumberOfProcessors, cpuFrequencyKhz, cpuTimeMs);
return EXIT_SUCCESS;
}
//Send DNS requesting process
size_t __fastcall SendProcess(const sockaddr_storage Target)
{
//Initialization
std::shared_ptr<char> Buffer(new char[BufferSize]()), RecvBuffer(new char[BufferSize]());
SSIZE_T DataLength = 0;
LARGE_INTEGER CPUFrequency = {0}, BeforeTime = {0}, AfterTime = {0};
SOCKET Socket = 0;
int AddrLen = 0;
//IPv6
if (Protocol == AF_INET6)
{
//Socket initialization
AddrLen = sizeof(sockaddr_in6);
if (RawSocket && RawData)
Socket = socket(AF_INET6, SOCK_RAW, ServiceName);
else
Socket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (Socket == INVALID_SOCKET)
{
wprintf(L"Socket initialization error, error code is %d.\n", WSAGetLastError());
WSACleanup();
return EXIT_FAILURE;
}
}
//IPv4
else {
//Socket initialization
AddrLen = sizeof(sockaddr_in);
if (RawSocket && RawData)
Socket = socket(AF_INET, SOCK_RAW, ServiceName);
else
Socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (Socket == INVALID_SOCKET)
{
wprintf(L"Socket initialization error, error code is %d.\n", WSAGetLastError());
WSACleanup();
return EXIT_FAILURE;
}
}
//Set socket timeout.
if (setsockopt(Socket, SOL_SOCKET, SO_SNDTIMEO, (PSTR)&SocketTimeout, sizeof(int)) == SOCKET_ERROR ||
setsockopt(Socket, SOL_SOCKET, SO_RCVTIMEO, (PSTR)&SocketTimeout, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set UDP socket timeout error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
//Set IP options.
if (Protocol == AF_INET6) //IPv6
{
if (IP_HopLimits != 0 && setsockopt(Socket, IPPROTO_IP, IPV6_UNICAST_HOPS, (PSTR)&IP_HopLimits, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set HopLimit/TTL flag error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
}
else { //IPv4
if (IP_HopLimits != 0 && setsockopt(Socket, IPPROTO_IP, IP_TTL, (PSTR)&IP_HopLimits, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set HopLimit/TTL flag error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
//Set "Don't Fragment" flag.
int iIPv4_DF = 1;
if (IPv4_DF && setsockopt(Socket, IPPROTO_IP, IP_DONTFRAGMENT, (PSTR)&iIPv4_DF, sizeof(int)) == SOCKET_ERROR)
{
wprintf(L"Set \"Don't Fragment\" flag error, error code is %d.\n", WSAGetLastError());
return EXIT_FAILURE;
}
}
//Make packet.
if (!RawData)
{
//DNS requesting
memcpy(Buffer.get() + DataLength, &HeaderParameter, sizeof(dns_hdr));
if (HeaderParameter.ID == 0)
{
auto pdns_hdr = (dns_hdr *)(Buffer.get() + DataLength);
pdns_hdr->ID = htons((uint16_t)GetCurrentProcessId());
}
DataLength += sizeof(dns_hdr);
DataLength += CharToDNSQuery((PSTR)TestDomain.c_str(), Buffer.get() + DataLength);
memcpy(Buffer.get() + DataLength, &QueryParameter, sizeof(dns_qry));
DataLength += sizeof(dns_qry);
if (EDNS0)
{
memcpy(Buffer.get() + DataLength, &EDNS0Parameter, sizeof(dns_edns0_label));
DataLength += sizeof(dns_edns0_label);
}
}
else {
if (BufferSize >= RawDataLen)
{
memcpy(Buffer.get(), RawData.get(), RawDataLen);
DataLength = RawDataLen;
}
else {
memcpy(Buffer.get(), RawData.get(), BufferSize);
DataLength = BufferSize;
}
}
//Send.
if (QueryPerformanceFrequency(&CPUFrequency) == 0 || QueryPerformanceCounter(&BeforeTime) == 0)
{
wprintf(L"Get current time form High Precision Event Timer/HPET error, error code is %d.\n", (int)GetLastError());
return EXIT_FAILURE;
}
sendto(Socket, Buffer.get(), (int)DataLength, NULL, (PSOCKADDR)&Target, AddrLen);
//Receive.
DataLength = recvfrom(Socket, RecvBuffer.get(), (int)BufferSize, NULL, (PSOCKADDR)&Target, &AddrLen);
if (QueryPerformanceCounter(&AfterTime) == 0)
{
wprintf(L"Get current time form High Precision Event Timer/HPET error, error code is %d.\n", (int)GetLastError());
return EXIT_FAILURE;
}
//Get waiting time.
long double Result = (long double)((AfterTime.QuadPart - BeforeTime.QuadPart) * (long double)1000 / (long double)CPUFrequency.QuadPart);
//Print to screen.
if (DataLength > 0)
{
wprintf(L"Receive from %ls:%u -> %d bytes, waiting %lf ms.\n", wTargetString.c_str(), ntohs(ServiceName), (int)DataLength, Result);
//Output to file.
if (OutputFile != nullptr)
fwprintf_s(OutputFile, L"Receive from %ls:%u -> %d bytes, waiting %lf ms.\n", wTargetString.c_str(), ntohs(ServiceName), (int)DataLength, Result);
TotalTime += Result;
RecvNum++;
//Mark time.
if (MaxTime == 0)
{
MinTime = Result;
MaxTime = Result;
}
else if (Result < MinTime)
{
MinTime = Result;
}
else if (Result > MaxTime)
{
MaxTime = Result;
}
//Transmission interval
if (TransmissionInterval != 0 && TransmissionInterval > Result)
Sleep((DWORD)(TransmissionInterval - Result));
else
Sleep(TIME_OUT - (DWORD)Result);
}
else { //SOCKET_ERROR
wprintf(L"Receive error: %d(%d), waiting %lf ms.\n", (int)DataLength, WSAGetLastError(), Result);
//Output to file.
if (OutputFile != nullptr)
fwprintf_s(OutputFile, L"Receive error: %d(%d), waiting %lf ms.\n", (int)DataLength, WSAGetLastError(), Result);
//Transmission interval
if (TransmissionInterval != 0 && TransmissionInterval > Result)
Sleep((DWORD)(TransmissionInterval - Result));
else if (Result <= TIME_OUT)
Sleep(TIME_OUT);
}
return EXIT_SUCCESS;
}
//Print statistics to screen(and/or output result to file)
size_t __fastcall PrintProcess(const bool PacketStatistics, const bool TimeStatistics)
{
//Packet Statistics
if (PacketStatistics)
{
wprintf(L"\nPacket statistics for pinging %ls:\n", wTargetString.c_str());
wprintf(L" Send: %lu\n", (ULONG)RealSendNum);
wprintf(L" Receive: %lu\n", (ULONG)RecvNum);
//Output to file.
if (OutputFile != nullptr)
{
fwprintf_s(OutputFile, L"\nPacket statistics for pinging %ls:\n", wTargetString.c_str());
fwprintf_s(OutputFile, L" Send: %lu\n", (ULONG)RealSendNum);
fwprintf_s(OutputFile, L" Receive: %lu\n", (ULONG)RecvNum);
}
if ((SSIZE_T)RealSendNum - (SSIZE_T)RecvNum >= 0)
{
wprintf(L" Lost: %lu", (ULONG)(RealSendNum - RecvNum));
if (RealSendNum > 0)
wprintf(L" (%lu%%)\n", (ULONG)((RealSendNum - RecvNum) * 100 / RealSendNum));
else //Not any packets.
wprintf(L"\n");
//Output to file.
if (OutputFile != nullptr)
{
fwprintf_s(OutputFile, L" Lost: %lu", (ULONG)(RealSendNum - RecvNum));
if (RealSendNum > 0)
fwprintf_s(OutputFile, L" (%lu%%)\n", (ULONG)((RealSendNum - RecvNum) * 100 / RealSendNum));
else //Not any packets.
fwprintf_s(OutputFile, L"\n");
}
}
else {
wprintf(L" Lost: 0 (0%%)\n");
//Output to file.
if (OutputFile != nullptr)
fwprintf_s(OutputFile, L" Lost: 0 (0%%)\n");
}
}
//Time Statistics
if (TimeStatistics &&
RecvNum > 0 && MaxTime > 0 && MinTime > 0)
{
wprintf(L"\nTime statistics for pinging %ls:\n", wTargetString.c_str());
wprintf(L" Minimum time: %lf ms.\n", MinTime);
wprintf(L" Maximum time: %lf ms.\n", MaxTime);
wprintf(L" Average time: %lf ms.\n", TotalTime / (long double)RecvNum);
//Output to file.
if (OutputFile != nullptr)
{
fwprintf_s(OutputFile, L"\nTime statistics for pinging %ls:\n", wTargetString.c_str());
fwprintf_s(OutputFile, L" Minimum time: %lf ms.\n", MinTime);
fwprintf_s(OutputFile, L" Maximum time: %lf ms.\n", MaxTime);
fwprintf_s(OutputFile, L" Average time: %lf ms.\n", TotalTime / (long double)RecvNum);
}
}
wprintf(L"\n");
//Output to file.
if (OutputFile != nullptr)
fwprintf_s(OutputFile, L"\n");
return EXIT_SUCCESS;
}
size_t __cdecl
Output::PrintBuffer(const char16 * buf, size_t size)
{
Output::s_Column += size;
const char16 * endbuf = wcschr(buf, '\n');
while (endbuf != nullptr)
{
Output::s_Column = size - (endbuf - buf) - 1;
endbuf = wcschr(endbuf + 1, '\n');
}
bool useConsoleOrFile = true;
if (!Output::s_capture)
{
if (Output::s_useDebuggerWindow)
{
OutputDebugStringW(buf);
useConsoleOrFile = false;
}
#ifdef ENABLE_TRACE
if (Output::s_inMemoryLogger)
{
s_inMemoryLogger->Write(buf);
useConsoleOrFile = false;
}
#endif
}
if (useConsoleOrFile)
{
if (s_file == nullptr || Output::s_capture)
{
bool addToBuffer = true;
if (Output::bufferFreeSize < size + 1)
{
if (Output::bufferAllocSize > MAX_OUTPUT_BUFFER_SIZE && !Output::s_capture)
{
Output::Flush();
if (Output::bufferFreeSize < size + 1)
{
DirectPrint(buf);
addToBuffer = false;
}
}
else
{
size_t oldBufferSize = bufferAllocSize - bufferFreeSize;
size_t newBufferAllocSize = (bufferAllocSize + size + 1) * 4 / 3;
char16 * newBuffer = (char16 *)realloc(buffer, (newBufferAllocSize * sizeof(char16)));
if (newBuffer == nullptr)
{
// See if I can just flush it and print directly
Output::Flush();
// Reset the buffer
free(Output::buffer);
Output::buffer = nullptr;
Output::bufferAllocSize = 0;
Output::bufferFreeSize = 0;
// Print it directly
DirectPrint(buf);
addToBuffer = false;
}
else
{
bufferAllocSize = newBufferAllocSize;
buffer = newBuffer;
bufferFreeSize = bufferAllocSize - oldBufferSize;
}
}
}
if (addToBuffer)
{
Assert(Output::bufferFreeSize >= size + 1);
memcpy_s(Output::buffer + Output::bufferAllocSize - Output::bufferFreeSize, Output::bufferFreeSize * sizeof(char16),
buf, (size + 1) * sizeof(char16));
bufferFreeSize -= size;
}
}
else
{
fwprintf_s(Output::s_file, _u("%s"), buf);
}
if(s_outputFile != nullptr && !Output::s_capture)
{
fwprintf_s(s_outputFile, _u("%s"), buf);
}
}
Output::Flush();
return size;
}
//MD2 hash function
bool __fastcall MD2_Hash(
FILE *Input)
{
//Parameters check
if (HashFamilyID != HASH_ID_MD2 || Input == nullptr)
{
fwprintf_s(stderr, L"Parameters error.\n");
return false;
}
//Initialization
std::shared_ptr<char> Buffer(new char[FILE_BUFFER_SIZE]()), StringBuffer(new char[FILE_BUFFER_SIZE]());
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
memset(StringBuffer.get(), 0, FILE_BUFFER_SIZE);
MD2_CTX HashInstance;
memset(&HashInstance, 0, sizeof(MD2_CTX));
size_t ReadLength = 0;
//MD2 initialization
MD2_Init(&HashInstance);
//Hash process
while (!feof(Input))
{
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
_set_errno(0);
ReadLength = fread_s(Buffer.get(), FILE_BUFFER_SIZE, sizeof(char), FILE_BUFFER_SIZE, Input);
if (ReadLength == 0)
{
fwprintf_s(stderr, L"Hash process error");
if (errno > 0)
fwprintf_s(stderr, L", error code is %d.\n", errno);
else
fwprintf_s(stderr, L".\n");
return false;
}
else {
MD2_Update(&HashInstance, (uint8_t *)Buffer.get(), (uint32_t)ReadLength);
}
}
//Binary to hex
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
MD2_Final(&HashInstance, (uint8_t *)Buffer.get());
if (sodium_bin2hex(StringBuffer.get(), FILE_BUFFER_SIZE, (const unsigned char *)Buffer.get(), MD2_DIGEST_SIZE) == nullptr)
{
fwprintf_s(stderr, L"Convert binary to hex error.\n");
return false;
}
else {
//Print to screen.
std::string HashResult = StringBuffer.get();
CaseConvert(true, HashResult);
for (size_t Index = 0;Index < HashResult.length();++Index)
fwprintf_s(stderr, L"%c", HashResult.c_str()[Index]);
fwprintf_s(stderr, L"\n");
}
return true;
}
int wmain(
int argc,
wchar_t* argv[])
{
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
int main(
int argc,
char *argv[])
{
#endif
//Get commands.
if (argc > 0)
{
if (!ReadCommand(argc, argv))
return EXIT_SUCCESS;
}
else {
return EXIT_FAILURE;
}
//Read configuration file.
if (!ReadParameter(true))
return EXIT_FAILURE;
//DNSCurve initialization
#if defined(ENABLE_LIBSODIUM)
if (Parameter.DNSCurve)
{
DNSCurveParameterModificating.SetToMonitorItem();
//Encryption mode initialization
if (DNSCurveParameter.IsEncryption)
DNSCurveInit();
}
#endif
//Mark Local DNS address to PTR Records, read Parameter(Monitor mode), IPFilter and Hosts.
ParameterModificating.SetToMonitorItem();
std::thread NetworkInformationMonitorThread(std::bind(NetworkInformationMonitor));
NetworkInformationMonitorThread.detach();
std::thread ReadParameterThread(std::bind(ReadParameter, false));
ReadParameterThread.detach();
std::thread ReadHostsThread(std::bind(ReadHosts));
ReadHostsThread.detach();
if (Parameter.OperationMode == LISTEN_MODE_CUSTOM || Parameter.DataCheck_Blacklist || Parameter.LocalRouting)
{
std::thread ReadIPFilterThread(std::bind(ReadIPFilter));
ReadIPFilterThread.detach();
}
#if defined(PLATFORM_WIN)
//Service initialization and start service.
SERVICE_TABLE_ENTRYW ServiceTable[]{{SYSTEM_SERVICE_NAME, (LPSERVICE_MAIN_FUNCTIONW)ServiceMain}, {nullptr, nullptr}};
if (!StartServiceCtrlDispatcherW(ServiceTable))
{
GlobalRunningStatus.Console = true;
auto ErrorCode = GetLastError();
//Print to screen.
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"System Error: Service start error, error code is %lu.\n", ErrorCode);
fwprintf_s(stderr, L"System Error: Program will continue to run in console mode.\n");
fwprintf_s(stderr, L"Please ignore these error messages if you want to run in console mode.\n\n");
ScreenMutex.unlock();
//Handle the system signal and start all monitors.
SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE);
MonitorInit();
}
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
MonitorInit();
#endif
return EXIT_SUCCESS;
}
//Read commands from main program
#if defined(PLATFORM_WIN)
bool __fastcall ReadCommand(
int argc,
wchar_t *argv[])
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
bool ReadCommand(
int argc,
char *argv[])
#endif
{
//Path initialization
#if defined(PLATFORM_WIN)
if (!FileNameInit(argv[0]))
return false;
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
char FileName[PATH_MAX + 1U] = {0};
if (getcwd(FileName, PATH_MAX) == nullptr)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf(stderr, L"Path initialization error.\n");
return false;
}
if (!FileNameInit(FileName))
return false;
#endif
//Screen output buffer setting
if (setvbuf(stderr, NULL, _IONBF, 0) != 0)
{
auto ErrorCode = errno;
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Screen output buffer setting error, error code is %d.\n", ErrorCode);
ScreenLock.unlock();
PrintError(LOG_LEVEL_2, LOG_ERROR_NETWORK, L"Screen output buffer setting error", ErrorCode, nullptr, 0);
return false;
}
//Winsock initialization
#if defined(PLATFORM_WIN)
WSAData WSAInitialization = {0};
if (WSAStartup(MAKEWORD(WINSOCK_VERSION_HIGH, WINSOCK_VERSION_LOW), &WSAInitialization) != 0 ||
LOBYTE(WSAInitialization.wVersion) != WINSOCK_VERSION_LOW || HIBYTE(WSAInitialization.wVersion) != WINSOCK_VERSION_HIGH)
{
auto ErrorCode = WSAGetLastError();
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Winsock initialization error, error code is %d.\n", ErrorCode);
ScreenLock.unlock();
PrintError(LOG_LEVEL_1, LOG_ERROR_NETWORK, L"Winsock initialization error", ErrorCode, nullptr, 0);
return false;
}
else {
GlobalRunningStatus.Initialization_WinSock = true;
}
//Read commands.
std::wstring Commands;
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
std::string Commands;
#endif
for (size_t Index = 1U;(SSIZE_T)Index < argc;++Index)
{
Commands = argv[Index];
//Flush DNS Cache from user.
if (Commands == COMMAND_FLUSH_DNS)
{
#if defined(PLATFORM_WIN)
FlushDNSMailSlotSender();
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
FlushDNSFIFOSender();
#endif
return false;
}
//Windows Firewall Test in first start.
#if defined(PLATFORM_WIN)
else if (Commands == COMMAND_FIREWALL_TEST)
{
if (!FirewallTest(AF_INET6) && !FirewallTest(AF_INET))
{
auto ErrorCode = WSAGetLastError();
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Windows Firewall Test error, error code is %d.\n", ErrorCode);
ScreenMutex.unlock();
PrintError(LOG_LEVEL_2, LOG_ERROR_NETWORK, L"Windows Firewall Test error", ErrorCode, nullptr, 0);
}
return false;
}
#endif
//Set system daemon.
#if defined(PLATFORM_LINUX)
else if (Commands == COMMAND_DISABLE_DAEMON)
{
GlobalRunningStatus.Daemon = false;
}
#endif
//Print current version.
else if (Commands == COMMAND_LONG_PRINT_VERSION || Commands == COMMAND_SHORT_PRINT_VERSION)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Pcap_DNSProxy ");
fwprintf_s(stderr, FULL_VERSION);
fwprintf_s(stderr, L"\n");
return false;
}
//Print library version.
else if (Commands == COMMAND_LIB_VERSION)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
#if (defined(ENABLE_LIBSODIUM) || defined(ENABLE_PCAP))
std::wstring LibVersion;
//LibSodium version
#if defined(ENABLE_LIBSODIUM)
if (MBSToWCSString(SODIUM_VERSION_STRING, strlen(SODIUM_VERSION_STRING), LibVersion))
fwprintf_s(stderr, L"LibSodium version %ls\n", LibVersion.c_str());
#endif
//WinPcap or LibPcap version
#if defined(ENABLE_PCAP)
if (MBSToWCSString(pcap_lib_version(), strlen(pcap_lib_version()), LibVersion))
fwprintf_s(stderr, L"%ls\n", LibVersion.c_str());
#endif
#else
fwprintf(stderr, L"No any available libraries.\n");
#endif
return false;
}
//Print help messages.
else if (Commands == COMMAND_LONG_HELP || Commands == COMMAND_SHORT_HELP)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Pcap_DNSProxy ");
fwprintf_s(stderr, FULL_VERSION);
#if defined(PLATFORM_WIN)
fwprintf_s(stderr, L"(Windows)\n");
#elif defined(PLATFORM_OPENWRT)
fwprintf(stderr, L"(OpenWrt)\n");
#elif defined(PLATFORM_LINUX)
fwprintf(stderr, L"(Linux)\n");
#elif defined(PLATFORM_MACX)
fwprintf(stderr, L"(Mac)\n");
#endif
fwprintf_s(stderr, COPYRIGHT_MESSAGE);
fwprintf_s(stderr, L"\nUsage: Please visit ReadMe... files in Documents folder.\n");
fwprintf_s(stderr, L" -v/--version: Print current version on screen.\n");
fwprintf_s(stderr, L" --lib-version: Print current version of libraries on screen.\n");
fwprintf_s(stderr, L" -h/--help: Print help messages on screen.\n");
fwprintf_s(stderr, L" --flush-dns: Flush all DNS cache in program and system immediately.\n");
#if defined(PLATFORM_WIN)
fwprintf_s(stderr, L" --first-setup: Test local firewall.\n");
#endif
fwprintf_s(stderr, L" -c/--config-file Path: Set path of configuration file.\n");
#if defined(PLATFORM_LINUX)
fwprintf(stderr, L" --disable-daemon: Disable daemon mode.\n");
#endif
return false;
}
//Set working directory from commands.
else if (Commands == COMMAND_LONG_SET_PATH || Commands == COMMAND_SHORT_SET_PATH)
{
//Commands check
if ((SSIZE_T)Index + 1 >= argc)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf(stderr, L"Commands error.\n");
ScreenMutex.unlock();
PrintError(LOG_LEVEL_1, LOG_ERROR_SYSTEM, L"Commands error", 0, nullptr, 0);
return false;
}
else {
++Index;
Commands = argv[Index];
//Path check.
if (Commands.length() > MAX_PATH)
{
std::unique_lock<std::mutex> ScreenMutex(ScreenLock);
fwprintf_s(stderr, L"Commands error.\n");
ScreenLock.unlock();
PrintError(LOG_LEVEL_1, LOG_ERROR_SYSTEM, L"Commands error", 0, nullptr, 0);
return false;
}
else {
if (!FileNameInit(Commands.c_str()))
return false;
}
}
}
}
//Set system daemon.
#if defined(PLATFORM_LINUX)
if (GlobalRunningStatus.Daemon && daemon(0, 0) == RETURN_ERROR)
{
PrintError(LOG_LEVEL_2, LOG_ERROR_SYSTEM, L"Set system daemon error", 0, nullptr, 0);
return false;
}
#endif
return true;
}
//Get path of program from the main function parameter and Winsock initialization
#if defined(PLATFORM_WIN)
bool __fastcall FileNameInit(
const wchar_t *OriginalPath)
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
bool FileNameInit(
const char *OriginalPath)
#endif
{
//Path process
#if defined(PLATFORM_WIN)
GlobalRunningStatus.Path_Global->clear();
GlobalRunningStatus.Path_Global->push_back(OriginalPath);
GlobalRunningStatus.Path_Global->front().erase(GlobalRunningStatus.Path_Global->front().rfind(L"\\") + 1U);
for (size_t Index = 0;Index < GlobalRunningStatus.Path_Global->front().length();++Index)
{
if ((GlobalRunningStatus.Path_Global->front()).at(Index) == L'\\')
{
GlobalRunningStatus.Path_Global->front().insert(Index, L"\\");
++Index;
}
}
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
GlobalRunningStatus.sPath_Global->clear();
GlobalRunningStatus.sPath_Global->push_back(OriginalPath);
GlobalRunningStatus.sPath_Global->front().append("/");
std::wstring StringTemp;
if (!MBSToWCSString(OriginalPath, PATH_MAX + 1U, StringTemp))
return false;
StringTemp.append(L"/");
GlobalRunningStatus.Path_Global->clear();
GlobalRunningStatus.Path_Global->push_back(StringTemp);
StringTemp.clear();
#endif
//Get path of error/running status log file and mark start time.
GlobalRunningStatus.Path_ErrorLog->clear();
*GlobalRunningStatus.Path_ErrorLog = GlobalRunningStatus.Path_Global->front();
GlobalRunningStatus.Path_ErrorLog->append(L"Error.log");
#if (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
GlobalRunningStatus.sPath_ErrorLog->clear();
*GlobalRunningStatus.sPath_ErrorLog = GlobalRunningStatus.sPath_Global->front();
GlobalRunningStatus.sPath_ErrorLog->append("Error.log");
#endif
Parameter.PrintLogLevel = DEFAULT_LOG_LEVEL;
GlobalRunningStatus.StartupTime = time(nullptr);
return true;
}
