globalutility.cpp

Shadow SDT的应用

#include <StdAfx.h>
#include <Shlwapi.h>
#include <time.h>
#include <ShellAPI.h>
#include "GlobalUtility.h"
#include <WtsApi32.h>
#pragma comment(lib, "WtsApi32.lib")

namespace NGlobalUtils
{
	TCHAR CGlobalUtility::m_szTime[MAX_PATH];
	TCHAR CGlobalUtility::m_szFileDir[MAX_PATH];
	map<stringx, HICON> CGlobalUtility::m_MapIcon;

	CGlobalUtility::CGlobalUtility(void)
	{
		GetModuleFileName(NULL, m_szFileDir, MAX_PATH);
		*StrRChr(m_szFileDir, m_szFileDir + MAX_PATH, _T('\\')) = 0;
		StrCat(m_szFileDir, _T("\\"));
	}

	CGlobalUtility::~CGlobalUtility(void)
	{
	}

	LPTSTR CGlobalUtility::GetTime()
	{
#if _MSC_VER > 1200
		__time64_t ltime;
		_time64( &ltime );

		//struct tm newtime;
		//_gmtime64_s( &newtime, &ltime );
		//TCHAR	szTime[MAX_PATH];

#ifdef UNICODE
		_wctime64_s(m_szTime, MAX_PATH, &ltime);
#else
		_ctime64_s(m_szTime, MAX_PATH, &ltime);
#endif

		//wsprintf(m_szTime, _T("%s %s"), szTime, pszCaption);
		return m_szTime;
#else
		return _T("Not Support");
#endif
	}

	LPTSTR CGlobalUtility::GetDir()
	{
		return m_szFileDir;
	}

	INT CGlobalUtility::Atoi(LPCTSTR szNum)
	{
		/*
#ifdef UNICODE
		sscanf(strType.GetBuffer(strType.GetLength()), _T("%d"), &iType);
#else
		swscanf(strType.GetBuffer(strType.GetLength()), _T("%d"), &iType);
#endif
		*/
		INT iCount = lstrlen(szNum);
		INT iRet = 0;
		for(INT i = 0;  i < iCount; i++)
		{
			iRet = iRet * 10 + szNum[i] - _T('0');
		}
		return iRet;
	}

	PTSTR CGlobalUtility::BigNumToString(LONGLONG lNum, PTSTR szBuf) 
	{
		TCHAR szNum[100];
		wsprintf(szNum, TEXT("%d"), lNum);
		NUMBERFMT nf;
		nf.NumDigits		= 0;
		nf.LeadingZero		= FALSE;
		nf.Grouping			= 3;
		nf.lpDecimalSep		= TEXT(".");
		nf.lpThousandSep	= TEXT(",");
		nf.NegativeOrder	= 0;
		GetNumberFormat(LOCALE_USER_DEFAULT, 0, szNum, &nf, szBuf, 100);
		return(szBuf);
	}

	//////////////////////////////////////////////////////////////////////////

	LPTSTR CGlobalUtility::UtfToChar(LPCSTR pInput)
	{
		return CustomToChar(pInput, CP_UTF8, NULL);
	}

	LPSTR CGlobalUtility::CharToUtf(LPCTSTR pInput)
	{
		return CharToCustom(pInput, CP_UTF8, NULL);
	}

	//////////////////////////////////////////////////////////////////////////

	LPTSTR CGlobalUtility::WCharToChar(LPCWSTR pInput, LPDWORD lpRetLen /*= NULL*/)
	{
#ifdef UNICODE
		DWORD dwDataLen = lstrlenW(pInput);
		PWCHAR pText = new WCHAR[dwDataLen + 1];
		lstrcpyW(pText, pInput);
		if(lpRetLen) *lpRetLen = dwDataLen;
#else
		// Convert
		DWORD dwNum = WideCharToMultiByte(CP_OEMCP, NULL, pInput, -1, NULL, 0, NULL, FALSE);
		PCHAR pText = new CHAR[dwNum];
		WideCharToMultiByte(CP_OEMCP, NULL, pInput, -1, pText, dwNum, NULL, FALSE);
		if(lpRetLen) *lpRetLen = dwNum - 1;
#endif
		return pText;
	}

	//////////////////////////////////////////////////////////////////////////

