summaryrefslogtreecommitdiff
path: root/libopie/oprocess.h
authorsandman <sandman>2002-12-17 19:12:05 (UTC)
committer sandman <sandman>2002-12-17 19:12:05 (UTC)
commitb6a03145553d7f536b04fc3355718cfdd72c590d (patch) (unidiff)
treecfadab49e69801a2000001f80d57ec081b2c5ea4 /libopie/oprocess.h
parent6bbe59222c6b439f2016d0a36a111f17d338d120 (diff)
downloadopie-b6a03145553d7f536b04fc3355718cfdd72c590d.zip
opie-b6a03145553d7f536b04fc3355718cfdd72c590d.tar.gz
opie-b6a03145553d7f536b04fc3355718cfdd72c590d.tar.bz2
- removed a the obsolete KShellProcess class
- added a few methods to OProcess to make it easier to port programs using QProcess
Diffstat (limited to 'libopie/oprocess.h') (more/less context) (ignore whitespace changes)
-rw-r--r--libopie/oprocess.h72
1 files changed, 7 insertions, 65 deletions
diff --git a/libopie/oprocess.h b/libopie/oprocess.h
index fd726b4..bf5fe0e 100644
--- a/libopie/oprocess.h
+++ b/libopie/oprocess.h
@@ -62,429 +62,433 @@ class OProcessPrivate;
62 *child process has already exited or not. 62 *child process has already exited or not.
63 * 63 *
64 *@li OProcess::NotifyOnExit -- The child process is invoked and both the 64 *@li OProcess::NotifyOnExit -- The child process is invoked and both the
65 *child and the parent process run concurrently. 65 *child and the parent process run concurrently.
66 * 66 *
67 *When the child process exits, the OProcess instance 67 *When the child process exits, the OProcess instance
68 *corresponding to it emits the Qt signal @ref processExited(). 68 *corresponding to it emits the Qt signal @ref processExited().
69 * 69 *
70 *Since this signal is @em not emitted from within a UN*X 70 *Since this signal is @em not emitted from within a UN*X
71 *signal handler, arbitrary function calls can be made. 71 *signal handler, arbitrary function calls can be made.
72 * 72 *
73 *Be aware: When the OProcess objects gets destructed, the child 73 *Be aware: When the OProcess objects gets destructed, the child
74 *process will be killed if it is still running! 74 *process will be killed if it is still running!
75 *This means in particular, that you cannot use a OProcess on the stack 75 *This means in particular, that you cannot use a OProcess on the stack
76 *with OProcess::NotifyOnExit. 76 *with OProcess::NotifyOnExit.
77 * 77 *
78 *@li OProcess::Block -- The child process starts and the parent process 78 *@li OProcess::Block -- The child process starts and the parent process
79 *is suspended until the child process exits. (@em Really not recommended 79 *is suspended until the child process exits. (@em Really not recommended
80 *for programs with a GUI.) 80 *for programs with a GUI.)
81 * 81 *
82 *OProcess also provides several functions for determining the exit status 82 *OProcess also provides several functions for determining the exit status
83 *and the pid of the child process it represents. 83 *and the pid of the child process it represents.
84 * 84 *
85 *Furthermore it is possible to supply command-line arguments to the process 85 *Furthermore it is possible to supply command-line arguments to the process
86 *in a clean fashion (no null -- terminated stringlists and such...) 86 *in a clean fashion (no null -- terminated stringlists and such...)
87 * 87 *
88 *A small usage example: 88 *A small usage example:
89 *<pre> 89 *<pre>
90 *OProcess *proc = new OProcess; 90 *OProcess *proc = new OProcess;
91 * 91 *
92 **proc << "my_executable"; 92 **proc << "my_executable";
93 **proc << "These" << "are" << "the" << "command" << "line" << "args"; 93 **proc << "These" << "are" << "the" << "command" << "line" << "args";
94 *QApplication::connect(proc, SIGNAL(processExited(OProcess *)), 94 *QApplication::connect(proc, SIGNAL(processExited(OProcess *)),
95 * pointer_to_my_object, SLOT(my_objects_slot(OProcess *))); 95 * pointer_to_my_object, SLOT(my_objects_slot(OProcess *)));
96 *proc->start(); 96 *proc->start();
97 *</pre> 97 *</pre>
98 * 98 *
99 *This will start "my_executable" with the commandline arguments "These"... 99 *This will start "my_executable" with the commandline arguments "These"...
100 * 100 *
101 *When the child process exits, the respective Qt signal will be emitted. 101 *When the child process exits, the respective Qt signal will be emitted.
102 * 102 *
103 *@sect Communication with the child process 103 *@sect Communication with the child process
104 * 104 *
105 *OProcess supports communication with the child process through 105 *OProcess supports communication with the child process through
106 *stdin/stdout/stderr. 106 *stdin/stdout/stderr.
107 * 107 *
108 *The following functions are provided for getting data from the child 108 *The following functions are provided for getting data from the child
109 *process or sending data to the child's stdin (For more information, 109 *process or sending data to the child's stdin (For more information,
110 *have a look at the documentation of each function): 110 *have a look at the documentation of each function):
111 * 111 *
112 *@li bool @ref writeStdin(char *buffer, int buflen); 112 *@li bool @ref writeStdin(char *buffer, int buflen);
113 *@li -- Transmit data to the child process's stdin. 113 *@li -- Transmit data to the child process's stdin.
114 * 114 *
115 *@li bool @ref closeStdin(); 115 *@li bool @ref closeStdin();
116 *@li -- Closes the child process's stdin (which causes it to see an feof(stdin)). 116 *@li -- Closes the child process's stdin (which causes it to see an feof(stdin)).
117 *Returns false if you try to close stdin for a process that has been started 117 *Returns false if you try to close stdin for a process that has been started
118 *without a communication channel to stdin. 118 *without a communication channel to stdin.
119 * 119 *
120 *@li bool @ref closeStdout(); 120 *@li bool @ref closeStdout();
121 *@li -- Closes the child process's stdout. 121 *@li -- Closes the child process's stdout.
122 *Returns false if you try to close stdout for a process that has been started 122 *Returns false if you try to close stdout for a process that has been started
123 *without a communication channel to stdout. 123 *without a communication channel to stdout.
124 * 124 *
125 *@li bool @ref closeStderr(); 125 *@li bool @ref closeStderr();
126 *@li -- Closes the child process's stderr. 126 *@li -- Closes the child process's stderr.
127 *Returns false if you try to close stderr for a process that has been started 127 *Returns false if you try to close stderr for a process that has been started
128 *without a communication channel to stderr. 128 *without a communication channel to stderr.
129 * 129 *
130 * 130 *
131 *@sect QT signals: 131 *@sect QT signals:
132 * 132 *
133 *@li void @ref receivedStdout(OProcess *proc, char *buffer, int buflen); 133 *@li void @ref receivedStdout(OProcess *proc, char *buffer, int buflen);
134 *@li void @ref receivedStderr(OProcess *proc, char *buffer, int buflen); 134 *@li void @ref receivedStderr(OProcess *proc, char *buffer, int buflen);
135 *@li -- Indicates that new data has arrived from either the 135 *@li -- Indicates that new data has arrived from either the
136 *child process's stdout or stderr. 136 *child process's stdout or stderr.
137 * 137 *
138 *@li void @ref wroteStdin(OProcess *proc); 138 *@li void @ref wroteStdin(OProcess *proc);
139 *@li -- Indicates that all data that has been sent to the child process 139 *@li -- Indicates that all data that has been sent to the child process
140 *by a prior call to @ref writeStdin() has actually been transmitted to the 140 *by a prior call to @ref writeStdin() has actually been transmitted to the
141 *client . 141 *client .
142 * 142 *
143 *@author Christian Czezakte e9025461@student.tuwien.ac.at 143 *@author Christian Czezakte e9025461@student.tuwien.ac.at
144 * 144 *
145 * 145 *
146 **/ 146 **/
147class OProcess : public QObject 147class OProcess : public QObject
148{ 148{
149 Q_OBJECT 149 Q_OBJECT
150 150
151public: 151public:
152 152
153 /** 153 /**
154 * Modes in which the communication channel can be opened. 154 * Modes in which the communication channel can be opened.
155 * 155 *
156 * If communication for more than one channel is required, 156 * If communication for more than one channel is required,
157 * the values have to be or'ed together, for example to get 157 * the values have to be or'ed together, for example to get
158 * communication with stdout as well as with stdin, you would 158 * communication with stdout as well as with stdin, you would
159 * specify @p Stdin @p | @p Stdout 159 * specify @p Stdin @p | @p Stdout
160 * 160 *
161 * If @p NoRead is specified in conjunction with @p Stdout, 161 * If @p NoRead is specified in conjunction with @p Stdout,
162 * no data is actually read from @p Stdout but only 162 * no data is actually read from @p Stdout but only
163 * the signal @ref childOutput(int fd) is emitted. 163 * the signal @ref childOutput(int fd) is emitted.
164 */ 164 */
165 enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4, 165 enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
166 AllOutput = 6, All = 7, 166 AllOutput = 6, All = 7,
167 NoRead }; 167 NoRead };
168 168
169 /** 169 /**
170 * Run-modes for a child process. 170 * Run-modes for a child process.
171 */ 171 */
172 enum RunMode { 172 enum RunMode {
173 /** 173 /**
174 * The application does not receive notifications from the subprocess when 174 * The application does not receive notifications from the subprocess when
175 * it is finished or aborted. 175 * it is finished or aborted.
176 */ 176 */
177 DontCare, 177 DontCare,
178 /** 178 /**
179 * The application is notified when the subprocess dies. 179 * The application is notified when the subprocess dies.
180 */ 180 */
181 NotifyOnExit, 181 NotifyOnExit,
182 /** 182 /**
183 * The application is suspended until the started process is finished. 183 * The application is suspended until the started process is finished.
184 */ 184 */
185 Block }; 185 Block };
186 186
187 /** 187 /**
188 * Constructor 188 * Constructor
189 */ 189 */
190 OProcess(); 190 OProcess(QObject *parent = 0, const char *name = 0);
191 OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
192 OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0);
191 193
192 /** 194 /**
193 *Destructor: 195 *Destructor:
194 * 196 *
195 * If the process is running when the destructor for this class 197 * If the process is running when the destructor for this class
196 * is called, the child process is killed with a SIGKILL, but 198 * is called, the child process is killed with a SIGKILL, but
197 * only if the run mode is not of type @p DontCare. 199 * only if the run mode is not of type @p DontCare.
198 * Processes started as @p DontCare keep running anyway. 200 * Processes started as @p DontCare keep running anyway.
199 */ 201 */
200 virtual ~OProcess(); 202 virtual ~OProcess();
201 203
202 /** 204 /**
203 @deprecated 205 @deprecated
204 206
205 The use of this function is now deprecated. -- Please use the 207 The use of this function is now deprecated. -- Please use the
206 "operator<<" instead of "setExecutable". 208 "operator<<" instead of "setExecutable".
207 209
208 Sets the executable to be started with this OProcess object. 210 Sets the executable to be started with this OProcess object.
209 Returns false if the process is currently running (in that 211 Returns false if the process is currently running (in that
210 case the executable remains unchanged.) 212 case the executable remains unchanged.)
211 213
212 @see operator<< 214 @see operator<<
213 215
214 */ 216 */
215 bool setExecutable(const QString& proc); 217 bool setExecutable(const QString& proc);
216 218
217 219
218 /** 220 /**
219 * Sets the executable and the command line argument list for this process. 221 * Sets the executable and the command line argument list for this process.
220 * 222 *
221 * For example, doing an "ls -l /usr/local/bin" can be achieved by: 223 * For example, doing an "ls -l /usr/local/bin" can be achieved by:
222 * <pre> 224 * <pre>
223 * OProcess p; 225 * OProcess p;
224 * ... 226 * ...
225 * p << "ls" << "-l" << "/usr/local/bin" 227 * p << "ls" << "-l" << "/usr/local/bin"
226 * </pre> 228 * </pre>
227 * 229 *
228 **/ 230 **/
229 OProcess &operator<<(const QString& arg); 231 OProcess &operator<<(const QString& arg);
230 /** 232 /**
231 * Similar to previous method, takes a char *, supposed to be in locale 8 bit already. 233 * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
232 */ 234 */
233 OProcess &operator<<(const char * arg); 235 OProcess &operator<<(const char * arg);
234 /** 236 /**
235 * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already. 237 * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
236 */ 238 */
237 OProcess &operator<<(const QCString & arg); 239 OProcess &operator<<(const QCString & arg);
238 240
239 /** 241 /**
240 * Sets the executable and the command line argument list for this process, 242 * Sets the executable and the command line argument list for this process,
241 * in a single method call, or add a list of arguments. 243 * in a single method call, or add a list of arguments.
242 **/ 244 **/
243 OProcess &operator<<(const QStringList& args); 245 OProcess &operator<<(const QStringList& args);
244 246
245 /** 247 /**
246 * Clear a command line argument list that has been set by using 248 * Clear a command line argument list that has been set by using
247 * the "operator<<". 249 * the "operator<<".
248 */ 250 */
249 void clearArguments(); 251 void clearArguments();
250 252
251 /** 253 /**
252 * Starts the process. 254 * Starts the process.
253 * For a detailed description of the 255 * For a detailed description of the
254 * various run modes and communication semantics, have a look at the 256 * various run modes and communication semantics, have a look at the
255 * general description of the OProcess class. 257 * general description of the OProcess class.
256 * 258 *
257 * The following problems could cause this function to 259 * The following problems could cause this function to
258 * return false: 260 * return false:
259 * 261 *
260 * @li The process is already running. 262 * @li The process is already running.
261 * @li The command line argument list is empty. 263 * @li The command line argument list is empty.
262 * @li The starting of the process failed (could not fork). 264 * @li The starting of the process failed (could not fork).
263 * @li The executable was not found. 265 * @li The executable was not found.
264 * 266 *
265 * @param comm Specifies which communication links should be 267 * @param comm Specifies which communication links should be
266 * established to the child process (stdin/stdout/stderr). By default, 268 * established to the child process (stdin/stdout/stderr). By default,
267 * no communication takes place and the respective communication 269 * no communication takes place and the respective communication
268 * signals will never get emitted. 270 * signals will never get emitted.
269 * 271 *
270 * @return true on success, false on error 272 * @return true on success, false on error
271 * (see above for error conditions) 273 * (see above for error conditions)
272 **/ 274 **/
273 virtual bool start(RunMode runmode = NotifyOnExit, 275 virtual bool start(RunMode runmode = NotifyOnExit,
274 Communication comm = NoCommunication); 276 Communication comm = NoCommunication);
275 277
276 /** 278 /**
277 * Stop the process (by sending it a signal). 279 * Stop the process (by sending it a signal).
278 * 280 *
279 * @param signoThe signal to send. The default is SIGTERM. 281 * @param signoThe signal to send. The default is SIGTERM.
280 * @return @p true if the signal was delivered successfully. 282 * @return @p true if the signal was delivered successfully.
281 */ 283 */
282 virtual bool kill(int signo = SIGTERM); 284 virtual bool kill(int signo = SIGTERM);
283 285
284 /** 286 /**
285 @return @p true if the process is (still) considered to be running 287 @return @p true if the process is (still) considered to be running
286 */ 288 */
287 bool isRunning() const; 289 bool isRunning() const;
288 290
289 /** Returns the process id of the process. 291 /** Returns the process id of the process.
290 * 292 *
291 * If it is called after 293 * If it is called after
292 * the process has exited, it returns the process id of the last 294 * the process has exited, it returns the process id of the last
293 * child process that was created by this instance of OProcess. 295 * child process that was created by this instance of OProcess.
294 * 296 *
295 * Calling it before any child process has been started by this 297 * Calling it before any child process has been started by this
296 * OProcess instance causes pid() to return 0. 298 * OProcess instance causes pid() to return 0.
297 **/ 299 **/
298 pid_t pid() const; 300 pid_t pid() const;
299 301
300 /** 302 /**
301 * Use pid(). 303 * Use pid().
302 * @deprecated 304 * @deprecated
303 */ 305 */
304 pid_t getPid() const { return pid(); } 306 pid_t getPid() const { return pid(); }
305 307
306 /** 308 /**
307 * Suspend processing of data from stdout of the child process. 309 * Suspend processing of data from stdout of the child process.
308 */ 310 */
309 void suspend(); 311 void suspend();
310 312
311 /** 313 /**
312 * Resume processing of data from stdout of the child process. 314 * Resume processing of data from stdout of the child process.
313 */ 315 */
314 void resume(); 316 void resume();
315 317
316 /** 318 /**
317 * @return @p true if the process has already finished and has exited 319 * @return @p true if the process has already finished and has exited
318 * "voluntarily", ie: it has not been killed by a signal. 320 * "voluntarily", ie: it has not been killed by a signal.
319 * 321 *
320 * Note that you should check @ref OProcess::exitStatus() to determine 322 * Note that you should check @ref OProcess::exitStatus() to determine
321 * whether the process completed its task successful or not. 323 * whether the process completed its task successful or not.
322 */ 324 */
323 bool normalExit() const; 325 bool normalExit() const;
324 326
325 /** 327 /**
326 * Returns the exit status of the process. 328 * Returns the exit status of the process.
327 * 329 *
328 * Please use 330 * Please use
329 * @ref OProcess::normalExit() to check whether the process has exited 331 * @ref OProcess::normalExit() to check whether the process has exited
330 * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling 332 * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
331 * this function because if the process did not exit normally, 333 * this function because if the process did not exit normally,
332 * it does not have a valid exit status. 334 * it does not have a valid exit status.
333 */ 335 */
334 int exitStatus() const; 336 int exitStatus() const;
335 337
336 338
337 /** 339 /**
338 * Transmit data to the child process's stdin. 340 * Transmit data to the child process's stdin.
339 * 341 *
340 * OProcess::writeStdin may return false in the following cases: 342 * OProcess::writeStdin may return false in the following cases:
341 * 343 *
342 * @li The process is not currently running. 344 * @li The process is not currently running.
343 * 345 *
344 * @li Communication to stdin has not been requested in the @ref start() call. 346 * @li Communication to stdin has not been requested in the @ref start() call.
345 * 347 *
346 * @li Transmission of data to the child process by a previous call to 348 * @li Transmission of data to the child process by a previous call to
347 * @ref writeStdin() is still in progress. 349 * @ref writeStdin() is still in progress.
348 * 350 *
349 * Please note that the data is sent to the client asynchronously, 351 * Please note that the data is sent to the client asynchronously,
350 * so when this function returns, the data might not have been 352 * so when this function returns, the data might not have been
351 * processed by the child process. 353 * processed by the child process.
352 * 354 *
353 * If all the data has been sent to the client, the signal 355 * If all the data has been sent to the client, the signal
354 * @ref wroteStdin() will be emitted. 356 * @ref wroteStdin() will be emitted.
355 * 357 *
356 * Please note that you must not free "buffer" or call @ref writeStdin() 358 * Please note that you must not free "buffer" or call @ref writeStdin()
357 * again until either a @ref wroteStdin() signal indicates that the 359 * again until either a @ref wroteStdin() signal indicates that the
358 * data has been sent or a @ref processHasExited() signal shows that 360 * data has been sent or a @ref processHasExited() signal shows that
359 * the child process is no longer alive... 361 * the child process is no longer alive...
360 **/ 362 **/
361 bool writeStdin(const char *buffer, int buflen); 363 bool writeStdin(const char *buffer, int buflen);
362 364
365 void flushStdin();
366
363 /** 367 /**
364 * This causes the stdin file descriptor of the child process to be 368 * This causes the stdin file descriptor of the child process to be
365 * closed indicating an "EOF" to the child. 369 * closed indicating an "EOF" to the child.
366 * 370 *
367 * @return @p false if no communication to the process's stdin 371 * @return @p false if no communication to the process's stdin
368 * had been specified in the call to @ref start(). 372 * had been specified in the call to @ref start().
369 */ 373 */
370 bool closeStdin(); 374 bool closeStdin();
371 375
372 /** 376 /**
373 * This causes the stdout file descriptor of the child process to be 377 * This causes the stdout file descriptor of the child process to be
374 * closed. 378 * closed.
375 * 379 *
376 * @return @p false if no communication to the process's stdout 380 * @return @p false if no communication to the process's stdout
377 * had been specified in the call to @ref start(). 381 * had been specified in the call to @ref start().
378 */ 382 */
379 bool closeStdout(); 383 bool closeStdout();
380 384
381 /** 385 /**
382 * This causes the stderr file descriptor of the child process to be 386 * This causes the stderr file descriptor of the child process to be
383 * closed. 387 * closed.
384 * 388 *
385 * @return @p false if no communication to the process's stderr 389 * @return @p false if no communication to the process's stderr
386 * had been specified in the call to @ref start(). 390 * had been specified in the call to @ref start().
387 */ 391 */
388 bool closeStderr(); 392 bool closeStderr();
389 393
390 /** 394 /**
391 * Lets you see what your arguments are for debugging. 395 * Lets you see what your arguments are for debugging.
392 */ 396 */
393 397
394 const QValueList<QCString> &args() { return arguments; } 398 const QValueList<QCString> &args() { return arguments; }
395 399
396 /** 400 /**
397 * Controls whether the started process should drop any 401 * Controls whether the started process should drop any
398 * setuid/segid privileges or whether it should keep them 402 * setuid/segid privileges or whether it should keep them
399 * 403 *
400 * The default is @p false : drop privileges 404 * The default is @p false : drop privileges
401 */ 405 */
402 void setRunPrivileged(bool keepPrivileges); 406 void setRunPrivileged(bool keepPrivileges);
403 407
404 /** 408 /**
405 * Returns whether the started process will drop any 409 * Returns whether the started process will drop any
406 * setuid/segid privileges or whether it will keep them 410 * setuid/segid privileges or whether it will keep them
407 */ 411 */
408 bool runPrivileged() const; 412 bool runPrivileged() const;
409 413
410 /** 414 /**
411 * Modifies the environment of the process to be started. 415 * Modifies the environment of the process to be started.
412 * This function must be called before starting the process. 416 * This function must be called before starting the process.
413 */ 417 */
414 void setEnvironment(const QString &name, const QString &value); 418 void setEnvironment(const QString &name, const QString &value);
415 419
416 /** 420 /**
417 * Changes the current working directory (CWD) of the process 421 * Changes the current working directory (CWD) of the process
418 * to be started. 422 * to be started.
419 * This function must be called before starting the process. 423 * This function must be called before starting the process.
420 */ 424 */
421 void setWorkingDirectory(const QString &dir); 425 void setWorkingDirectory(const QString &dir);
422 426
423 /** 427 /**
424 * Specify whether to start the command via a shell or directly. 428 * Specify whether to start the command via a shell or directly.
425 * The default is to start the command directly. 429 * The default is to start the command directly.
426 * If @p useShell is true @p shell will be used as shell, or 430 * If @p useShell is true @p shell will be used as shell, or
427 * if shell is empty, the standard shell is used. 431 * if shell is empty, the standard shell is used.
428 * @p quote A flag indicating whether to quote the arguments. 432 * @p quote A flag indicating whether to quote the arguments.
429 * 433 *
430 * When using a shell, the caller should make sure that all filenames etc. 434 * When using a shell, the caller should make sure that all filenames etc.
431 * are properly quoted when passed as argument. 435 * are properly quoted when passed as argument.
432 * @see quote() 436 * @see quote()
433 */ 437 */
434 void setUseShell(bool useShell, const char *shell = 0); 438 void setUseShell(bool useShell, const char *shell = 0);
435 439
436 /** 440 /**
437 * This function can be used to quote an argument string such that 441 * This function can be used to quote an argument string such that
438 * the shell processes it properly. This is e. g. necessary for 442 * the shell processes it properly. This is e. g. necessary for
439 * user-provided file names which may contain spaces or quotes. 443 * user-provided file names which may contain spaces or quotes.
440 * It also prevents expansion of wild cards and environment variables. 444 * It also prevents expansion of wild cards and environment variables.
441 */ 445 */
442 static QString quote(const QString &arg); 446 static QString quote(const QString &arg);
443 447
444 /** 448 /**
445 * Detaches OProcess from child process. All communication is closed. 449 * Detaches OProcess from child process. All communication is closed.
446 * No exit notification is emitted any more for the child process. 450 * No exit notification is emitted any more for the child process.
447 * Deleting the OProcess will no longer kill the child process. 451 * Deleting the OProcess will no longer kill the child process.
448 * Note that the current process remains the parent process of the 452 * Note that the current process remains the parent process of the
449 * child process. 453 * child process.
450 */ 454 */
451 void detach(); 455 void detach();
452 456
453 457
454 458
455signals: 459signals:
456 460
457 /** 461 /**
458 * Emitted after the process has terminated when 462 * Emitted after the process has terminated when
459 * the process was run in the @p NotifyOnExit (==default option to 463 * the process was run in the @p NotifyOnExit (==default option to
460 * @ref start()) or the @ref Block mode. 464 * @ref start()) or the @ref Block mode.
461 **/ 465 **/
462 void processExited(OProcess *proc); 466 void processExited(OProcess *proc);
463 467
464 468
465 /** 469 /**
466 * Emitted, when output from the child process has 470 * Emitted, when output from the child process has
467 * been received on stdout. 471 * been received on stdout.
468 * 472 *
469 * To actually get 473 * To actually get
470 * these signals, the respective communication link (stdout/stderr) 474 * these signals, the respective communication link (stdout/stderr)
471 * has to be turned on in @ref start(). 475 * has to be turned on in @ref start().
472 * 476 *
473 * @param buffer The data received. 477 * @param buffer The data received.
474 * @param buflen The number of bytes that are available. 478 * @param buflen The number of bytes that are available.
475 * 479 *
476 * You should copy the information contained in @p buffer to your private 480 * You should copy the information contained in @p buffer to your private
477 * data structures before returning from this slot. 481 * data structures before returning from this slot.
478 **/ 482 **/
479 void receivedStdout(OProcess *proc, char *buffer, int buflen); 483 void receivedStdout(OProcess *proc, char *buffer, int buflen);
480 484
481 /** 485 /**
482 * Emitted when output from the child process has 486 * Emitted when output from the child process has
483 * been received on stdout. 487 * been received on stdout.
484 * 488 *
485 * To actually get these signals, the respective communications link 489 * To actually get these signals, the respective communications link
486 * (stdout/stderr) has to be turned on in @ref start() and the 490 * (stdout/stderr) has to be turned on in @ref start() and the
487 * @p NoRead flag should have been passed. 491 * @p NoRead flag should have been passed.
488 * 492 *
489 * You will need to explicitly call resume() after your call to start() 493 * You will need to explicitly call resume() after your call to start()
490 * to begin processing data from the child process's stdout. This is 494 * to begin processing data from the child process's stdout. This is
@@ -606,200 +610,138 @@ protected:
606 -- frees all allocated communication resources in the parent 610 -- frees all allocated communication resources in the parent
607 after the process has exited 611 after the process has exited
608 */ 612 */
609 613
610 /** 614 /**
611 * This function is called from "OProcess::start" right before a "fork" takes 615 * This function is called from "OProcess::start" right before a "fork" takes
612 * place. According to 616 * place. According to
613 * the "comm" parameter this function has to initialize the "in", "out" and 617 * the "comm" parameter this function has to initialize the "in", "out" and
614 * "err" data member of OProcess. 618 * "err" data member of OProcess.
615 * 619 *
616 * This function should return 0 if setting the needed communication channels 620 * This function should return 0 if setting the needed communication channels
617 * was successful. 621 * was successful.
618 * 622 *
619 * The default implementation is to create UNIX STREAM sockets for the communication, 623 * The default implementation is to create UNIX STREAM sockets for the communication,
620 * but you could overload this function and establish a TCP/IP communication for 624 * but you could overload this function and establish a TCP/IP communication for
621 * network communication, for example. 625 * network communication, for example.
622 */ 626 */
623 virtual int setupCommunication(Communication comm); 627 virtual int setupCommunication(Communication comm);
624 628
625 /** 629 /**
626 * Called right after a (successful) fork on the parent side. This function 630 * Called right after a (successful) fork on the parent side. This function
627 * will usually do some communications cleanup, like closing the reading end 631 * will usually do some communications cleanup, like closing the reading end
628 * of the "stdin" communication channel. 632 * of the "stdin" communication channel.
629 * 633 *
630 * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and 634 * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and
631 * "errnot" and connect their Qt slots to the respective OProcess member functions. 635 * "errnot" and connect their Qt slots to the respective OProcess member functions.
632 * 636 *
633 * For a more detailed explanation, it is best to have a look at the default 637 * For a more detailed explanation, it is best to have a look at the default
634 * implementation of "setupCommunication" in kprocess.cpp. 638 * implementation of "setupCommunication" in kprocess.cpp.
635 */ 639 */
636 virtual int commSetupDoneP(); 640 virtual int commSetupDoneP();
637 641
638 /** 642 /**
639 * Called right after a (successful) fork, but before an "exec" on the child 643 * Called right after a (successful) fork, but before an "exec" on the child
640 * process' side. It usually just closes the unused communication ends of 644 * process' side. It usually just closes the unused communication ends of
641 * "in", "out" and "err" (like the writing end of the "in" communication 645 * "in", "out" and "err" (like the writing end of the "in" communication
642 * channel. 646 * channel.
643 */ 647 */
644 virtual int commSetupDoneC(); 648 virtual int commSetupDoneC();
645 649
646 650
647 /** 651 /**
648 * Immediately called after a process has exited. This function normally 652 * Immediately called after a process has exited. This function normally
649 * calls commClose to close all open communication channels to this 653 * calls commClose to close all open communication channels to this
650 * process and emits the "processExited" signal (if the process was 654 * process and emits the "processExited" signal (if the process was
651 * not running in the "DontCare" mode). 655 * not running in the "DontCare" mode).
652 */ 656 */
653 virtual void processHasExited(int state); 657 virtual void processHasExited(int state);
654 658
655 /** 659 /**
656 * Should clean up the communication links to the child after it has 660 * Should clean up the communication links to the child after it has
657 * exited. Should be called from "processHasExited". 661 * exited. Should be called from "processHasExited".
658 */ 662 */
659 virtual void commClose(); 663 virtual void commClose();
660 664
661 665
662 /** 666 /**
663 * the socket descriptors for stdin/stdout/stderr. 667 * the socket descriptors for stdin/stdout/stderr.
664 */ 668 */
665 int out[2]; 669 int out[2];
666 int in[2]; 670 int in[2];
667 int err[2]; 671 int err[2];
668 672
669 /** 673 /**
670 * The socket notifiers for the above socket descriptors. 674 * The socket notifiers for the above socket descriptors.
671 */ 675 */
672 QSocketNotifier *innot; 676 QSocketNotifier *innot;
673 QSocketNotifier *outnot; 677 QSocketNotifier *outnot;
674 QSocketNotifier *errnot; 678 QSocketNotifier *errnot;
675 679
676 /** 680 /**
677 * Lists the communication links that are activated for the child 681 * Lists the communication links that are activated for the child
678 * process. Should not be modified from derived classes. 682 * process. Should not be modified from derived classes.
679 */ 683 */
680 Communication communication; 684 Communication communication;
681 685
682 /** 686 /**
683 * Called by "slotChildOutput" this function copies data arriving from the 687 * Called by "slotChildOutput" this function copies data arriving from the
684 * child process's stdout to the respective buffer and emits the signal 688 * child process's stdout to the respective buffer and emits the signal
685 * "@ref receivedStderr". 689 * "@ref receivedStderr".
686 */ 690 */
687 int childOutput(int fdno); 691 int childOutput(int fdno);
688 692
689 /** 693 /**
690 * Called by "slotChildOutput" this function copies data arriving from the 694 * Called by "slotChildOutput" this function copies data arriving from the
691 * child process's stdout to the respective buffer and emits the signal 695 * child process's stdout to the respective buffer and emits the signal
692 * "@ref receivedStderr" 696 * "@ref receivedStderr"
693 */ 697 */
694 int childError(int fdno); 698 int childError(int fdno);
695 699
696 // information about the data that has to be sent to the child: 700 // information about the data that has to be sent to the child:
697 701
698 const char *input_data; // the buffer holding the data 702 const char *input_data; // the buffer holding the data
699 int input_sent; // # of bytes already transmitted 703 int input_sent; // # of bytes already transmitted
700 int input_total; // total length of input_data 704 int input_total; // total length of input_data
701 705
702 /** 706 /**
703 * @ref OProcessController is a friend of OProcess because it has to have 707 * @ref OProcessController is a friend of OProcess because it has to have
704 * access to various data members. 708 * access to various data members.
705 */ 709 */
706 friend class OProcessController; 710 friend class OProcessController;
707 711
708 712
709private: 713private:
710 /** 714 /**
711 * Searches for a valid shell. 715 * Searches for a valid shell.
712 * Here is the algorithm used for finding an executable shell: 716 * Here is the algorithm used for finding an executable shell:
713 * 717 *
714 * @li Try the executable pointed to by the "SHELL" environment 718 * @li Try the executable pointed to by the "SHELL" environment
715 * variable with white spaces stripped off 719 * variable with white spaces stripped off
716 * 720 *
717 * @li If your process runs with uid != euid or gid != egid, a shell 721 * @li If your process runs with uid != euid or gid != egid, a shell
718 * not listed in /etc/shells will not used. 722 * not listed in /etc/shells will not used.
719 * 723 *
720 * @li If no valid shell could be found, "/bin/sh" is used as a last resort. 724 * @li If no valid shell could be found, "/bin/sh" is used as a last resort.
721 */ 725 */
722 QCString searchShell(); 726 QCString searchShell();
723 727
724 /** 728 /**
725 * Used by @ref searchShell in order to find out whether the shell found 729 * Used by @ref searchShell in order to find out whether the shell found
726 * is actually executable at all. 730 * is actually executable at all.
727 */ 731 */
728 bool isExecutable(const QCString &filename); 732 bool isExecutable(const QCString &filename);
729 733
730 // Disallow assignment and copy-construction 734 // Disallow assignment and copy-construction
731 OProcess( const OProcess& ); 735 OProcess( const OProcess& );
732 OProcess& operator= ( const OProcess& ); 736 OProcess& operator= ( const OProcess& );
733 737
734protected:
735 virtual void virtual_hook( int id, void* data );
736private:
737 OProcessPrivate *d;
738};
739
740class KShellProcessPrivate;
741
742/**
743* @obsolete
744*
745* This class is obsolete. Use OProcess and OProcess::setUseShell(true)
746* instead.
747*
748* @short A class derived from @ref OProcess to start child
749 * processes through a shell.
750* @author Christian Czezakte <e9025461@student.tuwien.ac.at>
751* @version $Id$
752*/
753class KShellProcess: public OProcess
754{
755 Q_OBJECT
756
757public:
758
759 /**
760 * Constructor
761 *
762 * By specifying the name of a shell (like "/bin/bash") you can override
763 * the mechanism for finding a valid shell as described in OProcess::searchShell()
764 */
765 KShellProcess(const char *shellname=0);
766
767 /**
768 * Destructor.
769 */
770 ~KShellProcess();
771
772 /**
773 * Starts up the process. -- For a detailed description
774 * have a look at the "start" member function and the detailed
775 * description of @ref OProcess .
776 */
777 virtual bool start(RunMode runmode = NotifyOnExit,
778 Communication comm = NoCommunication);
779
780 /**
781 * This function can be used to quote an argument string such that
782 * the shell processes it properly. This is e. g. necessary for
783 * user-provided file names which may contain spaces or quotes.
784 * It also prevents expansion of wild cards and environment variables.
785 */
786 static QString quote(const QString &arg);
787
788private: 738private:
739 void init ( );
789 740
790 QCString shell; 741 OProcessPrivate *d;
791
792 // Disallow assignment and copy-construction
793 KShellProcess( const KShellProcess& );
794 KShellProcess& operator= ( const KShellProcess& );
795
796protected:
797 virtual void virtual_hook( int id, void* data );
798private:
799 KShellProcessPrivate *d;
800}; 742};
801 743
802 744
803 745
804#endif 746#endif
805 747