Changed usage of _TCHAR to wchar_t

Atvaark · Atvaark · commit 344799854894 · 2015-04-25T20:27:04.000+02:00
diff --git a/Eldorado.HttpProxy/include/Logger.h b/Eldorado.HttpProxy/include/Logger.h
@@ -1,16 +1,14 @@
 #pragma once
-#include <tchar.h>
 #include <utility>
 #include <fstream>
 
 class Logger
 {
 public:
-	Logger(const _TCHAR* log_file);
+	Logger(const wchar_t* log_file);
 	~Logger();
 
 	void Log(std::wstring message);
-	void LogFormat(const _TCHAR* format, ...);
 	void LogFormatA(const char* format, ...);
 	void LogFormatW(const wchar_t* format, ...);
 
diff --git a/Eldorado.HttpProxy/source/Logger.cpp b/Eldorado.HttpProxy/source/Logger.cpp
@@ -3,7 +3,7 @@
 #include <time.h>
 #include <iomanip>
 
-Logger::Logger(const _TCHAR* log_file)
+Logger::Logger(const wchar_t* log_file)
 {
 	log_stream.open(log_file, std::ios::out | std::ios::app);
 }
@@ -18,23 +18,8 @@ void Logger::Log(std::wstring message)
 	time_t time = std::time(nullptr);
 	tm localtime;
 	localtime_s(&localtime, &time);
-	log_stream << _T("[") << std::put_time(&localtime, _T("%d.%m.%Y %H:%M:%S")) << _T("] ");
-	log_stream << message.c_str() << _T("\n") << std::flush;
-}
-
-void Logger::LogFormat(const _TCHAR* format, ...)
-{
-	const int messageSize = 131072;
-	_TCHAR message[messageSize];
-	va_list args;
-	va_start(args, format);
-	_vstprintf_s(message, messageSize, format, args);
-	time_t time = std::time(nullptr);
-	tm localtime;
-	localtime_s(&localtime, &time);
-	log_stream << _T("[") << std::put_time(&localtime, _T("%d.%m.%Y %H:%M:%S")) << _T("] ");
-	log_stream << message << _T("\n") << std::flush;
-	va_end(args);
+	log_stream << L"[" << std::put_time(&localtime, L"%d.%m.%Y %H:%M:%S") << L"] ";
+	log_stream << message.c_str() << L"\n" << std::flush;
 }
 
 void Logger::LogFormatA(const char* format, ...)
diff --git a/Eldorado.HttpProxy/source/main.cpp b/Eldorado.HttpProxy/source/main.cpp
@@ -1,7 +1,6 @@
 #include <string>
 
 #include <Windows.h>
-#include <tchar.h>
 #include "Logger.h"
 
 #include "winhttp_functions.h"
@@ -32,7 +31,7 @@ BOOL WINAPI WinHttpCloseHandle(
 	IN HINTERNET hInternet
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpCloseHandle(%x)"), hInternet);
+	theLogger().LogFormatW(L"Calling WinHttpCloseHandle(%x)", hInternet);
 	return oWinHttpCloseHandle(hInternet);
 }
 
@@ -43,9 +42,9 @@ HINTERNET WINAPI WinHttpConnect(
 	IN DWORD dwReserved
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpConnect(%x, %s, %d)"), hSession, pswzServerName, nServerPort);
+	theLogger().LogFormatW(L"Calling WinHttpConnect(%x, %s, %d)", hSession, pswzServerName, nServerPort);
 	HINTERNET result = oWinHttpConnect(hSession, pswzServerName, nServerPort, dwReserved);
-	theLogger().LogFormat(_T("WinHttpConnect(%x, %s, %d) returned %x"), hSession, pswzServerName, nServerPort, result);
+	theLogger().LogFormatW(L"WinHttpConnect(%x, %s, %d) returned %x", hSession, pswzServerName, nServerPort, result);
 	return result;
 }
 
@@ -57,9 +56,9 @@ HINTERNET WINAPI WinHttpOpen(
 	_In_ DWORD dwFlags
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpOpen(...)"));
+	theLogger().LogFormatW(L"Calling WinHttpOpen(...)");
 	HINTERNET result = oWinHttpOpen(pszAgentW, dwAccessType, pszProxyW, pszProxyBypassW, dwFlags);
-	theLogger().LogFormat(_T("WinHttpOpen(...) returned %x"), result);
+	theLogger().LogFormatW(L"WinHttpOpen(...) returned %x"), result;
 	return result;
 }
 