	LPTSTR CGlobalUtility::OemToChar(LPCSTR pInput, LPDWORD lpRetLen /*= NULL*/)
	{
#ifdef UNICODE
		// Convert
		DWORD dwNum = MultiByteToWideChar(CP_ACP, 0, pInput, -1, NULL, 0);
		PWCHAR pText = new WCHAR[dwNum];
		MultiByteToWideChar (CP_ACP, 0, pInput, -1, pText, dwNum);
		if(lpRetLen) *lpRetLen = dwNum - 1;
		return pText;
#else
		DWORD dwDataLen = lstrlenA(pInput);
		PCHAR pText = new CHAR[dwDataLen + 1];
		lstrcpyA(pText, pInput);
		if(lpRetLen) *lpRetLen = dwDataLen;
#endif
		return pText;
	}

	LPSTR CGlobalUtility::CharToOem(LPCTSTR pInput, LPDWORD lpRetLen /*= NULL*/)
	{
#ifdef UNICODE
		// Convert
		DWORD dwNum = WideCharToMultiByte(CP_OEMCP, NULL, pInput, -1, NULL, 0, NULL, FALSE);
		PCHAR pText = new CHAR[dwNum];
		WideCharToMultiByte(CP_OEMCP, NULL, pInput, -1, pText, dwNum, NULL, FALSE);
		if(lpRetLen) *lpRetLen = dwNum - 1;
		return pText;
#else
		DWORD dwDataLen = lstrlenA(pInput);
		PCHAR pText = new CHAR[dwDataLen + 1];
		lstrcpyA(pText, pInput);
		if(lpRetLen) *lpRetLen = dwDataLen;
#endif
		return pText;	
	}

	//////////////////////////////////////////////////////////////////////////

	LPTSTR CGlobalUtility::CustomToChar( LPCSTR pInput, UINT uCodePage, LPDWORD lpRetLen /*= NULL*/ )
	{
		// Convert UTF to Unicode
		INT iUnicodeSize = MultiByteToWideChar(uCodePage, 0, pInput, -1, NULL, 0);
		PWCHAR pUnicode = new WCHAR[iUnicodeSize + 1];  
		memset(pUnicode, 0, (iUnicodeSize + 1) * sizeof(WCHAR)); 
		MultiByteToWideChar(uCodePage, 0, pInput, -1, (LPWSTR)pUnicode, iUnicodeSize);  
#ifndef UNICODE
		//
		INT iAnsiSize = WideCharToMultiByte(CP_OEMCP,NULL, pUnicode, -1, NULL, 0, NULL, FALSE);
		LPSTR lpszStr = new CHAR[iAnsiSize];
		WideCharToMultiByte(CP_OEMCP, NULL, pUnicode, -1, lpszStr, iAnsiSize, NULL, FALSE);
		delete[] pUnicode;
		pUnicode = NULL;
		return lpszStr;
#else
		//
		return pUnicode;
#endif
	}

	LPSTR CGlobalUtility::CharToCustom( LPCTSTR pInput, UINT uCodePage, LPDWORD lpRetLen /*= NULL*/ )
	{
#ifndef UNICODE
		// Convert
		DWORD dwNum = MultiByteToWideChar(CP_ACP, 0, pInput, -1, NULL, 0);
		PWCHAR pUnicode = new WCHAR[dwNum];
		MultiByteToWideChar (CP_ACP, 0, pInput, -1, pUnicode, dwNum);

		dwNum = WideCharToMultiByte(uCodePage, NULL, pUnicode, -1, NULL, 0, NULL, FALSE);
		PCHAR pText = new CHAR[dwNum];
		WideCharToMultiByte(uCodePage, NULL, pUnicode, -1, pText, dwNum, NULL, FALSE);
		delete[] pUnicode;
		pUnicode = NULL;
#else
		// Convert TCHAR to UTF
		DWORD dwNum = WideCharToMultiByte(uCodePage, NULL, pInput, -1, NULL, 0, NULL, FALSE);
		PCHAR pText = new CHAR[dwNum];
		WideCharToMultiByte(uCodePage, NULL, pInput, -1, pText, dwNum, NULL, FALSE);
#endif
		return pText;
	}

	HANDLE CGlobalUtility::CreateEvent(
		BOOL bManualReset /*= FALSE*/,
		BOOL bInitialState /*= FALSE*/)
	{
		return ::CreateEvent(NULL, bManualReset, bInitialState, NULL);
	}

	HANDLE CGlobalUtility::CreateThread(
		LPTHREAD_START_ROUTINE lpStartAddress,
		LPVOID lpParameter /*= NULL*/,
		LPDWORD lpThreadId /*= NULL*/)
	{
		return ::CreateThread(NULL, 0, lpStartAddress, (LPVOID)lpParameter, 0, lpThreadId);
	}

