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;
}
