ACE_Process(3)

ACE_Process (void);

Default construction. Must use ACE_Process::spawn to start.

virtual ~ACE_Process (void);

Destructor.

virtual int prepare (ACE_Process_Options &options);

Called just before ACE_OS::fork in the spawn. If this returns non-zero, the spawn is aborted (and returns ACE_INVALID_PID). The default simply returns zero.

virtual pid_t spawn (ACE_Process_Options &options);

Launch a new process as described by options. Returns the process id of the newly spawned child on success or -1 on failure.

virtual void parent (pid_t child);

Called just after ACE_OS::fork in the parent's context, if the fork succeeds. The default is to do nothing.

virtual void child (pid_t parent);

Called just after ACE_OS::fork in the child's context. The default does nothing. This function is *not* called on Win32 because the process-creation scheme does not allow it.

virtual void unmanage (void);

Called by a Process_Manager that is removing this Process from its table of managed Processes. Default is to do nothing.

pid_t wait (ACE_exitcode *status = 0, int wait_options = 0);

Wait for the process we've created to exit. If status != 0, it points to an integer where the function store the exit status of child process to. If wait_options == WNOHANG then return 0 and don't block if the child process hasn't exited yet. A return value of -1 represents the wait operation failed, otherwise, the child process id is returned.

pid_t wait (const ACE_Time_Value &tv, ACE_exitcode *status = 0);

Timed wait for the process we've created to exit. A return value of -1 indicates that the something failed; 0 indicates that a timeout occurred. Otherwise, the child's process id is returned. If status != 0, it points to an integer where the function stores the child's exit status.

NOTE: on UNIX platforms this function uses ualarm, i.e., it overwrites any existing alarm. In addition, it steals all SIGCHLDs during the timeout period, which will break another ACE_Process_Manager in the same process that's expecting SIGCHLD to kick off process reaping.

int kill (int signum = SIGINT);

Send the process a signal. This is only portable to operating systems that support signals, such as UNIX/POSIX.

int terminate (void);

Terminate the process abruptly using ACE::terminate_process. This call doesn't give the process a chance to cleanup, so use it with caution...

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.

int exit_code (void) const;

Return the Process' exit code

void exit_code (int code);

Set the Process' exit code (completely unrelated to whether the Process has actually exited)!

PROCESS_INFORMATION process_info (void);

PROCESS_INFORMATION process_info_;

pid_t child_id_;

Process id of the child.

int exit_code_;