	HICON CGlobalUtility::GetIconFromFileName( LPCTSTR lpszPathFilename, BOOL bDirectory )
	{
		/*
		HICON hIcon;
		WORD dIndex = 0; 
		hIcon = ExtractAssociatedIcon(NULL, const_cast<LPTSTR>(lpszPathFilename), &dIndex);
		return hIcon;
		*/

		//
		// Warning:
		// 频繁调用SHGetFileInfo会引起异常，只能用缓冲列表来解决
		// 但是这个问题很奇怪，也许是微软的实现有问题
		//
		SHFILEINFO  sfi;
		DWORD	dwType = SHGFI_ICON|SHGFI_LARGEICON|SHGFI_SYSICONINDEX;
		if(!bDirectory)
		{
			dwType |= SHGFI_USEFILEATTRIBUTES;
		}
		::SHGetFileInfo(lpszPathFilename, 0, &sfi,	sizeof(SHFILEINFO), dwType);
		return sfi.hIcon;
		

		// 	SHFILEINFO  ssfi, sfi;
		// 	CImageList  iconList;
		// 	int			iIndex;
		// 	HIMAGELIST  hSystemImageList;
		// 	HICON		retIcon;
		// 
		// 	//取得文件类型在系统图标列表中的索引
		// 	::SHGetFileInfo(lpszPathFilename, 0, &sfi,	sizeof(SHFILEINFO), SHGFI_SYSICONINDEX|SHGFI_SMALLICON );
		// 	iIndex =  sfi.iIcon;
		// 
		// 	//取得系统小图标列表
		// 	if(!bLarge)
		// 	{
		// 		hSystemImageList = (HIMAGELIST)::SHGetFileInfo((LPCTSTR)_T("C:\\"), 0, &ssfi,
		// 			sizeof(SHFILEINFO), SHGFI_SYSICONINDEX | SHGFI_SMALLICON); 
		// 	}
		// 	else
		// 	{
		// 		hSystemImageList = (HIMAGELIST)::SHGetFileInfo((LPCTSTR)_T("C:\\"), 0, &ssfi,
		// 			sizeof(SHFILEINFO), SHGFI_SYSICONINDEX | SHGFI_LARGEICON); 
		// 	}
		// 
		// 	iconList.Attach(hSystemImageList);
		// 	retIcon = iconList.ExtractIcon(iIndex);
		// 
		// 	iconList.Detach();
		// 	return retIcon;
	}

	HICON CGlobalUtility::GetIconFromFileExt( LPCTSTR lpszPathFilename, BOOL bDirectory )
	{
		//
		TCHAR szFilePath[256] = {0};
		lstrcpy(szFilePath, lpszPathFilename);
		_tcsupr_s(szFilePath);
		//
		// > - Directory
		// < - Have not
		//
		if(bDirectory)
		{
			HICON hIcon = m_MapIcon[_T(">")];
			if(hIcon == NULL)
			{
				SHFILEINFO  sfi;
				DWORD	dwType = SHGFI_ICON|SHGFI_LARGEICON|SHGFI_SYSICONINDEX;
				::SHGetFileInfo(_T("C:\\Program Files"), 0, &sfi, sizeof(SHFILEINFO), dwType);
				m_MapIcon[_T(">")] = hIcon = sfi.hIcon;
			}
			return hIcon;
		}
		else
		{
			LPTSTR pPoint = 
				StrRChr(szFilePath, szFilePath + lstrlen(szFilePath), _T('.'));
			if(pPoint == NULL)
			{
				HICON hIcon = m_MapIcon[_T("<")];
				if(hIcon == NULL)
				{
					SHFILEINFO sfi;
					DWORD dwType = SHGFI_ICON|SHGFI_LARGEICON|SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES;
					::SHGetFileInfo(szFilePath, 0, &sfi, sizeof(SHFILEINFO), dwType);
					m_MapIcon[_T("<")] = hIcon = sfi.hIcon;
				}
				return hIcon;
			}
			else
			{
				TCHAR szBuffer[12] = {0};
				lstrcpyn(szBuffer, (LPCTSTR)pPoint + 1, (int)(szFilePath + lstrlen(szFilePath) - pPoint));
				HICON hIcon = m_MapIcon[szBuffer];
				if(hIcon == NULL)
				{
					SHFILEINFO sfi;
					DWORD dwType = SHGFI_ICON|SHGFI_LARGEICON|SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES;
					::SHGetFileInfo(szFilePath, 0, &sfi, sizeof(SHFILEINFO), dwType);
					m_MapIcon[szBuffer] = hIcon = sfi.hIcon;
				}
				return hIcon;
			}
		}
	}

