int main (int argc, char **argv) { GOptionContext *context; GError *error = NULL; const gchar *abort_message; gchar *basename; GFile *system_gimprc_file = NULL; GFile *user_gimprc_file = NULL; gint i; #if defined (__GNUC__) && defined (_WIN64) /* mingw-w64, at least the unstable build from late July 2008, * starts subsystem:windows programs in main(), but passes them * bogus argc and argv. __argc and __argv are OK, though, so just * use them. */ argc = __argc; argv = __argv; #endif #ifdef G_OS_WIN32 /* Reduce risks */ { typedef BOOL (WINAPI *t_SetDllDirectoryA) (LPCSTR lpPathName); t_SetDllDirectoryA p_SetDllDirectoryA; p_SetDllDirectoryA = GetProcAddress (GetModuleHandle ("kernel32.dll"), "SetDllDirectoryA"); if (p_SetDllDirectoryA) (*p_SetDllDirectoryA) (""); } /* On Windows, set DLL search path to $INSTALLDIR/bin so that .exe plug-ins in the plug-ins directory can find libgimp and file library DLLs without needing to set external PATH. */ { const gchar *install_dir; gchar *bin_dir; LPWSTR w_bin_dir; int n; w_bin_dir = NULL; install_dir = gimp_installation_directory (); bin_dir = g_build_filename (install_dir, "bin", NULL); n = MultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, bin_dir, -1, NULL, 0); if (n == 0) goto out; w_bin_dir = g_malloc_n (n + 1, sizeof (wchar_t)); n = MultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, bin_dir, -1, w_bin_dir, (n + 1) * sizeof (wchar_t)); if (n == 0) goto out; SetDllDirectoryW (w_bin_dir); out: if (w_bin_dir) g_free (w_bin_dir); g_free (bin_dir); } #ifndef _WIN64 { typedef BOOL (WINAPI *t_SetProcessDEPPolicy) (DWORD dwFlags); t_SetProcessDEPPolicy p_SetProcessDEPPolicy; p_SetProcessDEPPolicy = GetProcAddress (GetModuleHandle ("kernel32.dll"), "SetProcessDEPPolicy"); if (p_SetProcessDEPPolicy) (*p_SetProcessDEPPolicy) (PROCESS_DEP_ENABLE|PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION); } #endif /* Group all our windows together on the taskbar */ { typedef HRESULT (WINAPI *t_SetCurrentProcessExplicitAppUserModelID) (PCWSTR lpPathName); t_SetCurrentProcessExplicitAppUserModelID p_SetCurrentProcessExplicitAppUserModelID; p_SetCurrentProcessExplicitAppUserModelID = GetProcAddress (GetModuleHandle ("shell32.dll"), "SetCurrentProcessExplicitAppUserModelID"); if (p_SetCurrentProcessExplicitAppUserModelID) (*p_SetCurrentProcessExplicitAppUserModelID) (L"gimp.GimpApplication"); } #endif #ifdef GIMP_UNSTABLE gimp_open_console_window (); #endif gimp_init_malloc (); gimp_env_init (FALSE); gimp_log_init (); gimp_init_i18n (); g_set_application_name (GIMP_NAME); #ifdef G_OS_WIN32 argv = g_win32_get_command_line (); #else argv = g_strdupv (argv); #endif basename = g_path_get_basename (argv[0]); g_set_prgname (basename); g_free (basename); /* Check argv[] for "--verbose" first */ for (i = 1; i < argc; i++) { const gchar *arg = argv[i]; if (arg[0] != '-') continue; if ((strcmp (arg, "--verbose") == 0) || (strcmp (arg, "-v") == 0)) { be_verbose = TRUE; } } /* Check argv[] for "--no-interface" before trying to initialize gtk+. */ for (i = 1; i < argc; i++) { const gchar *arg = argv[i]; if (arg[0] != '-') continue; if ((strcmp (arg, "--no-interface") == 0) || (strcmp (arg, "-i") == 0)) { no_interface = TRUE; } else if ((strcmp (arg, "--version") == 0) || (strcmp (arg, "-v") == 0)) { gimp_show_version_and_exit (); } #if defined (G_OS_WIN32) && !defined (GIMP_CONSOLE_COMPILATION) else if ((strcmp (arg, "--help") == 0) || (strcmp (arg, "-?") == 0) || (strncmp (arg, "--help-", 7) == 0)) { gimp_open_console_window (); } #endif } #ifdef GIMP_CONSOLE_COMPILATION no_interface = TRUE; #endif context = g_option_context_new (_("[FILE|URI...]")); g_option_context_set_summary (context, GIMP_NAME); g_option_context_add_main_entries (context, main_entries, GETTEXT_PACKAGE); app_libs_init (context, no_interface); if (! g_option_context_parse_strv (context, &argv, &error)) { if (error) { gimp_open_console_window (); g_print ("%s\n", error->message); g_error_free (error); } else { g_print ("%s\n", _("GIMP could not initialize the graphical user interface.\n" "Make sure a proper setup for your display environment " "exists.")); } app_exit (EXIT_FAILURE); } if (no_interface || be_verbose || console_messages || batch_commands != NULL) gimp_open_console_window (); if (no_interface) new_instance = TRUE; #ifndef GIMP_CONSOLE_COMPILATION if (! new_instance && gimp_unique_open (filenames, as_new)) { if (be_verbose) g_print ("%s\n", _("Another GIMP instance is already running.")); if (batch_commands) gimp_unique_batch_run (batch_interpreter, batch_commands); gdk_notify_startup_complete (); return EXIT_SUCCESS; } #endif abort_message = sanity_check (); if (abort_message) app_abort (no_interface, abort_message); gimp_init_signal_handlers (stack_trace_mode); if (system_gimprc) system_gimprc_file = g_file_new_for_commandline_arg (system_gimprc); if (user_gimprc) user_gimprc_file = g_file_new_for_commandline_arg (user_gimprc); app_run (argv[0], filenames, system_gimprc_file, user_gimprc_file, session_name, batch_interpreter, batch_commands, as_new, no_interface, no_data, no_fonts, no_splash, be_verbose, use_shm, use_cpu_accel, console_messages, use_debug_handler, show_playground, stack_trace_mode, pdb_compat_mode); if (system_gimprc_file) g_object_unref (system_gimprc_file); if (user_gimprc_file) g_object_unref (user_gimprc_file); g_strfreev (argv); g_option_context_free (context); return EXIT_SUCCESS; }
int content_process_main(int argc, char* argv[]) { // Check for the absolute minimum number of args we need to move // forward here. We expect the last arg to be the child process type. if (argc < 1) { return 3; } bool isNuwa = false; for (int i = 1; i < argc; i++) { isNuwa |= strcmp(argv[i], "-nuwa") == 0; } XREChildData childData; #if defined(XP_WIN) && defined(MOZ_SANDBOX) if (IsSandboxedProcess()) { childData.sandboxTargetServices = mozilla::sandboxing::GetInitializedTargetServices(); if (!childData.sandboxTargetServices) { return 1; } childData.ProvideLogFunction = mozilla::sandboxing::ProvideLogFunction; } #endif XRE_SetProcessType(argv[--argc]); #ifdef MOZ_NUWA_PROCESS if (isNuwa) { PrepareNuwaProcess(); } #endif #if defined(XP_LINUX) && defined(MOZ_SANDBOX) // This has to happen while we're still single-threaded, and on // B2G that means before the Android Binder library is // initialized. Additional special handling is needed for Nuwa: // the Nuwa process itself needs to be unsandboxed, and the same // single-threadedness condition applies to its children; see also // AfterNuwaFork(). mozilla::SandboxEarlyInit(XRE_GetProcessType(), isNuwa); #endif #ifdef MOZ_WIDGET_GONK // This creates a ThreadPool for binder ipc. A ThreadPool is necessary to // receive binder calls, though not necessary to send binder calls. // ProcessState::Self() also needs to be called once on the main thread to // register the main thread with the binder driver. #ifdef MOZ_NUWA_PROCESS if (!isNuwa) { InitializeBinder(nullptr); } else { NuwaAddFinalConstructor(&InitializeBinder, nullptr); } #else InitializeBinder(nullptr); #endif #endif #ifdef XP_WIN // For plugins, this is done in PluginProcessChild::Init, as we need to // avoid it for unsupported plugins. See PluginProcessChild::Init for // the details. if (XRE_GetProcessType() != GeckoProcessType_Plugin) { mozilla::SanitizeEnvironmentVariables(); SetDllDirectoryW(L""); } #endif #if !defined(MOZ_WIDGET_ANDROID) && !defined(MOZ_WIDGET_GONK) && defined(MOZ_PLUGIN_CONTAINER) // On desktop, the GMPLoader lives in plugin-container, so that its // code can be covered by an EME/GMP vendor's voucher. nsAutoPtr<mozilla::gmp::SandboxStarter> starter(MakeSandboxStarter()); if (XRE_GetProcessType() == GeckoProcessType_GMPlugin) { childData.gmpLoader = mozilla::gmp::CreateGMPLoader(starter); } #endif nsresult rv = XRE_InitChildProcess(argc, argv, &childData); NS_ENSURE_SUCCESS(rv, 1); return 0; }
BOOL FixIAT( DWORD dwProcessId, HANDLE hProcess, PBYTE imageBase, PIMAGE_NT_HEADERS pNtHeader, PIMAGE_IMPORT_DESCRIPTOR pImgImpDesc ) { BOOL bRet = FALSE; LPSTR lpModuleName = 0; HMODULE hLocalModule = 0; HMODULE hRemoteModule = 0; WCHAR modulePath[MAX_PATH + 1] = {0}; WCHAR moduleNtPath[500 + 1] = {0}; WCHAR targetProcPath[MAX_PATH + 1] = {0}; WCHAR *pch = 0; __try { //printf("Fixing Imports:\n"); // get target process path if(!GetModuleFileNameExW(hProcess, (HMODULE)0, targetProcPath, MAX_PATH)) { PRINT_ERROR_MSGA("Could not get path to target process."); __leave; } pch = wcsrchr(targetProcPath, '\\'); if(pch) { targetProcPath[ pch - targetProcPath + 1 ] = (WCHAR)0; } if(!SetDllDirectoryW(targetProcPath)) { PRINT_ERROR_MSGW(L"Could not set path to target process (%s).", targetProcPath); __leave; } while((lpModuleName = (LPSTR)GetPtrFromRVA(pImgImpDesc->Name, pNtHeader, imageBase))) { PIMAGE_THUNK_DATA itd = 0; //printf("module: %s\n", lpModuleName); // ACHTUNG: LoadLibraryEx kann eine DLL nur anhand des Namen aus einem anderen // Verzeichnis laden wie der Zielprozess! hLocalModule = LoadLibraryExA(lpModuleName, 0, DONT_RESOLVE_DLL_REFERENCES); if(!hLocalModule) { PRINT_ERROR_MSGA("Could not load module locally."); __leave; } // get full path of module if(!GetModuleFileNameW(hLocalModule, modulePath, MAX_PATH)) { PRINT_ERROR_MSGA("Could not get path to module (%s).", lpModuleName); __leave; } // get nt path if(!GetFileNameNtW(modulePath, moduleNtPath, 500)) { PRINT_ERROR_MSGA("Could not get the NT namespace path."); __leave; } // Module already in process? hRemoteModule = (HMODULE)ModuleInjectedW(hProcess, moduleNtPath); if(!hRemoteModule) { if(!InjectLibraryW(dwProcessId, modulePath)) { PRINT_ERROR_MSGW(L"Could not inject required module (%s).\n", modulePath); __leave; } hRemoteModule = (HMODULE)ModuleInjectedW(hProcess, moduleNtPath); } itd = (PIMAGE_THUNK_DATA)GetPtrFromRVA(pImgImpDesc->FirstThunk, pNtHeader, imageBase); while(itd->u1.AddressOfData) { IMAGE_IMPORT_BY_NAME *iibn = (PIMAGE_IMPORT_BY_NAME)GetPtrFromRVA(itd->u1.AddressOfData, pNtHeader, imageBase); itd->u1.Function = (DWORD_PTR)GetRemoteProcAddress(hProcess, hRemoteModule, (LPCSTR)iibn->Name); //printf("Function: %s\n", (LPCSTR)iibn->Name); itd++; } pImgImpDesc++; } bRet = TRUE; } __finally { if(hLocalModule) { FreeLibrary(hLocalModule); } } return bRet; }