LPKERNELEX_API BOOL WINAPI LPR_InitEx( int nChannel )
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_InitEx pFN = ( PLPR_InitEx ) GetFunctionPointer( "LPR_InitEx" );
if ( NULL == pFN ) {
return FALSE;
}
static BOOL bInitialize = FALSE;
if ( !bInitialize ) {
bInitialize = TRUE;
nChannel = 1;
bRet = pFN( nChannel );
} else {
bRet = TRUE;
}
return bRet;
}
LPKERNELEX_API BOOL WINAPI LPR_SetSpecialParameters(BOOL bNight,
int nImageplateThr,
int nImageRecogThr,
int nPlatesNum,
char *LocalProvince,
int nChannel)
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_SetSpecialParameters pFN = ( PLPR_SetSpecialParameters ) GetFunctionPointer( "LPR_SetSpecialParameters" );
if ( NULL == pFN ) {
return FALSE;
}
nChannel = 1;
bRet = pFN( bNight,
nImageplateThr,
nImageRecogThr,
nPlatesNum,
LocalProvince,
nChannel );
return bRet;
}
// COM Support function: Can DLL be unloaded now
STDAPI DllCanUnloadNow(void)
{
fnDllCanUnloadNow fpDllCanUnloadNow = NULL;
HRESULT hr = GetFunctionPointer(STR_DLLCANUNLOADNOW, (FARPROC*)&fpDllCanUnloadNow);
if (hr == S_OK)
{
hr = fpDllCanUnloadNow();
}
return hr;
}
// COM Support function: Unregister the provider
STDAPI DllUnregisterServer(void)
{
fnUnRegisterDLL fpUnRegisterDLL = NULL;
HRESULT hr = GetFunctionPointer(STR_UNREGISTERDLL, (FARPROC*)&fpUnRegisterDLL);
if (hr == S_OK)
{
hr = fpUnRegisterDLL(g_providerClassID);
}
return hr;
}
// COM Support function: Get the class object
_Check_return_
STDAPI DllGetClassObject(_In_ REFCLSID rclsid,
_In_ REFIID riid,
_Outptr_ LPVOID * ppv)
{
fnDllGetClassObject fpDllGetClassObject = NULL;
HRESULT hr = GetFunctionPointer(STR_DLLGETCLASSOBJECT, (FARPROC*)&fpDllGetClassObject);
if (SUCCEEDED(hr))
{
hr = fpDllGetClassObject(g_providerClassID, MI_Main, rclsid, riid, ppv);
}
return hr;
}
//GlobalStatus class constructor settings
void __fastcall GlobalStatusSetting(
GlobalStatus *GlobalRunningStatusParameter)
{
#if defined(PLATFORM_LINUX)
GlobalRunningStatusParameter->Daemon = true;
#endif
std::random_device RamdomDevice;
GlobalRunningStatusParameter->RamdomEngine->seed(RamdomDevice());
memset(GlobalRunningStatusParameter->DomainTable, 0, strlen(RFC_DOMAIN_TABLE) + 1U);
strncpy_s(GlobalRunningStatusParameter->DomainTable, strlen(RFC_DOMAIN_TABLE) + 1U, RFC_DOMAIN_TABLE, strlen(RFC_DOMAIN_TABLE));
GlobalRunningStatusParameter->GatewayAvailable_IPv4 = true;
memset(GlobalRunningStatusParameter->LocalAddress_Response[0], 0, PACKET_MAXSIZE);
memset(GlobalRunningStatusParameter->LocalAddress_Response[1U], 0, PACKET_MAXSIZE);
//Windows XP with SP3 support
#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
GetFunctionPointer(FUNCTION_GETTICKCOUNT64);
GetFunctionPointer(FUNCTION_INET_NTOP);
GetFunctionPointer(FUNCTION_INET_PTON);
#endif
return;
}
// COM Support function: Get the class object
STDAPI DllGetClassObject(_In_ REFCLSID rclsid,
_In_ REFIID riid,
_Outptr_result_maybenull_ LPVOID * ppv)
{
fnDllGetClassObject fpDllGetClassObject = NULL;
HRESULT hr = GetFunctionPointer(STR_DLLGETCLASSOBJECT, (FARPROC*)&fpDllGetClassObject);
if (hr == S_OK)
{
hr = fpDllGetClassObject(g_providerClassID, MI_Main, rclsid, riid, ppv);
}
else
{
*ppv = NULL;
}
return hr;
}
LPKERNELEX_API BOOL WINAPI LPR_SetParameters( BOOL bMovingImage,
int nPlatesNum,
BOOL bFlipVertical,
int nColorOrder,
BOOL bVertCompress,
int nImageplateThr, int nImageRecogThr,
int nMinPlateWidth, int nMaxPlateWidth,
char *LocalProvince,
BOOL bDwordAligned,
BOOL bInputHalfHeightImage,
BOOL bOutputSingleFrame,
BOOL bYellow2, BOOL bIndivi, BOOL bArmPol, BOOL bArmy2, BOOL bTractor,
BOOL bNight,
int nChannel )
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_SetParameters pFN = ( PLPR_SetParameters ) GetFunctionPointer( "LPR_SetParameters" );
if ( NULL == pFN ) {
return FALSE;
}
nChannel = 1;
bRet = pFN( bMovingImage,
nPlatesNum,
bFlipVertical,
nColorOrder,
bVertCompress,
nImageplateThr, nImageRecogThr,
nMinPlateWidth, nMaxPlateWidth,
LocalProvince,
bDwordAligned,
bInputHalfHeightImage,
bOutputSingleFrame,
bYellow2, bIndivi, bArmPol, bArmy2, bTractor,
bNight,
nChannel );
return bRet;
}
LPKERNELEX_API BOOL WINAPI LPR_FileEx( char* lpszFileName, char *lpszPlateFile, TH_PlateResult* pResult, int &nRecogNum, TH_RECT *prcRange, int nChannel )
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_FileEx pFN = ( PLPR_FileEx ) GetFunctionPointer( "LPR_FileEx" );
if ( NULL == pFN ) {
return FALSE;
}
nChannel = 1;
bRet = pFN( lpszFileName, lpszPlateFile, pResult, nRecogNum, prcRange, nChannel );
return bRet;
}
LPKERNELEX_API BOOL WINAPI LPR_GetImageBuf(unsigned char *&pImageBuf, int &nWidth, int &nHeight, int &nSize, int nChannel)
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_GetImageBuf pFN = ( PLPR_GetImageBuf ) GetFunctionPointer( "LPR_GetImageBuf" );
if ( NULL == pFN ) {
return FALSE;
}
nChannel = 1;
bRet = pFN( pImageBuf, nWidth, nHeight, nSize, nChannel );
return bRet;
}
LPKERNELEX_API BOOL WINAPI LPR_SetImageFormat(BOOL bMovingImage,
BOOL bFlipVertical,
int nColorOrder,
BOOL bVertCompress,
int nMinPlateWidth,
int nMaxPlateWidth,
BOOL bDwordAligned,
BOOL bInputHalfHeightImage,
BOOL bOutputSingleFrame,
int nChannel )
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_SetImageFormat pFN = ( PLPR_SetImageFormat ) GetFunctionPointer( "LPR_SetImageFormat" );
if ( NULL == pFN ) {
return FALSE;
}
nChannel = 1;
bRet = pFN( bMovingImage,
bFlipVertical,
nColorOrder,
bVertCompress,
nMinPlateWidth,
nMaxPlateWidth,
bDwordAligned,
bInputHalfHeightImage,
bOutputSingleFrame,
nChannel );
return bRet;
}
LPKERNELEX_API BOOL WINAPI LPR_RGB888Ex(unsigned char *pImg, int nWidth, int nHeight, TH_PlateResult* pResult, int &nRecogNum, TH_RECT *prcRange, int nChannel)
{
#pragma EXPORT
//return FALSE; // Not supprot video stream
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_RGB888Ex pFN = ( PLPR_RGB888Ex ) GetFunctionPointer( "LPR_RGB888Ex" );
if ( NULL == pFN ) {
return FALSE;
}
bRet = pFN( pImg, nWidth, nHeight, pResult, nRecogNum, prcRange, nChannel );
return bRet;
}
LPKERNELEX_API BOOL WINAPI LPR_SetPlateType(BOOL bYellow2,
BOOL bIndivi,
BOOL bArmPol,
BOOL bArmy2,
BOOL bTractor,
BOOL bOnlyDyellow,
BOOL bEmbassy,
BOOL bDarmpolice,
BOOL bOnlyLocation,
int nChannel )
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return FALSE;
}
static PLPR_SetPlateType pFN = ( PLPR_SetPlateType ) GetFunctionPointer( "LPR_SetPlateType" );
if ( NULL == pFN ) {
return FALSE;
}
nChannel = 1;
bRet = pFN( bYellow2,
bIndivi,
bArmPol,
bArmy2,
bTractor,
bOnlyDyellow,
bEmbassy,
bDarmpolice,
bOnlyLocation,
nChannel );
return bRet;
}
LPKERNELEX_API void WINAPI LPR_UninitEx( int nChannel )
{
#pragma EXPORT
BOOL bRet = ValidateChannel( nChannel );
if ( !bRet ) {
return;
}
static PLPR_UninitEx pFN = ( PLPR_UninitEx ) GetFunctionPointer( "LPR_UninitEx" );
if ( NULL == pFN ) {
return;
}
static BOOL bUninitialize = FALSE;
if ( !bUninitialize ) {
bUninitialize = TRUE;
nChannel = 1;
pFN( nChannel );
}
}
int wmain(int argc, wchar_t* argv[])
{
//Windows XP with SP3 support
#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
GetFunctionPointer(FUNCTION_GETTICKCOUNT64);
GetFunctionPointer(FUNCTION_INET_NTOP);
#endif
#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 and WinPcap or LibPcap initialization.
if (!ReadParameter())
{
WSACleanup();
return EXIT_FAILURE;
}
//Mark Local DNS address to PTR Records.
std::thread NetworkInformationMonitorThread(NetworkInformationMonitor);
NetworkInformationMonitorThread.detach();
//Read IPFilter and Hosts.
if (Parameter.OperationMode == LISTEN_MODE_CUSTOM || Parameter.BlacklistCheck || Parameter.LocalRouting)
{
std::thread IPFilterThread(ReadIPFilter);
IPFilterThread.detach();
}
std::thread HostsThread(ReadHosts);
HostsThread.detach();
//DNSCurve initialization
#if defined(ENABLE_LIBSODIUM)
if (Parameter.DNSCurve && DNSCurveParameter.IsEncryption)
{
randombytes_set_implementation(&randombytes_salsa20_implementation);
randombytes_stir();
DNSCurveInit();
}
#endif
#if defined(PLATFORM_WIN)
//Service initialization and start service.
SERVICE_TABLE_ENTRYW ServiceTable[] = {{DEFAULT_LOCAL_SERVICE_NAME, (LPSERVICE_MAIN_FUNCTIONW)ServiceMain}, {nullptr, nullptr}};
if (!StartServiceCtrlDispatcherW(ServiceTable))
{
Parameter.Console = true;
wprintf_s(L"System Error: Service start error, error code is %lu.\n", GetLastError());
wprintf_s(L"System Error: Program will continue to run in console mode.\n");
wprintf_s(L"Please ignore those error messages if you want to run in console mode.\n");
//Handle the system signal and start all monitors.
SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE);
MonitorInit();
}
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
MonitorInit();
#endif
WSACleanup();
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))
std::shared_ptr<char> FileName(new char[PATH_MAX + 1U]());
memset(FileName.get(), 0, PATH_MAX + 1U);
if (getcwd(FileName.get(), PATH_MAX) == nullptr)
{
wprintf(L"Path initialization error.\n");
return false;
}
if (!FileNameInit(FileName.get()))
return false;
FileName.reset();
#endif
#if defined(PLATFORM_WIN)
//Winsock initialization
std::shared_ptr<WSAData> WSAInitialization(new WSAData());
if (WSAStartup(MAKEWORD(WINSOCK_VERSION_HIGH, WINSOCK_VERSION_LOW), WSAInitialization.get()) != 0 ||
LOBYTE(WSAInitialization->wVersion) != WINSOCK_VERSION_LOW || HIBYTE(WSAInitialization->wVersion) != WINSOCK_VERSION_HIGH)
{
wprintf_s(L"Winsock initialization error, error code is %d.\n", WSAGetLastError());
PrintError(LOG_ERROR_NETWORK, L"Winsock initialization error", WSAGetLastError(), nullptr, 0);
WSACleanup();
return false;
}
//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
WSACleanup();
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))
{
wprintf_s(L"Windows Firewall Test error.\n");
PrintError(LOG_ERROR_NETWORK, L"Windows Firewall Test error", WSAGetLastError(), nullptr, 0);
}
WSACleanup();
return false;
}
#endif
//Set system daemon.
#if defined(PLATFORM_LINUX)
else if (Commands == COMMAND_DISABLE_DAEMON)
{
Parameter.Daemon = false;
}
#endif
//Print current version.
else if (Commands == COMMAND_LONG_PRINT_VERSION || Commands == COMMAND_SHORT_PRINT_VERSION)
{
wprintf_s(L"Pcap_DNSProxy ");
wprintf_s(FULL_VERSION);
wprintf_s(L"\n");
WSACleanup();
return false;
}
//Print help messages.
else if (Commands == COMMAND_LONG_HELP || Commands == COMMAND_SHORT_HELP)
{
wprintf_s(L"Usage: Please see ReadMe... files in Documents folder.\n");
WSACleanup();
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)
{
wprintf_s(L"Commands error.\n");
PrintError(LOG_ERROR_SYSTEM, L"Commands error", 0, nullptr, 0);
WSACleanup();
return false;
}
else {
++Index;
Commands = argv[Index];
//Path check.
if (Commands.length() > MAX_PATH)
{
wprintf_s(L"Commands error.\n");
PrintError(LOG_ERROR_SYSTEM, L"Commands error", 0, nullptr, 0);
WSACleanup();
return false;
}
else {
if (!FileNameInit(Commands.c_str()))
return false;
}
}
}
}
//Set system daemon.
#if defined(PLATFORM_LINUX)
if (Parameter.Daemon && daemon(0, 0) == RETURN_ERROR)
{
PrintError(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)
Parameter.Path_Global->clear();
Parameter.Path_Global->push_back(OriginalPath);
Parameter.Path_Global->front().erase(Parameter.Path_Global->front().rfind(L"\\") + 1U);
for (size_t Index = 0;Index < Parameter.Path_Global->front().length();++Index)
{
if ((Parameter.Path_Global->front()).at(Index) == L'\\')
{
Parameter.Path_Global->front().insert(Index, L"\\");
++Index;
}
}
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
Parameter.sPath_Global->clear();
Parameter.sPath_Global->push_back(OriginalPath);
Parameter.sPath_Global->front().append("/");
std::wstring StringTemp;
MBSToWCSString(StringTemp, OriginalPath);
StringTemp.append(L"/");
Parameter.Path_Global->clear();
Parameter.Path_Global->push_back(StringTemp);
StringTemp.clear();
#endif
//Get path of error/running status log file and mark start time.
Parameter.Path_ErrorLog->clear();
*Parameter.Path_ErrorLog = Parameter.Path_Global->front();
Parameter.Path_ErrorLog->append(L"Error.log");
#if (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
Parameter.sPath_ErrorLog->clear();
*Parameter.sPath_ErrorLog = Parameter.sPath_Global->front();
Parameter.sPath_ErrorLog->append("Error.log");
#endif
Parameter.PrintError = true;
time(&StartTime);
return true;
}
//Configuration class constructor
ConfigurationTable::ConfigurationTable(void)
{
memset(this, 0, sizeof(CONFIGURATION_TABLE));
try {
//[Listen] block
PcapDevicesBlacklist = new std::vector<std::string>();
ListenPort = new std::vector<uint16_t>();
//[Addresses] block
ListenAddress_IPv6 = new std::vector<sockaddr_storage>();
ListenAddress_IPv4 = new std::vector<sockaddr_storage>();
LocalhostSubnet.IPv6 = new ADDRESS_PREFIX_BLOCK();
LocalhostSubnet.IPv4 = new ADDRESS_PREFIX_BLOCK();
DNSTarget.IPv6_Multi = new std::vector<DNS_SERVER_DATA>();
DNSTarget.IPv4_Multi = new std::vector<DNS_SERVER_DATA>();
//[Data] block(A part)
#if defined(ENABLE_PCAP)
ICMP_PaddingData = new char[ICMP_PADDING_MAXSIZE]();
DomainTest_Data = new char[DOMAIN_MAXSIZE]();
#endif
//[Data] block(B part)
LocalFQDN_Response = new char[DOMAIN_MAXSIZE]();
LocalFQDN_String = new std::string();
#if !defined(PLATFORM_MACX)
LocalServer_Response = new char[DOMAIN_MAXSIZE + sizeof(dns_record_ptr) + sizeof(dns_record_opt)]();
#endif
LocalAddress_Response[0] = new char[PACKET_MAXSIZE]();
LocalAddress_Response[1U] = new char[PACKET_MAXSIZE]();
#if !defined(PLATFORM_MACX)
LocalAddress_ResponsePTR[0] = new std::vector<std::string>();
LocalAddress_ResponsePTR[1U] = new std::vector<std::string>();
#endif
//Global block
LocalSocket = new std::vector<SYSTEM_SOCKET>();
RamdomEngine = new std::default_random_engine();
Path_Global = new std::vector<std::wstring>();
Path_ErrorLog = new std::wstring();
FileList_Hosts = new std::vector<std::wstring>();
FileList_IPFilter = new std::vector<std::wstring>();
#if (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
sPath_Global = new std::vector<std::string>();
sPath_ErrorLog = new std::string();
sFileList_Hosts = new std::vector<std::string>();
sFileList_IPFilter = new std::vector<std::string>();
#endif
DomainTable = new char[strlen(RFC_DOMAIN_TABLE) + 1U]();
AcceptTypeList = new std::vector<uint16_t>();
}
catch (std::bad_alloc)
{
//[Listen] block
delete PcapDevicesBlacklist;
delete ListenPort;
//[Addresses] block
delete ListenAddress_IPv6;
delete ListenAddress_IPv4;
delete LocalhostSubnet.IPv6;
delete LocalhostSubnet.IPv4;
delete DNSTarget.IPv6_Multi;
delete DNSTarget.IPv4_Multi;
//[Data] block(A part)
#if defined(ENABLE_PCAP)
delete[] ICMP_PaddingData;
delete[] DomainTest_Data;
#endif
//[Data] block(B part)
delete[] LocalFQDN_Response;
delete LocalFQDN_String;
#if !defined(PLATFORM_MACX)
delete[] LocalServer_Response;
#endif
delete[] LocalAddress_Response[0];
delete[] LocalAddress_Response[1U];
#if !defined(PLATFORM_MACX)
delete LocalAddress_ResponsePTR[0];
delete LocalAddress_ResponsePTR[1U];
#endif
//Global block
delete LocalSocket;
delete RamdomEngine;
delete Path_Global;
delete Path_ErrorLog;
delete FileList_Hosts;
delete FileList_IPFilter;
delete[] DomainTable;
delete AcceptTypeList;
exit(EXIT_FAILURE);
return;
}
//Initialization
BufferQueueSize = DEFAULT_BUFFER_QUEUE;
//[Data] block(A part)
#if defined(ENABLE_PCAP)
memset(ICMP_PaddingData, 0, ICMP_PADDING_MAXSIZE);
memset(DomainTest_Data, 0, DOMAIN_MAXSIZE);
#endif
//[Data] block(B part)
memset(LocalFQDN_Response, 0, DOMAIN_MAXSIZE);
#if !defined(PLATFORM_MACX)
memset(LocalServer_Response, 0, DOMAIN_MAXSIZE + sizeof(dns_record_ptr) + sizeof(dns_record_opt));
#endif
memset(LocalAddress_Response[0], 0, PACKET_MAXSIZE);
memset(LocalAddress_Response[1U], 0, PACKET_MAXSIZE);
//Global block
memset(DomainTable, 0, strlen(RFC_DOMAIN_TABLE) + 1U);
//Default settings
strncpy_s(DomainTable, strlen(RFC_DOMAIN_TABLE) + 1U, RFC_DOMAIN_TABLE, strlen(RFC_DOMAIN_TABLE));
std::random_device RamdomDevice;
RamdomEngine->seed(RamdomDevice());
//Default values
FileRefreshTime = DEFAULT_FILEREFRESH_TIME * SECOND_TO_MILLISECOND;
LogMaxSize = DEFAULT_LOG_MAXSIZE;
HostsDefaultTTL = DEFAULT_HOSTS_TTL;
AlternateTimes = DEFAULT_ALTERNATE_TIMES;
AlternateTimeRange = DEFAULT_ALTERNATE_RANGE * SECOND_TO_MILLISECOND;
AlternateResetTime = DEFAULT_ALTERNATE_RESET_TIME * SECOND_TO_MILLISECOND;
#if defined(PLATFORM_WIN)
SocketTimeout_Reliable = DEFAULT_RELIABLE_SOCKET_TIMEOUT;
SocketTimeout_Unreliable = DEFAULT_UNRELIABLE_SOCKET_TIMEOUT;
#elif (defined(PLATFORM_LINUX) || defined(PLATFORM_MACX))
SocketTimeout_Reliable.tv_sec = DEFAULT_RELIABLE_SOCKET_TIMEOUT;
SocketTimeout_Unreliable.tv_sec = DEFAULT_UNRELIABLE_SOCKET_TIMEOUT;
#endif
#if defined(PLATFORM_LINUX)
Daemon = true;
#endif
#if defined(ENABLE_PCAP)
PcapReadingTimeout = DEFAULT_PCAP_CAPTURE_TIMEOUT;
#if defined(PLATFORM_MACX)
ICMP_ID = htons(*(uint16_t *)pthread_self());
#else
ICMP_ID = htons((uint16_t)GetCurrentProcessId()); //Default ICMP ID is current process ID.
#endif
ICMP_Sequence = htons(DEFAULT_SEQUENCE);
DomainTest_Speed = DEFAULT_DOMAINTEST_INTERVAL_TIME * SECOND_TO_MILLISECOND;
#if defined(PLATFORM_MACX)
DomainTest_ID = htons(*(uint16_t *)pthread_self());
#else
DomainTest_ID = htons((uint16_t)GetCurrentProcessId()); //Default DNS ID is current process ID.
#endif
#if defined(PLATFORM_WIN)
ICMP_PaddingLength = strlen(DEFAULT_PADDING_DATA) + 1U;
memcpy_s(ICMP_PaddingData, ICMP_PADDING_MAXSIZE, DEFAULT_PADDING_DATA, Parameter.ICMP_PaddingLength - 1U); //Load default padding data.
#elif defined(PLATFORM_LINUX)
size_t CharData = ICMP_STRING_START_NUM_LINUX;
for (size_t Index = 0;Index < ICMP_PADDING_LENGTH_LINUX;++Index, ++CharData)
ICMP_PaddingData[Index] = CharData;
ICMP_PaddingLength = strlen(ICMP_PaddingData) + 1U;
#elif defined(PLATFORM_MACX)
size_t CharData = ICMP_STRING_START_NUM_MAC;
for (size_t Index = 0;Index < ICMP_PADDING_LENGTH_MAC;++Index, ++CharData)
ICMP_PaddingData[Index] = CharData;
ICMP_PaddingLength = strlen(ICMP_PaddingData) + 1U;
#endif
#endif
//Default status
GatewayAvailable_IPv4 = true;
//Windows XP with SP3 support
#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
GetFunctionPointer(FUNCTION_GETTICKCOUNT64);
GetFunctionPointer(FUNCTION_INET_NTOP);
GetFunctionPointer(FUNCTION_INET_PTON);
#endif
return;
}
