void ACE_Process_Options::inherit_environment (void) { // Ensure only once execution. if (environment_inherited_) return; environment_inherited_ = 1; // Get the existing environment. ACE_TCHAR *existing_environment = 0; #if defined (ACE_HAS_WCHAR) && !defined (ACE_USES_WCHAR) WCHAR *existing_wide_env = 0; ACE_Vector<char> temp_narrow_env; if (this->use_unicode_environment_) { existing_wide_env = ::GetEnvironmentStringsW (); for (WCHAR *iter = existing_wide_env; *iter; ++iter) { ACE_Wide_To_Ascii wta (iter); size_t len = ACE_OS::strlen (wta.char_rep ()); size_t idx = temp_narrow_env.size (); temp_narrow_env.resize (idx + len + 1, 0); ACE_OS::strncpy (&temp_narrow_env[idx], wta.char_rep (), len); iter += len; } temp_narrow_env.push_back (0); existing_environment = &temp_narrow_env[0]; } else #endif existing_environment = ACE_OS::getenvstrings (); size_t slot = 0; while (existing_environment[slot] != '\0') { size_t len = ACE_OS::strlen (existing_environment + slot); // Add the string to our env buffer. if (this->setenv_i (existing_environment + slot, len) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), ACE_TEXT ("ACE_Process_Options::ACE_Process_Options"))); break; } // Skip to the next word. slot += len + 1; } #if defined (ACE_HAS_WCHAR) && !defined (ACE_USES_WCHAR) if (this->use_unicode_environment_) ::FreeEnvironmentStringsW (existing_wide_env); else #endif ACE_TEXT_FreeEnvironmentStrings (existing_environment); }
static void win32_spawn_environment_process (void) { PROCESS_INFORMATION process_info; ACE_TEXT_STARTUPINFO startup_info; ACE_OS::memset ((void *) &startup_info, 0, sizeof startup_info); ACE_OS::memset ((void *) &process_info, 0, sizeof process_info); startup_info.cb = sizeof (startup_info); startup_info.dwFlags = STARTF_USESTDHANDLES; ACE_HANDLE std_in = ACE_STDIN; ACE_HANDLE std_out = ACE_STDOUT; ACE_HANDLE std_err = ACE_STDERR; if (!::DuplicateHandle (::GetCurrentProcess(), std_out, ::GetCurrentProcess(), &startup_info.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p duplicate failed.\n"), ACE_TEXT ("spawn_environment_process"))); return; } if (!::DuplicateHandle (::GetCurrentProcess(), std_err, ::GetCurrentProcess(), &startup_info.hStdError, 0, TRUE, DUPLICATE_SAME_ACCESS)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p duplicate failed.\n"), ACE_TEXT ("spawn_environment_process"))); return; } if (!::DuplicateHandle (::GetCurrentProcess(), std_in, ::GetCurrentProcess(), &startup_info.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p duplicate failed.\n"), ACE_TEXT ("spawn_environment_process"))); return; } // Normally, this would be just GetEnvironmentStrings, but it // doesn't follow the same rules as the rest of the Win32 API ACE_TCHAR *existing_environment = ACE_OS::getenvstrings (); ACE_TCHAR environment[10240]; ACE_OS::sprintf (environment, ACE_TEXT("ACE_PROCESS_TEST=%s"), environment_string); int size = 0; while (existing_environment[size] != '\0') size += ACE_Utils::truncate_cast<int> ( ACE_OS::strlen (existing_environment + size) + 1); ACE_OS::memcpy (environment + (ACE_OS::strlen (environment) + 1), existing_environment, size); ACE_TEXT_FreeEnvironmentStrings (existing_environment); ACE_TCHAR cmd_line[16]; ACE_OS::strncpy (cmd_line, ACE_TEXT ("process -g"), sizeof (cmd_line)); BOOL fork_result = ACE_TEXT_CreateProcess (ACE_TEXT ("d:\\harrison\\ACE_wrappers\\examples\\OS\\Process\\process.exe"), cmd_line, 0, // No process attributes. 0, // No thread attributes. TRUE, // Allow handle inheritance. 0, // CREATE_NEW_CONSOLE, // Create a new console window. environment, // Environment. //"d:\\harrison\\ACE_wrappers\\examples\\OS\\Process\\", 0, &startup_info, &process_info); ::CloseHandle (startup_info.hStdOutput); ::CloseHandle (startup_info.hStdError); if (fork_result == 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), ACE_TEXT ("spawn_environment_process"))); else { ::WaitForSingleObject (process_info.hProcess, INFINITE); ACE_DEBUG ((LM_ERROR, ACE_TEXT ("spawn_environment_process succeeded.\n"))); } }