apis.c

See Hanoi.cpp for the implementation of this cla

	return (UTlsPtr()[TLSSLOT_KERNEL] & TLSKERN_TRYINGTODIE) ? 1 : 0;
}

typedef DWORD (*threadfunctype)(ulong);
typedef DWORD (*mainthreadfunctype)(ulong,ulong,ulong,ulong);
typedef DWORD (*comthreadfunctype)(ulong,ulong,ulong,ulong,ulong,ulong,ulong);

/* Initial functions for main thread and secondary threads.  They call the
   thread routine, and then clean up if the thread exits */

DWORD p1,p2,p3;

DWORD fatalfilter(PEXCEPTION_POINTERS ExceptionPointers) {
	p1 = ExceptionPointers->ExceptionRecord->ExceptionCode;
	p2 = (DWORD)ExceptionPointers->ExceptionRecord->ExceptionAddress;
	return EXCEPTION_EXECUTE_HANDLER;
}

void ShowErrorBox() {
	extern HANDLE hInstCoreDll;
	LPCWSTR pstr;
	WCHAR bufx[512];
	LPCWSTR pname = GetProcName();
	if (!IsAPIReady(SH_WMGR))
		RETAILMSG(1,(L"Main thread in proc %8.8lx faulted, WMGR not on line!\r\n",GetCurrentProcessId()));
	else if (!(pstr = (LPCWSTR)LoadString(hInstCoreDll,1,0,0)))
		RETAILMSG(1,(L"Main thread in proc %8.8lx faulted, unable to load strings!\r\n",GetCurrentProcessId()));
	else {
		swprintf(bufx,pstr,pname,pname,p1,p2);
		if (!(pstr = (LPCWSTR)LoadString(hInstCoreDll,2,0,0)))
			RETAILMSG(1,(L"Main thread in proc %8.8lx faulted, unable to load strings!\r\n",GetCurrentProcessId()));
		else {
			MessageBox(0,bufx,pstr,MB_OK|MB_ICONEXCLAMATION|MB_TOPMOST);
			RETAILMSG(1,(L"Main thread in proc %8.8lx faulted - cleaning up!\r\n",GetCurrentProcessId()));
		}
	}
}

HANDLE hMainThread;

void MainThreadBaseFunc(LPVOID pfn, ulong param1, ulong param2, ulong param3, ulong param4) {
	DWORD retval = 0;
	DebugNotify(DLL_PROCESS_ATTACH,(DWORD)pfn);
	hMainThread = (HANDLE)GetCurrentThreadId();
	PSLNotify(DLL_PROCESS_ATTACH,GetCurrentProcessId(),GetCurrentThreadId());
	__try {
		retval = ((mainthreadfunctype)pfn)(param1,param2,param3,param4);
	} __except (fatalfilter(GetExceptionInformation())) {
		ShowErrorBox();
		retval = p1;
	}
	ExitThread(retval);
	/* ExitThread stops execution of the current thread */
}

DWORD fatalfilter2(PEXCEPTION_POINTERS ExceptionPointers) {
	p3 = ExceptionPointers->ExceptionRecord->ExceptionCode;
	return EXCEPTION_EXECUTE_HANDLER;
}

void ThreadBaseFunc(LPVOID pfn, ulong param) {
	DWORD retval = 0;
	DebugNotify(DLL_THREAD_ATTACH,(DWORD)pfn);
	PSLNotify(DLL_THREAD_ATTACH,GetCurrentProcessId(),GetCurrentThreadId());
	ThreadAttachAllDLLs();
	__try {
		retval = ((threadfunctype)pfn)(param);
	} __except (fatalfilter2(GetExceptionInformation())) {
		LPCWSTR pname;
		pname = GetProcName();
		RETAILMSG(1,(L"Secondary thread in proc %8.8lx (%s) faulted!\r\n",GetCurrentProcessId(),pname));
		if (wcsicmp(pname,L"device.exe") && wcsicmp(pname,L"gwes.exe")) {
			RETAILMSG(1,(L"Terminating process %8.8lx (%s)!\r\n",GetCurrentProcessId(),pname));
			TerminateThread(hMainThread,p3);
		}
	}
	ExitThread(retval);
	/* ExitThread stops execution of the current thread */
}

