Formerly ../posix/unistd.h.~22~
[kopensolaris-gnu/glibc.git] / posix / unistd.h
1 /* Copyright (C) 1991, 1992 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 /*
20  *      POSIX Standard: 2.10 Symbolic Constants         <unistd.h>
21  */
22
23 #ifndef _UNISTD_H
24
25 #define _UNISTD_H       1
26 #include <features.h>
27
28 /* These may be used to determine what facilities are present at compile time.
29    Their values can be obtained at run time from sysconf.  */
30
31 /* POSIX Standard approved as IEEE Std 1003.1 as of August, 1988.  */
32 #define _POSIX_VERSION  199009L
33
34 #ifdef  __USE_POSIX2
35 #define _POSIX2_C_VERSION       199912L /* Invalid until 1003.2 is done.  */
36
37 /* If defined, the implementation supports the
38    C Language Bindings Option.  */
39 #define _POSIX2_C_BIND  1
40
41 /* If defined, the implementation supports the
42    C Language Development Utilities Option.  */
43 #define _POSIX2_C_DEV   1
44
45 /* If defined, the implementation supports the
46    FORTRAN Language Development Utilities Option.  */
47 #define _POSIX2_FORT_DEV        1
48
49 /* If defined, the implementation supports the
50    Software Development Utilities Option.  */
51 #define _POSIX2_SW_DEV  1
52 #endif
53
54
55 /* Get values of POSIX options:
56
57    If these symbols are defined, the corresponding features are
58    always available.  If not, they may be available sometimes.
59    The current values can be obtained with `sysconf'.
60
61    _POSIX_JOB_CONTROL   Job control is supported.
62    _POSIX_SAVED_IDS     Processes have a saved set-user-ID
63                         and a saved set-group-ID.
64
65    If any of these symbols is defined as -1, the corresponding option is not
66    true for any file.  If any is defined as other than -1, the corresponding
67    option is true for all files.  If a symbol is not defined at all, the value
68    for a specific file can be obtained from `pathconf' and `fpathconf'.
69
70    _POSIX_CHOWN_RESTRICTED      Only the super user can use `chown' to change
71                                 the owner of a file.  `chown' can only be used
72                                 to change the group ID of a file to a group of
73                                 which the calling process is a member.
74    _POSIX_NO_TRUNC              Pathname components longer than
75                                 NAME_MAX generate an error.
76    _POSIX_VDISABLE              If defined, if the value of an element of the
77                                 `c_cc' member of `struct termios' is
78                                 _POSIX_VDISABLE, no character will have the
79                                 effect associated with that element.
80    */
81
82 #include <posix_opt.h>
83
84
85 /* Standard file descriptors.  */
86 #define STDIN_FILENO    0       /* Standard input.  */
87 #define STDOUT_FILENO   1       /* Standard output.  */
88 #define STDERR_FILENO   2       /* Standard error output.  */
89
90
91 /* All functions that are not declared anywhere else.  */
92
93 #include <gnu/types.h>
94
95 #ifndef ssize_t
96 #define ssize_t __ssize_t
97 #endif
98
99 #define __need_size_t
100 #include <stddef.h>
101
102
103 /* Values for the second argument to access.
104    These may be OR'd together.  */
105 #define R_OK    4       /* Test for read permission.  */
106 #define W_OK    2       /* Test for write permission.  */
107 #define X_OK    1       /* Test for execute permission.  */
108 #define F_OK    0       /* Test for existence.  */
109
110 /* Test for access to NAME.  */
111 extern int EXFUN(__access, (CONST char *__name, int __type));
112 extern int EXFUN(access, (CONST char *__name, int __type));
113
114 #ifdef  __OPTIMIZE__
115 #define access(name, type)      __access((name), (type))
116 #endif  /* Optimizing.  */
117
118
119 /* Values for the WHENCE argument to lseek.  */
120 #ifndef _STDIO_H        /* <stdio.h> has the same definitions.  */
121 #define SEEK_SET        0       /* Seek from beginning of file.  */
122 #define SEEK_CUR        1       /* Seek from current position.  */
123 #define SEEK_END        2       /* Seek from end of file.  */
124 #endif
125
126 /* Move FD's file position to OFFSET bytes from the
127    beginning of the file (if WHENCE is SEEK_SET),
128    the current position (if WHENCE is SEEK_CUR),
129    or the end of the file (if WHENCE is SEEK_END).
130    Return the old file position.  */
131 extern __off_t EXFUN(__lseek, (int __fd, __off_t __offset, int __whence));
132 extern __off_t EXFUN(lseek, (int __fd, __off_t __offset, int __whence));
133
134 /* Close the file descriptor FD.  */
135 extern int EXFUN(__close, (int __fd));
136 extern int EXFUN(close, (int __fd));
137
138 /* Read NBYTES into BUF from FD.  Return the
139    number read, -1 for errors or 0 for EOF.  */
140 extern ssize_t EXFUN(__read, (int __fd, PTR __buf, size_t __nbytes));
141 extern ssize_t EXFUN(read, (int __fd, PTR __buf, size_t __nbytes));
142
143 /* Write N bytes of BUF to FD.  Return the number written, or -1.  */
144 extern ssize_t EXFUN(__write, (int __fd, CONST PTR __buf, size_t __n));
145 extern ssize_t EXFUN(write, (int __fd, CONST PTR __buf, size_t __n));
146
147 #ifdef  __OPTIMIZE__
148 #define lseek(fd, offset, whence)       __lseek((fd), (offset), (whence))
149 #define close(fd)                       __close(fd)
150 #define read(fd, buf, n)                __read((fd), (buf), (n))
151 #define write(fd, buf, n)               __write((fd), (buf), (n))
152 #endif  /* Optimizing.  */
153
154
155 /* Create a one-way communication channel (pipe).
156    If successul, two file descriptors are stored in PIPEDES;
157    bytes written on PIPEDES[1] can be read from PIPEDES[0].
158    Returns 0 if successful, -1 if not.  */
159 extern int EXFUN(__pipe, (int __pipedes[2]));
160 extern int EXFUN(pipe, (int __pipedes[2]));
161
162 #ifdef __OPTIMIZE__
163 #define pipe(pipedes)   __pipe(pipedes)
164 #endif  /* Optimizing.  */
165
166 /* Schedule an alarm.  In SECONDS seconds, the process will get a SIGALRM.
167    If SECONDS is zero, any currently scheduled alarm will be cancelled.
168    The function returns the number of seconds remaining until the last
169    alarm scheduled would have signaled, or zero if there wasn't one.
170    There is no return value to indicate an error, but you can set `errno'
171    to 0 and check its value after calling `alarm', and this might tell you.
172    The signal may come late due to processor scheduling.  */
173 extern unsigned int EXFUN(alarm, (unsigned int __seconds));
174
175 /* Make the process sleep for SECONDS seconds, or until a signal arrives
176    and is not ignored.  The function returns the number of seconds less
177    than SECONDS which it actually slept (thus zero if it slept the full time).
178    If a signal handler does a `longjmp' or modifies the handling of the
179    SIGALRM signal while inside `sleep' call, the handling of the SIGALRM
180    signal afterwards is undefined.  There is no return value to indicate
181    error, but if `sleep' returns SECONDS, it probably didn't work.  */
182 extern unsigned int EXFUN(sleep, (unsigned int __seconds));
183
184
185 /* Suspend the process until a signal arrives.
186    This always returns -1 and sets `errno' to EINTR.  */
187 extern int EXFUN(pause, (NOARGS));
188
189
190 /* Change the owner and group of FILE.  */
191 extern int EXFUN(__chown, (CONST char *__file AND
192                            __uid_t __owner AND __gid_t __group));
193 extern int EXFUN(chown, (CONST char *__file AND
194                          __uid_t __owner AND __gid_t __group));
195
196 #ifdef __OPTIMIZE__
197 #define chown(file, owner, group)       __chown((file), (owner), (group))
198 #endif  /* Optimizing.  */
199
200 #ifdef  __USE_BSD
201 /* Change the owner and group of the file that FD is open on.  */
202 extern int EXFUN(__fchown, (int __fd AND
203                             __uid_t __owner AND __gid_t __group));
204 extern int EXFUN(fchown, (int __fd AND
205                           __uid_t __owner AND __gid_t __group));
206 #ifdef __OPTIMIZE__
207 #define fchown(fd, owner, group)        __fchown((fd), (owner), (group))
208 #endif  /* Optimizing.  */
209 #endif  /* Use BSD.  */
210
211 /* Change the process's working directory to PATH.  */
212 extern int EXFUN(__chdir, (CONST char *__path));
213 extern int EXFUN(chdir, (CONST char *__path));
214
215 #ifdef __OPTIMIZE__
216 #define chdir(path)     __chdir(path)
217 #endif  /* Optimizing.  */
218  
219 /* Get the pathname of the current working directory,
220    and put it in SIZE bytes of BUF.  Returns NULL if the
221    directory couldn't be determined or SIZE was too small.
222    If successful, returns BUF.  In GNU, if BUF is NULL,
223    an array is allocated with `malloc'; the array is SIZE
224    bytes long, unless SIZE <= 0, in which case it is as
225    big as necessary.  */
226 extern char *EXFUN(getcwd, (char *__buf, size_t __size));
227
228 #ifdef  __USE_GNU
229 /* Return a malloc'd string containing the current directory name.
230    If the environment variable `PWD' is set, and its value is correct,
231    that value is used.  */
232 extern char *EXFUN(get_current_dir_name, (NOARGS));
233 #endif
234
235 #ifdef  __USE_BSD
236 /* Put the absolute pathname of the current working directory in BUF.
237    If successful, return BUF.  If not, put an error message in
238    BUF and return NULL.  BUF should be at least PATH_MAX bytes long.  */
239 extern char *EXFUN(getwd, (char *__buf));
240 #endif
241
242
243 /* Duplicate FD, returning a new file descriptor on the same file.  */
244 extern int EXFUN(__dup, (int __fd));
245 extern int EXFUN(dup, (int __fd));
246
247 #ifdef __OPTIMIZE__
248 #define dup(fd) __dup(fd)
249 #endif  /* Optimizing.  */
250
251 /* Duplicate FD to FD2, closing FD2 and making it open on the same file.  */
252 extern int EXFUN(__dup2, (int __fd, int __fd2));
253 extern int EXFUN(dup2, (int __fd, int __fd2));
254
255 #ifdef __OPTIMIZE__
256 #define dup2(fd, fd2)   __dup2((fd), (fd2))
257 #endif  /* Optimizing.  */
258
259 /* NULL-terminated array of "NAME=VALUE" environment variables.  */
260 extern char **__environ;
261 extern char **environ;
262
263
264 /* Replace the current process, executing PATH with arguments ARGV and
265    environment ENVP.  ARGV and ENVP are terminated by NULL pointers.  */
266 extern int EXFUN(__execve, (CONST char *__path, char *CONST __argv[],
267                             char *CONST __envp[]));
268 extern int EXFUN(execve, (CONST char *__path, char *CONST __argv[],
269                           char *CONST __envp[]));
270
271 #define execve  __execve
272
273 /* Execute PATH with arguments ARGV and environment from `environ'.  */
274 extern int EXFUN(execv, (CONST char *__path, char *CONST __argv[]));
275
276 /* Execute PATH with all arguments after PATH until a NULL pointer,
277    and the argument after that for environment.  */
278 extern int EXFUN(execle, (CONST char *__path, CONST char *__arg, ...));
279
280 /* Execute PATH with all arguments after PATH until
281    a NULL pointer and environment from `environ'.  */
282 extern int EXFUN(execl, (CONST char *__path, CONST char *__arg, ...));
283
284 /* Execute FILE, searching in the `PATH' environment variable if it contains
285    no slashes, with arguments ARGV and environment from `environ'.  */
286 extern int EXFUN(execvp, (CONST char *__file, char *CONST __argv[]));
287
288 /* Execute FILE, searching in the `PATH' environment variable if
289    it contains no slashes, with all arguments after FILE until a
290    NULL pointer and environment from `environ'.  */
291 extern int EXFUN(execlp, (CONST char *__file, CONST char *arg, ...));
292
293
294 #ifndef __NORETURN
295 #ifdef  __GNUC__
296 /* The `volatile' keyword tells GCC that a function never returns.  */
297 #define __NORETURN      __volatile
298 #else   /* Not GCC.  */
299 #define __NORETURN
300 #endif  /* GCC.  */
301 #endif  /* __NORETURN not defined.  */
302
303 /* Terminate program execution with the low-order 8 bits of STATUS.  */
304 extern __NORETURN void EXFUN(_exit, (int __status));
305
306
307 /* Values for the NAME argument to `pathconf' and `fpathconf'.
308    These correspond to the _POSIX_* symbols above, but for
309    specific files or file descriptors.  */
310 #define _PC_LINK_MAX            0
311 #define _PC_MAX_CANON           1
312 #define _PC_MAX_INPUT           2
313 #define _PC_NAME_MAX            3
314 #define _PC_PATH_MAX            4
315 #define _PC_PIPE_BUF            5
316 #define _PC_CHOWN_RESTRICTED    6
317 #define _PC_NO_TRUNC            7
318 #define _PC_VDISABLE            8
319
320 /* Get file-specific configuration information about PATH.  */
321 extern long int EXFUN(__pathconf, (CONST char *__path, int __name));
322 extern long int EXFUN(pathconf, (CONST char *__path, int __name));
323
324 /* Get file-specific configuration about descriptor FD.  */
325 extern long int EXFUN(__fpathconf, (int __fd, int __name));
326 extern long int EXFUN(fpathconf, (int __fd, int __name));
327
328 #define pathconf        __pathconf
329 #define fpathconf       __fpathconf
330
331
332 /* Values for the argument to `sysconf'.
333    These correspond to the _POSIX_* symbols in <posix_limits.h> and above,
334    but may vary at run time.  */
335 enum
336   {
337     _SC_ARG_MAX,
338     _SC_CHILD_MAX,
339     _SC_CLK_TCK,
340     _SC_NGROUPS_MAX,
341     _SC_OPEN_MAX,
342     _SC_STREAM_MAX,
343     _SC_TZNAME_MAX,
344     _SC_JOB_CONTROL,
345     _SC_SAVED_IDS,
346     _SC_VERSION,
347
348     /* Values for the argument to `sysconf'
349        corresponding to _POSIX2_* symbols.  */
350     _SC_BC_BASE_MAX,
351     _SC_BC_DIM_MAX,
352     _SC_BC_SCALE_MAX,
353     _SC_BC_STRING_MAX,
354     _SC_EQUIV_CLASS_MAX,
355     _SC_EXPR_NEST_MAX,
356     _SC_LINE_MAX,
357     _SC_RE_DUP_MAX,
358
359     _SC_2_VERSION,
360     _SC_2_C_BIND,
361     _SC_2_C_DEV,
362     _SC_2_FORT_DEV,
363     _SC_2_SW_DEV
364   };
365
366
367 /* Get the value of the system variable NAME.  */
368 extern long int EXFUN(__sysconf, (int __name));
369 extern long int EXFUN(sysconf, (int __name));
370
371 #ifdef __OPTIMIZE__
372 #define sysconf(name)   __sysconf(name)
373 #endif  /* Optimizing.  */
374
375
376 #ifdef  __USE_POSIX2
377 /* Values for the argument to `confstr'.  */
378 #define _CS_PATH        0       /* The default search path.  */
379
380 /* Get the value of the string-valued system variable NAME.  */
381 extern size_t EXFUN(confstr, (int __name, char *__buf, size_t __len));
382 #endif
383
384
385 /* Get the process ID of the calling process.  */
386 extern __pid_t EXFUN(__getpid, (NOARGS));
387 extern __pid_t EXFUN(getpid, (NOARGS));
388
389 /* Get the process ID of the calling process's parent.  */
390 extern __pid_t EXFUN(__getppid, (NOARGS));
391 extern __pid_t EXFUN(getppid, (NOARGS));
392
393 #ifdef  __OPTIMIZE__
394 #define getpid()        __getpid()
395 #define getppid()       __getppid()
396 #endif  /* Optimizing.  */
397
398 /* Get the process group ID of process PID.  */
399 extern __pid_t EXFUN(__getpgrp, (__pid_t __pid));
400
401 #ifndef __FAVOR_BSD
402 /* Get the process group ID of the calling process.  */
403 extern __pid_t EXFUN(getpgrp, (NOARGS));
404 #else   /* Favor BSD.  */
405 #define getpgrp(pid)    __getpgrp(pid)
406 #endif
407
408 /* Set the process group ID of the process matching PID to PGID.
409    If PID is zero, the current process's process group ID is set.
410    If PGID is zero, the process ID of the process is used.  */
411 extern int EXFUN(__setpgrp, (__pid_t __pid, __pid_t __pgid));
412 extern int EXFUN(setpgid, (__pid_t __pid, __pid_t __pgid));
413
414 #ifdef __OPTIMIZE__
415 #define setpgid(pid, pgid)      __setpgrp((pid), (pgid))
416 #endif  /* Optimizing.  */
417
418 #ifdef  __USE_BSD
419 /* Set the process group of PID to PGRP.  */
420 extern int EXFUN(setpgrp, (__pid_t __pid, __pid_t __pgrp));
421
422 #ifdef  __OPTIMIZE__
423 #define setpgrp(pid, pgrp)      setpgid((pid), (pgrp))
424 #endif  /* Optimizing.  */
425 #endif  /* Use BSD.  */
426
427 /* Create a new session with the calling process as its leader.
428    The process group IDs of the session and the calling process
429    are set to the process ID of the calling process, which is returned.  */
430 extern __pid_t EXFUN(__setsid, (NOARGS));
431 extern __pid_t EXFUN(setsid, (NOARGS));
432
433 #ifdef __OPTIMIZE__
434 #define setsid()        __setsid()
435 #endif  /* Optimizing.  */
436
437 /* Get the real user ID of the calling process.  */
438 extern __uid_t EXFUN(__getuid, (NOARGS));
439 extern __uid_t EXFUN(getuid, (NOARGS));
440
441 #ifdef __OPTIMIZE__
442 #define getuid()        __getuid()
443 #endif  /* Optimizing.  */
444
445 /* Get the effective user ID of the calling process.  */
446 extern __uid_t EXFUN(__geteuid, (NOARGS));
447 extern __uid_t EXFUN(geteuid, (NOARGS));
448
449 #ifdef __OPTIMIZE__
450 #define geteuid()       __geteuid()
451 #endif  /* Optimizing.  */
452
453 /* Get the real group ID of the calling process.  */
454 extern __gid_t EXFUN(__getgid, (NOARGS));
455 extern __gid_t EXFUN(getgid, (NOARGS));
456
457 #ifdef __OPTIMIZE__
458 #define getgid()        __getgid()
459 #endif /* Optimizing.  */
460
461 /* Get the effective group ID of the calling process.  */
462 extern __gid_t EXFUN(__getegid, (NOARGS));
463 extern __gid_t EXFUN(getegid, (NOARGS));
464
465 #ifdef __OPTIMIZE__
466 #define getegid()       __getegid()
467 #endif /* Optimizing.  */
468
469 /* If SIZE is zero, return the number of supplementary groups
470    the calling process is in.  Otherwise, fill in the group IDs
471    of its supplementary groups in LIST and return the number written.  */
472 extern int EXFUN(__getgroups, (int __size, __gid_t __list[]));
473 extern int EXFUN(getgroups, (int __size, __gid_t __list[]));
474
475 #ifdef __OPTIMIZE__
476 #define getgroups(size, list)   __getgroups((size), (list))
477 #endif /* Optimizing.  */
478
479 /* Set the user ID of the calling process to UID.
480    If the calling process is the super-user, set the real
481    and effective user IDs, and the saved set-user-ID to UID;
482    if not, the effective user ID is set to UID.  */
483 extern int EXFUN(__setuid, (__uid_t __uid));
484 extern int EXFUN(setuid, (__uid_t __uid));
485
486 #ifdef __OPTIMIZE__
487 #define setuid(uid)     __setuid(uid)
488 #endif  /* Optimizing.  */
489
490 #ifdef  __USE_BSD
491 /* Set the real user ID of the calling process to RUID,
492    and the effective user ID of the calling process to EUID.  */
493 extern int EXFUN(__setreuid, (__uid_t __ruid, __uid_t __euid));
494 extern int EXFUN(setreuid, (__uid_t __ruid, __uid_t __euid));
495
496 #ifdef __OPTIMIZE__
497 #define setreuid(ruid, euid)    __setreuid((ruid), (euid))
498 #endif  /* Optimizing.  */
499 #endif  /* Use BSD.  */
500
501 /* Set the group ID of the calling process to GID.
502    If the calling process is the super-user, set the real
503    and effective group IDs, and the saved set-group-ID to GID;
504    if not, the effective group ID is set to GID.  */
505 extern int EXFUN(__setgid, (__gid_t __gid));
506 extern int EXFUN(setgid, (__gid_t __gid));
507
508 #ifdef __OPTIMIZE__
509 #define setgid(gid)     __setgid(gid)
510 #endif /* Optimizing.  */
511
512 #ifdef  __USE_BSD
513 /* Set the real group ID of the calling process to RGID,
514    and the effective group ID of the calling process to EGID.  */
515 extern int EXFUN(__setregid, (int __rgid, int __egid));
516 extern int EXFUN(setregid, (int __rgid, int __egid));
517
518 #ifdef  __OPTIMIZE__
519 #define setregid(rgid, egid)    __setregid((rgid), (egid))
520 #endif  /* Optimizing.  */
521 #endif  /* Use BSD.  */
522
523
524 /* Clone the calling process, creating an exact copy.
525    Return -1 for errors, 0 to the new process,
526    and the process ID of the new process to the old process.  */
527 extern __pid_t EXFUN(__fork, (NOARGS));
528 extern __pid_t EXFUN(fork, (NOARGS));
529
530 #define fork    __fork
531
532 #ifdef  __USE_BSD
533 /* Clone the calling process, but without copying the whole address space.
534    The the calling process is suspended until the the new process exits or is
535    replaced by a call to `execve'.  Return -1 for errors, 0 to the new process,
536    and the process ID of the new process to the old process.  */
537 extern __pid_t EXFUN(__vfork, (NOARGS));
538 extern __pid_t EXFUN(vfork, (NOARGS));
539
540 #define vfork   __vfork
541 #endif  /* Use BSD. */
542
543
544 /* Return the pathname of the terminal FD is open on, or NULL on errors.
545    The returned storage is good only until the next call to this function.  */
546 extern char *EXFUN(ttyname, (int __fd));
547
548 /* Return 1 if FD is a valid descriptor associated
549    with a terminal, zero if not.  */
550 extern int EXFUN(__isatty, (int __fd));
551 extern int EXFUN(isatty, (int __fd));
552
553 #ifdef  __OPTIMIZE__
554 #define isatty(fd)      __isatty(fd)
555 #endif  /* Optimizing.  */
556
557
558 /* Make a link to FROM named TO.  */
559 extern int EXFUN(__link, (CONST char *__from, CONST char *__to));
560 extern int EXFUN(link, (CONST char *__from, CONST char *__to));
561 #define link    __link
562
563 #ifdef  __USE_BSD
564 /* Make a symbolic link to FROM named TO.  */
565 extern int EXFUN(__symlink, (CONST char *__from, CONST char *__to));
566 extern int EXFUN(symlink, (CONST char *__from, CONST char *__to));
567
568 #ifdef __OPTIMIZE__
569 #define symlink(from, to)       __symlink((from), (to))
570 #endif  /* Optimizing.  */
571
572 /* Read the contents of the symbolic link PATH into no more than
573    LEN bytes of BUF.  The contents are not null-terminated.
574    Returns the number of characters read, or -1 for errors.  */
575 extern int EXFUN(__readlink, (CONST char *__path, char *__buf, size_t __len));
576 extern int EXFUN(readlink, (CONST char *__path, char *__buf, size_t __len));
577
578 #ifdef __OPTIMIZE__
579 #define readlink(path, buf, len)        __readlink((path), (buf), (len))
580 #endif  /* Optimizing.  */
581 #endif  /* Use BSD.  */
582
583 /* Remove the link NAME.  */
584 extern int EXFUN(__unlink, (CONST char *__name));
585 extern int EXFUN(unlink, (CONST char *__name));
586
587 #ifdef  __OPTIMIZE__
588 #define unlink(name)    __unlink(name)
589 #endif  /* Optimizing.  */
590
591 /* Remove the directory PATH.  */
592 extern int EXFUN(__rmdir, (CONST char *__path));
593 extern int EXFUN(rmdir, (CONST char *__path));
594
595 #ifdef __OPTIMIZE__
596 #define rmdir(path)     __rmdir(path)
597 #endif /* Optimizing.  */
598
599
600 /* Return the foreground process group ID of FD.  */
601 extern __pid_t EXFUN(tcgetpgrp, (int __fd));
602
603 /* Set the foreground process group ID of FD set PGRP_ID.  */
604 extern int EXFUN(tcsetpgrp, (int __fd, __pid_t __pgrp_id));
605
606
607 /* Return the login name of the user.  */
608 extern char *EXFUN(getlogin, (NOARGS));
609
610 #ifdef  __USE_BSD
611 /* Set the login name returned by `getlogin'.  */
612 extern int EXFUN(setlogin, (CONST char *__name));
613 #endif
614
615
616 #ifdef  __USE_POSIX2
617 /* Process the arguments in ARGV (ARGC of them, minus
618    the program name) for options given in OPTS.
619
620    If `opterr' is zero, no messages are generated
621    for invalid options; it defaults to 1.
622    `optind' is the current index into ARGV.
623    `optarg' is the argument corresponding to the current option.
624    Return the option character from OPTS just read.
625    Return -1 when there are no more options.
626    For unrecognized options, or options missing arguments,
627    `optopt' is set to the option letter, and '?' is returned.
628
629    The OPTS string is a list of characters which are recognized option
630    letters, optionally followed by colons, specifying that that letter
631    takes an argument, to be placed in `optarg'.
632
633    If a letter in OPTS is followed by two colons, its argument is optional.
634    This behavior is specific to the GNU `getopt'.
635
636    The argument `--' causes premature termination of argument scanning,
637    explicitly telling `getopt' that there are no more options.
638
639    If OPTS begins with `--', then non-option arguments
640    are treated as arguments to the option '\0'.
641    This behavior is specific to the GNU `getopt'.  */
642 extern int EXFUN(getopt, (int __argc, char *CONST *__argv,
643                           CONST char *__opts));
644 extern int opterr;
645 extern int optind;
646 extern int optopt;
647 extern char *optarg;
648 #endif
649
650
651 #ifdef  __USE_BSD
652 /* Put the name of the current host in no more than LEN bytes of NAME.
653    The result is null-terminated if LEN is large enough for the full
654    name and the terminator.  */
655 extern int EXFUN(__gethostname, (char *__name, size_t __len));
656 extern int EXFUN(gethostname, (char *__name, size_t __len));
657
658 #ifdef  __OPTIMIZE__
659 #define gethostname(name, len)  __gethostname((name), (len))
660 #endif
661
662 /* Set the name of the current host to NAME, which is LEN bytes long.
663    This call is restricted to the super-user.  */
664 extern int EXFUN(sethostname, (CONST char *__name, size_t __len));
665
666 /* Return the current machine's Internet number.  */
667 extern long int EXFUN(gethostid, (NOARGS));
668
669 /* Set the current machine's Internet number to ID.
670    This call is restricted to the super-user.  */
671 extern int EXFUN(sethostid, (long int __id));
672
673
674 /* Return the number of bytes in a page.  This is the system's page size,
675    which is not necessarily the same as the hardware page size.  */
676 extern size_t EXFUN(__getpagesize, (NOARGS));
677 extern size_t EXFUN(getpagesize, (NOARGS));
678
679 #ifdef  __OPTIMIZE__
680 #define getpagesize()   __getpagesize()
681 #endif  /* Optimizing.  */
682
683
684 /* Return the maximum number of file descriptors
685    the current process could possibly have.  */
686 extern int EXFUN(__getdtablesize, (NOARGS));
687 extern int EXFUN(getdtablesize, (NOARGS));
688
689 #ifdef __OPTIMIZE__
690 #define getdtablesize() __getdtablesize()
691 #endif
692
693
694 /* Make all changes done to FD actually appear on disk.  */
695 extern int EXFUN(fsync, (int __fd));
696
697 /* Make all changes done to all files actually appear on disk.  */
698 extern int EXFUN(sync, (NOARGS));
699
700
701 /* Revoke access permissions to all processes currently communicating
702    with the control terminal, and then send a SIGHUP signal to the process
703    group of the control terminal.  */
704 extern int EXFUN(vhangup, (NOARGS));
705
706
707 /* Turn accounting on if NAME is an existing file.  The system will then write
708    a record for each process as it terminates, to this file.  If NAME is NULL,
709    turn accounting off.  This call is restricted to the super-user.  */
710 extern int EXFUN(acct, (CONST char *__name));
711
712 /* Make PATH be the root directory (the starting point for absolute paths).
713    This call is restricted to the super-user.  */
714 extern int EXFUN(chroot, (CONST char *__path));
715
716 /* Make the block special device PATH available to the system for swapping.
717    This call is restricted to the super-user.  */
718 extern int EXFUN(swapon, (CONST char *__path));
719 #endif  /* Use BSD.  */
720
721
722 #endif  /* unistd.h  */