	BOOL CGlobalUtility::CreateNormalProcessInSystem(LPCTSTR lpCommandLine, BOOL bHide /*= TRUE*/)
	{
		BOOL bOK = FALSE;

		// Get Active User's Session ID
		DWORD ConsoleSessionId = WTSGetActiveConsoleSessionId();

		HANDLE hTokenUser = NULL;
		while(1)
		{
			// Get Active User's Token
			bOK = WTSQueryUserToken(ConsoleSessionId, &hTokenUser);
			if(bOK == FALSE)
			{
				break;
			}

			// Imitate Active User
			bOK = ImpersonateLoggedOnUser(hTokenUser);
			if(bOK == FALSE)
			{
				break;
			}

			// Create Process
			STARTUPINFO si;
			ZeroMemory(&si, sizeof(si));
			si.cb			= sizeof(si);
			if(bHide)
			{
				si.wShowWindow	= SW_HIDE;
				si.dwFlags		= STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
			}
			else
			{
				si.dwFlags		= STARTF_USEPOSITION|STARTF_USESIZE;
				si.wShowWindow	= SW_NORMAL;
			}
			PROCESS_INFORMATION pi;
			ZeroMemory(&pi, sizeof(pi));

			// Start the child process.
			bOK =  ::CreateProcessAsUser(
				hTokenUser,	lpCommandLine, NULL, NULL, NULL, FALSE, CREATE_NEW_CONSOLE,
				NULL, NULL, &si, &pi);
			if(bOK == FALSE)
			{
				RevertToSelf();
				break;
			}

			// Close Imitate
			bOK = RevertToSelf();
			if(bOK == FALSE)
			{
				break;
			}

			//
			bOK = TRUE;
			//
			break;
		}
		if(hTokenUser != NULL)
		{
			CloseHandle(hTokenUser);
			hTokenUser = NULL;
		}
		return bOK;
	}

	BOOL CGlobalUtility::CreateNormalProcess(LPCTSTR lpCommandLine, BOOL bHide /*= TRUE*/, 
		LPPROCESS_INFORMATION lpProInfor /*= NULL*/)
	{
		// Create Process
		STARTUPINFO si;
		ZeroMemory(&si, sizeof(si));
		si.cb			= sizeof(si);
		if(bHide)
		{
			si.wShowWindow	= SW_HIDE;
			si.dwFlags		= STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
		}
		else
		{
			si.wShowWindow	= SW_NORMAL;
			si.dwFlags		= STARTF_USEPOSITION|STARTF_USESIZE;
		}
		/*
		#ifndef _DEBUG
		si.lpDesktop	= _T("Winsta0\\Winlogon");
		#endif
		*/

		PROCESS_INFORMATION pi;
		ZeroMemory(&pi, sizeof(pi));

		// Start the child process.
		TCHAR lpCommand[512] = {0};
		wsprintf(lpCommand, _T("%s"), lpCommandLine);
		BOOL bOK = ::CreateProcess(
			NULL, lpCommand, NULL, NULL, FALSE, CREATE_NEW_CONSOLE,
			NULL, NULL, &si, &pi);

		if(lpProInfor)
		{
			memcpy(lpProInfor, &pi, sizeof(PROCESS_INFORMATION));
		}
		return bOK;
	}

	BOOL CGlobalUtility::FileTimeToSystemTime(
		const LPFILETIME pFileTime, 
		LPSYSTEMTIME pSystemTime)
	{
		::FileTimeToSystemTime(pFileTime, pSystemTime);
		/*
		SYSTEMTIME stUTC;
		// Convert the last-write time to local time.
		::FileTimeToSystemTime(pFileTime, &stUTC);
		//
		TIME_ZONE_INFORMATION ZoneInformation;
		memset(&ZoneInformation, 0, sizeof(TIME_ZONE_INFORMATION));
		// In Minute
		// UTC = local time + bias
		// UTC = GMT+8 + (- 8 * 60)
		ZoneInformation.Bias = - 8 * 60;

		//GetTimeZoneInformation(&ZoneInformation);
		::SystemTimeToTzSpecificLocalTime(&ZoneInformation, &stUTC, pSystemTime);
		*/
		return TRUE;
	}
}