Fix menu and cross refs.
[kopensolaris-gnu/glibc.git] / manual / startup.texi
1 @node Process Startup, Child Processes, Signal Handling, Top
2 @chapter Process Startup and Termination
3
4 @cindex process
5 @dfn{Processes} are the primitive units for allocation of system
6 resources.  Each process has its own address space and (usually) one
7 thread of control.  A process executes a program; you can have multiple
8 processes executing the same program, but each process has its own copy
9 of the program within its own address space and executes it
10 independently of the other copies.
11
12 This chapter explains what your program should do to handle the startup
13 of a process, to terminate its process, and to receive information
14 (arguments and the environment) from the parent process.
15
16 @menu
17 * Program Arguments::           Parsing your program's command-line arguments.
18 * Environment Variables::       How to access parameters inherited from
19                                  a parent process.
20 * Program Termination::         How to cause a process to terminate and
21                                  return status information to its parent.
22 @end menu
23
24 @node Program Arguments
25 @section Program Arguments
26 @cindex program arguments
27 @cindex command line arguments
28
29 @cindex @code{main} function
30 The system starts a C program by calling the function @code{main}.  It
31 is up to you to write a function named @code{main}---otherwise, you
32 won't even be able to link your program without errors.
33
34 You can define @code{main} either to take no arguments, or to take two
35 arguments that represent the command line arguments to the program, like
36 this:
37
38 @example
39 int main (int @var{argc}, char *@var{argv}[])
40 @end example
41
42 @cindex argc (program argument count)
43 @cindex argv (program argument vector)
44 The command line arguments are the whitespace-separated tokens given in
45 the shell command used to invoke the program; thus, in @samp{cat foo
46 bar}, the arguments are @samp{foo} and @samp{bar}.  The only way a
47 program can look at its command line arguments is via the arguments of
48 @code{main}.  If @code{main} doesn't take arguments, then you cannot get
49 at the command line.
50
51 The value of the @var{argc} argument is the number of command line
52 arguments.  The @var{argv} argument is a vector of C strings; its
53 elements are the individual command line argument strings.  The file
54 name of the program being run is also included in the vector as the
55 first element; the value of @var{argc} counts this element.  A null
56 pointer always follows the last element: @code{@var{argv}[@var{argc}]}
57 is this null pointer.
58
59 For the command @samp{cat foo bar}, @var{argc} is 3 and @var{argv} has
60 three elements, @code{"cat"}, @code{"foo"} and @code{"bar"}.
61
62 If the syntax for the command line arguments to your program is simple
63 enough, you can simply pick the arguments off from @var{argv} by hand.
64 But unless your program takes a fixed number of arguments, or all of the
65 arguments are interpreted in the same way (as file names, for example),
66 you are usually better off using @code{getopt} to do the parsing.
67
68 @menu
69 * Argument Syntax::       By convention, options start with a hyphen.
70 * Parsing Options::       The @code{getopt} function.
71 * Example of Getopt::     An example of parsing options with @code{getopt}.
72 * Long Options::          GNU suggests utilities accept long-named options.
73                            Here is how to do that.
74 * Long Option Example::   An example of using @code{getopt_long}.
75 @end menu
76
77 @node Argument Syntax
78 @subsection Program Argument Syntax Conventions
79 @cindex program argument syntax
80 @cindex syntax, for program arguments
81 @cindex command argument syntax
82
83 POSIX recommends these conventions for command line arguments.
84 @code{getopt} (@pxref{Parsing Options}) makes it easy to implement them.
85
86 @itemize @bullet
87 @item
88 Arguments are options if they begin with a hyphen delimiter (@samp{-}).
89
90 @item
91 Multiple options may follow a hyphen delimiter in a single token if
92 the options do not take arguments.  Thus, @samp{-abc} is equivalent to
93 @samp{-a -b -c}.
94
95 @item
96 Option names are single alphanumeric characters (as for @code{isalnum};
97 see @ref{Classification of Characters}).
98
99 @item
100 Certain options require an argument.  For example, the @samp{-o} command
101 of the @code{ld} command requires an argument---an output file name.
102
103 @item
104 An option and its argument may or may appear as separate tokens.  (In
105 other words, the whitespace separating them is optional.)  Thus,
106 @samp{-o foo} and @samp{-ofoo} are equivalent.
107
108 @item
109 Options typically precede other non-option arguments.
110
111 The implementation of @code{getopt} in the GNU C library normally makes
112 it appear as if all the option arguments were specified before all the
113 non-option arguments for the purposes of parsing, even if the user of
114 your program intermixed option and non-option arguments.  It does this
115 by reordering the elements of the @var{argv} array.  This behavior is
116 nonstandard; if you want to suppress it, define the
117 @code{_POSIX_OPTION_ORDER} environment variable.  @xref{Standard
118 Environment}.
119
120 @item
121 The argument @samp{--} terminates all options; any following arguments
122 are treated as non-option arguments, even if they begin with a hyphen.
123
124 @item
125 A token consisting of a single hyphen character is interpreted as an
126 ordinary non-option argument.  By convention, it is used to specify
127 input from or output to the standard input and output streams.
128
129 @item
130 Options may be supplied in any order, or appear multiple times.  The
131 interpretation is left up to the particular application program.
132 @end itemize
133
134 @cindex long-named options
135 GNU adds @dfn{long options} to these conventions.  Long options consist
136 of @samp{--} followed by a name made of alphanumeric characters.  Option
137 names are typically one to three words long, with hyphens to separate
138 words.  Users can abbreviate the option names as long as the
139 abbreviations are unique.
140
141 To specify an argument for a long option, write
142 @samp{--@var{name}=@var{value}}.  This syntax enables a long option to
143 accept an argument that is itself optional.
144
145 Eventually, the GNU system will provide completion for long option names
146 in the shell.
147
148 @node Parsing Options
149 @subsection Parsing Program Options
150 @cindex program arguments, parsing
151 @cindex command arguments, parsing
152 @cindex parsing program arguments
153
154 Here are the details about how to call the @code{getopt} function.  To
155 use this facility, your program must include the header file
156 @file{unistd.h}.
157 @pindex unistd.h
158
159 @comment unistd.h
160 @comment POSIX.2
161 @deftypevar int opterr
162 If the value of this variable is nonzero, then @code{getopt} prints an
163 error message to the standard error stream if it encounters an unknown
164 option character or an option with a missing required argument.  This is
165 the default behavior.  If you set this variable to zero, @code{getopt}
166 does not print any messages, but it still returns @code{?} to indicate
167 an error.
168 @end deftypevar
169
170 @comment unistd.h
171 @comment POSIX.2
172 @deftypevar int optopt
173 When @code{getopt} encounters an unknown option character or an option
174 with a missing required argument, it stores that option character in
175 this variable.  You can use this for providing your own diagnostic
176 messages.
177 @end deftypevar
178
179 @comment unistd.h
180 @comment POSIX.2
181 @deftypevar int optind
182 This variable is set by @code{getopt} to the index of the next element
183 of the @var{argv} array to be processed.  Once @code{getopt} has found
184 all of the option arguments, you can use this variable to determine
185 where the remaining non-option arguments begin.  The initial value of
186 this variable is @code{1}.
187 @end deftypevar
188
189 @comment unistd.h
190 @comment POSIX.2
191 @deftypevar {char *} optarg
192 This variable is set by @code{getopt} to point at the value of the
193 option argument, for those options that accept arguments.
194 @end deftypevar
195
196 @comment unistd.h
197 @comment POSIX.2
198 @deftypefun int getopt (int @var{argc}, char **@var{argv}, const char *@var{options})
199 The @code{getopt} function gets the next option argument from the
200 argument list specified by the @var{argv} and @var{argc} arguments.
201 Normally these values come directly from the arguments received by
202 @code{main}.
203
204 The @var{options} argument is a string that specifies the option
205 characters that are valid for this program.  An option character in this
206 string can be followed by a colon (@samp{:}) to indicate that it takes a
207 required argument.
208
209 If the @var{options} argument string begins with a hyphen (@samp{-}), this
210 is treated specially.  It permits arguments without an option to be
211 returned as if they were associated with option character @samp{\0}.
212
213 The @code{getopt} function returns the option character for the next
214 command line option.  When no more option arguments are available, it
215 returns @code{-1}.  There may still be more non-option arguments; you
216 must compare the external variable @code{optind} against the @var{argv}
217 parameter to check this.
218
219 If the options has an argument, @code{getopt} returns the argument by
220 storing it in the varables @var{optarg}.  You don't ordinarily need to
221 copy the @code{optarg} string, since it is a pointer into the original
222 @var{argv} array, not into a static area that might be overwritten.
223
224 If @code{getopt} finds an option character in @var{argv} that was not
225 included in @var{options}, or a missing option argument, it returns
226 @samp{?} and sets the external variable @code{optopt} to the actual
227 option character.  In addition, if the external variable @code{opterr}
228 is nonzero, @code{getopt} prints an error message.
229 @end deftypefun
230
231 @node Example of Getopt
232 @subsection Example of Parsing Arguments with @code{getopt}
233
234 Here is an example showing how @code{getopt} is typically used.  The
235 key points to notice are:
236
237 @itemize @bullet
238 @item
239 Normally, @code{getopt} is called in a loop.  When @code{getopt} returns
240 @code{-1}, indicating no more options are present, the loop terminates.
241
242 @item
243 A @code{switch} statement is used to dispatch on the return value from
244 @code{getopt}.  In typical use, each case just sets a variable that
245 is used later in the program.
246
247 @item
248 A second loop is used to process the remaining non-option arguments.
249 @end itemize
250
251 @example
252 @include testopt.c.texi
253 @end example
254
255 Here are some examples showing what this program prints with different
256 combinations of arguments:
257
258 @example
259 % testopt
260 aflag = 0, bflag = 0, cvalue = (null)
261
262 % testopt -a -b
263 aflag = 1, bflag = 1, cvalue = (null)
264
265 % testopt -ab
266 aflag = 1, bflag = 1, cvalue = (null)
267
268 % testopt -c foo
269 aflag = 0, bflag = 0, cvalue = foo
270
271 % testopt -cfoo
272 aflag = 0, bflag = 0, cvalue = foo
273
274 % testopt arg1
275 aflag = 0, bflag = 0, cvalue = (null)
276 Non-option argument arg1
277
278 % testopt -a arg1
279 aflag = 1, bflag = 0, cvalue = (null)
280 Non-option argument arg1
281
282 % testopt -c foo arg1
283 aflag = 0, bflag = 0, cvalue = foo
284 Non-option argument arg1
285
286 % testopt -a -- -b
287 aflag = 1, bflag = 0, cvalue = (null)
288 Non-option argument -b
289
290 % testopt -a -
291 aflag = 1, bflag = 0, cvalue = (null)
292 Non-option argument -
293 @end example
294
295 @node Long Options
296 @subsection Parsing Long Options
297
298 To accept GNU-style long options as well as single-character options,
299 use the function @code{getopt_long} instead of @code{getopt}.  You
300 should do this in every program that uses options, for it takes little
301 extra work and helps beginners remember how to use the program.
302
303 @comment getopt.h
304 @comment GNU
305 @deftp {Data Type} {struct option}
306 This structure describes a single long option name for the sake of
307 @code{getopt_long}.  The argument @var{longopts} must be an array of
308 these structures, one for each long option.  Terminate the array with an
309 element containing all zeros.
310
311 The @code{struct option} structure has these fields:
312
313 @table @code
314 @item name
315 This field is the name of the option.  It is a string.
316
317 @item has_arg
318 This field says whether the option takes an argument.  It is an integer,
319 and there are three legitimate values: @code{no_argument},
320 @code{required_argument} and @code{optional_argument}.
321
322 @item flag
323 @itemx val
324 These fields control how to report or act on the option when it occurs.
325
326 If @code{flag} is zero, then the @code{val} is a value which identifies
327 this option.  Often these values are chosen to uniquely identify
328 particular long options.
329
330 If @code{flag} is nonzero, it should be the address of an @code{int}
331 variable which is the flag for this option.  The value in @code{val} is
332 the value to store in the flag to indicate that the option was seen.
333 @end table
334 @end deftp
335
336 @comment getopt.h
337 @comment GNU
338 @deftypefun int getopt_long (int @var{argc}, char **@var{argv}, const char *@var{short}, struct option *@var{long}, int *@var{indexptr})
339 Decode options from the vector @var{argv} (whose length is @var{argc}).
340 The argument @var{short} describes the short options to accept, just as
341 it does in @code{getopt}.  The argument @var{long} describes the long
342 options to accept (see above).
343
344 When @code{getopt_long} encounters a short option, it does the same
345 thing that @code{getopt} would do: it returns the character code for the
346 option, and stores the options argument (if it has one) in @code{optarg}.
347
348 When @code{getopt_long} encounters a long option, it takes actions based
349 on the @code{flag} and @code{val} fields of the definition of that
350 option.
351
352 If @code{flag} is zero, then @code{getopt_long} returns the contents of
353 @code{val} to indicate which option it found.  You should arrange
354 distinct values in the @code{val} field for options with different
355 meanings, so you can decode these values after @code{getopt_long}
356 returns.  If the long option is equivalent to a short option, you can
357 use the short option's character code in @code{val}.
358
359 If @code{flag} is nonzero, that means this option should just set a flag
360 in the program.  The flag is a variable of type @code{int} that you
361 define.  Put the address of the flag in the @code{flag} field.  Put in
362 the @code{val} field the value you would like this option to store in
363 the flag.  In this case, @code{getopt_long} returns @code{0}.
364
365 For any long option, @code{getopt_long} tells you the index in the array
366 @var{long} of the options definition, by storing it into
367 @code{*@var{indexptr}}.  You can get the name of the option with
368 @code{@var{long}[*@var{indexptr}].name}.  So you can distinguish among
369 long options either by the values in their @code{val} fields or by their
370 indices.  You can also distinguish in this way among long options that
371 set flags.
372
373 When a long option has an argument, @code{getopt_long} puts the argument
374 value in the variable @code{optarg} before returning.  When the option
375 has no argument, the value in @code{optarg} is @code{0}.  This is how
376 you can tell whether an optional argument was supplied.
377
378 When @code{getopt_long} has no more options to handle, it returns
379 @code{-1}, and leaves in the variable @code{optind} the index in
380 @var{argv} of the next remaining argument.
381 @end deftypefun
382
383 @node Long Option Example
384 @subsection Example of Parsing Long Options
385
386 @example
387 @include longopt.c.texi
388 @end example
389
390 @node Environment Variables
391 @section Environment Variables
392
393 @cindex environment variable
394 When a program is executed, it receives information about the context in
395 which it was invoked in two ways.  The first mechanism uses the
396 @var{argv} and @var{argc} arguments to its @code{main} function, and is
397 discussed in @ref{Program Arguments}.  The second mechanism is
398 uses @dfn{environment variables} and is discussed in this section.
399
400 The @var{argv} mechanism is typically used to pass command-line
401 arguments specific to the particular program being invoked.  The
402 environment, on the other hand, keeps track of information that is
403 shared by many programs, changes infrequently, and that is less
404 frequently accessed.
405
406 The environment variables discussed in this section are the same
407 environment variables that you set using assignments and the
408 @code{export} command in the shell.  Programs executed from the shell
409 inherit all of the environment variables from the shell.
410
411 @cindex environment
412 Standard environment variables are used for information about the user's
413 home directory, terminal type, current locale, and so on; you can define
414 additional variables for other purposes.  The set of all environment
415 variables that have values is collectively known as the
416 @dfn{environment}.
417
418 Names of environment variables are case-sensitive and must not contain
419 the character @samp{=}.  System-defined environment variables are
420 invariably uppercase.
421
422 The values of environment variables can be anything that can be
423 represented as a string.  A value must not contain an embedded null
424 character, since this is assumed to terminate the string.
425
426
427 @menu
428 * Environment Access::    How to get and set the values of
429                            environment variables.
430 * Standard Environment::  These environment variables have
431                            standard interpretations.
432 @end menu
433
434 @node Environment Access
435 @subsection Environment Access
436 @cindex environment access
437 @cindex environment representation
438
439 The value of an environment variable can be accessed with the
440 @code{getenv} function.  This is declared in the header file
441 @file{stdlib.h}.
442 @pindex stdlib.h
443
444 @comment stdlib.h
445 @comment ANSI
446 @deftypefun {char *} getenv (const char *@var{name})
447 This function returns a string that is the value of the environment
448 variable @var{name}.  You must not modify this string.  In some systems
449 not using the GNU library, it might be overwritten by subsequent calls
450 to @code{getenv} (but not by any other library function).  If the
451 environment variable @var{name} is not defined, the value is a null
452 pointer.
453 @end deftypefun
454
455
456 @comment stdlib.h
457 @comment SVID
458 @deftypefun int putenv (const char *@var{string})
459 The @code{putenv} function adds or removes definitions from the environment.
460 If the @var{string} is of the form @samp{@var{name}=@var{value}}, the
461 definition is added to the environment.  Otherwise, the @var{string} is
462 interpreted as the name of an environment variable, and any definition
463 for this variable in the environment is removed.
464
465 The GNU library provides this function for compatibility with SVID; it
466 may not be available in other systems.
467 @end deftypefun
468
469 You can deal directly with the underlying representation of environment
470 objects to add more variables to the environment (for example, to
471 communicate with another program you are about to execute; see
472 @ref{Executing a File}).  
473
474 @comment unistd.h
475 @comment POSIX.1
476 @deftypevar {char **} environ
477 The environment is represented as an array of strings.  Each string is
478 of the format @samp{@var{name}=@var{value}}.  The order in which
479 strings appear in the environment is not significant, but the same
480 @var{name} must not appear more than once.  The last element of the
481 array is a null pointer.
482
483 This variable is not declared in any header file, but if you declare it
484 in your own program as @code{extern}, the right thing will happen.
485
486 If you just want to get the value of an environment variable, use
487 @code{getenv}.
488 @end deftypevar
489
490 @node Standard Environment
491 @subsection Standard Environment Variables
492 @cindex standard environment variables
493
494 These environment variables have standard meanings.  This doesn't mean
495 that they are always present in the environment; but if these variables
496 @emph{are} present, they have these meanings, and that you shouldn't try
497 to use these environment variable names for some other purpose.
498
499 @table @code
500 @item HOME
501 @cindex HOME environment variable
502 @cindex home directory
503 This is a string representing the user's @dfn{home directory}, or
504 initial default working directory.
505
506 The user can set @code{HOME} to any value.
507 If you need to make sure to obtain the proper home directory
508 for a particular user, you should not use @code{HOME}; instead,
509 look up the user's name in the user database (@pxref{User Database}).
510
511 For most purposes, it is better to use @code{HOME}, precisely because
512 this lets the user specify the value.
513
514 @item LOGNAME
515 @cindex LOGNAME environment variable
516 This is the name that the user used to log in.  Since the value in the
517 environment can be tweaked arbitrarily, this is not a reliable way to
518 identify the user who is running a process; a function like
519 @code{getlogin} (@pxref{Who Logged In}) is better for that purpose.
520
521 For most purposes, it is better to use @code{LOGNAME}, precisely because
522 this lets the user specify the value.
523
524 @item PATH
525 @cindex PATH environment variable
526 A @dfn{path} is a sequence of directory names which is used for
527 searching for a file.  The variable @var{PATH} holds a path used
528 for searching for programs to be run.
529
530 The @code{execlp} and @code{execvp} functions (@pxref{Executing a File})
531 use this environment variable, as do many shells and other utilities
532 which are implemented in terms of those functions.
533
534 The syntax of a path is a sequence of directory names separated by
535 colons.  An empty string instead of a directory name stands for the 
536 current directory (@pxref{Working Directory}).
537
538 A typical value for this environment variable might be a string like:
539
540 @example
541 .:/bin:/etc:/usr/bin:/usr/new/X11:/usr/new:/usr/local:/usr/local/bin
542 @end example
543
544 This means that if the user tries to execute a program named @code{foo},
545 the system will look for files named @file{./foo}, @file{/bin/foo},
546 @file{/etc/foo}, and so on.  The first of these files that exists is
547 the one that is executed.
548
549 @item TERM
550 @cindex TERM environment variable
551 This specifies the kind of terminal that is receiving program output.
552 Some programs can make use of this information to take advantage of
553 special escape sequences or terminal modes supported by particular kinds
554 of terminals.  Many programs which use the termcap library
555 (@pxref{Finding a Terminal Description,Find,,termcap,The Termcap Library
556 Manual}) use the @code{TERM} environment variable, for example.
557
558 @item TZ
559 @cindex TZ environment variable
560 This specifies the time zone.  @xref{TZ Variable}, for information about
561 the format of this string and how it is used.
562
563 @item LANG
564 @cindex LANG environment variable
565 This specifies the default locale to use for attribute categories where
566 neither @code{LC_ALL} nor the specific environment variable for that
567 category is set.  @xref{Locales}, for more information about
568 locales.
569
570 @ignore
571 @c I doubt this really exists
572 @item LC_ALL
573 @cindex LC_ALL environment variable
574 This is similar to the @code{LANG} environment variable.  However, its
575 value takes precedence over any values provided for the individual
576 attribute category environment variables, or for the @code{LANG}
577 environment variable.
578 @end ignore
579
580 @item LC_COLLATE
581 @cindex LC_COLLATE environment variable
582 This specifies what locale to use for string sorting.
583
584 @item LC_CTYPE
585 @cindex LC_CTYPE environment variable
586 This specifies what locale to use for character sets and character
587 classification.
588
589 @item LC_MONETARY
590 @cindex LC_MONETARY environment variable
591 This specifies what locale to use for formatting monetary values.
592
593 @item LC_NUMERIC
594 @cindex LC_NUMERIC environment variable
595 This specifies what locale to use for formatting numbers.
596
597 @item LC_TIME
598 @cindex LC_TIME environment variable
599 This specifies what locale to use for formatting date/time values.
600
601 @item _POSIX_OPTION_ORDER
602 @cindex _POSIX_OPTION_ORDER environment variable.
603 If this environment variable is defined, it suppresses the usual
604 reordering of command line arguments by @code{getopt}.  @xref{Argument Syntax}.
605 @end table
606
607 @node Program Termination
608 @section Program Termination
609 @cindex program termination
610 @cindex process termination
611
612 @cindex exit status value
613 The usual way for a program to terminate is simply for its @code{main}
614 function to return.  The @dfn{exit status value} returned from the
615 @code{main} function is used to report information back to the process's
616 parent process or shell.
617
618 A program can also terminate normally by calling the @code{exit}
619 function.
620
621 In addition, programs can be terminated by signals; this is discussed in
622 more detail in @ref{Signal Handling}.  The @code{abort} function causes
623 a signal that kills the program.
624
625 @menu
626 * Normal Termination::          If a program calls @code{exit}, a
627                                  process terminates normally.
628 * Exit Status::                 The @code{exit status} provides information 
629                                  about why the process terminated. 
630 * Cleanups on Exit::            A process can run its own cleanup
631                                  functions upon normal termination. 
632 * Aborting a Program::          The @code{abort} function causes
633                                  abnormal program termination. 
634 * Termination Internals::       What happens when a process terminates.
635 @end menu
636
637 @node Normal Termination
638 @subsection Normal Termination
639
640 A process terminates normally when the program calls @code{exit}.
641 Returning from @code{main} is equivalent to calling @code{exit}, and
642 the value that @code{main} returns is used as the argument to @code{exit}.
643
644 @comment stdlib.h
645 @comment ANSI
646 @deftypefun void exit (int @var{status})
647 The @code{exit} function terminates the process with status
648 @var{status}.  This function does not return.
649 @end deftypefun
650
651 Normal termination causes the following actions:
652
653 @enumerate
654 @item 
655 Functions that were registered with the @code{atexit} or @code{on_exit}
656 functions are called in the reverse order of their registration.  This
657 mechanism allows your application to specify its own ``cleanup'' actions
658 to be performed at program termination.  Typically, this is used to do
659 things like saving program state information in a file, or unlocking
660 locks in shared data bases.
661
662 @item 
663 All open streams are closed, writing out any buffered output data.  See
664 @ref{Closing Streams}.  In addition, temporary files opened
665 with the @code{tmpfile} function are removed; see @ref{Temporary Files}.
666
667 @item 
668 @code{_exit} is called.  @xref{Termination Internals}.
669 @end enumerate
670
671 @node Exit Status
672 @subsection Exit Status
673 @cindex exit status
674
675 When a program exits, it can return to the parent process a small
676 amount of information about the cause of termination, using the
677 @dfn{exit status}.  This is a value between 0 and 255 that the exiting
678 process passes as an argument to @code{exit}.
679
680 Normally you should use the exit status to report very broad information
681 about success or failure.  You can't provide a lot of detail about the
682 reasons for the failure, and most parent processes would not want much
683 detail anyway.
684
685 There are conventions for what sorts of status values certain programs
686 should return.  The most common convention is simply 0 for success and 1
687 for failure.  Programs that perform comparison use a different
688 convention: they use status 1 to indicate a mismatch, and status 2 to
689 indicate an inability to compare.  Your program should follow an
690 existing convention if an existing convention makes sense for it.
691
692 A general convention reserves status values 128 and up for special
693 purposes.  In particular, the value 128 is used to indicate failure to
694 execute another program in a subprocess.  This convention is not
695 universally obeyed, but it is a good idea to follow it in your programs.
696
697 @strong{Warning:} Don't try to use the number of errors as the exit
698 status.  This is actually not very useful; a parent process would
699 generally not care how many errors occurred.  Worse than that, it does
700 not work, because the status value is truncated to eight bits.
701 Thus, if the program tried to report 256 errors, the parent would
702 receive a report of 0 errors---that is, success.
703
704 For the same reason, it does not work to use the value of @code{errno}
705 as the exit status---these can exceed 255.
706
707 @strong{Portability note:} Some non-POSIX systems use different
708 conventions for exit status values.  For greater portability, you can
709 use the macros @code{EXIT_SUCCESS} and @code{EXIT_FAILURE} for the
710 conventional status value for success and failure, respectively.  They
711 are declared in the file @file{stdlib.h}.
712 @pindex stdlib.h
713
714 @comment stdlib.h
715 @comment ANSI
716 @deftypevr Macro int EXIT_SUCCESS
717 This macro can be used with the @code{exit} function to indicate
718 successful program completion.
719
720 On POSIX systems, the value of this macro is @code{0}.  On other
721 systems, the value might be some other (possibly non-constant) integer
722 expression.
723 @end deftypevr
724
725 @comment stdlib.h
726 @comment ANSI
727 @deftypevr Macro int EXIT_FAILURE
728 This macro can be used with the @code{exit} function to indicate
729 unsuccessful program completion in a general sense.
730
731 On POSIX systems, the value of this macro is @code{1}.  On other
732 systems, the value might be some other (possibly non-constant) integer
733 expression.  Other nonzero status values also indicate future.  Certain
734 programs use different nonzero status values to indicate particular
735 kinds of "non-success".  For example, @code{diff} uses status value
736 @code{1} to mean that the files are different, and @code{2} or more to
737 mean that there was difficulty in opening the files.
738 @end deftypevr
739
740 @node Cleanups on Exit
741 @subsection Cleanups on Exit
742
743 Your program can arrange to run its own cleanup functions if normal
744 termination happens.  If you are writing a library for use in various
745 application programs, then it is unreliable to insist that all
746 applications call the library's cleanup functions explicitly before
747 exiting.  It is much more robust to make the cleanup invisible to the
748 application, by setting up a cleanup function in the library itself
749 using @code{atexit} or @code{on_exit}.
750
751 @comment stdlib.h
752 @comment ANSI
753 @deftypefun int atexit (void (*@var{function}) ())
754 The @code{atexit} function registers the function @var{function} to be
755 called at normal program termination.  The @var{function} is called with
756 no arguments.
757
758 The return value from @code{atexit} is zero on success and nonzero if
759 the function cannot be registered. 
760 @end deftypefun
761
762 @comment stdlib.h
763 @comment SunOS
764 @deftypefun int on_exit (void (*@var{function})(int @var{status}, void *@var{arg}), void *@var{arg})
765 This function is a somewhat more powerful variant of @code{atexit}.  It
766 accepts two arguments, a function @var{function} and an arbitrary
767 pointer @var{arg}.  At normal program termination, the @var{function} is
768 called with two arguments:  the @var{status} value passed to @code{exit},
769 and the @var{arg}.
770
771 This function is included in the GNU C library only for compatibility
772 for SunOS, and may not be supported by other implementations.
773 @end deftypefun
774
775 Here's a trivial program that illustrates the use of @code{exit} and
776 @code{atexit}:
777
778 @example
779 #include <stdio.h>
780 #include <stdlib.h>
781
782 void
783 bye ()
784 @{
785   printf ("Goodbye, cruel world....\n");
786 @}
787
788 void
789 main ()
790 @{
791   atexit (bye);
792   exit (EXIT_SUCCESS);
793 @}
794 @end example
795
796 @noindent
797 When this program is executed, it just prints the message and exits.
798
799 @node Aborting a Program
800 @subsection Aborting a Program
801 @cindex aborting a program
802
803 You can abort your program using the @code{abort} function.  The prototype
804 for this function is in @file{stdlib.h}.
805 @pindex stdlib.h
806
807 @comment stdlib.h
808 @comment ANSI
809 @deftypefun void abort ()
810 The @code{abort} function causes abnormal program termination.  This
811 does not execute cleanup functions registered with @code{atexit} or
812 @code{on_exit}.
813
814 This function actually terminates the process by raising a
815 @code{SIGABRT} signal, and your program can include a handler to
816 intercept this signal; see @ref{Signal Handling}.
817
818 @strong{Incomplete:}  Why would you want to define such a handler?
819 @end deftypefun
820
821 @c rms: I put this in.
822 @strong{Future Change Warning:} Proposed Federal censorship regulations
823 may prohibit us us from giving you information about the possibility of
824 calling this function.  We would be required to say that this is not an
825 acceptable way of terminating a program.
826
827 @node Termination Internals
828 @subsection Termination Internals
829
830 The @code{_exit} function is the primitive used for process termination
831 by @code{exit}.  It is declared in the header file @file{unistd.h}.
832 @pindex unistd.h
833
834 @comment unistd.h
835 @comment POSIX.1
836 @deftypefun void _exit (int @var{status})
837 The @code{_exit} function is the primitive for causing a process to
838 terminate with status @var{status}.  Calling this function does not
839 execute cleanup functions registered with @code{atexit} or
840 @code{on_exit}.
841 @end deftypefun
842
843 When a process terminates for any reason---either by an explicit
844 termination call, or termination as a result of a signal---the
845 following things happen:
846
847 @itemize @bullet
848 @item
849 All open file descriptors in the process are closed.  @xref{Low-Level I/O}.
850
851 @item
852 The low-order 8 bits of the return status code are saved to be reported
853 back to the parent process via @code{wait} or @code{waitpid}; see
854 @ref{Process Completion}.
855
856 @item
857 Any child processes of the process being terminated are assigned a new
858 parent process.  (This is the @code{init} process, with process ID 1.)
859
860 @item
861 A @code{SIGCHLD} signal is sent to the parent process.
862
863 @item
864 If the process is a session leader that has a controlling terminal, then
865 a @code{SIGHUP} signal is sent to each process in the foreground job,
866 and the controlling terminal is disassociated from that session.
867 @xref{Job Control}.
868
869 @item
870 If termination of a process causes a process group to become orphaned,
871 and any member of that process group is stopped, then a @code{SIGHUP}
872 signal and a @code{SIGCONT} signal are sent to each process in the
873 group.  @xref{Job Control}.
874 @end itemize