C++ ACE_Process_Options::passed_handles方法代码示例

pid_t
ACE_Process::spawn (ACE_Process_Options &options)
{
    if (this->prepare (options) < 0)
        return ACE_INVALID_PID;

    // Stash the passed/duped handle sets away in this object for later
    // closing if needed or requested. At the same time, figure out which
    // ones to include in command line options if that's needed below.
    ACE_Handle_Set *set_p = 0;
    if (options.dup_handles (this->dup_handles_))
        set_p = &this->dup_handles_;
    else if (options.passed_handles (this->handles_passed_))
        set_p = &this->handles_passed_;

    // If we are going to end up running a new program (i.e. Win32, or
    // NO_EXEC option is set) then get any handles passed in the options,
    // and tack them onto the command line with +H <handle> options,
    // unless the command line runs out of space.
    // Note that we're using the knowledge that all the options, argvs, etc.
    // passed to the options are all sitting in the command_line_buf. Any
    // call to get the argv then splits them out. So, regardless of the
    // platform, tack them all onto the command line buf and take it
    // from there.
    if (set_p && !ACE_BIT_ENABLED (options.creation_flags (),
                                   ACE_Process_Options::NO_EXEC))
    {
        int maxlen = 0;
        ACE_TCHAR *cmd_line_buf = options.command_line_buf (&maxlen);
        size_t max_len = static_cast<size_t> (maxlen);
        size_t curr_len = ACE_OS::strlen (cmd_line_buf);
        ACE_Handle_Set_Iterator h_iter (*set_p);
        // Because the length of the to-be-formatted +H option is not
        // known, and we don't have a snprintf, guess at the space
        // needed (20 chars), and use that as a limit.
        for (ACE_HANDLE h = h_iter ();
                h != ACE_INVALID_HANDLE && curr_len + 20 < max_len;
                h = h_iter ())
        {
#if defined (ACE_WIN32)
# if defined (ACE_WIN64)
            curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len],
                                         ACE_TEXT (" +H %I64p"),
                                         h);
# else
            curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len],
                                         ACE_TEXT (" +H %p"),
                                         h);
# endif  /* ACE_WIN64 */
#else
            curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len],
                                         ACE_TEXT (" +H %d"),
                                         h);
#endif /* ACE_WIN32 */
        }
    }

#if defined (ACE_HAS_WINCE)
    // Note that WinCE does not have process name included in the command line as argv[0]
    // like other OS environment.  Therefore, it is user's whole responsibility to call
    // 'ACE_Process_Options::process_name(const ACE_TCHAR *name)' to set the proper
    // process name (the execution file name with path if needed).
    BOOL fork_result =
        ACE_TEXT_CreateProcess (options.process_name(),
                                options.command_line_buf(),
                                options.get_process_attributes(),  // must be NULL in CE
                                options.get_thread_attributes(),   // must be NULL in CE
                                options.handle_inheritance(),      // must be false in CE
                                options.creation_flags(),          // must be NULL in CE
                                options.env_buf(),                 // environment variables, must be NULL in CE
                                options.working_directory(),       // must be NULL in CE
                                options.startup_info(),            // must be NULL in CE
                                &this->process_info_);

    if (fork_result)
    {
        parent (this->getpid ());
        return this->getpid ();
    }
    return ACE_INVALID_PID;

#elif defined (ACE_WIN32)
    void* env_buf = options.env_buf ();
    DWORD flags = options.creation_flags ();
# if defined (ACE_HAS_WCHAR) && !defined (ACE_USES_WCHAR)
    wchar_t* wenv_buf = 0;
    if (options.use_unicode_environment ())
    {
        wenv_buf = this->convert_env_buffer (options.env_buf ());
        env_buf = wenv_buf;
        flags |= CREATE_UNICODE_ENVIRONMENT;
    }
# endif

    BOOL fork_result =
        ACE_TEXT_CreateProcess (0,
                                options.command_line_buf (),
                                options.get_process_attributes (),
                                options.get_thread_attributes (),
                                options.handle_inheritance (),
//.........这里部分代码省略.........