| 1 | @c -*- mode: texinfo -*- |
| 2 | @deftypefn Extension {struct pex_obj *} pex_init (int @var{flags}, const char *@var{pname}, const char *@var{tempbase}) |
| 3 | |
| 4 | Prepare to execute one or more programs, with standard output of each |
| 5 | program fed to standard input of the next. This is a system |
| 6 | independent interface to execute a pipeline. |
| 7 | |
| 8 | @var{flags} is a bitwise combination of the following: |
| 9 | |
| 10 | @table @code |
| 11 | |
| 12 | @vindex PEX_RECORD_TIMES |
| 13 | @item PEX_RECORD_TIMES |
| 14 | Record subprocess times if possible. |
| 15 | |
| 16 | @vindex PEX_USE_PIPES |
| 17 | @item PEX_USE_PIPES |
| 18 | Use pipes for communication between processes, if possible. |
| 19 | |
| 20 | @vindex PEX_SAVE_TEMPS |
| 21 | @item PEX_SAVE_TEMPS |
| 22 | Don't delete temporary files used for communication between |
| 23 | processes. |
| 24 | |
| 25 | @end table |
| 26 | |
| 27 | @var{pname} is the name of program to be executed, used in error |
| 28 | messages. @var{tempbase} is a base name to use for any required |
| 29 | temporary files; it may be @code{NULL} to use a randomly chosen name. |
| 30 | |
| 31 | @end deftypefn |
| 32 | |
| 33 | @deftypefn Extension {const char *} pex_run (struct pex_obj *@var{obj}, int @var{flags}, const char *@var{executable}, char * const *@var{argv}, const char *@var{outname}, const char *@var{errname}, int *@var{err}) |
| 34 | |
| 35 | Execute one program in a pipeline. On success this returns |
| 36 | @code{NULL}. On failure it returns an error message, a statically |
| 37 | allocated string. |
| 38 | |
| 39 | @var{obj} is returned by a previous call to @code{pex_init}. |
| 40 | |
| 41 | @var{flags} is a bitwise combination of the following: |
| 42 | |
| 43 | @table @code |
| 44 | |
| 45 | @vindex PEX_LAST |
| 46 | @item PEX_LAST |
| 47 | This must be set on the last program in the pipeline. In particular, |
| 48 | it should be set when executing a single program. The standard output |
| 49 | of the program will be sent to @var{outname}, or, if @var{outname} is |
| 50 | @code{NULL}, to the standard output of the calling program. Do @emph{not} |
| 51 | set this bit if you want to call @code{pex_read_output} |
| 52 | (described below). After a call to @code{pex_run} with this bit set, |
| 53 | @var{pex_run} may no longer be called with the same @var{obj}. |
| 54 | |
| 55 | @vindex PEX_SEARCH |
| 56 | @item PEX_SEARCH |
| 57 | Search for the program using the user's executable search path. |
| 58 | |
| 59 | @vindex PEX_SUFFIX |
| 60 | @item PEX_SUFFIX |
| 61 | @var{outname} is a suffix. See the description of @var{outname}, |
| 62 | below. |
| 63 | |
| 64 | @vindex PEX_STDERR_TO_STDOUT |
| 65 | @item PEX_STDERR_TO_STDOUT |
| 66 | Send the program's standard error to standard output, if possible. |
| 67 | |
| 68 | @vindex PEX_BINARY_INPUT |
| 69 | @vindex PEX_BINARY_OUTPUT |
| 70 | @item PEX_BINARY_INPUT |
| 71 | @itemx PEX_BINARY_OUTPUT |
| 72 | The standard input (output) of the program should be read (written) in |
| 73 | binary mode rather than text mode. These flags are ignored on systems |
| 74 | which do not distinguish binary mode and text mode, such as Unix. For |
| 75 | proper behavior these flags should match appropriately---a call to |
| 76 | @code{pex_run} using @code{PEX_BINARY_OUTPUT} should be followed by a |
| 77 | call using @code{PEX_BINARY_INPUT}. |
| 78 | @end table |
| 79 | |
| 80 | @var{executable} is the program to execute. @var{argv} is the set of |
| 81 | arguments to pass to the program; normally @code{@var{argv}[0]} will |
| 82 | be a copy of @var{executable}. |
| 83 | |
| 84 | @var{outname} is used to set the name of the file to use for standard |
| 85 | output. There are two cases in which no output file will be used: |
| 86 | |
| 87 | @enumerate |
| 88 | @item |
| 89 | if @code{PEX_LAST} is not set in @var{flags}, and @code{PEX_USE_PIPES} |
| 90 | was set in the call to @code{pex_init}, and the system supports pipes |
| 91 | |
| 92 | @item |
| 93 | if @code{PEX_LAST} is set in @var{flags}, and @var{outname} is |
| 94 | @code{NULL} |
| 95 | @end enumerate |
| 96 | |
| 97 | @noindent |
| 98 | Otherwise the code will use a file to hold standard |
| 99 | output. If @code{PEX_LAST} is not set, this file is considered to be |
| 100 | a temporary file, and it will be removed when no longer needed, unless |
| 101 | @code{PEX_SAVE_TEMPS} was set in the call to @code{pex_init}. |
| 102 | |
| 103 | There are two cases to consider when setting the name of the file to |
| 104 | hold standard output. |
| 105 | |
| 106 | @enumerate |
| 107 | @item |
| 108 | @code{PEX_SUFFIX} is set in @var{flags}. In this case |
| 109 | @var{outname} may not be @code{NULL}. If the @var{tempbase} parameter |
| 110 | to @code{pex_init} was not @code{NULL}, then the output file name is |
| 111 | the concatenation of @var{tempbase} and @var{outname}. If |
| 112 | @var{tempbase} was @code{NULL}, then the output file name is a random |
| 113 | file name ending in @var{outname}. |
| 114 | |
| 115 | @item |
| 116 | @code{PEX_SUFFIX} was not set in @var{flags}. In this |
| 117 | case, if @var{outname} is not @code{NULL}, it is used as the output |
| 118 | file name. If @var{outname} is @code{NULL}, and @var{tempbase} was |
| 119 | not NULL, the output file name is randomly chosen using |
| 120 | @var{tempbase}. Otherwise the output file name is chosen completely |
| 121 | at random. |
| 122 | @end enumerate |
| 123 | |
| 124 | @var{errname} is the file name to use for standard error output. If |
| 125 | it is @code{NULL}, standard error is the same as the caller's. |
| 126 | Otherwise, standard error is written to the named file. |
| 127 | |
| 128 | On an error return, the code sets @code{*@var{err}} to an @code{errno} |
| 129 | value, or to 0 if there is no relevant @code{errno}. |
| 130 | |
| 131 | @end deftypefn |
| 132 | |
| 133 | @deftypefn Extension {const char *} pex_run_in_environment (struct pex_obj *@var{obj}, int @var{flags}, const char *@var{executable}, char * const *@var{argv}, char * const *@var{env}, int @var{env_size}, const char *@var{outname}, const char *@var{errname}, int *@var{err}) |
| 134 | |
| 135 | Execute one program in a pipeline, permitting the environment for the |
| 136 | program to be specified. Behaviour and parameters not listed below are |
| 137 | as for @code{pex_run}. |
| 138 | |
| 139 | @var{env} is the environment for the child process, specified as an array of |
| 140 | character pointers. Each element of the array should point to a string of the |
| 141 | form @code{VAR=VALUE}, with the exception of the last element that must be |
| 142 | @code{NULL}. |
| 143 | |
| 144 | @end deftypefn |
| 145 | |
| 146 | @deftypefn Extension {FILE *} pex_input_file (struct pex_obj *@var{obj}, int @var{flags}, const char *@var{in_name}) |
| 147 | |
| 148 | Return a stream for a temporary file to pass to the first program in |
| 149 | the pipeline as input. |
| 150 | |
| 151 | The name of the input file is chosen according to the same rules |
| 152 | @code{pex_run} uses to choose output file names, based on |
| 153 | @var{in_name}, @var{obj} and the @code{PEX_SUFFIX} bit in @var{flags}. |
| 154 | |
| 155 | Don't call @code{fclose} on the returned stream; the first call to |
| 156 | @code{pex_run} closes it automatically. |
| 157 | |
| 158 | If @var{flags} includes @code{PEX_BINARY_OUTPUT}, open the stream in |
| 159 | binary mode; otherwise, open it in the default mode. Including |
| 160 | @code{PEX_BINARY_OUTPUT} in @var{flags} has no effect on Unix. |
| 161 | @end deftypefn |
| 162 | |
| 163 | @deftypefn Extension {FILE *} pex_input_pipe (struct pex_obj *@var{obj}, int @var{binary}) |
| 164 | |
| 165 | Return a stream @var{fp} for a pipe connected to the standard input of |
| 166 | the first program in the pipeline; @var{fp} is opened for writing. |
| 167 | You must have passed @code{PEX_USE_PIPES} to the @code{pex_init} call |
| 168 | that returned @var{obj}. |
| 169 | |
| 170 | You must close @var{fp} using @code{fclose} yourself when you have |
| 171 | finished writing data to the pipeline. |
| 172 | |
| 173 | The file descriptor underlying @var{fp} is marked not to be inherited |
| 174 | by child processes. |
| 175 | |
| 176 | On systems that do not support pipes, this function returns |
| 177 | @code{NULL}, and sets @code{errno} to @code{EINVAL}. If you would |
| 178 | like to write code that is portable to all systems the @code{pex} |
| 179 | functions support, consider using @code{pex_input_file} instead. |
| 180 | |
| 181 | There are two opportunities for deadlock using |
| 182 | @code{pex_input_pipe}: |
| 183 | |
| 184 | @itemize @bullet |
| 185 | @item |
| 186 | Most systems' pipes can buffer only a fixed amount of data; a process |
| 187 | that writes to a full pipe blocks. Thus, if you write to @file{fp} |
| 188 | before starting the first process, you run the risk of blocking when |
| 189 | there is no child process yet to read the data and allow you to |
| 190 | continue. @code{pex_input_pipe} makes no promises about the |
| 191 | size of the pipe's buffer, so if you need to write any data at all |
| 192 | before starting the first process in the pipeline, consider using |
| 193 | @code{pex_input_file} instead. |
| 194 | |
| 195 | @item |
| 196 | Using @code{pex_input_pipe} and @code{pex_read_output} together |
| 197 | may also cause deadlock. If the output pipe fills up, so that each |
| 198 | program in the pipeline is waiting for the next to read more data, and |
| 199 | you fill the input pipe by writing more data to @var{fp}, then there |
| 200 | is no way to make progress: the only process that could read data from |
| 201 | the output pipe is you, but you are blocked on the input pipe. |
| 202 | |
| 203 | @end itemize |
| 204 | |
| 205 | @end deftypefn |
| 206 | |
| 207 | @deftypefn Extension {FILE *} pex_read_output (struct pex_obj *@var{obj}, int @var{binary}) |
| 208 | |
| 209 | Returns a @code{FILE} pointer which may be used to read the standard |
| 210 | output of the last program in the pipeline. When this is used, |
| 211 | @code{PEX_LAST} should not be used in a call to @code{pex_run}. After |
| 212 | this is called, @code{pex_run} may no longer be called with the same |
| 213 | @var{obj}. @var{binary} should be non-zero if the file should be |
| 214 | opened in binary mode. Don't call @code{fclose} on the returned file; |
| 215 | it will be closed by @code{pex_free}. |
| 216 | |
| 217 | @end deftypefn |
| 218 | |
| 219 | @deftypefn Extension int pex_get_status (struct pex_obj *@var{obj}, int @var{count}, int *@var{vector}) |
| 220 | |
| 221 | Returns the exit status of all programs run using @var{obj}. |
| 222 | @var{count} is the number of results expected. The results will be |
| 223 | placed into @var{vector}. The results are in the order of the calls |
| 224 | to @code{pex_run}. Returns 0 on error, 1 on success. |
| 225 | |
| 226 | @end deftypefn |
| 227 | |
| 228 | @deftypefn Extension int pex_get_times (struct pex_obj *@var{obj}, int @var{count}, struct pex_time *@var{vector}) |
| 229 | |
| 230 | Returns the process execution times of all programs run using |
| 231 | @var{obj}. @var{count} is the number of results expected. The |
| 232 | results will be placed into @var{vector}. The results are in the |
| 233 | order of the calls to @code{pex_run}. Returns 0 on error, 1 on |
| 234 | success. |
| 235 | |
| 236 | @code{struct pex_time} has the following fields of the type |
| 237 | @code{unsigned long}: @code{user_seconds}, |
| 238 | @code{user_microseconds}, @code{system_seconds}, |
| 239 | @code{system_microseconds}. On systems which do not support reporting |
| 240 | process times, all the fields will be set to @code{0}. |
| 241 | |
| 242 | @end deftypefn |
| 243 | |
| 244 | @deftypefn Extension void pex_free (struct pex_obj @var{obj}) |
| 245 | |
| 246 | Clean up and free all data associated with @var{obj}. |
| 247 | |
| 248 | @end deftypefn |
| 249 | |
| 250 | @deftypefn Extension {const char *} pex_one (int @var{flags}, const char *@var{executable}, char * const *@var{argv}, const char *@var{pname}, const char *@var{outname}, const char *@var{errname}, int *@var{status}, int *@var{err}) |
| 251 | |
| 252 | An interface to permit the easy execution of a |
| 253 | single program. The return value and most of the parameters are as |
| 254 | for a call to @code{pex_run}. @var{flags} is restricted to a |
| 255 | combination of @code{PEX_SEARCH}, @code{PEX_STDERR_TO_STDOUT}, and |
| 256 | @code{PEX_BINARY_OUTPUT}. @var{outname} is interpreted as if |
| 257 | @code{PEX_LAST} were set. On a successful return, @code{*@var{status}} will |
| 258 | be set to the exit status of the program. |
| 259 | |
| 260 | @end deftypefn |
| 261 | |
| 262 | @deftypefn Extension int pexecute (const char *@var{program}, char * const *@var{argv}, const char *@var{this_pname}, const char *@var{temp_base}, char **@var{errmsg_fmt}, char **@var{errmsg_arg}, int @var{flags}) |
| 263 | |
| 264 | This is the old interface to execute one or more programs. It is |
| 265 | still supported for compatibility purposes, but is no longer |
| 266 | documented. |
| 267 | |
| 268 | @end deftypefn |
| 269 | |
| 270 | @deftypefn Extension int pwait (int @var{pid}, int *@var{status}, int @var{flags}) |
| 271 | |
| 272 | Another part of the old execution interface. |
| 273 | |
| 274 | @end deftypefn |