ACE: ACE_Process class Reference

Launch a new process as described by options. On success, returns 1 if the option avoid_zombies is set, else returns the process id of the newly spawned child. Returns -1 on failure. This will be fixed in the future versions of ACE when the process id of the child will be returned regardless of the option.
00075 {
00076   if (prepare (options) < 0)
00077     return ACE_INVALID_PID;
00078 
00079   // Stash the passed/duped handle sets away in this object for later
00080   // closing if needed or requested. At the same time, figure out which
00081   // ones to include in command line options if that's needed below.
00082   ACE_Handle_Set *set_p = 0;
00083   if (options.dup_handles (this->dup_handles_))
00084     set_p = &this->dup_handles_;
00085   else if (options.passed_handles (this->handles_passed_))
00086     set_p = &this->handles_passed_;
00087 
00088   // If we are going to end up running a new program (i.e. Win32, or
00089   // NO_EXEC option is set) then get any handles passed in the options,
00090   // and tack them onto the command line with +H <handle> options,
00091   // unless the command line runs out of space.
00092   // Note that we're using the knowledge that all the options, argvs, etc.
00093   // passed to the options are all sitting in the command_line_buf. Any
00094   // call to get the argv then splits them out. So, regardless of the
00095   // platform, tack them all onto the command line buf and take it
00096   // from there.
00097   if (set_p && !ACE_BIT_ENABLED (options.creation_flags (),
00098                                  ACE_Process_Options::NO_EXEC))
00099     {
00100       int maxlen = 0;
00101       ACE_TCHAR *cmd_line_buf = options.command_line_buf (&maxlen);
00102       size_t max_len = static_cast<size_t> (maxlen);
00103       size_t curr_len = ACE_OS::strlen (cmd_line_buf);
00104       ACE_Handle_Set_Iterator h_iter (*set_p);
00105       // Because the length of the to-be-formatted +H option is not
00106       // known, and we don't have a snprintf, guess at the space
00107       // needed (20 chars), and use that as a limit.
00108       for (ACE_HANDLE h = h_iter ();
00109            h != ACE_INVALID_HANDLE && curr_len + 20 < max_len;
00110            h = h_iter ())
00111         {
00112 #if defined (ACE_WIN64)
00113           curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len],
00114                                        ACE_LIB_TEXT (" +H %I64d"),
00115                                        h);
00116 #else
00117           curr_len += ACE_OS::sprintf (&cmd_line_buf[curr_len],
00118                                        ACE_LIB_TEXT (" +H %d"),
00119                                        h);
00120 #endif /* ACE_WIN64 */
00121         }
00122     }
00123 
00124 #if defined (ACE_HAS_WINCE)
00125   // Note that WinCE does not have process name included in the command line as argv[0]
00126   // like other OS environment.  Therefore, it is user's whole responsibility to call
00127   // 'ACE_Process_Options::process_name(const ACE_TCHAR *name)' to set the proper
00128   // process name (the execution file name with path if needed).
00129 
00130   BOOL fork_result =
00131     ACE_TEXT_CreateProcess (options.process_name(),
00132                             options.command_line_buf(),
00133                             options.get_process_attributes(),  // must be NULL in CE
00134                             options.get_thread_attributes(),   // must be NULL in CE
00135                             options.handle_inheritence(),      // must be false in CE
00136                             options.creation_flags(),          // must be NULL in CE
00137                             options.env_buf(),                 // environment variables, must be NULL in CE
00138                             options.working_directory(),       // must be NULL in CE
00139                             options.startup_info(),            // must be NULL in CE
00140                             &this->process_info_);
00141 
00142   if (fork_result)
00143     {
00144       parent (this->getpid ());
00145       return this->getpid ();
00146     }
00147   return ACE_INVALID_PID;
00148 
00149 #elif defined (ACE_WIN32)
00150   BOOL fork_result =
00151     ACE_TEXT_CreateProcess (0,
00152                             options.command_line_buf (),
00153                             options.get_process_attributes (),
00154                             options.get_thread_attributes (),
00155                             options.handle_inheritence (),
00156                             options.creation_flags (),
00157                             options.env_buf (), // environment variables
00158                             options.working_directory (),
00159                             options.startup_info (),
00160                             &this->process_info_);
00161 
00162   if (fork_result)
00163     {
00164       parent (this->getpid ());
00165       return this->getpid ();
00166     }
00167   return ACE_INVALID_PID;
00168 
00169 #elif defined(ACE_OPENVMS)
00170   if (ACE_BIT_ENABLED (options.creation_flags (),
00171                        ACE_Process_Options::NO_EXEC))
00172     ACE_NOTSUP_RETURN (ACE_INVALID_PID);
00173 
00174   int saved_stdin = ACE_STDIN;
00175   int saved_stdout = ACE_STDOUT;
00176   int saved_stderr = ACE_STDERR;
00177   // Save STD file descriptors and redirect
00178   if (options.get_stdin () != ACE_INVALID_HANDLE) {
00179     if ((saved_stdin = ACE_OS::dup (ACE_STDIN)) == -1 && errno != EBADF)
00180       ACE_OS::exit (errno);
00181     if (ACE_OS::dup2 (options.get_stdin (), ACE_STDIN) == -1)
00182       ACE_OS::exit (errno);
00183   }
00184   if (options.get_stdout () != ACE_INVALID_HANDLE) {
00185     if ((saved_stdout = ACE_OS::dup (ACE_STDOUT)) == -1 && errno != EBADF)
00186       ACE_OS::exit (errno);
00187     if (ACE_OS::dup2 (options.get_stdout (), ACE_STDOUT) == -1)
00188       ACE_OS::exit (errno);
00189   }
00190   if (options.get_stderr () != ACE_INVALID_HANDLE) {
00191     if ((saved_stderr = ACE_OS::dup (ACE_STDERR)) == -1 && errno != EBADF)
00192       ACE_OS::exit (errno);
00193     if (ACE_OS::dup2 (options.get_stderr (), ACE_STDERR) == -1)
00194       ACE_OS::exit (errno);
00195   }
00196 
00197   if (options.working_directory () != 0)
00198     ACE_NOTSUP_RETURN (ACE_INVALID_PID);
00199 
00200   this->child_id_ = vfork();
00201   if (this->child_id_ == 0) {
00202       ACE_OS::execvp (options.process_name (),
00203                 options.command_line_argv ());
00204       // something went wrong
00205       this->child_id_ = ACE_INVALID_PID;
00206   }
00207 
00208   // restore STD file descriptors (if necessary)
00209   if (options.get_stdin () != ACE_INVALID_HANDLE) {
00210     if (saved_stdin == -1)
00211       ACE_OS::close (ACE_STDIN);
00212     else
00213       ACE_OS::dup2 (saved_stdin, ACE_STDIN);
00214   }
00215   if (options.get_stdout () != ACE_INVALID_HANDLE) {
00216     if (saved_stdout == -1)
00217       ACE_OS::close (ACE_STDOUT);
00218     else
00219       ACE_OS::dup2 (saved_stdout, ACE_STDOUT);
00220   }
00221   if (options.get_stderr () != ACE_INVALID_HANDLE) {
00222     if (saved_stderr == -1)
00223       ACE_OS::close (ACE_STDERR);
00224     else
00225       ACE_OS::dup2 (saved_stderr, ACE_STDERR);
00226   }
00227 
00228   return this->child_id_;
00229 #elif (defined (ACE_VXWORKS) && (ACE_VXWORKS > 0x600)) && defined (__RTP__)
00230   if (ACE_BIT_ENABLED (options.creation_flags (),
00231                        ACE_Process_Options::NO_EXEC))
00232     ACE_NOTSUP_RETURN (ACE_INVALID_PID);
00233 
00234   if (options.working_directory () != 0)
00235     ACE_NOTSUP_RETURN (ACE_INVALID_PID);
00236 
00237   int saved_stdin = ACE_STDIN;
00238   int saved_stdout = ACE_STDOUT;
00239   int saved_stderr = ACE_STDERR;
00240   // Save STD file descriptors and redirect
00241   if (options.get_stdin () != ACE_INVALID_HANDLE) {
00242     if ((saved_stdin = ACE_OS::dup (ACE_STDIN)) == -1 && errno != EBADF)
00243       ACE_OS::exit (errno);
00244     if (ACE_OS::dup2 (options.get_stdin (), ACE_STDIN) == -1)
00245       ACE_OS::exit (errno);
00246   }
00247   if (options.get_stdout () != ACE_INVALID_HANDLE) {
00248     if ((saved_stdout = ACE_OS::dup (ACE_STDOUT)) == -1 && errno != EBADF)
00249       ACE_OS::exit (errno);
00250     if (ACE_OS::dup2 (options.get_stdout (), ACE_STDOUT) == -1)
00251       ACE_OS::exit (errno);
00252   }
00253   if (options.get_stderr () != ACE_INVALID_HANDLE) {
00254     if ((saved_stderr = ACE_OS::dup (ACE_STDERR)) == -1 && errno != EBADF)
00255       ACE_OS::exit (errno);
00256     if (ACE_OS::dup2 (options.get_stderr (), ACE_STDERR) == -1)
00257       ACE_OS::exit (errno);
00258   }
00259 
00260   // Wide-char builds need narrow-char strings for commandline and
00261   // environment variables.
00262 # if defined (ACE_USES_WCHAR)
00263   wchar_t * const *wargv = options.command_line_argv ();
00264   size_t vcount, i;
00265   for (vcount = 0; wargv[vcount] != 0; ++vcount)
00266     ;
00267   char **procargv = new char *[vcount + 1];  // Need 0 at the end
00268   procargv[vcount] = 0;
00269   for (i = 0; i < vcount; ++i)
00270     procargv[i] = ACE_Wide_To_Ascii::convert (wargv[i]);
00271 
00272   char **procenv = 0;
00273   if (options.inherit_environment ())
00274     {
00275       wargv = options.env_argv ();
00276       for (vcount = 0; wargv[vcount] != 0; ++vcount)
00277         ;
00278       procenv = new char *[vcount + 1];  // Need 0 at the end
00279       procenv[vcount] = 0;
00280       for (i = 0; i < vcount; ++i)
00281         procenv[i] = ACE_Wide_To_Ascii::convert (wargv[i]);
00282     }
00283 # else
00284   const char **procargv = const_cast<const char**> (options.command_line_argv ());
00285   const char **procenv = const_cast<const char**> (options.env_argv ());
00286 # endif /* ACE_USES_WCHAR */
00287 
00288   this->child_id_ = ::rtpSpawn (procargv[0],
00289                                 procargv,
00290                                 procenv,
00291                                 200,          // priority
00292                                 0x10000,      // uStackSize
00293                                 0,            // options
00294                                 VX_FP_TASK);  // taskOptions
00295   int my_errno_ = errno;
00296   if (this->child_id_ == ERROR) {
00297       // something went wrong
00298       this->child_id_ = ACE_INVALID_PID;
00299   }
00300 
00301 # if defined (ACE_USES_WCHAR)
00302   if (procenv)
00303     delete procenv;
00304 # endif /* ACE_USES_WCHAR */
00305 
00306   // restore STD file descriptors (if necessary)
00307   if (options.get_stdin () != ACE_INVALID_HANDLE) {
00308     if (saved_stdin == -1)
00309       ACE_OS::close (ACE_STDIN);
00310     else
00311       ACE_OS::dup2 (saved_stdin, ACE_STDIN);
00312   }
00313   if (options.get_stdout () != ACE_INVALID_HANDLE) {
00314     if (saved_stdout == -1)
00315       ACE_OS::close (ACE_STDOUT);
00316     else
00317       ACE_OS::dup2 (saved_stdout, ACE_STDOUT);
00318   }
00319   if (options.get_stderr () != ACE_INVALID_HANDLE) {
00320     if (saved_stderr == -1)
00321       ACE_OS::close (ACE_STDERR);
00322     else
00323       ACE_OS::dup2 (saved_stderr, ACE_STDERR);
00324   }
00325 
00326   if (this->child_id_ == ACE_INVALID_PID) {
00327     errno = my_errno_;
00328   }
00329 
00330   return this->child_id_;
00331 #else /* ACE_WIN32 */
00332   // Fork the new process.
00333   this->child_id_ = ACE::fork (options.process_name (),
00334                                options.avoid_zombies ());
00335 
00336   if (this->child_id_ == 0)
00337     {
00338 # if !defined (ACE_LACKS_SETPGID)
00339       // If we're the child and the options specified a non-default
00340       // process group, try to set our pgid to it.  This allows the
00341       // <ACE_Process_Manager> to wait for processes by their
00342       // process-group.
00343       if (options.getgroup () != ACE_INVALID_PID
00344           && ACE_OS::setpgid (0,
00345                               options.getgroup ()) < 0)
00346         ACE_ERROR ((LM_ERROR,
00347                     ACE_LIB_TEXT ("%p.\n"),
00348                     ACE_LIB_TEXT ("ACE_Process::spawn: setpgid failed.")));
00349 # endif /* ACE_LACKS_SETPGID */
00350 
00351 # if !defined (ACE_LACKS_SETREGID)
00352       if (options.getrgid () != (uid_t) -1
00353           || options.getegid () != (uid_t) -1)
00354         if (ACE_OS::setregid (options.getrgid (),
00355                               options.getegid ()) == -1)
00356           ACE_ERROR ((LM_ERROR,
00357                       ACE_LIB_TEXT ("%p.\n"),
00358                       ACE_LIB_TEXT ("ACE_Process::spawn: setregid failed.")));
00359 # endif /* ACE_LACKS_SETREGID */
00360 
00361 # if !defined (ACE_LACKS_SETREUID)
00362       // Set user and group id's.
00363       if (options.getruid () != (uid_t) -1
00364           || options.geteuid () != (uid_t) -1)
00365         if (ACE_OS::setreuid (options.getruid (),
00366                               options.geteuid ()) == -1)
00367           ACE_ERROR ((LM_ERROR,
00368                       ACE_LIB_TEXT ("%p.\n"),
00369                       ACE_LIB_TEXT ("ACE_Process::spawn: setreuid failed.")));
00370 # endif /* ACE_LACKS_SETREUID */
00371 
00372       this->child (ACE_OS::getppid ());
00373     }
00374   else if (this->child_id_ != -1)
00375     this->parent (this->child_id_);
00376 
00377   // If we're not supposed to exec, return the process id.
00378   if (ACE_BIT_ENABLED (options.creation_flags (),
00379                        ACE_Process_Options::NO_EXEC))
00380     return this->child_id_;
00381 
00382   switch (this->child_id_)
00383     {
00384     case -1:
00385       // Error.
00386       return ACE_INVALID_PID;
00387     case 0:
00388       // Child process...exec the
00389       {
00390         if (options.get_stdin () != ACE_INVALID_HANDLE
00391             && ACE_OS::dup2 (options.get_stdin (),
00392                              ACE_STDIN) == -1)
00393           ACE_OS::exit (errno);
00394         else if (options.get_stdout () != ACE_INVALID_HANDLE
00395                  && ACE_OS::dup2 (options.get_stdout (),
00396                                   ACE_STDOUT) == -1)
00397           ACE_OS::exit (errno);
00398         else if (options.get_stderr () != ACE_INVALID_HANDLE
00399                  && ACE_OS::dup2 (options.get_stderr (),
00400                                   ACE_STDERR) == -1)
00401           ACE_OS::exit (errno);
00402 
00403         // close down unneeded descriptors
00404         ACE_OS::close (options.get_stdin ());
00405         ACE_OS::close (options.get_stdout ());
00406         ACE_OS::close (options.get_stderr ());
00407 
00408         // If we must, set the working directory for the child
00409         // process.
00410         if (options.working_directory () != 0)
00411           ACE_OS::chdir (options.working_directory ());
00412         // Should check for error here!
00413 
00414         // Child process executes the command.
00415         int result = 0;
00416 
00417         // Wide-char builds not on Windows need narrow-char strings for
00418         // exec() and environment variables. Don't need to worry about
00419         // releasing any of the converted string memory since this
00420         // process will either exec() or exit() shortly.
00421 # if defined (ACE_USES_WCHAR)
00422         ACE_Wide_To_Ascii n_procname (options.process_name ());
00423         const char *procname = n_procname.char_rep ();
00424 
00425         wchar_t * const *wargv = options.command_line_argv ();
00426         size_t vcount, i;
00427         for (vcount = 0; wargv[vcount] != 0; ++vcount)
00428           ;
00429         char **procargv = new char *[vcount + 1];  // Need 0 at the end
00430         procargv[vcount] = 0;
00431         for (i = 0; i < vcount; ++i)
00432           procargv[i] = ACE_Wide_To_Ascii::convert (wargv[i]);
00433 
00434         wargv = options.env_argv ();
00435         for (vcount = 0; wargv[vcount] != 0; ++vcount)
00436           ;
00437         char **procenv = new char *[vcount + 1];  // Need 0 at the end
00438         procenv[vcount] = 0;
00439         for (i = 0; i < vcount; ++i)
00440           procenv[i] = ACE_Wide_To_Ascii::convert (wargv[i]);
00441 # else
00442         const char *procname = options.process_name ();
00443         char *const *procargv = options.command_line_argv ();
00444         char *const *procenv = options.env_argv ();
00445 # endif /* ACE_USES_WCHAR */
00446 
00447         if (options.inherit_environment ())
00448           {
00449             // Add the new environment variables to the environment
00450             // context of the context before doing an <execvp>.
00451             for (size_t i = 0; procenv[i] != 0; i++)
00452               if (ACE_OS::putenv (procenv[i]) != 0)
00453                 return ACE_INVALID_PID;
00454 
00455             // Now the forked process has both inherited variables and
00456             // the user's supplied variables.
00457             result = ACE_OS::execvp (procname, procargv);
00458           }
00459         else
00460           {
00461 # if defined (ghs)
00462             // GreenHills 1.8.8 (for VxWorks 5.3.x) can't compile this
00463             // code.  Processes aren't supported on VxWorks anyways.
00464             ACE_NOTSUP_RETURN (ACE_INVALID_PID);
00465 # else
00466             result = ACE_OS::execve (procname, procargv, procenv);
00467 # endif /* ghs */
00468           }
00469         if (result == -1)
00470           {
00471             // If the execv fails, this child needs to exit.
00472 
00473             // Exit with the errno so that the calling process can
00474             // catch this and figure out what went wrong.
00475             ACE_OS::_exit (errno);
00476           }
00477         // ... otherwise, this is never reached.
00478         return 0;
00479       }
00480     default:
00481       // Server process.  The fork succeeded.
00482       return this->child_id_;
00483     }
00484 #endif /* ACE_WIN32 */
00485 }

