diff options
Diffstat (limited to 'posix/unistd.h')
| -rw-r--r-- | posix/unistd.h | 642 |
1 files changed, 642 insertions, 0 deletions
diff --git a/posix/unistd.h b/posix/unistd.h new file mode 100644 index 0000000000..7143fe1606 --- /dev/null +++ b/posix/unistd.h @@ -0,0 +1,642 @@ +/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +/* + * POSIX Standard: 2.10 Symbolic Constants <unistd.h> + */ + +#ifndef _UNISTD_H + +#define _UNISTD_H 1 +#include <features.h> + +__BEGIN_DECLS + +/* These may be used to determine what facilities are present at compile time. + Their values can be obtained at run time from sysconf. */ + +/* POSIX Standard approved as IEEE Std 1003.1 as of August, 1988. */ +#define _POSIX_VERSION 199009L + +/* These are not #ifdef __USE_POSIX2 because they are + in the theoretically application-owned namespace. */ + +#define _POSIX2_C_VERSION 199912L /* Invalid until 1003.2 is done. */ + +/* If defined, the implementation supports the + C Language Bindings Option. */ +#define _POSIX2_C_BIND 1 + +/* If defined, the implementation supports the + C Language Development Utilities Option. */ +#define _POSIX2_C_DEV 1 + +/* If defined, the implementation supports the + Software Development Utilities Option. */ +#define _POSIX2_SW_DEV 1 + + +/* Get values of POSIX options: + + If these symbols are defined, the corresponding features are + always available. If not, they may be available sometimes. + The current values can be obtained with `sysconf'. + + _POSIX_JOB_CONTROL Job control is supported. + _POSIX_SAVED_IDS Processes have a saved set-user-ID + and a saved set-group-ID. + + If any of these symbols is defined as -1, the corresponding option is not + true for any file. If any is defined as other than -1, the corresponding + option is true for all files. If a symbol is not defined at all, the value + for a specific file can be obtained from `pathconf' and `fpathconf'. + + _POSIX_CHOWN_RESTRICTED Only the super user can use `chown' to change + the owner of a file. `chown' can only be used + to change the group ID of a file to a group of + which the calling process is a member. + _POSIX_NO_TRUNC Pathname components longer than + NAME_MAX generate an error. + _POSIX_VDISABLE If defined, if the value of an element of the + `c_cc' member of `struct termios' is + _POSIX_VDISABLE, no character will have the + effect associated with that element. + */ + +#include <posix_opt.h> + + +/* Standard file descriptors. */ +#define STDIN_FILENO 0 /* Standard input. */ +#define STDOUT_FILENO 1 /* Standard output. */ +#define STDERR_FILENO 2 /* Standard error output. */ + + +/* All functions that are not declared anywhere else. */ + +#include <gnu/types.h> + +#ifndef ssize_t +#define ssize_t __ssize_t +#endif + +#define __need_size_t +#define __need_NULL +#include <stddef.h> + + +/* Values for the second argument to access. + These may be OR'd together. */ +#define R_OK 4 /* Test for read permission. */ +#define W_OK 2 /* Test for write permission. */ +#define X_OK 1 /* Test for execute permission. */ +#define F_OK 0 /* Test for existence. */ + +/* Test for access to NAME. */ +extern int __access __P ((__const char *__name, int __type)); +extern int access __P ((__const char *__name, int __type)); + + +/* Values for the WHENCE argument to lseek. */ +#ifndef _STDIO_H /* <stdio.h> has the same definitions. */ +#define SEEK_SET 0 /* Seek from beginning of file. */ +#define SEEK_CUR 1 /* Seek from current position. */ +#define SEEK_END 2 /* Seek from end of file. */ +#endif + +/* Move FD's file position to OFFSET bytes from the + beginning of the file (if WHENCE is SEEK_SET), + the current position (if WHENCE is SEEK_CUR), + or the end of the file (if WHENCE is SEEK_END). + Return the new file position. */ +extern __off_t __lseek __P ((int __fd, __off_t __offset, int __whence)); +extern __off_t lseek __P ((int __fd, __off_t __offset, int __whence)); + +/* Close the file descriptor FD. */ +extern int __close __P ((int __fd)); +extern int close __P ((int __fd)); + +/* Read NBYTES into BUF from FD. Return the + number read, -1 for errors or 0 for EOF. */ +extern ssize_t __read __P ((int __fd, __ptr_t __buf, size_t __nbytes)); +extern ssize_t read __P ((int __fd, __ptr_t __buf, size_t __nbytes)); + +/* Write N bytes of BUF to FD. Return the number written, or -1. */ +extern ssize_t __write __P ((int __fd, __const __ptr_t __buf, size_t __n)); +extern ssize_t write __P ((int __fd, __const __ptr_t __buf, size_t __n)); + + +/* Create a one-way communication channel (pipe). + If successul, two file descriptors are stored in PIPEDES; + bytes written on PIPEDES[1] can be read from PIPEDES[0]. + Returns 0 if successful, -1 if not. */ +extern int __pipe __P ((int __pipedes[2])); +extern int pipe __P ((int __pipedes[2])); + +/* Schedule an alarm. In SECONDS seconds, the process will get a SIGALRM. + If SECONDS is zero, any currently scheduled alarm will be cancelled. + The function returns the number of seconds remaining until the last + alarm scheduled would have signaled, or zero if there wasn't one. + There is no return value to indicate an error, but you can set `errno' + to 0 and check its value after calling `alarm', and this might tell you. + The signal may come late due to processor scheduling. */ +extern unsigned int alarm __P ((unsigned int __seconds)); + +/* Make the process sleep for SECONDS seconds, or until a signal arrives + and is not ignored. The function returns the number of seconds less + than SECONDS which it actually slept (thus zero if it slept the full time). + If a signal handler does a `longjmp' or modifies the handling of the + SIGALRM signal while inside `sleep' call, the handling of the SIGALRM + signal afterwards is undefined. There is no return value to indicate + error, but if `sleep' returns SECONDS, it probably didn't work. */ +extern unsigned int sleep __P ((unsigned int __seconds)); + + +/* Suspend the process until a signal arrives. + This always returns -1 and sets `errno' to EINTR. */ +extern int pause __P ((void)); + + +/* Change the owner and group of FILE. */ +extern int __chown __P ((__const char *__file, + __uid_t __owner, __gid_t __group)); +extern int chown __P ((__const char *__file, + __uid_t __owner, __gid_t __group)); + +#ifdef __USE_BSD +/* Change the owner and group of the file that FD is open on. */ +extern int __fchown __P ((int __fd, + __uid_t __owner, __gid_t __group)); +extern int fchown __P ((int __fd, + __uid_t __owner, __gid_t __group)); +#endif /* Use BSD. */ + +/* Change the process's working directory to PATH. */ +extern int __chdir __P ((__const char *__path)); +extern int chdir __P ((__const char *__path)); + +#ifdef __USE_BSD +/* Change the process's working directory to the one FD is open on. */ +extern int fchdir __P ((int __fd)); +#endif + +/* Get the pathname of the current working directory, + and put it in SIZE bytes of BUF. Returns NULL if the + directory couldn't be determined or SIZE was too small. + If successful, returns BUF. In GNU, if BUF is NULL, + an array is allocated with `malloc'; the array is SIZE + bytes long, unless SIZE <= 0, in which case it is as + big as necessary. */ +extern char *getcwd __P ((char *__buf, size_t __size)); + +#ifdef __USE_GNU +/* Return a malloc'd string containing the current directory name. + If the environment variable `PWD' is set, and its value is correct, + that value is used. */ +extern char *get_current_dir_name __P ((void)); +#endif + +#ifdef __USE_BSD +/* Put the absolute pathname of the current working directory in BUF. + If successful, return BUF. If not, put an error message in + BUF and return NULL. BUF should be at least PATH_MAX bytes long. */ +extern char *getwd __P ((char *__buf)); +#endif + + +/* Duplicate FD, returning a new file descriptor on the same file. */ +extern int __dup __P ((int __fd)); +extern int dup __P ((int __fd)); + +/* Duplicate FD to FD2, closing FD2 and making it open on the same file. */ +extern int __dup2 __P ((int __fd, int __fd2)); +extern int dup2 __P ((int __fd, int __fd2)); + +/* NULL-terminated array of "NAME=VALUE" environment variables. */ +extern char **__environ; +extern char **environ; + + +/* Replace the current process, executing PATH with arguments ARGV and + environment ENVP. ARGV and ENVP are terminated by NULL pointers. */ +extern int __execve __P ((__const char *__path, char *__const __argv[], + char *__const __envp[])); +extern int execve __P ((__const char *__path, char *__const __argv[], + char *__const __envp[])); + +#ifdef __USE_GNU +/* Execute the file FD refers to, overlaying the running program image. + ARGV and ENVP are passed to the new program, as for `execve'. */ +extern int fexecve __P ((int __fd, + char *const __argv[], char *const __envp[])); + +#endif + + +/* Execute PATH with arguments ARGV and environment from `environ'. */ +extern int execv __P ((__const char *__path, char *__const __argv[])); + +/* Execute PATH with all arguments after PATH until a NULL pointer, + and the argument after that for environment. */ +extern int execle __P ((__const char *__path, __const char *__arg,...)); + +/* Execute PATH with all arguments after PATH until + a NULL pointer and environment from `environ'. */ +extern int execl __P ((__const char *__path, __const char *__arg,...)); + +/* Execute FILE, searching in the `PATH' environment variable if it contains + no slashes, with arguments ARGV and environment from `environ'. */ +extern int execvp __P ((__const char *__file, char *__const __argv[])); + +/* Execute FILE, searching in the `PATH' environment variable if + it contains no slashes, with all arguments after FILE until a + NULL pointer and environment from `environ'. */ +extern int execlp __P ((__const char *__file, ...)); + + +/* Terminate program execution with the low-order 8 bits of STATUS. */ +extern void _exit __P ((int __status)) __attribute__ ((__noreturn__)); + + +/* Get the `_PC_*' symbols for the NAME argument to `pathconf' and `fpathconf'; + the `_SC_*' symbols for the NAME argument to `sysconf'; + and the `_CS_*' symbols for the NAME argument to `confstr'. */ +#include <confname.h> + +/* Get file-specific configuration information about PATH. */ +extern long int __pathconf __P ((__const char *__path, int __name)); +extern long int pathconf __P ((__const char *__path, int __name)); + +/* Get file-specific configuration about descriptor FD. */ +extern long int __fpathconf __P ((int __fd, int __name)); +extern long int fpathconf __P ((int __fd, int __name)); + +/* Get the value of the system variable NAME. */ +extern long int __sysconf __P ((int __name)); +extern long int sysconf __P ((int __name)); + +#ifdef __USE_POSIX2 +/* Get the value of the string-valued system variable NAME. */ +extern size_t confstr __P ((int __name, char *__buf, size_t __len)); +#endif + + +/* Get the process ID of the calling process. */ +extern __pid_t __getpid __P ((void)); +extern __pid_t getpid __P ((void)); + +/* Get the process ID of the calling process's parent. */ +extern __pid_t __getppid __P ((void)); +extern __pid_t getppid __P ((void)); + +/* Get the process group ID of the calling process. */ +extern __pid_t getpgrp __P ((void)); + +/* Set the process group ID of the process matching PID to PGID. + If PID is zero, the current process's process group ID is set. + If PGID is zero, the process ID of the process is used. */ +extern int setpgid __P ((__pid_t __pid, __pid_t __pgid)); + +/* Get the process group ID of process PID. */ +extern __pid_t __getpgid __P ((__pid_t __pid)); +#ifdef __USE_GNU +extern __pid_t getpgid __P ((__pid_t __pid)); +#endif + +#ifdef __USE_BSD +/* Another name for `setpgid'. */ +extern int setpgrp __P ((__pid_t __pid, __pid_t __pgrp)); +#endif /* Use BSD. */ + +/* Create a new session with the calling process as its leader. + The process group IDs of the session and the calling process + are set to the process ID of the calling process, which is returned. */ +extern __pid_t __setsid __P ((void)); +extern __pid_t setsid __P ((void)); + +/* Get the real user ID of the calling process. */ +extern __uid_t __getuid __P ((void)); +extern __uid_t getuid __P ((void)); + +/* Get the effective user ID of the calling process. */ +extern __uid_t __geteuid __P ((void)); +extern __uid_t geteuid __P ((void)); + +/* Get the real group ID of the calling process. */ +extern __gid_t __getgid __P ((void)); +extern __gid_t getgid __P ((void)); + +/* Get the effective group ID of the calling process. */ +extern __gid_t __getegid __P ((void)); +extern __gid_t getegid __P ((void)); + +/* If SIZE is zero, return the number of supplementary groups + the calling process is in. Otherwise, fill in the group IDs + of its supplementary groups in LIST and return the number written. */ +extern int __getgroups __P ((int __size, __gid_t __list[])); +extern int getgroups __P ((int __size, __gid_t __list[])); + +/* Set the user ID of the calling process to UID. + If the calling process is the super-user, set the real + and effective user IDs, and the saved set-user-ID to UID; + if not, the effective user ID is set to UID. */ +extern int __setuid __P ((__uid_t __uid)); +extern int setuid __P ((__uid_t __uid)); + +#ifdef __USE_BSD +/* Set the real user ID of the calling process to RUID, + and the effective user ID of the calling process to EUID. */ +extern int __setreuid __P ((__uid_t __ruid, __uid_t __euid)); +extern int setreuid __P ((__uid_t __ruid, __uid_t __euid)); + +/* Set the effective user ID of the calling process to UID. */ +extern int seteuid __P ((__uid_t __uid)); +#endif /* Use BSD. */ + +/* Set the group ID of the calling process to GID. + If the calling process is the super-user, set the real + and effective group IDs, and the saved set-group-ID to GID; + if not, the effective group ID is set to GID. */ +extern int __setgid __P ((__gid_t __gid)); +extern int setgid __P ((__gid_t __gid)); + +#ifdef __USE_BSD +/* Set the real group ID of the calling process to RGID, + and the effective group ID of the calling process to EGID. */ +extern int __setregid __P ((__gid_t __rgid, __gid_t __egid)); +extern int setregid __P ((__gid_t __rgid, __gid_t __egid)); + +/* Set the effective group ID of the calling process to GID. */ +extern int setegid __P ((__gid_t __gid)); +#endif /* Use BSD. */ + + +/* Clone the calling process, creating an exact copy. + Return -1 for errors, 0 to the new process, + and the process ID of the new process to the old process. */ +extern __pid_t __fork __P ((void)); +extern __pid_t fork __P ((void)); + +#ifdef __USE_BSD +/* Clone the calling process, but without copying the whole address space. + The the calling process is suspended until the the new process exits or is + replaced by a call to `execve'. Return -1 for errors, 0 to the new process, + and the process ID of the new process to the old process. */ +extern __pid_t __vfork __P ((void)); +extern __pid_t vfork __P ((void)); +#endif /* Use BSD. */ + + +/* Return the pathname of the terminal FD is open on, or NULL on errors. + The returned storage is good only until the next call to this function. */ +extern char *ttyname __P ((int __fd)); + +/* Return 1 if FD is a valid descriptor associated + with a terminal, zero if not. */ +extern int __isatty __P ((int __fd)); +extern int isatty __P ((int __fd)); + + +/* Make a link to FROM named TO. */ +extern int __link __P ((__const char *__from, __const char *__to)); +extern int link __P ((__const char *__from, __const char *__to)); + +#ifdef __USE_BSD +/* Make a symbolic link to FROM named TO. */ +extern int __symlink __P ((__const char *__from, __const char *__to)); +extern int symlink __P ((__const char *__from, __const char *__to)); + +/* Read the contents of the symbolic link PATH into no more than + LEN bytes of BUF. The contents are not null-terminated. + Returns the number of characters read, or -1 for errors. */ +extern int __readlink __P ((__const char *__path, char *__buf, size_t __len)); +extern int readlink __P ((__const char *__path, char *__buf, size_t __len)); +#endif /* Use BSD. */ + +/* Remove the link NAME. */ +extern int __unlink __P ((__const char *__name)); +extern int unlink __P ((__const char *__name)); + +/* Remove the directory PATH. */ +extern int __rmdir __P ((__const char *__path)); +extern int rmdir __P ((__const char *__path)); + + +/* Return the foreground process group ID of FD. */ +extern __pid_t tcgetpgrp __P ((int __fd)); + +/* Set the foreground process group ID of FD set PGRP_ID. */ +extern int tcsetpgrp __P ((int __fd, __pid_t __pgrp_id)); + + +/* Return the login name of the user. */ +extern char *getlogin __P ((void)); + +#ifdef __USE_BSD +/* Set the login name returned by `getlogin'. */ +extern int setlogin __P ((__const char *__name)); +#endif + + +#ifdef __USE_POSIX2 +/* Process the arguments in ARGV (ARGC of them, minus + the program name) for options given in OPTS. + + If `opterr' is zero, no messages are generated + for invalid options; it defaults to 1. + `optind' is the current index into ARGV. + `optarg' is the argument corresponding to the current option. + Return the option character from OPTS just read. + Return -1 when there are no more options. + For unrecognized options, or options missing arguments, + `optopt' is set to the option letter, and '?' is returned. + + The OPTS string is a list of characters which are recognized option + letters, optionally followed by colons, specifying that that letter + takes an argument, to be placed in `optarg'. + + If a letter in OPTS is followed by two colons, its argument is optional. + This behavior is specific to the GNU `getopt'. + + The argument `--' causes premature termination of argument scanning, + explicitly telling `getopt' that there are no more options. + + If OPTS begins with `--', then non-option arguments + are treated as arguments to the option '\0'. + This behavior is specific to the GNU `getopt'. */ +extern int getopt __P ((int __argc, char *__const * __argv, + __const char *__opts)); +extern int opterr; +extern int optind; +extern int optopt; +extern char *optarg; +#endif + + +#ifdef __USE_BSD + +/* Put the name of the current host in no more than LEN bytes of NAME. + The result is null-terminated if LEN is large enough for the full + name and the terminator. */ +extern int __gethostname __P ((char *__name, size_t __len)); +extern int gethostname __P ((char *__name, size_t __len)); + +/* Set the name of the current host to NAME, which is LEN bytes long. + This call is restricted to the super-user. */ +extern int sethostname __P ((__const char *__name, size_t __len)); + +/* Return the current machine's Internet number. */ +extern long int gethostid __P ((void)); + +/* Set the current machine's Internet number to ID. + This call is restricted to the super-user. */ +extern int sethostid __P ((long int __id)); + + +/* Return the number of bytes in a page. This is the system's page size, + which is not necessarily the same as the hardware page size. */ +extern size_t __getpagesize __P ((void)); +extern size_t getpagesize __P ((void)); + + +/* Return the maximum number of file descriptors + the current process could possibly have. */ +extern int __getdtablesize __P ((void)); +extern int getdtablesize __P ((void)); + + +/* Truncate FILE to LENGTH bytes. */ +extern int truncate __P ((__const char *__file, __off_t __length)); + +/* Truncate the file FD is open on to LENGTH bytes. */ +extern int ftruncate __P ((int __fd, __off_t __length)); + + +/* Make all changes done to FD actually appear on disk. */ +extern int fsync __P ((int __fd)); + +/* Make all changes done to all files actually appear on disk. */ +extern int sync __P ((void)); + + +/* Revoke access permissions to all processes currently communicating + with the control terminal, and then send a SIGHUP signal to the process + group of the control terminal. */ +extern int vhangup __P ((void)); + + +/* Turn accounting on if NAME is an existing file. The system will then write + a record for each process as it terminates, to this file. If NAME is NULL, + turn accounting off. This call is restricted to the super-user. */ +extern int acct __P ((__const char *__name)); + +/* Make PATH be the root directory (the starting point for absolute paths). + This call is restricted to the super-user. */ +extern int chroot __P ((__const char *__path)); + +/* Make the block special device PATH available to the system for swapping. + This call is restricted to the super-user. */ +extern int swapon __P ((__const char *__path)); + +/* Reboot or halt the system. */ +extern int reboot __P ((int __howto)); + + +/* Successive calls return the shells listed in `/etc/shells'. */ +extern char *getusershell __P ((void)); +extern void endusershell __P ((void)); /* Discard cached info. */ +extern void setusershell __P ((void)); /* Rewind and re-read the file. */ + + +/* Prompt with PROMPT and read a string from the terminal without echoing. + Uses /dev/tty if possible; otherwise stderr and stdin. */ +extern char *getpass __P ((const char *__prompt)); + +/* Put the program in the background, and dissociate from the controlling + terminal. If NOCHDIR is zero, do `chdir ("/")'. If NOCLOSE is zero, + redirects stdin, stdout, and stderr to /dev/null. */ +extern int daemon __P ((int __nochdir, int __noclose)); + +#endif /* Use BSD. */ + + +#ifdef __USE_MISC + +/* Generate a unique temporary file name from TEMPLATE. + The last six characters of TEMPLATE must be "XXXXXX"; + they are replaced with a string that makes the file name unique. + Returns TEMPLATE, or a null pointer if it cannot get a unique file name. */ +extern char *mktemp __P ((char *__template)); + +/* Generate a unique temporary file name from TEMPLATE. + The last six characters of TEMPLATE must be "XXXXXX"; + they are replaced with a string that makes the filename unique. + Returns a file descriptor open on the file for reading and writing, + or -1 if it cannot create a uniquely-named file. */ +extern int mkstemp __P ((char *__template)); + + +/* Invoke `system call' number SYSNO, passing it the remaining arguments. + This is completely system-dependent, and not often useful. + + In Unix, `syscall' sets `errno' for all errors and most calls return -1 + for errors; in many systems you cannot pass arguments or get return + values for all system calls (`pipe', `fork', and `getppid' typically + among them). + + In Mach, all system calls take normal arguments and always return an + error code (zero for success). */ +extern int syscall __P ((int __sysno, ...)); + +#endif /* Use misc. */ + + +#if defined (__USE_MISC) && !defined (F_LOCK) +/* NOTE: These declarations also appear in <fcntl.h>; be sure to keep both + files consistent. Some systems have them there and some here, and some + software depends on the macros being defined without including both. */ + +/* `lockf' is a simpler interface to the locking facilities of `fcntl'. + LEN is always relative to the current file position. + The CMD argument is one of the following. */ + +#define F_ULOCK 0 /* Unlock a previously locked region. */ +#define F_LOCK 1 /* Lock a region for exclusive use. */ +#define F_TLOCK 2 /* Test and lock a region for exclusive use. */ +#define F_TEST 3 /* Test a region for other processes locks. */ + +extern int lockf __P ((int __fd, int __cmd, __off_t __len)); +#endif /* Use misc and F_LOCK not already defined. */ + + +#ifdef __USE_GNU + +/* Evaluate EXPRESSION, and repeat as long as it returns -1 with `errno' + set to EINTR. */ + +#define TEMP_FAILURE_RETRY(expression) \ + ({ long int __result; \ + do __result = (long int) (expression); \ + while (__result == -1L && errno == EINTR); \ + __result; }) + +#endif + +__END_DECLS + +#endif /* unistd.h */ |