void Dlg_OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify) { switch (id) { case IDCANCEL: EndDialog(hWnd, id); break; case IDC_INJECT: DWORD dwProcessId = GetDlgItemInt(hWnd, IDC_PROCESSID, NULL, FALSE); if (dwProcessId == 0) { // A process ID of 0 causes everything to take place in the // local process; this makes things easier for debugging. dwProcessId = GetCurrentProcessId(); } TCHAR szLibFile[MAX_PATH]; GetModuleFileName(NULL, szLibFile, _countof(szLibFile)); PTSTR pFilename = _tcsrchr(szLibFile, TEXT('\\')) + 1; _tcscpy_s(pFilename, _countof(szLibFile) - (pFilename - szLibFile), TEXT("22-ImgWalk.DLL")); if (InjectLib(dwProcessId, szLibFile)) { chVERIFY(EjectLib(dwProcessId, szLibFile)); chMB("DLL Injection/Ejection successful."); } else { chMB("DLL Injection/Ejection failed."); } break; } }
void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) { switch (id) { case IDCANCEL: // User is terminating our app, kill the job too. KillTimer(hwnd, 1); g_job.Terminate(0); EndDialog(hwnd, id); break; case IDC_PERJOBUSERTIMELIMIT: { // The job time must be reset if setting a job time limit BOOL f; GetDlgItemInt(hwnd, IDC_PERJOBUSERTIMELIMIT, &f, FALSE); EnableWindow( GetDlgItem(hwnd, IDC_PRESERVEJOBTIMEWHENAPPLYINGLIMITS), !f); } break; case IDC_APPLYLIMITS: Dlg_ApplyLimits(hwnd); PostQueuedCompletionStatus(g_hIOCP, 0, COMPKEY_STATUS, NULL); break; case IDC_TERMINATE: g_job.Terminate(0); PostQueuedCompletionStatus(g_hIOCP, 0, COMPKEY_STATUS, NULL); break; case IDC_SPAWNCMDINJOB: { // Spawn a command shell and place it in the job STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; TCHAR sz[] = TEXT("CMD"); CreateProcess(NULL, sz, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi); g_job.AssignProcess(pi.hProcess); ResumeThread(pi.hThread); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } PostQueuedCompletionStatus(g_hIOCP, 0, COMPKEY_STATUS, NULL); break; case IDC_ASSIGNPROCESSTOJOB: { DWORD dwProcessId = GetDlgItemInt(hwnd, IDC_PROCESSID, NULL, FALSE); HANDLE hProcess = OpenProcess( PROCESS_SET_QUOTA | PROCESS_TERMINATE, FALSE, dwProcessId); if (hProcess != NULL) { chVERIFY(g_job.AssignProcess(hProcess)); CloseHandle(hProcess); } else chMB("Could not assign process to job."); } PostQueuedCompletionStatus(g_hIOCP, 0, COMPKEY_STATUS, NULL); break; } }
VOID FirstFunc(BOOL fLocal, COptex& optex) { optex.Enter(); // Gain ownership of the optex // Since this thread owns the optex, we should be able to get it again chVERIFY(optex.TryEnter()); HANDLE hOtherThread = NULL; if (fLocal) { // Spawn a secondary thread for testing purposes (pass it the optex) DWORD dwThreadId; hOtherThread = chBEGINTHREADEX(NULL, 0, SecondFunc, (PVOID) &optex, 0, &dwThreadId); } else { // Spawn a secondary process for testing purposes STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; TCHAR szPath[MAX_PATH]; GetModuleFileName(NULL, szPath, chDIMOF(szPath)); CreateProcess(NULL, szPath, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi); hOtherThread = pi.hProcess; CloseHandle(pi.hThread); } // Wait for the second thread to own the optex chMB("Primary: Hit OK to give optex to secondary"); // Let the second thread gain ownership of the optex optex.Leave(); optex.Leave(); // Wait for the second thread to own the optex chMB("Primary: Hit OK to wait for the optex\n(Dismiss me 1st)"); optex.Enter(); // Try to gain ownership back WaitForSingleObject(hOtherThread, INFINITE); CloseHandle(hOtherThread); optex.Leave(); }
void Dlg_OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify) { TCHAR szPathname[MAX_PATH]; switch (id) { case IDCANCEL: EndDialog(hWnd, id); break; case IDC_FILENAME: EnableWindow(GetDlgItem(hWnd, IDC_REVERSE), Edit_GetTextLength(hWndCtl) > 0); break; case IDC_REVERSE: GetDlgItemText(hWnd, IDC_FILENAME, szPathname, _countof(szPathname)); // Make copy of input file so that we don't destroy it if (!CopyFile(szPathname, FILENAME, FALSE)) { chMB("New file could not be created."); break; } BOOL bIsTextUnicode; if (FileReverse(FILENAME, &bIsTextUnicode)) { SetDlgItemText(hWnd, IDC_TEXTTYPE, bIsTextUnicode ? TEXT("Unicode") : TEXT("ANSI")); // Spawn Notepad to see the fruits of our labors. STARTUPINFO si = { sizeof(si) }; PROCESS_INFORMATION pi; TCHAR sz[] = TEXT("Notepad ") FILENAME; if (CreateProcess(NULL, sz, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { CloseHandle(pi.hThread); CloseHandle(pi.hProcess); } } break; case IDC_FILESELECT: OPENFILENAME ofn = { OPENFILENAME_SIZE_VERSION_400 }; ofn.hwndOwner = hWnd; ofn.lpstrFile = szPathname; ofn.lpstrFile[0] = 0; ofn.nMaxFile = _countof(szPathname); ofn.lpstrTitle = TEXT("Select file for reversing"); ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST; GetOpenFileName(&ofn); SetDlgItemText(hWnd, IDC_FILENAME, ofn.lpstrFile); SetFocus(GetDlgItem(hWnd, IDC_REVERSE)); break; } }
DWORD WINAPI SecondFunc(PVOID pvParam) { COptex& optex = * (COptex*) pvParam; // The primary thread should own the optex here, this should fail chVERIFY(optex.TryEnter() == FALSE); // Wait for the primary thread to give up the optex optex.Enter(); optex.Enter(); // Test recursive ownership chMB("Secondary: Entered the optex\n(Dismiss me 2nd)"); // Leave the optex but we still own it once optex.Leave(); chMB("Secondary: The primary thread should not display a box yet"); optex.Leave(); // The primary thread should be able to run now return(0); }
void IsModuleLoaded(PCTSTR pszModuleName) { HMODULE hmod = GetModuleHandle(pszModuleName); char sz[100]; #ifdef UNICODE StringCchPrintfA(sz, _countof(sz), "Module \"%S\" is %Sloaded.", pszModuleName, (hmod == NULL) ? L"not " : L""); #else StringCchPrintfA(sz, _countof(sz), "Module \"%s\" is %sloaded.", pszModuleName, (hmod == NULL) ? "not " : ""); #endif chMB(sz); }
void Dlg_OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify) { switch (id) { case IDCANCEL: EndDialog(hWnd, id); break; case IDC_WINDOW0STORAGE: case IDC_WINDOW1STORAGE: if (codeNotify == CBN_SELCHANGE) { // Show different storage in address window int nWindow = ((id == IDC_WINDOW0STORAGE) ? 0 : 1); int nStorage = ComboBox_GetCurSel(hWndCtl) - 1; if (nStorage == -1) { // Show no storage in this window chVERIFY(g_aw[nWindow].UnmapStorage()); } else { if (!g_aws[nStorage].MapStorage(g_aw[nWindow])) { // Couldn't map storage in window chVERIFY(g_aw[nWindow].UnmapStorage()); ComboBox_SetCurSel(hWndCtl, 0); // Force "No storage" chMB("This storage can be mapped only once."); } } // Update the address window's text display HWND hWndText = GetDlgItem(hWnd, ((nWindow == 0) ? IDC_WINDOW0TEXT : IDC_WINDOW1TEXT)); MEMORY_BASIC_INFORMATION mbi; VirtualQuery(g_aw[nWindow], &mbi, sizeof(mbi)); // Note: mbi.State == MEM_RESERVE if no storage is in address window EnableWindow(hWndText, (mbi.State == MEM_COMMIT)); Edit_SetText(hWndText, IsWindowEnabled(hWndText) ? (PCTSTR) (PVOID) g_aw[nWindow] : TEXT("(No storage)")); } break; case IDC_WINDOW0TEXT: case IDC_WINDOW1TEXT: if (codeNotify == EN_CHANGE) { // Update the storage in the address window int nWindow = ((id == IDC_WINDOW0TEXT) ? 0 : 1); Edit_GetText(hWndCtl, (PTSTR) (PVOID) g_aw[nWindow], g_nChars); } break; } }
BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, PVOID fImpLoad) { if (fdwReason == DLL_PROCESS_ATTACH) { char szBuf[MAX_PATH * 100] = { 0 }; PBYTE pb = NULL; MEMORY_BASIC_INFORMATION mbi; while (VirtualQuery(pb, &mbi, sizeof(mbi)) == sizeof(mbi)) { int nLen; char szModName[MAX_PATH]; if (mbi.State == MEM_FREE) mbi.AllocationBase = mbi.BaseAddress; if ((mbi.AllocationBase == hInstDll) || (mbi.AllocationBase != mbi.BaseAddress) || (mbi.AllocationBase == NULL)) { // Do not add the module name to the list // if any of the following is true: // 1. If this region contains this DLL // 2. If this block is NOT the beginning of a region // 3. If the address is NULL nLen = 0; } else { nLen = GetModuleFileNameA((HINSTANCE) mbi.AllocationBase, szModName, _countof(szModName)); } if (nLen > 0) { wsprintfA(strchr(szBuf, 0), "\n%p-%s", mbi.AllocationBase, szModName); } pb += mbi.RegionSize; } // NOTE: Normally, you should not display a message box in DllMain // due to the loader lock described in Chapter 20. However, to keep // this sample application simple, I am violating this rule. chMB(&szBuf[1]); } return(TRUE); }
BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD fdwReason, PVOID fImpLoad) { if (fdwReason == DLL_PROCESS_ATTACH) { char szBuf[MAX_PATH * 100] = { 0 }; PBYTE pb = NULL; MEMORY_BASIC_INFORMATION mbi; while (VirtualQuery(pb, &mbi, sizeof(mbi)) == sizeof(mbi)) { int nLen; char szModName[MAX_PATH]; if (mbi.State == MEM_FREE) mbi.AllocationBase = mbi.BaseAddress; if ((mbi.AllocationBase == hinstDll) || (mbi.AllocationBase != mbi.BaseAddress) || (mbi.AllocationBase == NULL)) { // Do not add the module name to the list // if any of the following is true: // 1. If this region contains this DLL // 2. If this block is NOT the beginning of a region // 3. If the address is NULL nLen = 0; } else { nLen = GetModuleFileNameA((HINSTANCE) mbi.AllocationBase, szModName, chDIMOF(szModName)); } if (nLen > 0) { wsprintfA(strchr(szBuf, 0), "\n%p-%s", mbi.AllocationBase, szModName); } pb += mbi.RegionSize; } chMB(&szBuf[1]); } return(TRUE); }
void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) { static BOOL s_fProcesses = TRUE; switch (id) { case IDCANCEL: EndDialog(hwnd, id); break; /* Restart the application when we are not running * as Elevated Administrator. */ case IDC_BTN_SYSTEM_PROCESSES: { /* Hide ourself before trying to start the same application * but with elevated privileges. */ ShowWindow(hwnd, SW_HIDE); TCHAR szApplication[MAX_PATH]; DWORD cchLength = _countof(szApplication); /* Retrieves the full name of the executable * image for the specified process. * hProcess [in] * A handle to the process. * This handle must be created with the PROCESS_QUERY_INFORMATION * or PROCESS_QUERY_LIMITED_INFORMATION access right. * For more information, see Process Security and Access Rights. * dwFlags [in] * This parameter can be one of the following values. * 0 The name should use the Win32 path format. * The name should use the native system path format. * lpExeName [out] * The path to the executable image. * If the function succeeds, this string is null-terminated. * lpdwSize [in, out] * On input, specifies the size of the lpExeName buffer, in characters. * On success, receives the number of characters written to the buffer, * not including the null-terminating character. */ QueryFullProcessImageName( GetCurrentProcess(), 0, szApplication, &cchLength); DWORD dwStatus = StartElevatedProcess(szApplication, NULL); if (dwStatus == S_OK) { /* not need to keep on working under lower privileges. */ ExitProcess(0); } /* In case of error, show up again. */ ShowWindow(hwnd, SW_SHOWNORMAL); } break; case ID_PROCESSES: s_fProcesses = TRUE; EnableMenuItem(GetMenu(hwnd), ID_VMMAP, MF_BYCOMMAND | MF_ENABLED); DrawMenuBar(hwnd); Dlg_PopulateProcessList(hwnd); break; case ID_MODULES: EnableMenuItem(GetMenu(hwnd), ID_VMMAP, MF_BYCOMMAND | MF_GRAYED); DrawMenuBar(hwnd); s_fProcesses = FALSE; Dlg_PopulateModuleList(hwnd); break; case IDC_PROCESSMODULELIST: if (codeNotify == CBN_SELCHANGE) { DWORD dw = ComboBox_GetCurSel(hwndCtl); if (s_fProcesses) { dw = (DWORD) ComboBox_GetItemData(hwndCtl, dw); // Process ID ShowProcessInfo(GetDlgItem(hwnd, IDC_RESULTS), dw); } else { // Index in helper listbox of full path dw = (DWORD) ComboBox_GetItemData(hwndCtl, dw); TCHAR szModulePath[1024]; ListBox_GetText(GetDlgItem(hwnd, IDC_MODULEHELP), dw, szModulePath); ShowModuleInfo(GetDlgItem(hwnd, IDC_RESULTS), szModulePath); } } break; case ID_VMMAP: { TCHAR szCmdLine[32]; HWND hwndCB = GetDlgItem(hwnd, IDC_PROCESSMODULELIST); DWORD dwProcessId = (DWORD) ComboBox_GetItemData(hwndCB, ComboBox_GetCurSel(hwndCB)); StringCchPrintf(szCmdLine, _countof(szCmdLine), TEXT("%d"), dwProcessId); DWORD dwStatus = StartElevatedProcess(TEXT("\"14-VMMap.exe\""), szCmdLine); if (dwStatus == ERROR_CANCELLED) { chMB("Failed to run 14-VMMap.exe: you refused access."); } } break; } }
BOOL FileReverse(PCTSTR pszPathname, PBOOL pbIsTextUnicode) { *pbIsTextUnicode = FALSE; // Assume text is Unicode // Open the file for reading and writing. HANDLE hFile = CreateFile(pszPathname, GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { chMB("File could not be opened."); return(FALSE); } // Get the size of the file (I assume the whole file can be mapped). DWORD dwFileSize = GetFileSize(hFile, NULL); // Create the file-mapping object. The file-mapping object is 1 character // bigger than the file size so that a zero character can be placed at the // end of the file to terminate the string (file). Because I don't yet know // if the file contains ANSI or Unicode characters, I assume worst case // and add the size of a WCHAR instead of CHAR. HANDLE hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, dwFileSize + sizeof(WCHAR), NULL); if (hFileMap == NULL) { chMB("File map could not be opened."); CloseHandle(hFile); return(FALSE); } // Get the address where the first byte of the file is mapped into memory. PVOID pvFile = MapViewOfFile(hFileMap, FILE_MAP_WRITE, 0, 0, 0); if (pvFile == NULL) { chMB("Could not map view of file."); CloseHandle(hFileMap); CloseHandle(hFile); return(FALSE); } // Does the buffer contain ANSI or Unicode? int iUnicodeTestFlags = -1; // Try all tests *pbIsTextUnicode = IsTextUnicode(pvFile, dwFileSize, &iUnicodeTestFlags); if (!*pbIsTextUnicode) { // For all the file manipulations below, we explicitly use ANSI // functions because we are processing an ANSI file. // Put a zero character at the very end of the file. PSTR pchANSI = (PSTR) pvFile; pchANSI[dwFileSize / sizeof(CHAR)] = 0; // Reverse the contents of the file. _strrev(pchANSI); // Convert all "\n\r" combinations back to "\r\n" to // preserve the normal end-of-line sequence. pchANSI = strstr(pchANSI, "\n\r"); // Find first "\r\n". while (pchANSI != NULL) { // We have found an occurrence.... *pchANSI++ = '\r'; // Change '\n' to '\r'. *pchANSI++ = '\n'; // Change '\r' to '\n'. pchANSI = strstr(pchANSI, "\n\r"); // Find the next occurrence. } } else { // For all the file manipulations below, we explicitly use Unicode // functions because we are processing a Unicode file. // Put a zero character at the very end of the file. PWSTR pchUnicode = (PWSTR) pvFile; pchUnicode[dwFileSize / sizeof(WCHAR)] = 0; if ((iUnicodeTestFlags & IS_TEXT_UNICODE_SIGNATURE) != 0) { // If the first character is the Unicode BOM (byte-order-mark), // 0xFEFF, keep this character at the beginning of the file. pchUnicode++; } // Reverse the contents of the file. _wcsrev(pchUnicode); // Convert all "\n\r" combinations back to "\r\n" to // preserve the normal end-of-line sequence. pchUnicode = wcsstr(pchUnicode, L"\n\r"); // Find first '\n\r'. while (pchUnicode != NULL) { // We have found an occurrence.... *pchUnicode++ = L'\r'; // Change '\n' to '\r'. *pchUnicode++ = L'\n'; // Change '\r' to '\n'. pchUnicode = wcsstr(pchUnicode, L"\n\r"); // Find the next occurrence. } } // Clean up everything before exiting. UnmapViewOfFile(pvFile); CloseHandle(hFileMap); // Remove trailing zero character added earlier. SetFilePointer(hFile, dwFileSize, NULL, FILE_BEGIN); SetEndOfFile(hFile); CloseHandle(hFile); return(TRUE); }
void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) { static BOOL s_fProcesses = TRUE; switch (id) { case IDCANCEL: EndDialog(hwnd, id); break; // Restart the application when we are not running // as Elevated Administrator. case IDC_BTN_SYSTEM_PROCESSES: { // Hide ourself before trying to start the same application // but with elevated privileges. ShowWindow(hwnd, SW_HIDE); TCHAR szApplication[MAX_PATH]; DWORD cchLength = _countof(szApplication); QueryFullProcessImageName( GetCurrentProcess(), 0, szApplication, &cchLength); DWORD dwStatus = StartElevatedProcess(szApplication, NULL); if (dwStatus == S_OK) { // not need to keep on working under lower privileges. ExitProcess(0); } // In case of error, show up again. ShowWindow(hwnd, SW_SHOWNORMAL); } break; case ID_PROCESSES: s_fProcesses = TRUE; EnableMenuItem(GetMenu(hwnd), ID_VMMAP, MF_BYCOMMAND | MF_ENABLED); DrawMenuBar(hwnd); Dlg_PopulateProcessList(hwnd); break; case ID_MODULES: EnableMenuItem(GetMenu(hwnd), ID_VMMAP, MF_BYCOMMAND | MF_GRAYED); DrawMenuBar(hwnd); s_fProcesses = FALSE; Dlg_PopulateModuleList(hwnd); break; case IDC_PROCESSMODULELIST: if (codeNotify == CBN_SELCHANGE) { DWORD dw = ComboBox_GetCurSel(hwndCtl); if (s_fProcesses) { dw = (DWORD) ComboBox_GetItemData(hwndCtl, dw); // Process ID ShowProcessInfo(GetDlgItem(hwnd, IDC_RESULTS), dw); } else { // Index in helper listbox of full path dw = (DWORD) ComboBox_GetItemData(hwndCtl, dw); TCHAR szModulePath[1024]; ListBox_GetText(GetDlgItem(hwnd, IDC_MODULEHELP), dw, szModulePath); ShowModuleInfo(GetDlgItem(hwnd, IDC_RESULTS), szModulePath); } } break; case ID_VMMAP: { TCHAR szCmdLine[32]; HWND hwndCB = GetDlgItem(hwnd, IDC_PROCESSMODULELIST); DWORD dwProcessId = (DWORD) ComboBox_GetItemData(hwndCB, ComboBox_GetCurSel(hwndCB)); StringCchPrintf(szCmdLine, _countof(szCmdLine), TEXT("%d"), dwProcessId); DWORD dwStatus = StartElevatedProcess(TEXT("\"14-VMMap.exe\""), szCmdLine); if (dwStatus == ERROR_CANCELLED) { chMB("Failed to run 14-VMMap.exe: you refused access."); } } break; } }
void Dlg_ApplyLimits(HWND hwnd) { const int nNanosecondsPerSecond = 1000000000; const int nMillisecondsPerSecond = 1000; const int nNanosecondsPerMillisecond = nNanosecondsPerSecond / nMillisecondsPerSecond; BOOL f; __int64 q; SIZE_T s; DWORD d; // Set Basic and Extended Limits JOBOBJECT_EXTENDED_LIMIT_INFORMATION joeli = { 0 }; joeli.BasicLimitInformation.LimitFlags = 0; q = GetDlgItemInt(hwnd, IDC_PERPROCESSUSERTIMELIMIT, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PROCESS_TIME; joeli.BasicLimitInformation.PerProcessUserTimeLimit.QuadPart = q * nNanosecondsPerMillisecond / 100; } q = GetDlgItemInt(hwnd, IDC_PERJOBUSERTIMELIMIT, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_JOB_TIME; joeli.BasicLimitInformation.PerJobUserTimeLimit.QuadPart = q * nNanosecondsPerMillisecond / 100; } s = GetDlgItemInt(hwnd, IDC_MINWORKINGSETSIZE, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_WORKINGSET; joeli.BasicLimitInformation.MinimumWorkingSetSize = s * 1024 * 1024; s = GetDlgItemInt(hwnd, IDC_MAXWORKINGSETSIZE, &f, FALSE); if (f) { joeli.BasicLimitInformation.MaximumWorkingSetSize = s * 1024 * 1024; } else { joeli.BasicLimitInformation.LimitFlags &=~JOB_OBJECT_LIMIT_WORKINGSET; chMB("Both minimum and maximum working set sizes must be set.\n" "The working set limits will NOT be in effect."); } } d = GetDlgItemInt(hwnd, IDC_ACTIVEPROCESSLIMIT, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_ACTIVE_PROCESS; joeli.BasicLimitInformation.ActiveProcessLimit = d; } s = GetDlgItemInt(hwnd, IDC_AFFINITYMASK, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_AFFINITY; joeli.BasicLimitInformation.Affinity = s; } joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PRIORITY_CLASS; switch (ComboBox_GetCurSel(GetDlgItem(hwnd, IDC_PRIORITYCLASS))) { case 0: joeli.BasicLimitInformation.LimitFlags &= ~JOB_OBJECT_LIMIT_PRIORITY_CLASS; break; case 1: joeli.BasicLimitInformation.PriorityClass = IDLE_PRIORITY_CLASS; break; case 2: joeli.BasicLimitInformation.PriorityClass = BELOW_NORMAL_PRIORITY_CLASS; break; case 3: joeli.BasicLimitInformation.PriorityClass = NORMAL_PRIORITY_CLASS; break; case 4: joeli.BasicLimitInformation.PriorityClass = ABOVE_NORMAL_PRIORITY_CLASS; break; case 5: joeli.BasicLimitInformation.PriorityClass = HIGH_PRIORITY_CLASS; break; case 6: joeli.BasicLimitInformation.PriorityClass = REALTIME_PRIORITY_CLASS; break; } int nSchedulingClass = ComboBox_GetCurSel(GetDlgItem(hwnd, IDC_SCHEDULINGCLASS)); if (nSchedulingClass > 0) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_SCHEDULING_CLASS; joeli.BasicLimitInformation.SchedulingClass = nSchedulingClass - 1; } s = GetDlgItemInt(hwnd, IDC_MAXCOMMITPERJOB, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_JOB_MEMORY; joeli.JobMemoryLimit = s * 1024 * 1024; } s = GetDlgItemInt(hwnd, IDC_MAXCOMMITPERPROCESS, &f, FALSE); if (f) { joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PROCESS_MEMORY; joeli.ProcessMemoryLimit = s * 1024 * 1024; } if (IsDlgButtonChecked(hwnd, IDC_CHILDPROCESSESCANBREAKAWAYFROMJOB)) joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_BREAKAWAY_OK; if (IsDlgButtonChecked(hwnd, IDC_CHILDPROCESSESDOBREAKAWAYFROMJOB)) joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK; if (IsDlgButtonChecked(hwnd, IDC_TERMINATEPROCESSONEXCEPTIONS)) joeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION; f = g_job.SetExtendedLimitInfo(&joeli, ((joeli.BasicLimitInformation.LimitFlags & JOB_OBJECT_LIMIT_JOB_TIME) != 0) ? FALSE : IsDlgButtonChecked(hwnd, IDC_PRESERVEJOBTIMEWHENAPPLYINGLIMITS)); chASSERT(f); // Set UI Restrictions DWORD jobuir = JOB_OBJECT_UILIMIT_NONE; // A fancy zero (0) if (IsDlgButtonChecked(hwnd, IDC_RESTRICTACCESSTOOUTSIDEUSEROBJECTS)) jobuir |= JOB_OBJECT_UILIMIT_HANDLES; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTREADINGCLIPBOARD)) jobuir |= JOB_OBJECT_UILIMIT_READCLIPBOARD; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTWRITINGCLIPBOARD)) jobuir |= JOB_OBJECT_UILIMIT_WRITECLIPBOARD; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTEXITWINDOW)) jobuir |= JOB_OBJECT_UILIMIT_EXITWINDOWS; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTCHANGINGSYSTEMPARAMETERS)) jobuir |= JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTDESKTOPS)) jobuir |= JOB_OBJECT_UILIMIT_DESKTOP; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTDISPLAYSETTINGS)) jobuir |= JOB_OBJECT_UILIMIT_DISPLAYSETTINGS; if (IsDlgButtonChecked(hwnd, IDC_RESTRICTGLOBALATOMS)) jobuir |= JOB_OBJECT_UILIMIT_GLOBALATOMS; chVERIFY(g_job.SetBasicUIRestrictions(jobuir)); }