@@ -90,7 +89,7 @@ HINTERNET WINAPI WinHttpOpenRequest(
 		pwszReferrer,
 		ppwszAcceptTypes,
 		dwFlags);
-	theLogger().LogFormat(_T("WinHttpOpenRequest(%x, ...) returned %x"), hConnect, result);
+	theLogger().LogFormatW(L"WinHttpOpenRequest(%x, ...) returned %x", hConnect, result);
 	return result;
 }
 
@@ -144,7 +143,7 @@ BOOL WINAPI WinHttpQueryOption(
 	IN OUT LPDWORD lpdwBufferLength
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpQueryOption(%x, %d, ...)"), hInternet, dwOption);
+	theLogger().LogFormatW(L"Calling WinHttpQueryOption(%x, %d, ...)", hInternet, dwOption);
 	return oWinHttpQueryOption(hInternet, dwOption, lpBuffer, lpdwBufferLength);
 }
 
@@ -155,7 +154,7 @@ BOOL WINAPI WinHttpReadData(
 	OUT LPDWORD lpdwNumberOfBytesRead
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpReadData(%x, ...)"), hRequest);
+	theLogger().LogFormatW(L"Calling WinHttpReadData(%x, ...)", hRequest);
 	BOOL result = oWinHttpReadData(hRequest, lpBuffer, dwNumberOfBytesToRead, lpdwNumberOfBytesRead);
 	std::string readData = std::string(static_cast<char*>(lpBuffer), dwNumberOfBytesToRead);
 	theLogger().LogFormatA("WinHttpReadData(%x, ...) returend: %s", hRequest, readData.c_str());
@@ -167,7 +166,7 @@ BOOL WINAPI WinHttpReceiveResponse(
 	IN LPVOID lpReserved
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpReceiveResponse(%x, ...)"), hRequest);
+	theLogger().LogFormatW(L"Calling WinHttpReceiveResponse(%x, ...)", hRequest);
 	return oWinHttpReceiveResponse(hRequest, lpReserved);
 }
 
@@ -181,7 +180,7 @@ BOOL WINAPI WinHttpSendRequest(
 	IN DWORD_PTR dwContext
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpSendRequest(%x, ...)"), hRequest);
+	theLogger().LogFormatW(L"Calling WinHttpSendRequest(%x, ...)", hRequest);
 
 	std::wstring header = dwHeadersLength == -1 ? std::wstring(lpszHeaders) : std::wstring(lpszHeaders, dwHeadersLength);
 	theLogger().LogFormatW(L"WinHttpSendRequest(%x, ...) called with header: %s", hRequest, header.c_str());
@@ -207,7 +206,7 @@ WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback(
 	IN DWORD_PTR dwReserved
 	)
 {
-	theLogger().LogFormat(_T("Calling WinHttpSetStatusCallback(%x, ...)"), hInternet);
+	theLogger().LogFormatW(L"Calling WinHttpSetStatusCallback(%x, ...)", hInternet);
 	return oWinHttpSetStatusCallback(hInternet, lpfnInternetCallback, dwNotificationFlags, dwReserved);
 }
 
@@ -219,8 +218,8 @@ BOOL WINAPI WinHttpSetTimeouts(
 	IN int nReceiveTimeout
 	)
 {
-	theLogger().LogFormat(
-		_T("Calling WinHttpSetTimeouts(%x, %d, %d, %d, %d)"),
+	theLogger().LogFormatW(
+		L"Calling WinHttpSetTimeouts(%x, %d, %d, %d, %d)",
 		hInternet,
 		nResolveTimeout,
 		nConnectTimeout,
@@ -232,19 +231,19 @@ BOOL WINAPI WinHttpSetTimeouts(
 // dll functions
 
 Logger& theLogger() {
-	static Logger logger = Logger(_T("winhttp.log"));
+	static Logger logger = Logger(L"winhttp.log");
 	return logger;
 }
 
 void Exit(TCHAR* reason)
 {
-	theLogger().LogFormat(_T("Exit called with reason (%s)"), reason);
+	theLogger().LogFormatW(L"Exit called with reason (%s)", reason);
 	ExitProcess(1);
 }
 
 void Exit()
 {
-	Exit(_T(""));
+	Exit(L"");
 }
 
 template<typename FunctionPointerType>
@@ -253,14 +252,14 @@ void SetOriginalDllFunctionAddress(const CHAR* originalFunctionName, FunctionPoi
 	FARPROC originalFunctionAddress = GetProcAddress(g_original_dll_hInstance, originalFunctionName);
 	if (!originalFunctionAddress)
 	{
-		Exit(_T("Unable to get an original function address"));
+		Exit(L"Unable to get an original function address");
 	}
 	pFunctionPointer = reinterpret_cast<FunctionPointerType>(originalFunctionAddress);
 }
 
 void InitializeOriginalDllFunctions()
 {
-	theLogger().LogFormat(_T("Initializing original function addresses"));
+	theLogger().LogFormatW(L"Initializing original function addresses");
 	SetOriginalDllFunctionAddress("WinHttpCloseHandle", oWinHttpCloseHandle);
 	SetOriginalDllFunctionAddress("WinHttpConnect", oWinHttpConnect);
 	SetOriginalDllFunctionAddress("WinHttpOpen", oWinHttpOpen);
@@ -272,36 +271,36 @@ void InitializeOriginalDllFunctions()
 	SetOriginalDllFunctionAddress("WinHttpSendRequest", oWinHttpSendRequest);
 	SetOriginalDllFunctionAddress("WinHttpSetStatusCallback", oWinHttpSetStatusCallback);
 	SetOriginalDllFunctionAddress("WinHttpSetTimeouts", oWinHttpSetTimeouts);
-	theLogger().LogFormat(_T("Original function addresses initialized"));
+	theLogger().LogFormatW(L"Original function addresses initialized");
 }
 
 HMODULE LoadOriginalDll()
 {
-	theLogger().LogFormat(_T("Loading the original winhttp.dll"));
+	theLogger().LogFormatW(L"Loading the original winhttp.dll");
 	TCHAR original_dll_path_buffer[MAX_PATH];
 	GetSystemDirectory(original_dll_path_buffer, MAX_PATH);
-	_tcscat_s(original_dll_path_buffer, MAX_PATH, _T("\\winhttp.dll"));
+	wcscat_s(original_dll_path_buffer, MAX_PATH, L"\\winhttp.dll");	
 
 	HMODULE original_dll_hInstance = LoadLibrary(original_dll_path_buffer);
 	if (!original_dll_hInstance)
 	{
-		Exit(_T("Unable to load the original winhttp.dll"));
+		Exit(L"Unable to load the original winhttp.dll");
 	}
 
-	theLogger().LogFormat(_T("Original winhttp.dll was loaded successfully"));
+	theLogger().LogFormatW(L"Original winhttp.dll was loaded successfully");
 	return original_dll_hInstance;
 }
 
 void InitializeDll(HINSTANCE hInstance)
 {
-	theLogger().LogFormat(_T("("###############################################"));
-	theLogger().LogFormat(_T("Initializing the winhttp proxy dll"));
+	theLogger().LogFormatW(L"###############################################");
+	theLogger().LogFormatW(L"Initializing the winhttp proxy dll");
 	DisableThreadLibraryCalls(hInstance);
 	g_proxy_dll_hInstance = hInstance;
 	g_original_dll_hInstance = LoadOriginalDll();
 	InitializeOriginalDllFunctions();
-	theLogger().LogFormat(_T("Proxy dll initialized"));
-	theLogger().LogFormat(_T("("###############################################"));
+	theLogger().LogFormatW(L"Proxy dll initialized");
+	theLogger().LogFormatW(L"###############################################");
 }
 
 BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD reason, LPVOID /*reserved*/)

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`#include <string>`
`2`	`2`
`3`	`3`	`#include <Windows.h>`
`4`		`-#include <tchar.h>`
`5`	`4`	`#include "Logger.h"`
`6`	`5`
`7`	`6`	`#include "winhttp_functions.h"`
`@@ -32,7 +31,7 @@ BOOL WINAPI WinHttpCloseHandle(`
`32`	`31`	`IN HINTERNET hInternet`
`33`	`32`	`)`
`34`	`33`	`{`
`35`		`- theLogger().LogFormat(_T("Calling WinHttpCloseHandle(%x)"), hInternet);`
	`34`	`+ theLogger().LogFormatW(L"Calling WinHttpCloseHandle(%x)", hInternet);`
`36`	`35`	`return oWinHttpCloseHandle(hInternet);`
`37`	`36`	`}`
`38`	`37`
`@@ -43,9 +42,9 @@ HINTERNET WINAPI WinHttpConnect(`
`43`	`42`	`IN DWORD dwReserved`
`44`	`43`	`)`
`45`	`44`	`{`
`46`		`- theLogger().LogFormat(_T("Calling WinHttpConnect(%x, %s, %d)"), hSession, pswzServerName, nServerPort);`
	`45`	`+ theLogger().LogFormatW(L"Calling WinHttpConnect(%x, %s, %d)", hSession, pswzServerName, nServerPort);`
`47`	`46`	`HINTERNET result = oWinHttpConnect(hSession, pswzServerName, nServerPort, dwReserved);`
`48`		`- theLogger().LogFormat(_T("WinHttpConnect(%x, %s, %d) returned %x"), hSession, pswzServerName, nServerPort, result);`
	`47`	`+ theLogger().LogFormatW(L"WinHttpConnect(%x, %s, %d) returned %x", hSession, pswzServerName, nServerPort, result);`
`49`	`48`	`return result;`
`50`	`49`	`}`
`51`	`50`
`@@ -57,9 +56,9 @@ HINTERNET WINAPI WinHttpOpen(`
`57`	`56`	`_In_ DWORD dwFlags`
`58`	`57`	`)`
`59`	`58`	`{`
`60`		`- theLogger().LogFormat(_T("Calling WinHttpOpen(...)"));`
	`59`	`+ theLogger().LogFormatW(L"Calling WinHttpOpen(...)");`
`61`	`60`	`HINTERNET result = oWinHttpOpen(pszAgentW, dwAccessType, pszProxyW, pszProxyBypassW, dwFlags);`
`62`		`- theLogger().LogFormat(_T("WinHttpOpen(...) returned %x"), result);`
	`61`	`+ theLogger().LogFormatW(L"WinHttpOpen(...) returned %x"), result;`
`63`	`62`	`return result;`
`64`	`63`	`}`
`65`	`64`
`@@ -90,7 +89,7 @@ HINTERNET WINAPI WinHttpOpenRequest(`
`90`	`89`	`pwszReferrer,`
`91`	`90`	`ppwszAcceptTypes,`
`92`	`91`	`dwFlags);`
`93`		`- theLogger().LogFormat(_T("WinHttpOpenRequest(%x, ...) returned %x"), hConnect, result);`
	`92`	`+ theLogger().LogFormatW(L"WinHttpOpenRequest(%x, ...) returned %x", hConnect, result);`
`94`	`93`	`return result;`
`95`	`94`	`}`
`96`	`95`
`@@ -144,7 +143,7 @@ BOOL WINAPI WinHttpQueryOption(`
`144`	`143`	`IN OUT LPDWORD lpdwBufferLength`
`145`	`144`	`)`
`146`	`145`	`{`
`147`		`- theLogger().LogFormat(_T("Calling WinHttpQueryOption(%x, %d, ...)"), hInternet, dwOption);`
	`146`	`+ theLogger().LogFormatW(L"Calling WinHttpQueryOption(%x, %d, ...)", hInternet, dwOption);`
`148`	`147`	`return oWinHttpQueryOption(hInternet, dwOption, lpBuffer, lpdwBufferLength);`
`149`	`148`	`}`
`150`	`149`
`@@ -155,7 +154,7 @@ BOOL WINAPI WinHttpReadData(`
`155`	`154`	`OUT LPDWORD lpdwNumberOfBytesRead`
`156`	`155`	`)`
`157`	`156`	`{`
`158`		`- theLogger().LogFormat(_T("Calling WinHttpReadData(%x, ...)"), hRequest);`
	`157`	`+ theLogger().LogFormatW(L"Calling WinHttpReadData(%x, ...)", hRequest);`
`159`	`158`	`BOOL result = oWinHttpReadData(hRequest, lpBuffer, dwNumberOfBytesToRead, lpdwNumberOfBytesRead);`
`160`	`159`	`std::string readData = std::string(static_cast<char*>(lpBuffer), dwNumberOfBytesToRead);`
`161`	`160`	`theLogger().LogFormatA("WinHttpReadData(%x, ...) returend: %s", hRequest, readData.c_str());`
`@@ -167,7 +166,7 @@ BOOL WINAPI WinHttpReceiveResponse(`
`167`	`166`	`IN LPVOID lpReserved`
`168`	`167`	`)`
`169`	`168`	`{`
`170`		`- theLogger().LogFormat(_T("Calling WinHttpReceiveResponse(%x, ...)"), hRequest);`
	`169`	`+ theLogger().LogFormatW(L"Calling WinHttpReceiveResponse(%x, ...)", hRequest);`
`171`	`170`	`return oWinHttpReceiveResponse(hRequest, lpReserved);`
`172`	`171`	`}`
`173`	`172`
`@@ -181,7 +180,7 @@ BOOL WINAPI WinHttpSendRequest(`
`181`	`180`	`IN DWORD_PTR dwContext`
`182`	`181`	`)`
`183`	`182`	`{`
`184`		`- theLogger().LogFormat(_T("Calling WinHttpSendRequest(%x, ...)"), hRequest);`
	`183`	`+ theLogger().LogFormatW(L"Calling WinHttpSendRequest(%x, ...)", hRequest);`
`185`	`184`
`186`	`185`	`std::wstring header = dwHeadersLength == -1 ? std::wstring(lpszHeaders) : std::wstring(lpszHeaders, dwHeadersLength);`
`187`	`186`	`theLogger().LogFormatW(L"WinHttpSendRequest(%x, ...) called with header: %s", hRequest, header.c_str());`
`@@ -207,7 +206,7 @@ WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback(`
`207`	`206`	`IN DWORD_PTR dwReserved`
`208`	`207`	`)`
`209`	`208`	`{`
`210`		`- theLogger().LogFormat(_T("Calling WinHttpSetStatusCallback(%x, ...)"), hInternet);`
	`209`	`+ theLogger().LogFormatW(L"Calling WinHttpSetStatusCallback(%x, ...)", hInternet);`
`211`	`210`	`return oWinHttpSetStatusCallback(hInternet, lpfnInternetCallback, dwNotificationFlags, dwReserved);`
`212`	`211`	`}`
`213`	`212`
`@@ -219,8 +218,8 @@ BOOL WINAPI WinHttpSetTimeouts(`
`219`	`218`	`IN int nReceiveTimeout`
`220`	`219`	`)`
`221`	`220`	`{`
`222`		`- theLogger().LogFormat(`
`223`		`- _T("Calling WinHttpSetTimeouts(%x, %d, %d, %d, %d)"),`
	`221`	`+ theLogger().LogFormatW(`
	`222`	`+ L"Calling WinHttpSetTimeouts(%x, %d, %d, %d, %d)",`
`224`	`223`	`hInternet,`
`225`	`224`	`nResolveTimeout,`
`226`	`225`	`nConnectTimeout,`
`@@ -232,19 +231,19 @@ BOOL WINAPI WinHttpSetTimeouts(`
`232`	`231`	`// dll functions`
`233`	`232`
`234`	`233`	`Logger& theLogger() {`
`235`		`- static Logger logger = Logger(_T("winhttp.log"));`
	`234`	`+ static Logger logger = Logger(L"winhttp.log");`
`236`	`235`	`return logger;`
`237`	`236`	`}`
`238`	`237`
`239`	`238`	`void Exit(TCHAR* reason)`
`240`	`239`	`{`
`241`		`- theLogger().LogFormat(_T("Exit called with reason (%s)"), reason);`
	`240`	`+ theLogger().LogFormatW(L"Exit called with reason (%s)", reason);`
`242`	`241`	`ExitProcess(1);`
`243`	`242`	`}`
`244`	`243`
`245`	`244`	`void Exit()`
`246`	`245`	`{`
`247`		`- Exit(_T(""));`
	`246`	`+ Exit(L"");`
`248`	`247`	`}`
`249`	`248`
`250`	`249`	`template<typename FunctionPointerType>`
`@@ -253,14 +252,14 @@ void SetOriginalDllFunctionAddress(const CHAR* originalFunctionName, FunctionPoi`
`253`	`252`	`FARPROC originalFunctionAddress = GetProcAddress(g_original_dll_hInstance, originalFunctionName);`
`254`	`253`	`if (!originalFunctionAddress)`
`255`	`254`	`{`
`256`		`- Exit(_T("Unable to get an original function address"));`
	`255`	`+ Exit(L"Unable to get an original function address");`
`257`	`256`	`}`
`258`	`257`	`pFunctionPointer = reinterpret_cast<FunctionPointerType>(originalFunctionAddress);`
`259`	`258`	`}`
`260`	`259`
`261`	`260`	`void InitializeOriginalDllFunctions()`
`262`	`261`	`{`
`263`		`- theLogger().LogFormat(_T("Initializing original function addresses"));`
	`262`	`+ theLogger().LogFormatW(L"Initializing original function addresses");`
`264`	`263`	`SetOriginalDllFunctionAddress("WinHttpCloseHandle", oWinHttpCloseHandle);`
`265`	`264`	`SetOriginalDllFunctionAddress("WinHttpConnect", oWinHttpConnect);`
`266`	`265`	`SetOriginalDllFunctionAddress("WinHttpOpen", oWinHttpOpen);`
`@@ -272,36 +271,36 @@ void InitializeOriginalDllFunctions()`
`272`	`271`	`SetOriginalDllFunctionAddress("WinHttpSendRequest", oWinHttpSendRequest);`
`273`	`272`	`SetOriginalDllFunctionAddress("WinHttpSetStatusCallback", oWinHttpSetStatusCallback);`
`274`	`273`	`SetOriginalDllFunctionAddress("WinHttpSetTimeouts", oWinHttpSetTimeouts);`
`275`		`- theLogger().LogFormat(_T("Original function addresses initialized"));`
	`274`	`+ theLogger().LogFormatW(L"Original function addresses initialized");`
`276`	`275`	`}`
`277`	`276`
`278`	`277`	`HMODULE LoadOriginalDll()`
`279`	`278`	`{`
`280`		`- theLogger().LogFormat(_T("Loading the original winhttp.dll"));`
	`279`	`+ theLogger().LogFormatW(L"Loading the original winhttp.dll");`
`281`	`280`	`TCHAR original_dll_path_buffer[MAX_PATH];`
`282`	`281`	`GetSystemDirectory(original_dll_path_buffer, MAX_PATH);`
`283`		`- _tcscat_s(original_dll_path_buffer, MAX_PATH, _T("\\winhttp.dll"));`
	`282`	`+ wcscat_s(original_dll_path_buffer, MAX_PATH, L"\\winhttp.dll");`
`284`	`283`
`285`	`284`	`HMODULE original_dll_hInstance = LoadLibrary(original_dll_path_buffer);`
`286`	`285`	`if (!original_dll_hInstance)`
`287`	`286`	`{`
`288`		`- Exit(_T("Unable to load the original winhttp.dll"));`
	`287`	`+ Exit(L"Unable to load the original winhttp.dll");`
`289`	`288`	`}`
`290`	`289`
`291`		`- theLogger().LogFormat(_T("Original winhttp.dll was loaded successfully"));`
	`290`	`+ theLogger().LogFormatW(L"Original winhttp.dll was loaded successfully");`
`292`	`291`	`return original_dll_hInstance;`
`293`	`292`	`}`
`294`	`293`
`295`	`294`	`void InitializeDll(HINSTANCE hInstance)`
`296`	`295`	`{`
`297`		`- theLogger().LogFormat(_T("("###############################################"));`
`298`		`- theLogger().LogFormat(_T("Initializing the winhttp proxy dll"));`
	`296`	`+ theLogger().LogFormatW(L"###############################################");`
	`297`	`+ theLogger().LogFormatW(L"Initializing the winhttp proxy dll");`
`299`	`298`	`DisableThreadLibraryCalls(hInstance);`
`300`	`299`	`g_proxy_dll_hInstance = hInstance;`
`301`	`300`	`g_original_dll_hInstance = LoadOriginalDll();`
`302`	`301`	`InitializeOriginalDllFunctions();`
`303`		`- theLogger().LogFormat(_T("Proxy dll initialized"));`
`304`		`- theLogger().LogFormat(_T("("###############################################"));`
	`302`	`+ theLogger().LogFormatW(L"Proxy dll initialized");`
	`303`	`+ theLogger().LogFormatW(L"###############################################");`
`305`	`304`	`}`
`306`	`305`
`307`	`306`	`BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD reason, LPVOID /reserved/)`