void ComThreadBaseFunc(LPVOID pfn, ulong param1, ulong param2, ulong param3, ulong param4) {
	DWORD retval = 0;
	DWORD dwExeBase, dwRva14, dwSize14;
	PPROCESS pProc;
	hMainThread = (HANDLE)GetCurrentThreadId();
	PSLNotify(DLL_PROCESS_ATTACH,GetCurrentProcessId(),GetCurrentThreadId());
	DebugNotify(DLL_PROCESS_ATTACH,(DWORD)pfn);
	__try {
		SetKMode(1);
		pProc = (PPROCESS)param4;
		dwExeBase = (DWORD)pProc->BasePtr;
		dwRva14 = pProc->e32.e32_sect14rva;
		dwSize14 = pProc->e32.e32_sect14size;
		SetKMode(0);
		retval = ((comthreadfunctype)pfn)(param1,param2,param3,SW_SHOW,dwExeBase,dwRva14,dwSize14);
	} __except (fatalfilter(GetExceptionInformation())) {
		ShowErrorBox();
	}
	ExitThread(retval);
	/* ExitThread stops execution of the current thread */
}

/*
	@doc BOTH EXTERNAL
	
	@func VOID | GlobalMemoryStatus | Gets information on the physical and virtual memory of the system
    @parm LPMEMORYSTATUS | lpmst | pointer to structure to receive information
    @comm Follows the Win32 reference description without restrictions or modifications.
*/

VOID WINAPI GlobalMemoryStatus(LPMEMORYSTATUS lpmst) {
	DWORD addr;
	MEMORY_BASIC_INFORMATION mbi;
	lpmst->dwLength = sizeof(MEMORYSTATUS);
	lpmst->dwMemoryLoad = 100 - ((UserKInfo[KINX_PAGEFREE]*100) / UserKInfo[KINX_NUMPAGES]);
	lpmst->dwTotalPhys = UserKInfo[KINX_NUMPAGES]*UserKInfo[KINX_PAGESIZE];
	lpmst->dwAvailPhys = UserKInfo[KINX_PAGEFREE]*UserKInfo[KINX_PAGESIZE];
	lpmst->dwTotalPageFile = 0;
	lpmst->dwAvailPageFile = 0;
	lpmst->dwTotalVirtual = 32*1024*1024;
	lpmst->dwAvailVirtual = 0;
	for (addr = 0x10000; addr < 32*1024*1024; addr += (DWORD)mbi.RegionSize) {
		if (!VirtualQuery((LPCVOID)addr,&mbi,sizeof(mbi)))
			break;
		if (mbi.State == MEM_FREE)
			lpmst->dwAvailVirtual += (mbi.RegionSize - ((~(DWORD)mbi.BaseAddress+1)&0xffff)) & 0xffff0000;
	}
}

BOOL AttachDebugger(LPCWSTR dbgname) {
	HANDLE hLib;
	LPVOID pInit;
    if (CeGetCurrentTrust() != OEM_CERTIFY_TRUST) {
		ERRORMSG(1,(L"AttachDebugger failed due to insufficient trust\r\n"));
		SetLastError(ERROR_ACCESS_DENIED);
		return FALSE;
    }
	if (!(hLib = LoadLibrary((LPCWSTR)((DWORD)dbgname|1)))) {
		SetLastError(ERROR_FILE_NOT_FOUND);
		return FALSE;
	}
	if (!(pInit = (LPVOID)GetProcAddress(hLib,L"DbgInit")) ||
		!(ConnectDebugger(pInit))) {
		SetLastError(ERROR_INVALID_PARAMETER);
		FreeLibrary(hLib);
		return FALSE;
	}
	return TRUE;
}

BOOL SetInterruptEvent(DWORD idInt) {
    long mask;
    long pend;
    long *ptrPend;
	
    if ((idInt < SYSINTR_DEVICES) || (idInt >= SYSINTR_MAXIMUM))
        return FALSE;
    idInt -= SYSINTR_DEVICES;
    mask = 1 << idInt;
    ptrPend = (long*)(UserKInfo[KINX_KDATA_ADDR]+KINFO_OFFSET) + KINX_PENDEVENTS;
    do {
        pend = *ptrPend;
        if (pend & mask)
            return TRUE;    // The bit is already set, so all done.
    } while (InterlockedTestExchange(ptrPend, pend, pend|mask) != pend);
    return TRUE;
}

VOID FreeLibraryAndExitThread(HMODULE hLibModule, DWORD dwExitCode) {
	FreeLibrary(hLibModule);
	ExitThread(dwExitCode);
}

static CONST WCHAR szHex[] = L"0123456789ABCDEF";

UINT GetTempFileNameW(LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName) {
	DWORD Length, Length2, PassCount, dwAttr;
	UINT uMyUnique;
	HANDLE hFile;
	Length = wcslen(lpPathName);
	if (!Length || (Length >= MAX_PATH)) {
		SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
	}
	memcpy(lpTempFileName,lpPathName,Length*sizeof(WCHAR));
    if (lpTempFileName[Length-1] != (WCHAR)'\\')
        Length++;
    lpTempFileName[Length-1] = 0;
    dwAttr = GetFileAttributesW(lpTempFileName);
    if ((dwAttr == 0xFFFFFFFF) || !(dwAttr & FILE_ATTRIBUTE_DIRECTORY)) {
        SetLastError(ERROR_DIRECTORY);
        return 0;
    }
    lpTempFileName[Length-1] = L'\\';
    PassCount = 0;
    Length2 = wcslen(lpPrefixString);
    if (Length2 > 3)
    	Length2 = 3;
    memcpy(&lpTempFileName[Length],lpPrefixString,Length2*sizeof(WCHAR));
    Length += Length2;
    uUnique &= 0x0000ffff;
    if ((Length + 9) > MAX_PATH) { // 4 hex digits, .tmp,  and a null
		SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
    }
    lpTempFileName[Length+4] = '.';
    lpTempFileName[Length+5] = 't';
    lpTempFileName[Length+6] = 'm';
    lpTempFileName[Length+7] = 'p';
try_again:
    if (!uUnique) {
        if (!(uMyUnique = (UINT)Random() & 0x0000ffff)) {
            if (!(++PassCount & 0xffff0000))
   	        	goto try_again;
   	        SetLastError(ERROR_RETRY);
   	        return 0;
        }
    } else
        uMyUnique = uUnique;
    lpTempFileName[Length] = szHex[(uMyUnique >> 12) & 0xf];
    lpTempFileName[Length+1] = szHex[(uMyUnique >> 8) & 0xf];
    lpTempFileName[Length+2] = szHex[(uMyUnique >> 4) & 0xf];
    lpTempFileName[Length+3] = szHex[uMyUnique & 0xf];
    lpTempFileName[Length+8] = 0;
    if (!uUnique) {
        if ((hFile = CreateFileW(lpTempFileName, GENERIC_READ, 0, 0, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0)) == INVALID_HANDLE_VALUE) {
        	switch (GetLastError()) {
        		case ERROR_FILE_EXISTS:
	        	case ERROR_ALREADY_EXISTS:
		            if (!(++PassCount & 0xffff0000))
	    	        	goto try_again;
	    	    	break;
	    	}
	        return 0;
        } else
           	CloseHandle(hFile);
    }
    return uMyUnique;
}

BOOL GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation) {
	LPCWSTR pTrav;
	HANDLE hFind;
	WIN32_FIND_DATA w32fd;
	for (pTrav = lpFileName; *pTrav; pTrav++)
		if (*pTrav == '*' || *pTrav == '?') {
			SetLastError(ERROR_INVALID_NAME);
			return FALSE;
		}
	if (fInfoLevelId != GetFileExInfoStandard) {
		SetLastError(ERROR_INVALID_PARAMETER);
		return FALSE;
	}
	if ((hFind = FindFirstFile(lpFileName,&w32fd)) == INVALID_HANDLE_VALUE) {
		SetLastError(ERROR_FILE_NOT_FOUND);
		return FALSE;
	}
	CloseHandle(hFind);
	((WIN32_FILE_ATTRIBUTE_DATA *)lpFileInformation)->dwFileAttributes = w32fd.dwFileAttributes;
	((WIN32_FILE_ATTRIBUTE_DATA *)lpFileInformation)->ftCreationTime = w32fd.ftCreationTime;
	((WIN32_FILE_ATTRIBUTE_DATA *)lpFileInformation)->ftLastAccessTime = w32fd.ftLastAccessTime;
	((WIN32_FILE_ATTRIBUTE_DATA *)lpFileInformation)->ftLastWriteTime = w32fd.ftLastWriteTime;
	((WIN32_FILE_ATTRIBUTE_DATA *)lpFileInformation)->nFileSizeHigh = w32fd.nFileSizeHigh;
	((WIN32_FILE_ATTRIBUTE_DATA *)lpFileInformation)->nFileSizeLow = w32fd.nFileSizeLow;
	return TRUE;
}