Public Member Functions
	ACE_Process (void)
	Default construction. Must use <ACE_Process::spawn> to start.
virtual	~ACE_Process (void)
	Destructor.
virtual int	prepare (ACE_Process_Options &options)
virtual pid_t	spawn (ACE_Process_Options &options)
virtual void	parent (pid_t child)
virtual void	child (pid_t parent)
virtual void	unmanage (void)
pid_t	wait (ACE_exitcode *status=0, int wait_options=0)
pid_t	wait (const ACE_Time_Value &tv, ACE_exitcode *status=0)
int	kill (int signum=SIGINT)
int	terminate (void)
pid_t	getpid (void) const
	Return the process id of the new child process.
ACE_HANDLE	gethandle (void) const
	Return the handle of the process, if it has one.
int	running (void) const
	Return 1 if running; 0 otherwise.
ACE_exitcode	exit_code (void) const
int	return_value (void) const
void	close_dup_handles (void)
void	close_passed_handles (void)
PROCESS_INFORMATION	process_info (void)
Protected Member Functions
void	exit_code (ACE_exitcode code)
Protected Attributes
PROCESS_INFORMATION	process_info_
ACE_exitcode	exit_code_
ACE_Handle_Set	handles_passed_
	Set of handles that were passed to the child process.
ACE_Handle_Set	dup_handles_
	Handle duplicates made for the child process.
Private Member Functions
	ACE_Process (const ACE_Process &)
void	operator= (const ACE_Process &)
Friends
class	ACE_Process_Manager
ACE_Process Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation
