| This is libc.info, produced by makeinfo version 5.2 from libc.texinfo. |
| |
| This file documents the GNU C Library. |
| |
| This is 'The GNU C Library Reference Manual', for version 2.19 |
| (Buildroot). |
| |
| Copyright (C) 1993-2014 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "Free Software Needs Free Documentation" and |
| "GNU Lesser General Public License", the Front-Cover texts being "A GNU |
| Manual", and with the Back-Cover Texts as in (a) below. A copy of the |
| license is included in the section entitled "GNU Free Documentation |
| License". |
| |
| (a) The FSF's Back-Cover Text is: "You have the freedom to copy and |
| modify this GNU manual. Buying copies from the FSF supports it in |
| developing GNU and promoting software freedom." |
| INFO-DIR-SECTION Software libraries |
| START-INFO-DIR-ENTRY |
| * Libc: (libc). C library. |
| END-INFO-DIR-ENTRY |
| |
| INFO-DIR-SECTION GNU C library functions and macros |
| START-INFO-DIR-ENTRY |
| * ALTWERASE: (libc)Local Modes. |
| * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. |
| * ARG_MAX: (libc)General Limits. |
| * BC_BASE_MAX: (libc)Utility Limits. |
| * BC_DIM_MAX: (libc)Utility Limits. |
| * BC_SCALE_MAX: (libc)Utility Limits. |
| * BC_STRING_MAX: (libc)Utility Limits. |
| * BRKINT: (libc)Input Modes. |
| * BUFSIZ: (libc)Controlling Buffering. |
| * CCTS_OFLOW: (libc)Control Modes. |
| * CHILD_MAX: (libc)General Limits. |
| * CIGNORE: (libc)Control Modes. |
| * CLK_TCK: (libc)Processor Time. |
| * CLOCAL: (libc)Control Modes. |
| * CLOCKS_PER_SEC: (libc)CPU Time. |
| * COLL_WEIGHTS_MAX: (libc)Utility Limits. |
| * CPU_CLR: (libc)CPU Affinity. |
| * CPU_ISSET: (libc)CPU Affinity. |
| * CPU_SET: (libc)CPU Affinity. |
| * CPU_SETSIZE: (libc)CPU Affinity. |
| * CPU_ZERO: (libc)CPU Affinity. |
| * CREAD: (libc)Control Modes. |
| * CRTS_IFLOW: (libc)Control Modes. |
| * CS5: (libc)Control Modes. |
| * CS6: (libc)Control Modes. |
| * CS7: (libc)Control Modes. |
| * CS8: (libc)Control Modes. |
| * CSIZE: (libc)Control Modes. |
| * CSTOPB: (libc)Control Modes. |
| * DES_FAILED: (libc)DES Encryption. |
| * DTTOIF: (libc)Directory Entries. |
| * E2BIG: (libc)Error Codes. |
| * EACCES: (libc)Error Codes. |
| * EADDRINUSE: (libc)Error Codes. |
| * EADDRNOTAVAIL: (libc)Error Codes. |
| * EADV: (libc)Error Codes. |
| * EAFNOSUPPORT: (libc)Error Codes. |
| * EAGAIN: (libc)Error Codes. |
| * EALREADY: (libc)Error Codes. |
| * EAUTH: (libc)Error Codes. |
| * EBACKGROUND: (libc)Error Codes. |
| * EBADE: (libc)Error Codes. |
| * EBADF: (libc)Error Codes. |
| * EBADFD: (libc)Error Codes. |
| * EBADMSG: (libc)Error Codes. |
| * EBADR: (libc)Error Codes. |
| * EBADRPC: (libc)Error Codes. |
| * EBADRQC: (libc)Error Codes. |
| * EBADSLT: (libc)Error Codes. |
| * EBFONT: (libc)Error Codes. |
| * EBUSY: (libc)Error Codes. |
| * ECANCELED: (libc)Error Codes. |
| * ECHILD: (libc)Error Codes. |
| * ECHO: (libc)Local Modes. |
| * ECHOCTL: (libc)Local Modes. |
| * ECHOE: (libc)Local Modes. |
| * ECHOK: (libc)Local Modes. |
| * ECHOKE: (libc)Local Modes. |
| * ECHONL: (libc)Local Modes. |
| * ECHOPRT: (libc)Local Modes. |
| * ECHRNG: (libc)Error Codes. |
| * ECOMM: (libc)Error Codes. |
| * ECONNABORTED: (libc)Error Codes. |
| * ECONNREFUSED: (libc)Error Codes. |
| * ECONNRESET: (libc)Error Codes. |
| * ED: (libc)Error Codes. |
| * EDEADLK: (libc)Error Codes. |
| * EDEADLOCK: (libc)Error Codes. |
| * EDESTADDRREQ: (libc)Error Codes. |
| * EDIED: (libc)Error Codes. |
| * EDOM: (libc)Error Codes. |
| * EDOTDOT: (libc)Error Codes. |
| * EDQUOT: (libc)Error Codes. |
| * EEXIST: (libc)Error Codes. |
| * EFAULT: (libc)Error Codes. |
| * EFBIG: (libc)Error Codes. |
| * EFTYPE: (libc)Error Codes. |
| * EGRATUITOUS: (libc)Error Codes. |
| * EGREGIOUS: (libc)Error Codes. |
| * EHOSTDOWN: (libc)Error Codes. |
| * EHOSTUNREACH: (libc)Error Codes. |
| * EHWPOISON: (libc)Error Codes. |
| * EIDRM: (libc)Error Codes. |
| * EIEIO: (libc)Error Codes. |
| * EILSEQ: (libc)Error Codes. |
| * EINPROGRESS: (libc)Error Codes. |
| * EINTR: (libc)Error Codes. |
| * EINVAL: (libc)Error Codes. |
| * EIO: (libc)Error Codes. |
| * EISCONN: (libc)Error Codes. |
| * EISDIR: (libc)Error Codes. |
| * EISNAM: (libc)Error Codes. |
| * EKEYEXPIRED: (libc)Error Codes. |
| * EKEYREJECTED: (libc)Error Codes. |
| * EKEYREVOKED: (libc)Error Codes. |
| * EL2HLT: (libc)Error Codes. |
| * EL2NSYNC: (libc)Error Codes. |
| * EL3HLT: (libc)Error Codes. |
| * EL3RST: (libc)Error Codes. |
| * ELIBACC: (libc)Error Codes. |
| * ELIBBAD: (libc)Error Codes. |
| * ELIBEXEC: (libc)Error Codes. |
| * ELIBMAX: (libc)Error Codes. |
| * ELIBSCN: (libc)Error Codes. |
| * ELNRNG: (libc)Error Codes. |
| * ELOOP: (libc)Error Codes. |
| * EMEDIUMTYPE: (libc)Error Codes. |
| * EMFILE: (libc)Error Codes. |
| * EMLINK: (libc)Error Codes. |
| * EMSGSIZE: (libc)Error Codes. |
| * EMULTIHOP: (libc)Error Codes. |
| * ENAMETOOLONG: (libc)Error Codes. |
| * ENAVAIL: (libc)Error Codes. |
| * ENEEDAUTH: (libc)Error Codes. |
| * ENETDOWN: (libc)Error Codes. |
| * ENETRESET: (libc)Error Codes. |
| * ENETUNREACH: (libc)Error Codes. |
| * ENFILE: (libc)Error Codes. |
| * ENOANO: (libc)Error Codes. |
| * ENOBUFS: (libc)Error Codes. |
| * ENOCSI: (libc)Error Codes. |
| * ENODATA: (libc)Error Codes. |
| * ENODEV: (libc)Error Codes. |
| * ENOENT: (libc)Error Codes. |
| * ENOEXEC: (libc)Error Codes. |
| * ENOKEY: (libc)Error Codes. |
| * ENOLCK: (libc)Error Codes. |
| * ENOLINK: (libc)Error Codes. |
| * ENOMEDIUM: (libc)Error Codes. |
| * ENOMEM: (libc)Error Codes. |
| * ENOMSG: (libc)Error Codes. |
| * ENONET: (libc)Error Codes. |
| * ENOPKG: (libc)Error Codes. |
| * ENOPROTOOPT: (libc)Error Codes. |
| * ENOSPC: (libc)Error Codes. |
| * ENOSR: (libc)Error Codes. |
| * ENOSTR: (libc)Error Codes. |
| * ENOSYS: (libc)Error Codes. |
| * ENOTBLK: (libc)Error Codes. |
| * ENOTCONN: (libc)Error Codes. |
| * ENOTDIR: (libc)Error Codes. |
| * ENOTEMPTY: (libc)Error Codes. |
| * ENOTNAM: (libc)Error Codes. |
| * ENOTRECOVERABLE: (libc)Error Codes. |
| * ENOTSOCK: (libc)Error Codes. |
| * ENOTSUP: (libc)Error Codes. |
| * ENOTTY: (libc)Error Codes. |
| * ENOTUNIQ: (libc)Error Codes. |
| * ENXIO: (libc)Error Codes. |
| * EOF: (libc)EOF and Errors. |
| * EOPNOTSUPP: (libc)Error Codes. |
| * EOVERFLOW: (libc)Error Codes. |
| * EOWNERDEAD: (libc)Error Codes. |
| * EPERM: (libc)Error Codes. |
| * EPFNOSUPPORT: (libc)Error Codes. |
| * EPIPE: (libc)Error Codes. |
| * EPROCLIM: (libc)Error Codes. |
| * EPROCUNAVAIL: (libc)Error Codes. |
| * EPROGMISMATCH: (libc)Error Codes. |
| * EPROGUNAVAIL: (libc)Error Codes. |
| * EPROTO: (libc)Error Codes. |
| * EPROTONOSUPPORT: (libc)Error Codes. |
| * EPROTOTYPE: (libc)Error Codes. |
| * EQUIV_CLASS_MAX: (libc)Utility Limits. |
| * ERANGE: (libc)Error Codes. |
| * EREMCHG: (libc)Error Codes. |
| * EREMOTE: (libc)Error Codes. |
| * EREMOTEIO: (libc)Error Codes. |
| * ERESTART: (libc)Error Codes. |
| * ERFKILL: (libc)Error Codes. |
| * EROFS: (libc)Error Codes. |
| * ERPCMISMATCH: (libc)Error Codes. |
| * ESHUTDOWN: (libc)Error Codes. |
| * ESOCKTNOSUPPORT: (libc)Error Codes. |
| * ESPIPE: (libc)Error Codes. |
| * ESRCH: (libc)Error Codes. |
| * ESRMNT: (libc)Error Codes. |
| * ESTALE: (libc)Error Codes. |
| * ESTRPIPE: (libc)Error Codes. |
| * ETIME: (libc)Error Codes. |
| * ETIMEDOUT: (libc)Error Codes. |
| * ETOOMANYREFS: (libc)Error Codes. |
| * ETXTBSY: (libc)Error Codes. |
| * EUCLEAN: (libc)Error Codes. |
| * EUNATCH: (libc)Error Codes. |
| * EUSERS: (libc)Error Codes. |
| * EWOULDBLOCK: (libc)Error Codes. |
| * EXDEV: (libc)Error Codes. |
| * EXFULL: (libc)Error Codes. |
| * EXIT_FAILURE: (libc)Exit Status. |
| * EXIT_SUCCESS: (libc)Exit Status. |
| * EXPR_NEST_MAX: (libc)Utility Limits. |
| * FD_CLOEXEC: (libc)Descriptor Flags. |
| * FD_CLR: (libc)Waiting for I/O. |
| * FD_ISSET: (libc)Waiting for I/O. |
| * FD_SET: (libc)Waiting for I/O. |
| * FD_SETSIZE: (libc)Waiting for I/O. |
| * FD_ZERO: (libc)Waiting for I/O. |
| * FILENAME_MAX: (libc)Limits for Files. |
| * FLUSHO: (libc)Local Modes. |
| * FOPEN_MAX: (libc)Opening Streams. |
| * FP_ILOGB0: (libc)Exponents and Logarithms. |
| * FP_ILOGBNAN: (libc)Exponents and Logarithms. |
| * F_DUPFD: (libc)Duplicating Descriptors. |
| * F_GETFD: (libc)Descriptor Flags. |
| * F_GETFL: (libc)Getting File Status Flags. |
| * F_GETLK: (libc)File Locks. |
| * F_GETOWN: (libc)Interrupt Input. |
| * F_OK: (libc)Testing File Access. |
| * F_SETFD: (libc)Descriptor Flags. |
| * F_SETFL: (libc)Getting File Status Flags. |
| * F_SETLK: (libc)File Locks. |
| * F_SETLKW: (libc)File Locks. |
| * F_SETOWN: (libc)Interrupt Input. |
| * HUGE_VAL: (libc)Math Error Reporting. |
| * HUGE_VALF: (libc)Math Error Reporting. |
| * HUGE_VALL: (libc)Math Error Reporting. |
| * HUPCL: (libc)Control Modes. |
| * I: (libc)Complex Numbers. |
| * ICANON: (libc)Local Modes. |
| * ICRNL: (libc)Input Modes. |
| * IEXTEN: (libc)Local Modes. |
| * IFNAMSIZ: (libc)Interface Naming. |
| * IFTODT: (libc)Directory Entries. |
| * IGNBRK: (libc)Input Modes. |
| * IGNCR: (libc)Input Modes. |
| * IGNPAR: (libc)Input Modes. |
| * IMAXBEL: (libc)Input Modes. |
| * INADDR_ANY: (libc)Host Address Data Type. |
| * INADDR_BROADCAST: (libc)Host Address Data Type. |
| * INADDR_LOOPBACK: (libc)Host Address Data Type. |
| * INADDR_NONE: (libc)Host Address Data Type. |
| * INFINITY: (libc)Infinity and NaN. |
| * INLCR: (libc)Input Modes. |
| * INPCK: (libc)Input Modes. |
| * IPPORT_RESERVED: (libc)Ports. |
| * IPPORT_USERRESERVED: (libc)Ports. |
| * ISIG: (libc)Local Modes. |
| * ISTRIP: (libc)Input Modes. |
| * IXANY: (libc)Input Modes. |
| * IXOFF: (libc)Input Modes. |
| * IXON: (libc)Input Modes. |
| * LINE_MAX: (libc)Utility Limits. |
| * LINK_MAX: (libc)Limits for Files. |
| * L_ctermid: (libc)Identifying the Terminal. |
| * L_cuserid: (libc)Who Logged In. |
| * L_tmpnam: (libc)Temporary Files. |
| * MAXNAMLEN: (libc)Limits for Files. |
| * MAXSYMLINKS: (libc)Symbolic Links. |
| * MAX_CANON: (libc)Limits for Files. |
| * MAX_INPUT: (libc)Limits for Files. |
| * MB_CUR_MAX: (libc)Selecting the Conversion. |
| * MB_LEN_MAX: (libc)Selecting the Conversion. |
| * MDMBUF: (libc)Control Modes. |
| * MSG_DONTROUTE: (libc)Socket Data Options. |
| * MSG_OOB: (libc)Socket Data Options. |
| * MSG_PEEK: (libc)Socket Data Options. |
| * NAME_MAX: (libc)Limits for Files. |
| * NAN: (libc)Infinity and NaN. |
| * NCCS: (libc)Mode Data Types. |
| * NGROUPS_MAX: (libc)General Limits. |
| * NOFLSH: (libc)Local Modes. |
| * NOKERNINFO: (libc)Local Modes. |
| * NSIG: (libc)Standard Signals. |
| * NULL: (libc)Null Pointer Constant. |
| * ONLCR: (libc)Output Modes. |
| * ONOEOT: (libc)Output Modes. |
| * OPEN_MAX: (libc)General Limits. |
| * OPOST: (libc)Output Modes. |
| * OXTABS: (libc)Output Modes. |
| * O_ACCMODE: (libc)Access Modes. |
| * O_APPEND: (libc)Operating Modes. |
| * O_ASYNC: (libc)Operating Modes. |
| * O_CREAT: (libc)Open-time Flags. |
| * O_EXCL: (libc)Open-time Flags. |
| * O_EXEC: (libc)Access Modes. |
| * O_EXLOCK: (libc)Open-time Flags. |
| * O_FSYNC: (libc)Operating Modes. |
| * O_IGNORE_CTTY: (libc)Open-time Flags. |
| * O_NDELAY: (libc)Operating Modes. |
| * O_NOATIME: (libc)Operating Modes. |
| * O_NOCTTY: (libc)Open-time Flags. |
| * O_NOLINK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Operating Modes. |
| * O_NOTRANS: (libc)Open-time Flags. |
| * O_RDONLY: (libc)Access Modes. |
| * O_RDWR: (libc)Access Modes. |
| * O_READ: (libc)Access Modes. |
| * O_SHLOCK: (libc)Open-time Flags. |
| * O_SYNC: (libc)Operating Modes. |
| * O_TRUNC: (libc)Open-time Flags. |
| * O_WRITE: (libc)Access Modes. |
| * O_WRONLY: (libc)Access Modes. |
| * PARENB: (libc)Control Modes. |
| * PARMRK: (libc)Input Modes. |
| * PARODD: (libc)Control Modes. |
| * PATH_MAX: (libc)Limits for Files. |
| * PA_FLAG_MASK: (libc)Parsing a Template String. |
| * PENDIN: (libc)Local Modes. |
| * PF_FILE: (libc)Local Namespace Details. |
| * PF_INET6: (libc)Internet Namespace. |
| * PF_INET: (libc)Internet Namespace. |
| * PF_LOCAL: (libc)Local Namespace Details. |
| * PF_UNIX: (libc)Local Namespace Details. |
| * PIPE_BUF: (libc)Limits for Files. |
| * P_tmpdir: (libc)Temporary Files. |
| * RAND_MAX: (libc)ISO Random. |
| * RE_DUP_MAX: (libc)General Limits. |
| * RLIM_INFINITY: (libc)Limits on Resources. |
| * R_OK: (libc)Testing File Access. |
| * SA_NOCLDSTOP: (libc)Flags for Sigaction. |
| * SA_ONSTACK: (libc)Flags for Sigaction. |
| * SA_RESTART: (libc)Flags for Sigaction. |
| * SEEK_CUR: (libc)File Positioning. |
| * SEEK_END: (libc)File Positioning. |
| * SEEK_SET: (libc)File Positioning. |
| * SIGABRT: (libc)Program Error Signals. |
| * SIGALRM: (libc)Alarm Signals. |
| * SIGBUS: (libc)Program Error Signals. |
| * SIGCHLD: (libc)Job Control Signals. |
| * SIGCLD: (libc)Job Control Signals. |
| * SIGCONT: (libc)Job Control Signals. |
| * SIGEMT: (libc)Program Error Signals. |
| * SIGFPE: (libc)Program Error Signals. |
| * SIGHUP: (libc)Termination Signals. |
| * SIGILL: (libc)Program Error Signals. |
| * SIGINFO: (libc)Miscellaneous Signals. |
| * SIGINT: (libc)Termination Signals. |
| * SIGIO: (libc)Asynchronous I/O Signals. |
| * SIGIOT: (libc)Program Error Signals. |
| * SIGKILL: (libc)Termination Signals. |
| * SIGLOST: (libc)Operation Error Signals. |
| * SIGPIPE: (libc)Operation Error Signals. |
| * SIGPOLL: (libc)Asynchronous I/O Signals. |
| * SIGPROF: (libc)Alarm Signals. |
| * SIGQUIT: (libc)Termination Signals. |
| * SIGSEGV: (libc)Program Error Signals. |
| * SIGSTOP: (libc)Job Control Signals. |
| * SIGSYS: (libc)Program Error Signals. |
| * SIGTERM: (libc)Termination Signals. |
| * SIGTRAP: (libc)Program Error Signals. |
| * SIGTSTP: (libc)Job Control Signals. |
| * SIGTTIN: (libc)Job Control Signals. |
| * SIGTTOU: (libc)Job Control Signals. |
| * SIGURG: (libc)Asynchronous I/O Signals. |
| * SIGUSR1: (libc)Miscellaneous Signals. |
| * SIGUSR2: (libc)Miscellaneous Signals. |
| * SIGVTALRM: (libc)Alarm Signals. |
| * SIGWINCH: (libc)Miscellaneous Signals. |
| * SIGXCPU: (libc)Operation Error Signals. |
| * SIGXFSZ: (libc)Operation Error Signals. |
| * SIG_ERR: (libc)Basic Signal Handling. |
| * SOCK_DGRAM: (libc)Communication Styles. |
| * SOCK_RAW: (libc)Communication Styles. |
| * SOCK_RDM: (libc)Communication Styles. |
| * SOCK_SEQPACKET: (libc)Communication Styles. |
| * SOCK_STREAM: (libc)Communication Styles. |
| * SOL_SOCKET: (libc)Socket-Level Options. |
| * SSIZE_MAX: (libc)General Limits. |
| * STREAM_MAX: (libc)General Limits. |
| * SUN_LEN: (libc)Local Namespace Details. |
| * SV_INTERRUPT: (libc)BSD Handler. |
| * SV_ONSTACK: (libc)BSD Handler. |
| * SV_RESETHAND: (libc)BSD Handler. |
| * S_IFMT: (libc)Testing File Type. |
| * S_ISBLK: (libc)Testing File Type. |
| * S_ISCHR: (libc)Testing File Type. |
| * S_ISDIR: (libc)Testing File Type. |
| * S_ISFIFO: (libc)Testing File Type. |
| * S_ISLNK: (libc)Testing File Type. |
| * S_ISREG: (libc)Testing File Type. |
| * S_ISSOCK: (libc)Testing File Type. |
| * S_TYPEISMQ: (libc)Testing File Type. |
| * S_TYPEISSEM: (libc)Testing File Type. |
| * S_TYPEISSHM: (libc)Testing File Type. |
| * TMP_MAX: (libc)Temporary Files. |
| * TOSTOP: (libc)Local Modes. |
| * TZNAME_MAX: (libc)General Limits. |
| * VDISCARD: (libc)Other Special. |
| * VDSUSP: (libc)Signal Characters. |
| * VEOF: (libc)Editing Characters. |
| * VEOL2: (libc)Editing Characters. |
| * VEOL: (libc)Editing Characters. |
| * VERASE: (libc)Editing Characters. |
| * VINTR: (libc)Signal Characters. |
| * VKILL: (libc)Editing Characters. |
| * VLNEXT: (libc)Other Special. |
| * VMIN: (libc)Noncanonical Input. |
| * VQUIT: (libc)Signal Characters. |
| * VREPRINT: (libc)Editing Characters. |
| * VSTART: (libc)Start/Stop Characters. |
| * VSTATUS: (libc)Other Special. |
| * VSTOP: (libc)Start/Stop Characters. |
| * VSUSP: (libc)Signal Characters. |
| * VTIME: (libc)Noncanonical Input. |
| * VWERASE: (libc)Editing Characters. |
| * WCHAR_MAX: (libc)Extended Char Intro. |
| * WCHAR_MIN: (libc)Extended Char Intro. |
| * WCOREDUMP: (libc)Process Completion Status. |
| * WEOF: (libc)EOF and Errors. |
| * WEOF: (libc)Extended Char Intro. |
| * WEXITSTATUS: (libc)Process Completion Status. |
| * WIFEXITED: (libc)Process Completion Status. |
| * WIFSIGNALED: (libc)Process Completion Status. |
| * WIFSTOPPED: (libc)Process Completion Status. |
| * WSTOPSIG: (libc)Process Completion Status. |
| * WTERMSIG: (libc)Process Completion Status. |
| * W_OK: (libc)Testing File Access. |
| * X_OK: (libc)Testing File Access. |
| * _Complex_I: (libc)Complex Numbers. |
| * _Exit: (libc)Termination Internals. |
| * _IOFBF: (libc)Controlling Buffering. |
| * _IOLBF: (libc)Controlling Buffering. |
| * _IONBF: (libc)Controlling Buffering. |
| * _Imaginary_I: (libc)Complex Numbers. |
| * _PATH_UTMP: (libc)Manipulating the Database. |
| * _PATH_WTMP: (libc)Manipulating the Database. |
| * _POSIX2_C_DEV: (libc)System Options. |
| * _POSIX2_C_VERSION: (libc)Version Supported. |
| * _POSIX2_FORT_DEV: (libc)System Options. |
| * _POSIX2_FORT_RUN: (libc)System Options. |
| * _POSIX2_LOCALEDEF: (libc)System Options. |
| * _POSIX2_SW_DEV: (libc)System Options. |
| * _POSIX_CHOWN_RESTRICTED: (libc)Options for Files. |
| * _POSIX_JOB_CONTROL: (libc)System Options. |
| * _POSIX_NO_TRUNC: (libc)Options for Files. |
| * _POSIX_SAVED_IDS: (libc)System Options. |
| * _POSIX_VDISABLE: (libc)Options for Files. |
| * _POSIX_VERSION: (libc)Version Supported. |
| * __fbufsize: (libc)Controlling Buffering. |
| * __flbf: (libc)Controlling Buffering. |
| * __fpending: (libc)Controlling Buffering. |
| * __fpurge: (libc)Flushing Buffers. |
| * __freadable: (libc)Opening Streams. |
| * __freading: (libc)Opening Streams. |
| * __fsetlocking: (libc)Streams and Threads. |
| * __fwritable: (libc)Opening Streams. |
| * __fwriting: (libc)Opening Streams. |
| * __gconv_end_fct: (libc)glibc iconv Implementation. |
| * __gconv_fct: (libc)glibc iconv Implementation. |
| * __gconv_init_fct: (libc)glibc iconv Implementation. |
| * __ppc_get_timebase: (libc)PowerPC. |
| * __ppc_get_timebase_freq: (libc)PowerPC. |
| * __ppc_mdoio: (libc)PowerPC. |
| * __ppc_mdoom: (libc)PowerPC. |
| * __ppc_set_ppr_low: (libc)PowerPC. |
| * __ppc_set_ppr_med: (libc)PowerPC. |
| * __ppc_set_ppr_med_low: (libc)PowerPC. |
| * __ppc_yield: (libc)PowerPC. |
| * __va_copy: (libc)Argument Macros. |
| * _exit: (libc)Termination Internals. |
| * _flushlbf: (libc)Flushing Buffers. |
| * _tolower: (libc)Case Conversion. |
| * _toupper: (libc)Case Conversion. |
| * a64l: (libc)Encode Binary Data. |
| * abort: (libc)Aborting a Program. |
| * abs: (libc)Absolute Value. |
| * accept: (libc)Accepting Connections. |
| * access: (libc)Testing File Access. |
| * acos: (libc)Inverse Trig Functions. |
| * acosf: (libc)Inverse Trig Functions. |
| * acosh: (libc)Hyperbolic Functions. |
| * acoshf: (libc)Hyperbolic Functions. |
| * acoshl: (libc)Hyperbolic Functions. |
| * acosl: (libc)Inverse Trig Functions. |
| * addmntent: (libc)mtab. |
| * addseverity: (libc)Adding Severity Classes. |
| * adjtime: (libc)High-Resolution Calendar. |
| * adjtimex: (libc)High-Resolution Calendar. |
| * aio_cancel64: (libc)Cancel AIO Operations. |
| * aio_cancel: (libc)Cancel AIO Operations. |
| * aio_error64: (libc)Status of AIO Operations. |
| * aio_error: (libc)Status of AIO Operations. |
| * aio_fsync64: (libc)Synchronizing AIO Operations. |
| * aio_fsync: (libc)Synchronizing AIO Operations. |
| * aio_init: (libc)Configuration of AIO. |
| * aio_read64: (libc)Asynchronous Reads/Writes. |
| * aio_read: (libc)Asynchronous Reads/Writes. |
| * aio_return64: (libc)Status of AIO Operations. |
| * aio_return: (libc)Status of AIO Operations. |
| * aio_suspend64: (libc)Synchronizing AIO Operations. |
| * aio_suspend: (libc)Synchronizing AIO Operations. |
| * aio_write64: (libc)Asynchronous Reads/Writes. |
| * aio_write: (libc)Asynchronous Reads/Writes. |
| * alarm: (libc)Setting an Alarm. |
| * aligned_alloc: (libc)Aligned Memory Blocks. |
| * alloca: (libc)Variable Size Automatic. |
| * alphasort64: (libc)Scanning Directory Content. |
| * alphasort: (libc)Scanning Directory Content. |
| * argp_error: (libc)Argp Helper Functions. |
| * argp_failure: (libc)Argp Helper Functions. |
| * argp_help: (libc)Argp Help. |
| * argp_parse: (libc)Argp. |
| * argp_state_help: (libc)Argp Helper Functions. |
| * argp_usage: (libc)Argp Helper Functions. |
| * argz_add: (libc)Argz Functions. |
| * argz_add_sep: (libc)Argz Functions. |
| * argz_append: (libc)Argz Functions. |
| * argz_count: (libc)Argz Functions. |
| * argz_create: (libc)Argz Functions. |
| * argz_create_sep: (libc)Argz Functions. |
| * argz_delete: (libc)Argz Functions. |
| * argz_extract: (libc)Argz Functions. |
| * argz_insert: (libc)Argz Functions. |
| * argz_next: (libc)Argz Functions. |
| * argz_replace: (libc)Argz Functions. |
| * argz_stringify: (libc)Argz Functions. |
| * asctime: (libc)Formatting Calendar Time. |
| * asctime_r: (libc)Formatting Calendar Time. |
| * asin: (libc)Inverse Trig Functions. |
| * asinf: (libc)Inverse Trig Functions. |
| * asinh: (libc)Hyperbolic Functions. |
| * asinhf: (libc)Hyperbolic Functions. |
| * asinhl: (libc)Hyperbolic Functions. |
| * asinl: (libc)Inverse Trig Functions. |
| * asprintf: (libc)Dynamic Output. |
| * assert: (libc)Consistency Checking. |
| * assert_perror: (libc)Consistency Checking. |
| * atan2: (libc)Inverse Trig Functions. |
| * atan2f: (libc)Inverse Trig Functions. |
| * atan2l: (libc)Inverse Trig Functions. |
| * atan: (libc)Inverse Trig Functions. |
| * atanf: (libc)Inverse Trig Functions. |
| * atanh: (libc)Hyperbolic Functions. |
| * atanhf: (libc)Hyperbolic Functions. |
| * atanhl: (libc)Hyperbolic Functions. |
| * atanl: (libc)Inverse Trig Functions. |
| * atexit: (libc)Cleanups on Exit. |
| * atof: (libc)Parsing of Floats. |
| * atoi: (libc)Parsing of Integers. |
| * atol: (libc)Parsing of Integers. |
| * atoll: (libc)Parsing of Integers. |
| * backtrace: (libc)Backtraces. |
| * backtrace_symbols: (libc)Backtraces. |
| * backtrace_symbols_fd: (libc)Backtraces. |
| * basename: (libc)Finding Tokens in a String. |
| * basename: (libc)Finding Tokens in a String. |
| * bcmp: (libc)String/Array Comparison. |
| * bcopy: (libc)Copying and Concatenation. |
| * bind: (libc)Setting Address. |
| * bind_textdomain_codeset: (libc)Charset conversion in gettext. |
| * bindtextdomain: (libc)Locating gettext catalog. |
| * brk: (libc)Resizing the Data Segment. |
| * bsearch: (libc)Array Search Function. |
| * btowc: (libc)Converting a Character. |
| * bzero: (libc)Copying and Concatenation. |
| * cabs: (libc)Absolute Value. |
| * cabsf: (libc)Absolute Value. |
| * cabsl: (libc)Absolute Value. |
| * cacos: (libc)Inverse Trig Functions. |
| * cacosf: (libc)Inverse Trig Functions. |
| * cacosh: (libc)Hyperbolic Functions. |
| * cacoshf: (libc)Hyperbolic Functions. |
| * cacoshl: (libc)Hyperbolic Functions. |
| * cacosl: (libc)Inverse Trig Functions. |
| * calloc: (libc)Allocating Cleared Space. |
| * canonicalize_file_name: (libc)Symbolic Links. |
| * carg: (libc)Operations on Complex. |
| * cargf: (libc)Operations on Complex. |
| * cargl: (libc)Operations on Complex. |
| * casin: (libc)Inverse Trig Functions. |
| * casinf: (libc)Inverse Trig Functions. |
| * casinh: (libc)Hyperbolic Functions. |
| * casinhf: (libc)Hyperbolic Functions. |
| * casinhl: (libc)Hyperbolic Functions. |
| * casinl: (libc)Inverse Trig Functions. |
| * catan: (libc)Inverse Trig Functions. |
| * catanf: (libc)Inverse Trig Functions. |
| * catanh: (libc)Hyperbolic Functions. |
| * catanhf: (libc)Hyperbolic Functions. |
| * catanhl: (libc)Hyperbolic Functions. |
| * catanl: (libc)Inverse Trig Functions. |
| * catclose: (libc)The catgets Functions. |
| * catgets: (libc)The catgets Functions. |
| * catopen: (libc)The catgets Functions. |
| * cbc_crypt: (libc)DES Encryption. |
| * cbrt: (libc)Exponents and Logarithms. |
| * cbrtf: (libc)Exponents and Logarithms. |
| * cbrtl: (libc)Exponents and Logarithms. |
| * ccos: (libc)Trig Functions. |
| * ccosf: (libc)Trig Functions. |
| * ccosh: (libc)Hyperbolic Functions. |
| * ccoshf: (libc)Hyperbolic Functions. |
| * ccoshl: (libc)Hyperbolic Functions. |
| * ccosl: (libc)Trig Functions. |
| * ceil: (libc)Rounding Functions. |
| * ceilf: (libc)Rounding Functions. |
| * ceill: (libc)Rounding Functions. |
| * cexp: (libc)Exponents and Logarithms. |
| * cexpf: (libc)Exponents and Logarithms. |
| * cexpl: (libc)Exponents and Logarithms. |
| * cfgetispeed: (libc)Line Speed. |
| * cfgetospeed: (libc)Line Speed. |
| * cfmakeraw: (libc)Noncanonical Input. |
| * cfree: (libc)Freeing after Malloc. |
| * cfsetispeed: (libc)Line Speed. |
| * cfsetospeed: (libc)Line Speed. |
| * cfsetspeed: (libc)Line Speed. |
| * chdir: (libc)Working Directory. |
| * chmod: (libc)Setting Permissions. |
| * chown: (libc)File Owner. |
| * cimag: (libc)Operations on Complex. |
| * cimagf: (libc)Operations on Complex. |
| * cimagl: (libc)Operations on Complex. |
| * clearenv: (libc)Environment Access. |
| * clearerr: (libc)Error Recovery. |
| * clearerr_unlocked: (libc)Error Recovery. |
| * clock: (libc)CPU Time. |
| * clog10: (libc)Exponents and Logarithms. |
| * clog10f: (libc)Exponents and Logarithms. |
| * clog10l: (libc)Exponents and Logarithms. |
| * clog: (libc)Exponents and Logarithms. |
| * clogf: (libc)Exponents and Logarithms. |
| * clogl: (libc)Exponents and Logarithms. |
| * close: (libc)Opening and Closing Files. |
| * closedir: (libc)Reading/Closing Directory. |
| * closelog: (libc)closelog. |
| * confstr: (libc)String Parameters. |
| * conj: (libc)Operations on Complex. |
| * conjf: (libc)Operations on Complex. |
| * conjl: (libc)Operations on Complex. |
| * connect: (libc)Connecting. |
| * copysign: (libc)FP Bit Twiddling. |
| * copysignf: (libc)FP Bit Twiddling. |
| * copysignl: (libc)FP Bit Twiddling. |
| * cos: (libc)Trig Functions. |
| * cosf: (libc)Trig Functions. |
| * cosh: (libc)Hyperbolic Functions. |
| * coshf: (libc)Hyperbolic Functions. |
| * coshl: (libc)Hyperbolic Functions. |
| * cosl: (libc)Trig Functions. |
| * cpow: (libc)Exponents and Logarithms. |
| * cpowf: (libc)Exponents and Logarithms. |
| * cpowl: (libc)Exponents and Logarithms. |
| * cproj: (libc)Operations on Complex. |
| * cprojf: (libc)Operations on Complex. |
| * cprojl: (libc)Operations on Complex. |
| * creal: (libc)Operations on Complex. |
| * crealf: (libc)Operations on Complex. |
| * creall: (libc)Operations on Complex. |
| * creat64: (libc)Opening and Closing Files. |
| * creat: (libc)Opening and Closing Files. |
| * crypt: (libc)crypt. |
| * crypt_r: (libc)crypt. |
| * csin: (libc)Trig Functions. |
| * csinf: (libc)Trig Functions. |
| * csinh: (libc)Hyperbolic Functions. |
| * csinhf: (libc)Hyperbolic Functions. |
| * csinhl: (libc)Hyperbolic Functions. |
| * csinl: (libc)Trig Functions. |
| * csqrt: (libc)Exponents and Logarithms. |
| * csqrtf: (libc)Exponents and Logarithms. |
| * csqrtl: (libc)Exponents and Logarithms. |
| * ctan: (libc)Trig Functions. |
| * ctanf: (libc)Trig Functions. |
| * ctanh: (libc)Hyperbolic Functions. |
| * ctanhf: (libc)Hyperbolic Functions. |
| * ctanhl: (libc)Hyperbolic Functions. |
| * ctanl: (libc)Trig Functions. |
| * ctermid: (libc)Identifying the Terminal. |
| * ctime: (libc)Formatting Calendar Time. |
| * ctime_r: (libc)Formatting Calendar Time. |
| * cuserid: (libc)Who Logged In. |
| * dcgettext: (libc)Translation with gettext. |
| * dcngettext: (libc)Advanced gettext functions. |
| * des_setparity: (libc)DES Encryption. |
| * dgettext: (libc)Translation with gettext. |
| * difftime: (libc)Elapsed Time. |
| * dirfd: (libc)Opening a Directory. |
| * dirname: (libc)Finding Tokens in a String. |
| * div: (libc)Integer Division. |
| * dngettext: (libc)Advanced gettext functions. |
| * drand48: (libc)SVID Random. |
| * drand48_r: (libc)SVID Random. |
| * drem: (libc)Remainder Functions. |
| * dremf: (libc)Remainder Functions. |
| * dreml: (libc)Remainder Functions. |
| * dup2: (libc)Duplicating Descriptors. |
| * dup: (libc)Duplicating Descriptors. |
| * ecb_crypt: (libc)DES Encryption. |
| * ecvt: (libc)System V Number Conversion. |
| * ecvt_r: (libc)System V Number Conversion. |
| * encrypt: (libc)DES Encryption. |
| * encrypt_r: (libc)DES Encryption. |
| * endfsent: (libc)fstab. |
| * endgrent: (libc)Scanning All Groups. |
| * endhostent: (libc)Host Names. |
| * endmntent: (libc)mtab. |
| * endnetent: (libc)Networks Database. |
| * endnetgrent: (libc)Lookup Netgroup. |
| * endprotoent: (libc)Protocols Database. |
| * endpwent: (libc)Scanning All Users. |
| * endservent: (libc)Services Database. |
| * endutent: (libc)Manipulating the Database. |
| * endutxent: (libc)XPG Functions. |
| * envz_add: (libc)Envz Functions. |
| * envz_entry: (libc)Envz Functions. |
| * envz_get: (libc)Envz Functions. |
| * envz_merge: (libc)Envz Functions. |
| * envz_strip: (libc)Envz Functions. |
| * erand48: (libc)SVID Random. |
| * erand48_r: (libc)SVID Random. |
| * erf: (libc)Special Functions. |
| * erfc: (libc)Special Functions. |
| * erfcf: (libc)Special Functions. |
| * erfcl: (libc)Special Functions. |
| * erff: (libc)Special Functions. |
| * erfl: (libc)Special Functions. |
| * err: (libc)Error Messages. |
| * errno: (libc)Checking for Errors. |
| * error: (libc)Error Messages. |
| * error_at_line: (libc)Error Messages. |
| * errx: (libc)Error Messages. |
| * execl: (libc)Executing a File. |
| * execle: (libc)Executing a File. |
| * execlp: (libc)Executing a File. |
| * execv: (libc)Executing a File. |
| * execve: (libc)Executing a File. |
| * execvp: (libc)Executing a File. |
| * exit: (libc)Normal Termination. |
| * exp10: (libc)Exponents and Logarithms. |
| * exp10f: (libc)Exponents and Logarithms. |
| * exp10l: (libc)Exponents and Logarithms. |
| * exp2: (libc)Exponents and Logarithms. |
| * exp2f: (libc)Exponents and Logarithms. |
| * exp2l: (libc)Exponents and Logarithms. |
| * exp: (libc)Exponents and Logarithms. |
| * expf: (libc)Exponents and Logarithms. |
| * expl: (libc)Exponents and Logarithms. |
| * expm1: (libc)Exponents and Logarithms. |
| * expm1f: (libc)Exponents and Logarithms. |
| * expm1l: (libc)Exponents and Logarithms. |
| * fabs: (libc)Absolute Value. |
| * fabsf: (libc)Absolute Value. |
| * fabsl: (libc)Absolute Value. |
| * fchdir: (libc)Working Directory. |
| * fchmod: (libc)Setting Permissions. |
| * fchown: (libc)File Owner. |
| * fclose: (libc)Closing Streams. |
| * fcloseall: (libc)Closing Streams. |
| * fcntl: (libc)Control Operations. |
| * fcvt: (libc)System V Number Conversion. |
| * fcvt_r: (libc)System V Number Conversion. |
| * fdatasync: (libc)Synchronizing I/O. |
| * fdim: (libc)Misc FP Arithmetic. |
| * fdimf: (libc)Misc FP Arithmetic. |
| * fdiml: (libc)Misc FP Arithmetic. |
| * fdopen: (libc)Descriptors and Streams. |
| * fdopendir: (libc)Opening a Directory. |
| * feclearexcept: (libc)Status bit operations. |
| * fedisableexcept: (libc)Control Functions. |
| * feenableexcept: (libc)Control Functions. |
| * fegetenv: (libc)Control Functions. |
| * fegetexcept: (libc)Control Functions. |
| * fegetexceptflag: (libc)Status bit operations. |
| * fegetround: (libc)Rounding. |
| * feholdexcept: (libc)Control Functions. |
| * feof: (libc)EOF and Errors. |
| * feof_unlocked: (libc)EOF and Errors. |
| * feraiseexcept: (libc)Status bit operations. |
| * ferror: (libc)EOF and Errors. |
| * ferror_unlocked: (libc)EOF and Errors. |
| * fesetenv: (libc)Control Functions. |
| * fesetexceptflag: (libc)Status bit operations. |
| * fesetround: (libc)Rounding. |
| * fetestexcept: (libc)Status bit operations. |
| * feupdateenv: (libc)Control Functions. |
| * fflush: (libc)Flushing Buffers. |
| * fflush_unlocked: (libc)Flushing Buffers. |
| * fgetc: (libc)Character Input. |
| * fgetc_unlocked: (libc)Character Input. |
| * fgetgrent: (libc)Scanning All Groups. |
| * fgetgrent_r: (libc)Scanning All Groups. |
| * fgetpos64: (libc)Portable Positioning. |
| * fgetpos: (libc)Portable Positioning. |
| * fgetpwent: (libc)Scanning All Users. |
| * fgetpwent_r: (libc)Scanning All Users. |
| * fgets: (libc)Line Input. |
| * fgets_unlocked: (libc)Line Input. |
| * fgetwc: (libc)Character Input. |
| * fgetwc_unlocked: (libc)Character Input. |
| * fgetws: (libc)Line Input. |
| * fgetws_unlocked: (libc)Line Input. |
| * fileno: (libc)Descriptors and Streams. |
| * fileno_unlocked: (libc)Descriptors and Streams. |
| * finite: (libc)Floating Point Classes. |
| * finitef: (libc)Floating Point Classes. |
| * finitel: (libc)Floating Point Classes. |
| * flockfile: (libc)Streams and Threads. |
| * floor: (libc)Rounding Functions. |
| * floorf: (libc)Rounding Functions. |
| * floorl: (libc)Rounding Functions. |
| * fma: (libc)Misc FP Arithmetic. |
| * fmaf: (libc)Misc FP Arithmetic. |
| * fmal: (libc)Misc FP Arithmetic. |
| * fmax: (libc)Misc FP Arithmetic. |
| * fmaxf: (libc)Misc FP Arithmetic. |
| * fmaxl: (libc)Misc FP Arithmetic. |
| * fmemopen: (libc)String Streams. |
| * fmin: (libc)Misc FP Arithmetic. |
| * fminf: (libc)Misc FP Arithmetic. |
| * fminl: (libc)Misc FP Arithmetic. |
| * fmod: (libc)Remainder Functions. |
| * fmodf: (libc)Remainder Functions. |
| * fmodl: (libc)Remainder Functions. |
| * fmtmsg: (libc)Printing Formatted Messages. |
| * fnmatch: (libc)Wildcard Matching. |
| * fopen64: (libc)Opening Streams. |
| * fopen: (libc)Opening Streams. |
| * fopencookie: (libc)Streams and Cookies. |
| * fork: (libc)Creating a Process. |
| * forkpty: (libc)Pseudo-Terminal Pairs. |
| * fpathconf: (libc)Pathconf. |
| * fpclassify: (libc)Floating Point Classes. |
| * fprintf: (libc)Formatted Output Functions. |
| * fputc: (libc)Simple Output. |
| * fputc_unlocked: (libc)Simple Output. |
| * fputs: (libc)Simple Output. |
| * fputs_unlocked: (libc)Simple Output. |
| * fputwc: (libc)Simple Output. |
| * fputwc_unlocked: (libc)Simple Output. |
| * fputws: (libc)Simple Output. |
| * fputws_unlocked: (libc)Simple Output. |
| * fread: (libc)Block Input/Output. |
| * fread_unlocked: (libc)Block Input/Output. |
| * free: (libc)Freeing after Malloc. |
| * freopen64: (libc)Opening Streams. |
| * freopen: (libc)Opening Streams. |
| * frexp: (libc)Normalization Functions. |
| * frexpf: (libc)Normalization Functions. |
| * frexpl: (libc)Normalization Functions. |
| * fscanf: (libc)Formatted Input Functions. |
| * fseek: (libc)File Positioning. |
| * fseeko64: (libc)File Positioning. |
| * fseeko: (libc)File Positioning. |
| * fsetpos64: (libc)Portable Positioning. |
| * fsetpos: (libc)Portable Positioning. |
| * fstat64: (libc)Reading Attributes. |
| * fstat: (libc)Reading Attributes. |
| * fsync: (libc)Synchronizing I/O. |
| * ftell: (libc)File Positioning. |
| * ftello64: (libc)File Positioning. |
| * ftello: (libc)File Positioning. |
| * ftruncate64: (libc)File Size. |
| * ftruncate: (libc)File Size. |
| * ftrylockfile: (libc)Streams and Threads. |
| * ftw64: (libc)Working with Directory Trees. |
| * ftw: (libc)Working with Directory Trees. |
| * funlockfile: (libc)Streams and Threads. |
| * futimes: (libc)File Times. |
| * fwide: (libc)Streams and I18N. |
| * fwprintf: (libc)Formatted Output Functions. |
| * fwrite: (libc)Block Input/Output. |
| * fwrite_unlocked: (libc)Block Input/Output. |
| * fwscanf: (libc)Formatted Input Functions. |
| * gamma: (libc)Special Functions. |
| * gammaf: (libc)Special Functions. |
| * gammal: (libc)Special Functions. |
| * gcvt: (libc)System V Number Conversion. |
| * get_avphys_pages: (libc)Query Memory Parameters. |
| * get_current_dir_name: (libc)Working Directory. |
| * get_nprocs: (libc)Processor Resources. |
| * get_nprocs_conf: (libc)Processor Resources. |
| * get_phys_pages: (libc)Query Memory Parameters. |
| * getauxval: (libc)Auxiliary Vector. |
| * getc: (libc)Character Input. |
| * getc_unlocked: (libc)Character Input. |
| * getchar: (libc)Character Input. |
| * getchar_unlocked: (libc)Character Input. |
| * getcontext: (libc)System V contexts. |
| * getcwd: (libc)Working Directory. |
| * getdate: (libc)General Time String Parsing. |
| * getdate_r: (libc)General Time String Parsing. |
| * getdelim: (libc)Line Input. |
| * getdomainnname: (libc)Host Identification. |
| * getegid: (libc)Reading Persona. |
| * getenv: (libc)Environment Access. |
| * geteuid: (libc)Reading Persona. |
| * getfsent: (libc)fstab. |
| * getfsfile: (libc)fstab. |
| * getfsspec: (libc)fstab. |
| * getgid: (libc)Reading Persona. |
| * getgrent: (libc)Scanning All Groups. |
| * getgrent_r: (libc)Scanning All Groups. |
| * getgrgid: (libc)Lookup Group. |
| * getgrgid_r: (libc)Lookup Group. |
| * getgrnam: (libc)Lookup Group. |
| * getgrnam_r: (libc)Lookup Group. |
| * getgrouplist: (libc)Setting Groups. |
| * getgroups: (libc)Reading Persona. |
| * gethostbyaddr: (libc)Host Names. |
| * gethostbyaddr_r: (libc)Host Names. |
| * gethostbyname2: (libc)Host Names. |
| * gethostbyname2_r: (libc)Host Names. |
| * gethostbyname: (libc)Host Names. |
| * gethostbyname_r: (libc)Host Names. |
| * gethostent: (libc)Host Names. |
| * gethostid: (libc)Host Identification. |
| * gethostname: (libc)Host Identification. |
| * getitimer: (libc)Setting an Alarm. |
| * getline: (libc)Line Input. |
| * getloadavg: (libc)Processor Resources. |
| * getlogin: (libc)Who Logged In. |
| * getmntent: (libc)mtab. |
| * getmntent_r: (libc)mtab. |
| * getnetbyaddr: (libc)Networks Database. |
| * getnetbyname: (libc)Networks Database. |
| * getnetent: (libc)Networks Database. |
| * getnetgrent: (libc)Lookup Netgroup. |
| * getnetgrent_r: (libc)Lookup Netgroup. |
| * getopt: (libc)Using Getopt. |
| * getopt_long: (libc)Getopt Long Options. |
| * getopt_long_only: (libc)Getopt Long Options. |
| * getpagesize: (libc)Query Memory Parameters. |
| * getpass: (libc)getpass. |
| * getpeername: (libc)Who is Connected. |
| * getpgid: (libc)Process Group Functions. |
| * getpgrp: (libc)Process Group Functions. |
| * getpid: (libc)Process Identification. |
| * getppid: (libc)Process Identification. |
| * getpriority: (libc)Traditional Scheduling Functions. |
| * getprotobyname: (libc)Protocols Database. |
| * getprotobynumber: (libc)Protocols Database. |
| * getprotoent: (libc)Protocols Database. |
| * getpt: (libc)Allocation. |
| * getpwent: (libc)Scanning All Users. |
| * getpwent_r: (libc)Scanning All Users. |
| * getpwnam: (libc)Lookup User. |
| * getpwnam_r: (libc)Lookup User. |
| * getpwuid: (libc)Lookup User. |
| * getpwuid_r: (libc)Lookup User. |
| * getrlimit64: (libc)Limits on Resources. |
| * getrlimit: (libc)Limits on Resources. |
| * getrusage: (libc)Resource Usage. |
| * gets: (libc)Line Input. |
| * getservbyname: (libc)Services Database. |
| * getservbyport: (libc)Services Database. |
| * getservent: (libc)Services Database. |
| * getsid: (libc)Process Group Functions. |
| * getsockname: (libc)Reading Address. |
| * getsockopt: (libc)Socket Option Functions. |
| * getsubopt: (libc)Suboptions. |
| * gettext: (libc)Translation with gettext. |
| * gettimeofday: (libc)High-Resolution Calendar. |
| * getuid: (libc)Reading Persona. |
| * getumask: (libc)Setting Permissions. |
| * getutent: (libc)Manipulating the Database. |
| * getutent_r: (libc)Manipulating the Database. |
| * getutid: (libc)Manipulating the Database. |
| * getutid_r: (libc)Manipulating the Database. |
| * getutline: (libc)Manipulating the Database. |
| * getutline_r: (libc)Manipulating the Database. |
| * getutmp: (libc)XPG Functions. |
| * getutmpx: (libc)XPG Functions. |
| * getutxent: (libc)XPG Functions. |
| * getutxid: (libc)XPG Functions. |
| * getutxline: (libc)XPG Functions. |
| * getw: (libc)Character Input. |
| * getwc: (libc)Character Input. |
| * getwc_unlocked: (libc)Character Input. |
| * getwchar: (libc)Character Input. |
| * getwchar_unlocked: (libc)Character Input. |
| * getwd: (libc)Working Directory. |
| * glob64: (libc)Calling Glob. |
| * glob: (libc)Calling Glob. |
| * globfree64: (libc)More Flags for Globbing. |
| * globfree: (libc)More Flags for Globbing. |
| * gmtime: (libc)Broken-down Time. |
| * gmtime_r: (libc)Broken-down Time. |
| * grantpt: (libc)Allocation. |
| * gsignal: (libc)Signaling Yourself. |
| * gtty: (libc)BSD Terminal Modes. |
| * hasmntopt: (libc)mtab. |
| * hcreate: (libc)Hash Search Function. |
| * hcreate_r: (libc)Hash Search Function. |
| * hdestroy: (libc)Hash Search Function. |
| * hdestroy_r: (libc)Hash Search Function. |
| * hsearch: (libc)Hash Search Function. |
| * hsearch_r: (libc)Hash Search Function. |
| * htonl: (libc)Byte Order. |
| * htons: (libc)Byte Order. |
| * hypot: (libc)Exponents and Logarithms. |
| * hypotf: (libc)Exponents and Logarithms. |
| * hypotl: (libc)Exponents and Logarithms. |
| * iconv: (libc)Generic Conversion Interface. |
| * iconv_close: (libc)Generic Conversion Interface. |
| * iconv_open: (libc)Generic Conversion Interface. |
| * if_freenameindex: (libc)Interface Naming. |
| * if_indextoname: (libc)Interface Naming. |
| * if_nameindex: (libc)Interface Naming. |
| * if_nametoindex: (libc)Interface Naming. |
| * ilogb: (libc)Exponents and Logarithms. |
| * ilogbf: (libc)Exponents and Logarithms. |
| * ilogbl: (libc)Exponents and Logarithms. |
| * imaxabs: (libc)Absolute Value. |
| * imaxdiv: (libc)Integer Division. |
| * in6addr_any: (libc)Host Address Data Type. |
| * in6addr_loopback: (libc)Host Address Data Type. |
| * index: (libc)Search Functions. |
| * inet_addr: (libc)Host Address Functions. |
| * inet_aton: (libc)Host Address Functions. |
| * inet_lnaof: (libc)Host Address Functions. |
| * inet_makeaddr: (libc)Host Address Functions. |
| * inet_netof: (libc)Host Address Functions. |
| * inet_network: (libc)Host Address Functions. |
| * inet_ntoa: (libc)Host Address Functions. |
| * inet_ntop: (libc)Host Address Functions. |
| * inet_pton: (libc)Host Address Functions. |
| * initgroups: (libc)Setting Groups. |
| * initstate: (libc)BSD Random. |
| * initstate_r: (libc)BSD Random. |
| * innetgr: (libc)Netgroup Membership. |
| * ioctl: (libc)IOCTLs. |
| * isalnum: (libc)Classification of Characters. |
| * isalpha: (libc)Classification of Characters. |
| * isascii: (libc)Classification of Characters. |
| * isatty: (libc)Is It a Terminal. |
| * isblank: (libc)Classification of Characters. |
| * iscntrl: (libc)Classification of Characters. |
| * isdigit: (libc)Classification of Characters. |
| * isfinite: (libc)Floating Point Classes. |
| * isgraph: (libc)Classification of Characters. |
| * isgreater: (libc)FP Comparison Functions. |
| * isgreaterequal: (libc)FP Comparison Functions. |
| * isinf: (libc)Floating Point Classes. |
| * isinff: (libc)Floating Point Classes. |
| * isinfl: (libc)Floating Point Classes. |
| * isless: (libc)FP Comparison Functions. |
| * islessequal: (libc)FP Comparison Functions. |
| * islessgreater: (libc)FP Comparison Functions. |
| * islower: (libc)Classification of Characters. |
| * isnan: (libc)Floating Point Classes. |
| * isnan: (libc)Floating Point Classes. |
| * isnanf: (libc)Floating Point Classes. |
| * isnanl: (libc)Floating Point Classes. |
| * isnormal: (libc)Floating Point Classes. |
| * isprint: (libc)Classification of Characters. |
| * ispunct: (libc)Classification of Characters. |
| * issignaling: (libc)Floating Point Classes. |
| * isspace: (libc)Classification of Characters. |
| * isunordered: (libc)FP Comparison Functions. |
| * isupper: (libc)Classification of Characters. |
| * iswalnum: (libc)Classification of Wide Characters. |
| * iswalpha: (libc)Classification of Wide Characters. |
| * iswblank: (libc)Classification of Wide Characters. |
| * iswcntrl: (libc)Classification of Wide Characters. |
| * iswctype: (libc)Classification of Wide Characters. |
| * iswdigit: (libc)Classification of Wide Characters. |
| * iswgraph: (libc)Classification of Wide Characters. |
| * iswlower: (libc)Classification of Wide Characters. |
| * iswprint: (libc)Classification of Wide Characters. |
| * iswpunct: (libc)Classification of Wide Characters. |
| * iswspace: (libc)Classification of Wide Characters. |
| * iswupper: (libc)Classification of Wide Characters. |
| * iswxdigit: (libc)Classification of Wide Characters. |
| * isxdigit: (libc)Classification of Characters. |
| * j0: (libc)Special Functions. |
| * j0f: (libc)Special Functions. |
| * j0l: (libc)Special Functions. |
| * j1: (libc)Special Functions. |
| * j1f: (libc)Special Functions. |
| * j1l: (libc)Special Functions. |
| * jn: (libc)Special Functions. |
| * jnf: (libc)Special Functions. |
| * jnl: (libc)Special Functions. |
| * jrand48: (libc)SVID Random. |
| * jrand48_r: (libc)SVID Random. |
| * kill: (libc)Signaling Another Process. |
| * killpg: (libc)Signaling Another Process. |
| * l64a: (libc)Encode Binary Data. |
| * labs: (libc)Absolute Value. |
| * lcong48: (libc)SVID Random. |
| * lcong48_r: (libc)SVID Random. |
| * ldexp: (libc)Normalization Functions. |
| * ldexpf: (libc)Normalization Functions. |
| * ldexpl: (libc)Normalization Functions. |
| * ldiv: (libc)Integer Division. |
| * lfind: (libc)Array Search Function. |
| * lgamma: (libc)Special Functions. |
| * lgamma_r: (libc)Special Functions. |
| * lgammaf: (libc)Special Functions. |
| * lgammaf_r: (libc)Special Functions. |
| * lgammal: (libc)Special Functions. |
| * lgammal_r: (libc)Special Functions. |
| * link: (libc)Hard Links. |
| * lio_listio64: (libc)Asynchronous Reads/Writes. |
| * lio_listio: (libc)Asynchronous Reads/Writes. |
| * listen: (libc)Listening. |
| * llabs: (libc)Absolute Value. |
| * lldiv: (libc)Integer Division. |
| * llrint: (libc)Rounding Functions. |
| * llrintf: (libc)Rounding Functions. |
| * llrintl: (libc)Rounding Functions. |
| * llround: (libc)Rounding Functions. |
| * llroundf: (libc)Rounding Functions. |
| * llroundl: (libc)Rounding Functions. |
| * localeconv: (libc)The Lame Way to Locale Data. |
| * localtime: (libc)Broken-down Time. |
| * localtime_r: (libc)Broken-down Time. |
| * log10: (libc)Exponents and Logarithms. |
| * log10f: (libc)Exponents and Logarithms. |
| * log10l: (libc)Exponents and Logarithms. |
| * log1p: (libc)Exponents and Logarithms. |
| * log1pf: (libc)Exponents and Logarithms. |
| * log1pl: (libc)Exponents and Logarithms. |
| * log2: (libc)Exponents and Logarithms. |
| * log2f: (libc)Exponents and Logarithms. |
| * log2l: (libc)Exponents and Logarithms. |
| * log: (libc)Exponents and Logarithms. |
| * logb: (libc)Exponents and Logarithms. |
| * logbf: (libc)Exponents and Logarithms. |
| * logbl: (libc)Exponents and Logarithms. |
| * logf: (libc)Exponents and Logarithms. |
| * login: (libc)Logging In and Out. |
| * login_tty: (libc)Logging In and Out. |
| * logl: (libc)Exponents and Logarithms. |
| * logout: (libc)Logging In and Out. |
| * logwtmp: (libc)Logging In and Out. |
| * longjmp: (libc)Non-Local Details. |
| * lrand48: (libc)SVID Random. |
| * lrand48_r: (libc)SVID Random. |
| * lrint: (libc)Rounding Functions. |
| * lrintf: (libc)Rounding Functions. |
| * lrintl: (libc)Rounding Functions. |
| * lround: (libc)Rounding Functions. |
| * lroundf: (libc)Rounding Functions. |
| * lroundl: (libc)Rounding Functions. |
| * lsearch: (libc)Array Search Function. |
| * lseek64: (libc)File Position Primitive. |
| * lseek: (libc)File Position Primitive. |
| * lstat64: (libc)Reading Attributes. |
| * lstat: (libc)Reading Attributes. |
| * lutimes: (libc)File Times. |
| * madvise: (libc)Memory-mapped I/O. |
| * makecontext: (libc)System V contexts. |
| * mallinfo: (libc)Statistics of Malloc. |
| * malloc: (libc)Basic Allocation. |
| * mallopt: (libc)Malloc Tunable Parameters. |
| * mblen: (libc)Non-reentrant Character Conversion. |
| * mbrlen: (libc)Converting a Character. |
| * mbrtowc: (libc)Converting a Character. |
| * mbsinit: (libc)Keeping the state. |
| * mbsnrtowcs: (libc)Converting Strings. |
| * mbsrtowcs: (libc)Converting Strings. |
| * mbstowcs: (libc)Non-reentrant String Conversion. |
| * mbtowc: (libc)Non-reentrant Character Conversion. |
| * mcheck: (libc)Heap Consistency Checking. |
| * memalign: (libc)Aligned Memory Blocks. |
| * memccpy: (libc)Copying and Concatenation. |
| * memchr: (libc)Search Functions. |
| * memcmp: (libc)String/Array Comparison. |
| * memcpy: (libc)Copying and Concatenation. |
| * memfrob: (libc)Trivial Encryption. |
| * memmem: (libc)Search Functions. |
| * memmove: (libc)Copying and Concatenation. |
| * mempcpy: (libc)Copying and Concatenation. |
| * memrchr: (libc)Search Functions. |
| * memset: (libc)Copying and Concatenation. |
| * mkdir: (libc)Creating Directories. |
| * mkdtemp: (libc)Temporary Files. |
| * mkfifo: (libc)FIFO Special Files. |
| * mknod: (libc)Making Special Files. |
| * mkstemp: (libc)Temporary Files. |
| * mktemp: (libc)Temporary Files. |
| * mktime: (libc)Broken-down Time. |
| * mlock: (libc)Page Lock Functions. |
| * mlockall: (libc)Page Lock Functions. |
| * mmap64: (libc)Memory-mapped I/O. |
| * mmap: (libc)Memory-mapped I/O. |
| * modf: (libc)Rounding Functions. |
| * modff: (libc)Rounding Functions. |
| * modfl: (libc)Rounding Functions. |
| * mount: (libc)Mount-Unmount-Remount. |
| * mprobe: (libc)Heap Consistency Checking. |
| * mrand48: (libc)SVID Random. |
| * mrand48_r: (libc)SVID Random. |
| * mremap: (libc)Memory-mapped I/O. |
| * msync: (libc)Memory-mapped I/O. |
| * mtrace: (libc)Tracing malloc. |
| * munlock: (libc)Page Lock Functions. |
| * munlockall: (libc)Page Lock Functions. |
| * munmap: (libc)Memory-mapped I/O. |
| * muntrace: (libc)Tracing malloc. |
| * nan: (libc)FP Bit Twiddling. |
| * nanf: (libc)FP Bit Twiddling. |
| * nanl: (libc)FP Bit Twiddling. |
| * nanosleep: (libc)Sleeping. |
| * nearbyint: (libc)Rounding Functions. |
| * nearbyintf: (libc)Rounding Functions. |
| * nearbyintl: (libc)Rounding Functions. |
| * nextafter: (libc)FP Bit Twiddling. |
| * nextafterf: (libc)FP Bit Twiddling. |
| * nextafterl: (libc)FP Bit Twiddling. |
| * nexttoward: (libc)FP Bit Twiddling. |
| * nexttowardf: (libc)FP Bit Twiddling. |
| * nexttowardl: (libc)FP Bit Twiddling. |
| * nftw64: (libc)Working with Directory Trees. |
| * nftw: (libc)Working with Directory Trees. |
| * ngettext: (libc)Advanced gettext functions. |
| * nice: (libc)Traditional Scheduling Functions. |
| * nl_langinfo: (libc)The Elegant and Fast Way. |
| * nrand48: (libc)SVID Random. |
| * nrand48_r: (libc)SVID Random. |
| * ntohl: (libc)Byte Order. |
| * ntohs: (libc)Byte Order. |
| * ntp_adjtime: (libc)High Accuracy Clock. |
| * ntp_gettime: (libc)High Accuracy Clock. |
| * obstack_1grow: (libc)Growing Objects. |
| * obstack_1grow_fast: (libc)Extra Fast Growing. |
| * obstack_alignment_mask: (libc)Obstacks Data Alignment. |
| * obstack_alloc: (libc)Allocation in an Obstack. |
| * obstack_base: (libc)Status of an Obstack. |
| * obstack_blank: (libc)Growing Objects. |
| * obstack_blank_fast: (libc)Extra Fast Growing. |
| * obstack_chunk_size: (libc)Obstack Chunks. |
| * obstack_copy0: (libc)Allocation in an Obstack. |
| * obstack_copy: (libc)Allocation in an Obstack. |
| * obstack_finish: (libc)Growing Objects. |
| * obstack_free: (libc)Freeing Obstack Objects. |
| * obstack_grow0: (libc)Growing Objects. |
| * obstack_grow: (libc)Growing Objects. |
| * obstack_init: (libc)Preparing for Obstacks. |
| * obstack_int_grow: (libc)Growing Objects. |
| * obstack_int_grow_fast: (libc)Extra Fast Growing. |
| * obstack_next_free: (libc)Status of an Obstack. |
| * obstack_object_size: (libc)Growing Objects. |
| * obstack_object_size: (libc)Status of an Obstack. |
| * obstack_printf: (libc)Dynamic Output. |
| * obstack_ptr_grow: (libc)Growing Objects. |
| * obstack_ptr_grow_fast: (libc)Extra Fast Growing. |
| * obstack_room: (libc)Extra Fast Growing. |
| * obstack_vprintf: (libc)Variable Arguments Output. |
| * offsetof: (libc)Structure Measurement. |
| * on_exit: (libc)Cleanups on Exit. |
| * open64: (libc)Opening and Closing Files. |
| * open: (libc)Opening and Closing Files. |
| * open_memstream: (libc)String Streams. |
| * opendir: (libc)Opening a Directory. |
| * openlog: (libc)openlog. |
| * openpty: (libc)Pseudo-Terminal Pairs. |
| * parse_printf_format: (libc)Parsing a Template String. |
| * pathconf: (libc)Pathconf. |
| * pause: (libc)Using Pause. |
| * pclose: (libc)Pipe to a Subprocess. |
| * perror: (libc)Error Messages. |
| * pipe: (libc)Creating a Pipe. |
| * popen: (libc)Pipe to a Subprocess. |
| * posix_memalign: (libc)Aligned Memory Blocks. |
| * pow10: (libc)Exponents and Logarithms. |
| * pow10f: (libc)Exponents and Logarithms. |
| * pow10l: (libc)Exponents and Logarithms. |
| * pow: (libc)Exponents and Logarithms. |
| * powf: (libc)Exponents and Logarithms. |
| * powl: (libc)Exponents and Logarithms. |
| * pread64: (libc)I/O Primitives. |
| * pread: (libc)I/O Primitives. |
| * printf: (libc)Formatted Output Functions. |
| * printf_size: (libc)Predefined Printf Handlers. |
| * printf_size_info: (libc)Predefined Printf Handlers. |
| * psignal: (libc)Signal Messages. |
| * pthread_getattr_default_np: (libc)Default Thread Attributes. |
| * pthread_getspecific: (libc)Thread-specific Data. |
| * pthread_key_create: (libc)Thread-specific Data. |
| * pthread_key_delete: (libc)Thread-specific Data. |
| * pthread_setattr_default_np: (libc)Default Thread Attributes. |
| * pthread_setspecific: (libc)Thread-specific Data. |
| * ptsname: (libc)Allocation. |
| * ptsname_r: (libc)Allocation. |
| * putc: (libc)Simple Output. |
| * putc_unlocked: (libc)Simple Output. |
| * putchar: (libc)Simple Output. |
| * putchar_unlocked: (libc)Simple Output. |
| * putenv: (libc)Environment Access. |
| * putpwent: (libc)Writing a User Entry. |
| * puts: (libc)Simple Output. |
| * pututline: (libc)Manipulating the Database. |
| * pututxline: (libc)XPG Functions. |
| * putw: (libc)Simple Output. |
| * putwc: (libc)Simple Output. |
| * putwc_unlocked: (libc)Simple Output. |
| * putwchar: (libc)Simple Output. |
| * putwchar_unlocked: (libc)Simple Output. |
| * pwrite64: (libc)I/O Primitives. |
| * pwrite: (libc)I/O Primitives. |
| * qecvt: (libc)System V Number Conversion. |
| * qecvt_r: (libc)System V Number Conversion. |
| * qfcvt: (libc)System V Number Conversion. |
| * qfcvt_r: (libc)System V Number Conversion. |
| * qgcvt: (libc)System V Number Conversion. |
| * qsort: (libc)Array Sort Function. |
| * raise: (libc)Signaling Yourself. |
| * rand: (libc)ISO Random. |
| * rand_r: (libc)ISO Random. |
| * random: (libc)BSD Random. |
| * random_r: (libc)BSD Random. |
| * rawmemchr: (libc)Search Functions. |
| * read: (libc)I/O Primitives. |
| * readdir64: (libc)Reading/Closing Directory. |
| * readdir64_r: (libc)Reading/Closing Directory. |
| * readdir: (libc)Reading/Closing Directory. |
| * readdir_r: (libc)Reading/Closing Directory. |
| * readlink: (libc)Symbolic Links. |
| * readv: (libc)Scatter-Gather. |
| * realloc: (libc)Changing Block Size. |
| * realpath: (libc)Symbolic Links. |
| * recv: (libc)Receiving Data. |
| * recvfrom: (libc)Receiving Datagrams. |
| * recvmsg: (libc)Receiving Datagrams. |
| * regcomp: (libc)POSIX Regexp Compilation. |
| * regerror: (libc)Regexp Cleanup. |
| * regexec: (libc)Matching POSIX Regexps. |
| * regfree: (libc)Regexp Cleanup. |
| * register_printf_function: (libc)Registering New Conversions. |
| * remainder: (libc)Remainder Functions. |
| * remainderf: (libc)Remainder Functions. |
| * remainderl: (libc)Remainder Functions. |
| * remove: (libc)Deleting Files. |
| * rename: (libc)Renaming Files. |
| * rewind: (libc)File Positioning. |
| * rewinddir: (libc)Random Access Directory. |
| * rindex: (libc)Search Functions. |
| * rint: (libc)Rounding Functions. |
| * rintf: (libc)Rounding Functions. |
| * rintl: (libc)Rounding Functions. |
| * rmdir: (libc)Deleting Files. |
| * round: (libc)Rounding Functions. |
| * roundf: (libc)Rounding Functions. |
| * roundl: (libc)Rounding Functions. |
| * rpmatch: (libc)Yes-or-No Questions. |
| * sbrk: (libc)Resizing the Data Segment. |
| * scalb: (libc)Normalization Functions. |
| * scalbf: (libc)Normalization Functions. |
| * scalbl: (libc)Normalization Functions. |
| * scalbln: (libc)Normalization Functions. |
| * scalblnf: (libc)Normalization Functions. |
| * scalblnl: (libc)Normalization Functions. |
| * scalbn: (libc)Normalization Functions. |
| * scalbnf: (libc)Normalization Functions. |
| * scalbnl: (libc)Normalization Functions. |
| * scandir64: (libc)Scanning Directory Content. |
| * scandir: (libc)Scanning Directory Content. |
| * scanf: (libc)Formatted Input Functions. |
| * sched_get_priority_max: (libc)Basic Scheduling Functions. |
| * sched_get_priority_min: (libc)Basic Scheduling Functions. |
| * sched_getaffinity: (libc)CPU Affinity. |
| * sched_getparam: (libc)Basic Scheduling Functions. |
| * sched_getscheduler: (libc)Basic Scheduling Functions. |
| * sched_rr_get_interval: (libc)Basic Scheduling Functions. |
| * sched_setaffinity: (libc)CPU Affinity. |
| * sched_setparam: (libc)Basic Scheduling Functions. |
| * sched_setscheduler: (libc)Basic Scheduling Functions. |
| * sched_yield: (libc)Basic Scheduling Functions. |
| * secure_getenv: (libc)Environment Access. |
| * seed48: (libc)SVID Random. |
| * seed48_r: (libc)SVID Random. |
| * seekdir: (libc)Random Access Directory. |
| * select: (libc)Waiting for I/O. |
| * send: (libc)Sending Data. |
| * sendmsg: (libc)Receiving Datagrams. |
| * sendto: (libc)Sending Datagrams. |
| * setbuf: (libc)Controlling Buffering. |
| * setbuffer: (libc)Controlling Buffering. |
| * setcontext: (libc)System V contexts. |
| * setdomainname: (libc)Host Identification. |
| * setegid: (libc)Setting Groups. |
| * setenv: (libc)Environment Access. |
| * seteuid: (libc)Setting User ID. |
| * setfsent: (libc)fstab. |
| * setgid: (libc)Setting Groups. |
| * setgrent: (libc)Scanning All Groups. |
| * setgroups: (libc)Setting Groups. |
| * sethostent: (libc)Host Names. |
| * sethostid: (libc)Host Identification. |
| * sethostname: (libc)Host Identification. |
| * setitimer: (libc)Setting an Alarm. |
| * setjmp: (libc)Non-Local Details. |
| * setkey: (libc)DES Encryption. |
| * setkey_r: (libc)DES Encryption. |
| * setlinebuf: (libc)Controlling Buffering. |
| * setlocale: (libc)Setting the Locale. |
| * setlogmask: (libc)setlogmask. |
| * setmntent: (libc)mtab. |
| * setnetent: (libc)Networks Database. |
| * setnetgrent: (libc)Lookup Netgroup. |
| * setpgid: (libc)Process Group Functions. |
| * setpgrp: (libc)Process Group Functions. |
| * setpriority: (libc)Traditional Scheduling Functions. |
| * setprotoent: (libc)Protocols Database. |
| * setpwent: (libc)Scanning All Users. |
| * setregid: (libc)Setting Groups. |
| * setreuid: (libc)Setting User ID. |
| * setrlimit64: (libc)Limits on Resources. |
| * setrlimit: (libc)Limits on Resources. |
| * setservent: (libc)Services Database. |
| * setsid: (libc)Process Group Functions. |
| * setsockopt: (libc)Socket Option Functions. |
| * setstate: (libc)BSD Random. |
| * setstate_r: (libc)BSD Random. |
| * settimeofday: (libc)High-Resolution Calendar. |
| * setuid: (libc)Setting User ID. |
| * setutent: (libc)Manipulating the Database. |
| * setutxent: (libc)XPG Functions. |
| * setvbuf: (libc)Controlling Buffering. |
| * shm_open: (libc)Memory-mapped I/O. |
| * shm_unlink: (libc)Memory-mapped I/O. |
| * shutdown: (libc)Closing a Socket. |
| * sigaction: (libc)Advanced Signal Handling. |
| * sigaddset: (libc)Signal Sets. |
| * sigaltstack: (libc)Signal Stack. |
| * sigblock: (libc)Blocking in BSD. |
| * sigdelset: (libc)Signal Sets. |
| * sigemptyset: (libc)Signal Sets. |
| * sigfillset: (libc)Signal Sets. |
| * siginterrupt: (libc)BSD Handler. |
| * sigismember: (libc)Signal Sets. |
| * siglongjmp: (libc)Non-Local Exits and Signals. |
| * sigmask: (libc)Blocking in BSD. |
| * signal: (libc)Basic Signal Handling. |
| * signbit: (libc)FP Bit Twiddling. |
| * significand: (libc)Normalization Functions. |
| * significandf: (libc)Normalization Functions. |
| * significandl: (libc)Normalization Functions. |
| * sigpause: (libc)Blocking in BSD. |
| * sigpending: (libc)Checking for Pending Signals. |
| * sigprocmask: (libc)Process Signal Mask. |
| * sigsetjmp: (libc)Non-Local Exits and Signals. |
| * sigsetmask: (libc)Blocking in BSD. |
| * sigstack: (libc)Signal Stack. |
| * sigsuspend: (libc)Sigsuspend. |
| * sigvec: (libc)BSD Handler. |
| * sin: (libc)Trig Functions. |
| * sincos: (libc)Trig Functions. |
| * sincosf: (libc)Trig Functions. |
| * sincosl: (libc)Trig Functions. |
| * sinf: (libc)Trig Functions. |
| * sinh: (libc)Hyperbolic Functions. |
| * sinhf: (libc)Hyperbolic Functions. |
| * sinhl: (libc)Hyperbolic Functions. |
| * sinl: (libc)Trig Functions. |
| * sleep: (libc)Sleeping. |
| * snprintf: (libc)Formatted Output Functions. |
| * socket: (libc)Creating a Socket. |
| * socketpair: (libc)Socket Pairs. |
| * sprintf: (libc)Formatted Output Functions. |
| * sqrt: (libc)Exponents and Logarithms. |
| * sqrtf: (libc)Exponents and Logarithms. |
| * sqrtl: (libc)Exponents and Logarithms. |
| * srand48: (libc)SVID Random. |
| * srand48_r: (libc)SVID Random. |
| * srand: (libc)ISO Random. |
| * srandom: (libc)BSD Random. |
| * srandom_r: (libc)BSD Random. |
| * sscanf: (libc)Formatted Input Functions. |
| * ssignal: (libc)Basic Signal Handling. |
| * stat64: (libc)Reading Attributes. |
| * stat: (libc)Reading Attributes. |
| * stime: (libc)Simple Calendar Time. |
| * stpcpy: (libc)Copying and Concatenation. |
| * stpncpy: (libc)Copying and Concatenation. |
| * strcasecmp: (libc)String/Array Comparison. |
| * strcasestr: (libc)Search Functions. |
| * strcat: (libc)Copying and Concatenation. |
| * strchr: (libc)Search Functions. |
| * strchrnul: (libc)Search Functions. |
| * strcmp: (libc)String/Array Comparison. |
| * strcoll: (libc)Collation Functions. |
| * strcpy: (libc)Copying and Concatenation. |
| * strcspn: (libc)Search Functions. |
| * strdup: (libc)Copying and Concatenation. |
| * strdupa: (libc)Copying and Concatenation. |
| * strerror: (libc)Error Messages. |
| * strerror_r: (libc)Error Messages. |
| * strfmon: (libc)Formatting Numbers. |
| * strfry: (libc)strfry. |
| * strftime: (libc)Formatting Calendar Time. |
| * strlen: (libc)String Length. |
| * strncasecmp: (libc)String/Array Comparison. |
| * strncat: (libc)Copying and Concatenation. |
| * strncmp: (libc)String/Array Comparison. |
| * strncpy: (libc)Copying and Concatenation. |
| * strndup: (libc)Copying and Concatenation. |
| * strndupa: (libc)Copying and Concatenation. |
| * strnlen: (libc)String Length. |
| * strpbrk: (libc)Search Functions. |
| * strptime: (libc)Low-Level Time String Parsing. |
| * strrchr: (libc)Search Functions. |
| * strsep: (libc)Finding Tokens in a String. |
| * strsignal: (libc)Signal Messages. |
| * strspn: (libc)Search Functions. |
| * strstr: (libc)Search Functions. |
| * strtod: (libc)Parsing of Floats. |
| * strtof: (libc)Parsing of Floats. |
| * strtoimax: (libc)Parsing of Integers. |
| * strtok: (libc)Finding Tokens in a String. |
| * strtok_r: (libc)Finding Tokens in a String. |
| * strtol: (libc)Parsing of Integers. |
| * strtold: (libc)Parsing of Floats. |
| * strtoll: (libc)Parsing of Integers. |
| * strtoq: (libc)Parsing of Integers. |
| * strtoul: (libc)Parsing of Integers. |
| * strtoull: (libc)Parsing of Integers. |
| * strtoumax: (libc)Parsing of Integers. |
| * strtouq: (libc)Parsing of Integers. |
| * strverscmp: (libc)String/Array Comparison. |
| * strxfrm: (libc)Collation Functions. |
| * stty: (libc)BSD Terminal Modes. |
| * swapcontext: (libc)System V contexts. |
| * swprintf: (libc)Formatted Output Functions. |
| * swscanf: (libc)Formatted Input Functions. |
| * symlink: (libc)Symbolic Links. |
| * sync: (libc)Synchronizing I/O. |
| * syscall: (libc)System Calls. |
| * sysconf: (libc)Sysconf Definition. |
| * sysctl: (libc)System Parameters. |
| * syslog: (libc)syslog; vsyslog. |
| * system: (libc)Running a Command. |
| * sysv_signal: (libc)Basic Signal Handling. |
| * tan: (libc)Trig Functions. |
| * tanf: (libc)Trig Functions. |
| * tanh: (libc)Hyperbolic Functions. |
| * tanhf: (libc)Hyperbolic Functions. |
| * tanhl: (libc)Hyperbolic Functions. |
| * tanl: (libc)Trig Functions. |
| * tcdrain: (libc)Line Control. |
| * tcflow: (libc)Line Control. |
| * tcflush: (libc)Line Control. |
| * tcgetattr: (libc)Mode Functions. |
| * tcgetpgrp: (libc)Terminal Access Functions. |
| * tcgetsid: (libc)Terminal Access Functions. |
| * tcsendbreak: (libc)Line Control. |
| * tcsetattr: (libc)Mode Functions. |
| * tcsetpgrp: (libc)Terminal Access Functions. |
| * tdelete: (libc)Tree Search Function. |
| * tdestroy: (libc)Tree Search Function. |
| * telldir: (libc)Random Access Directory. |
| * tempnam: (libc)Temporary Files. |
| * textdomain: (libc)Locating gettext catalog. |
| * tfind: (libc)Tree Search Function. |
| * tgamma: (libc)Special Functions. |
| * tgammaf: (libc)Special Functions. |
| * tgammal: (libc)Special Functions. |
| * time: (libc)Simple Calendar Time. |
| * timegm: (libc)Broken-down Time. |
| * timelocal: (libc)Broken-down Time. |
| * times: (libc)Processor Time. |
| * tmpfile64: (libc)Temporary Files. |
| * tmpfile: (libc)Temporary Files. |
| * tmpnam: (libc)Temporary Files. |
| * tmpnam_r: (libc)Temporary Files. |
| * toascii: (libc)Case Conversion. |
| * tolower: (libc)Case Conversion. |
| * toupper: (libc)Case Conversion. |
| * towctrans: (libc)Wide Character Case Conversion. |
| * towlower: (libc)Wide Character Case Conversion. |
| * towupper: (libc)Wide Character Case Conversion. |
| * trunc: (libc)Rounding Functions. |
| * truncate64: (libc)File Size. |
| * truncate: (libc)File Size. |
| * truncf: (libc)Rounding Functions. |
| * truncl: (libc)Rounding Functions. |
| * tsearch: (libc)Tree Search Function. |
| * ttyname: (libc)Is It a Terminal. |
| * ttyname_r: (libc)Is It a Terminal. |
| * twalk: (libc)Tree Search Function. |
| * tzset: (libc)Time Zone Functions. |
| * ulimit: (libc)Limits on Resources. |
| * umask: (libc)Setting Permissions. |
| * umount2: (libc)Mount-Unmount-Remount. |
| * umount: (libc)Mount-Unmount-Remount. |
| * uname: (libc)Platform Type. |
| * ungetc: (libc)How Unread. |
| * ungetwc: (libc)How Unread. |
| * unlink: (libc)Deleting Files. |
| * unlockpt: (libc)Allocation. |
| * unsetenv: (libc)Environment Access. |
| * updwtmp: (libc)Manipulating the Database. |
| * utime: (libc)File Times. |
| * utimes: (libc)File Times. |
| * utmpname: (libc)Manipulating the Database. |
| * utmpxname: (libc)XPG Functions. |
| * va_arg: (libc)Argument Macros. |
| * va_copy: (libc)Argument Macros. |
| * va_end: (libc)Argument Macros. |
| * va_start: (libc)Argument Macros. |
| * valloc: (libc)Aligned Memory Blocks. |
| * vasprintf: (libc)Variable Arguments Output. |
| * verr: (libc)Error Messages. |
| * verrx: (libc)Error Messages. |
| * versionsort64: (libc)Scanning Directory Content. |
| * versionsort: (libc)Scanning Directory Content. |
| * vfork: (libc)Creating a Process. |
| * vfprintf: (libc)Variable Arguments Output. |
| * vfscanf: (libc)Variable Arguments Input. |
| * vfwprintf: (libc)Variable Arguments Output. |
| * vfwscanf: (libc)Variable Arguments Input. |
| * vlimit: (libc)Limits on Resources. |
| * vprintf: (libc)Variable Arguments Output. |
| * vscanf: (libc)Variable Arguments Input. |
| * vsnprintf: (libc)Variable Arguments Output. |
| * vsprintf: (libc)Variable Arguments Output. |
| * vsscanf: (libc)Variable Arguments Input. |
| * vswprintf: (libc)Variable Arguments Output. |
| * vswscanf: (libc)Variable Arguments Input. |
| * vsyslog: (libc)syslog; vsyslog. |
| * vtimes: (libc)Resource Usage. |
| * vwarn: (libc)Error Messages. |
| * vwarnx: (libc)Error Messages. |
| * vwprintf: (libc)Variable Arguments Output. |
| * vwscanf: (libc)Variable Arguments Input. |
| * wait3: (libc)BSD Wait Functions. |
| * wait4: (libc)Process Completion. |
| * wait: (libc)Process Completion. |
| * waitpid: (libc)Process Completion. |
| * warn: (libc)Error Messages. |
| * warnx: (libc)Error Messages. |
| * wcpcpy: (libc)Copying and Concatenation. |
| * wcpncpy: (libc)Copying and Concatenation. |
| * wcrtomb: (libc)Converting a Character. |
| * wcscasecmp: (libc)String/Array Comparison. |
| * wcscat: (libc)Copying and Concatenation. |
| * wcschr: (libc)Search Functions. |
| * wcschrnul: (libc)Search Functions. |
| * wcscmp: (libc)String/Array Comparison. |
| * wcscoll: (libc)Collation Functions. |
| * wcscpy: (libc)Copying and Concatenation. |
| * wcscspn: (libc)Search Functions. |
| * wcsdup: (libc)Copying and Concatenation. |
| * wcsftime: (libc)Formatting Calendar Time. |
| * wcslen: (libc)String Length. |
| * wcsncasecmp: (libc)String/Array Comparison. |
| * wcsncat: (libc)Copying and Concatenation. |
| * wcsncmp: (libc)String/Array Comparison. |
| * wcsncpy: (libc)Copying and Concatenation. |
| * wcsnlen: (libc)String Length. |
| * wcsnrtombs: (libc)Converting Strings. |
| * wcspbrk: (libc)Search Functions. |
| * wcsrchr: (libc)Search Functions. |
| * wcsrtombs: (libc)Converting Strings. |
| * wcsspn: (libc)Search Functions. |
| * wcsstr: (libc)Search Functions. |
| * wcstod: (libc)Parsing of Floats. |
| * wcstof: (libc)Parsing of Floats. |
| * wcstoimax: (libc)Parsing of Integers. |
| * wcstok: (libc)Finding Tokens in a String. |
| * wcstol: (libc)Parsing of Integers. |
| * wcstold: (libc)Parsing of Floats. |
| * wcstoll: (libc)Parsing of Integers. |
| * wcstombs: (libc)Non-reentrant String Conversion. |
| * wcstoq: (libc)Parsing of Integers. |
| * wcstoul: (libc)Parsing of Integers. |
| * wcstoull: (libc)Parsing of Integers. |
| * wcstoumax: (libc)Parsing of Integers. |
| * wcstouq: (libc)Parsing of Integers. |
| * wcswcs: (libc)Search Functions. |
| * wcsxfrm: (libc)Collation Functions. |
| * wctob: (libc)Converting a Character. |
| * wctomb: (libc)Non-reentrant Character Conversion. |
| * wctrans: (libc)Wide Character Case Conversion. |
| * wctype: (libc)Classification of Wide Characters. |
| * wmemchr: (libc)Search Functions. |
| * wmemcmp: (libc)String/Array Comparison. |
| * wmemcpy: (libc)Copying and Concatenation. |
| * wmemmove: (libc)Copying and Concatenation. |
| * wmempcpy: (libc)Copying and Concatenation. |
| * wmemset: (libc)Copying and Concatenation. |
| * wordexp: (libc)Calling Wordexp. |
| * wordfree: (libc)Calling Wordexp. |
| * wprintf: (libc)Formatted Output Functions. |
| * write: (libc)I/O Primitives. |
| * writev: (libc)Scatter-Gather. |
| * wscanf: (libc)Formatted Input Functions. |
| * y0: (libc)Special Functions. |
| * y0f: (libc)Special Functions. |
| * y0l: (libc)Special Functions. |
| * y1: (libc)Special Functions. |
| * y1f: (libc)Special Functions. |
| * y1l: (libc)Special Functions. |
| * yn: (libc)Special Functions. |
| * ynf: (libc)Special Functions. |
| * ynl: (libc)Special Functions. |
| END-INFO-DIR-ENTRY |
| |
| |
| File: libc.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) |
| |
| Main Menu |
| ********* |
| |
| This is 'The GNU C Library Reference Manual', for Version 2.19 |
| (Buildroot) of the GNU C Library. |
| |
| * Menu: |
| |
| * Introduction:: Purpose of the GNU C Library. |
| * Error Reporting:: How library functions report errors. |
| * Memory:: Allocating virtual memory and controlling |
| paging. |
| * Character Handling:: Character testing and conversion functions. |
| * String and Array Utilities:: Utilities for copying and comparing strings |
| and arrays. |
| * Character Set Handling:: Support for extended character sets. |
| * Locales:: The country and language can affect the |
| behavior of library functions. |
| * Message Translation:: How to make the program speak the user's |
| language. |
| * Searching and Sorting:: General searching and sorting functions. |
| * Pattern Matching:: Matching shell "globs" and regular |
| expressions. |
| * I/O Overview:: Introduction to the I/O facilities. |
| * I/O on Streams:: High-level, portable I/O facilities. |
| * Low-Level I/O:: Low-level, less portable I/O. |
| * File System Interface:: Functions for manipulating files. |
| * Pipes and FIFOs:: A simple interprocess communication |
| mechanism. |
| * Sockets:: A more complicated IPC mechanism, with |
| networking support. |
| * Low-Level Terminal Interface:: How to change the characteristics of a |
| terminal device. |
| * Syslog:: System logging and messaging. |
| * Mathematics:: Math functions, useful constants, random |
| numbers. |
| * Arithmetic:: Low level arithmetic functions. |
| * Date and Time:: Functions for getting the date and time and |
| formatting them nicely. |
| * Resource Usage And Limitation:: Functions for examining resource usage and |
| getting and setting limits. |
| * Non-Local Exits:: Jumping out of nested function calls. |
| * Signal Handling:: How to send, block, and handle signals. |
| * Program Basics:: Writing the beginning and end of your |
| program. |
| * Processes:: How to create processes and run other |
| programs. |
| * Job Control:: All about process groups and sessions. |
| * Name Service Switch:: Accessing system databases. |
| * Users and Groups:: How users are identified and classified. |
| * System Management:: Controlling the system and getting |
| information about it. |
| * System Configuration:: Parameters describing operating system |
| limits. |
| * Cryptographic Functions:: DES encryption and password handling. |
| * Debugging Support:: Functions to help debugging applications. |
| * POSIX Threads:: POSIX Threads. |
| * Internal Probes:: Probes to monitor libc internal behavior. |
| |
| Appendices |
| |
| * Language Features:: C language features provided by the library. |
| * Library Summary:: A summary showing the syntax, header file, |
| and derivation of each library feature. |
| * Installation:: How to install the GNU C Library. |
| * Maintenance:: How to enhance and port the GNU C Library. |
| * Platform:: Describe all platform-specific facilities |
| provided. |
| * Contributors:: Who wrote what parts of the GNU C Library. |
| * Free Manuals:: Free Software Needs Free Documentation. |
| * Copying:: The GNU Lesser General Public License says |
| how you can copy and share the GNU C Library. |
| * Documentation License:: This manual is under the GNU Free |
| Documentation License. |
| |
| Indices |
| |
| * Concept Index:: Index of concepts and names. |
| * Type Index:: Index of types and type qualifiers. |
| * Function Index:: Index of functions and function-like macros. |
| * Variable Index:: Index of variables and variable-like macros. |
| * File Index:: Index of programs and files. |
| |
| |
| -- The Detailed Node Listing -- |
| |
| Introduction |
| |
| * Getting Started:: What this manual is for and how to use it. |
| * Standards and Portability:: Standards and sources upon which the GNU |
| C library is based. |
| * Using the Library:: Some practical uses for the library. |
| * Roadmap to the Manual:: Overview of the remaining chapters in |
| this manual. |
| |
| Standards and Portability |
| |
| * ISO C:: The international standard for the C |
| programming language. |
| * POSIX:: The ISO/IEC 9945 (aka IEEE 1003) standards |
| for operating systems. |
| * Berkeley Unix:: BSD and SunOS. |
| * SVID:: The System V Interface Description. |
| * XPG:: The X/Open Portability Guide. |
| |
| POSIX |
| |
| * POSIX Safety Concepts:: Safety concepts from POSIX. |
| * Unsafe Features:: Features that make functions unsafe. |
| * Conditionally Safe Features:: Features that make functions unsafe |
| in the absence of workarounds. |
| * Other Safety Remarks:: Additional safety features and remarks. |
| |
| Using the Library |
| |
| * Header Files:: How to include the header files in your |
| programs. |
| * Macro Definitions:: Some functions in the library may really |
| be implemented as macros. |
| * Reserved Names:: The C standard reserves some names for |
| the library, and some for users. |
| * Feature Test Macros:: How to control what names are defined. |
| |
| Error Reporting |
| |
| * Checking for Errors:: How errors are reported by library functions. |
| * Error Codes:: Error code macros; all of these expand |
| into integer constant values. |
| * Error Messages:: Mapping error codes onto error messages. |
| |
| Memory |
| |
| * Memory Concepts:: An introduction to concepts and terminology. |
| * Memory Allocation:: Allocating storage for your program data |
| * Resizing the Data Segment:: 'brk', 'sbrk' |
| * Locking Pages:: Preventing page faults |
| |
| Memory Allocation |
| |
| * Memory Allocation and C:: How to get different kinds of allocation in C. |
| * Unconstrained Allocation:: The 'malloc' facility allows fully general |
| dynamic allocation. |
| * Allocation Debugging:: Finding memory leaks and not freed memory. |
| * Obstacks:: Obstacks are less general than malloc |
| but more efficient and convenient. |
| * Variable Size Automatic:: Allocation of variable-sized blocks |
| of automatic storage that are freed when the |
| calling function returns. |
| |
| Unconstrained Allocation |
| |
| * Basic Allocation:: Simple use of 'malloc'. |
| * Malloc Examples:: Examples of 'malloc'. 'xmalloc'. |
| * Freeing after Malloc:: Use 'free' to free a block you |
| got with 'malloc'. |
| * Changing Block Size:: Use 'realloc' to make a block |
| bigger or smaller. |
| * Allocating Cleared Space:: Use 'calloc' to allocate a |
| block and clear it. |
| * Efficiency and Malloc:: Efficiency considerations in use of |
| these functions. |
| * Aligned Memory Blocks:: Allocating specially aligned memory. |
| * Malloc Tunable Parameters:: Use 'mallopt' to adjust allocation |
| parameters. |
| * Heap Consistency Checking:: Automatic checking for errors. |
| * Hooks for Malloc:: You can use these hooks for debugging |
| programs that use 'malloc'. |
| * Statistics of Malloc:: Getting information about how much |
| memory your program is using. |
| * Summary of Malloc:: Summary of 'malloc' and related functions. |
| |
| Allocation Debugging |
| |
| * Tracing malloc:: How to install the tracing functionality. |
| * Using the Memory Debugger:: Example programs excerpts. |
| * Tips for the Memory Debugger:: Some more or less clever ideas. |
| * Interpreting the traces:: What do all these lines mean? |
| |
| Obstacks |
| |
| * Creating Obstacks:: How to declare an obstack in your program. |
| * Preparing for Obstacks:: Preparations needed before you can |
| use obstacks. |
| * Allocation in an Obstack:: Allocating objects in an obstack. |
| * Freeing Obstack Objects:: Freeing objects in an obstack. |
| * Obstack Functions:: The obstack functions are both |
| functions and macros. |
| * Growing Objects:: Making an object bigger by stages. |
| * Extra Fast Growing:: Extra-high-efficiency (though more |
| complicated) growing objects. |
| * Status of an Obstack:: Inquiries about the status of an obstack. |
| * Obstacks Data Alignment:: Controlling alignment of objects in obstacks. |
| * Obstack Chunks:: How obstacks obtain and release chunks; |
| efficiency considerations. |
| * Summary of Obstacks:: |
| |
| Variable Size Automatic |
| |
| * Alloca Example:: Example of using 'alloca'. |
| * Advantages of Alloca:: Reasons to use 'alloca'. |
| * Disadvantages of Alloca:: Reasons to avoid 'alloca'. |
| * GNU C Variable-Size Arrays:: Only in GNU C, here is an alternative |
| method of allocating dynamically and |
| freeing automatically. |
| |
| Locking Pages |
| |
| * Why Lock Pages:: Reasons to read this section. |
| * Locked Memory Details:: Everything you need to know locked |
| memory |
| * Page Lock Functions:: Here's how to do it. |
| |
| Character Handling |
| |
| * Classification of Characters:: Testing whether characters are |
| letters, digits, punctuation, etc. |
| |
| * Case Conversion:: Case mapping, and the like. |
| * Classification of Wide Characters:: Character class determination for |
| wide characters. |
| * Using Wide Char Classes:: Notes on using the wide character |
| classes. |
| * Wide Character Case Conversion:: Mapping of wide characters. |
| |
| String and Array Utilities |
| |
| * Representation of Strings:: Introduction to basic concepts. |
| * String/Array Conventions:: Whether to use a string function or an |
| arbitrary array function. |
| * String Length:: Determining the length of a string. |
| * Copying and Concatenation:: Functions to copy the contents of strings |
| and arrays. |
| * String/Array Comparison:: Functions for byte-wise and character-wise |
| comparison. |
| * Collation Functions:: Functions for collating strings. |
| * Search Functions:: Searching for a specific element or substring. |
| * Finding Tokens in a String:: Splitting a string into tokens by looking |
| for delimiters. |
| * strfry:: Function for flash-cooking a string. |
| * Trivial Encryption:: Obscuring data. |
| * Encode Binary Data:: Encoding and Decoding of Binary Data. |
| * Argz and Envz Vectors:: Null-separated string vectors. |
| |
| Argz and Envz Vectors |
| |
| * Argz Functions:: Operations on argz vectors. |
| * Envz Functions:: Additional operations on environment vectors. |
| |
| Character Set Handling |
| |
| * Extended Char Intro:: Introduction to Extended Characters. |
| * Charset Function Overview:: Overview about Character Handling |
| Functions. |
| * Restartable multibyte conversion:: Restartable multibyte conversion |
| Functions. |
| * Non-reentrant Conversion:: Non-reentrant Conversion Function. |
| * Generic Charset Conversion:: Generic Charset Conversion. |
| |
| Restartable multibyte conversion |
| |
| * Selecting the Conversion:: Selecting the conversion and its properties. |
| * Keeping the state:: Representing the state of the conversion. |
| * Converting a Character:: Converting Single Characters. |
| * Converting Strings:: Converting Multibyte and Wide Character |
| Strings. |
| * Multibyte Conversion Example:: A Complete Multibyte Conversion Example. |
| |
| Non-reentrant Conversion |
| |
| * Non-reentrant Character Conversion:: Non-reentrant Conversion of Single |
| Characters. |
| * Non-reentrant String Conversion:: Non-reentrant Conversion of Strings. |
| * Shift State:: States in Non-reentrant Functions. |
| |
| Generic Charset Conversion |
| |
| * Generic Conversion Interface:: Generic Character Set Conversion Interface. |
| * iconv Examples:: A complete 'iconv' example. |
| * Other iconv Implementations:: Some Details about other 'iconv' |
| Implementations. |
| * glibc iconv Implementation:: The 'iconv' Implementation in the GNU C |
| library. |
| |
| Locales |
| |
| * Effects of Locale:: Actions affected by the choice of |
| locale. |
| * Choosing Locale:: How the user specifies a locale. |
| * Locale Categories:: Different purposes for which you can |
| select a locale. |
| * Setting the Locale:: How a program specifies the locale |
| with library functions. |
| * Standard Locales:: Locale names available on all systems. |
| * Locale Information:: How to access the information for the locale. |
| * Formatting Numbers:: A dedicated function to format numbers. |
| * Yes-or-No Questions:: Check a Response against the locale. |
| |
| Locale Information |
| |
| * The Lame Way to Locale Data:: ISO C's 'localeconv'. |
| * The Elegant and Fast Way:: X/Open's 'nl_langinfo'. |
| |
| The Lame Way to Locale Data |
| |
| * General Numeric:: Parameters for formatting numbers and |
| currency amounts. |
| * Currency Symbol:: How to print the symbol that identifies an |
| amount of money (e.g. '$'). |
| * Sign of Money Amount:: How to print the (positive or negative) sign |
| for a monetary amount, if one exists. |
| |
| Message Translation |
| |
| * Message catalogs a la X/Open:: The 'catgets' family of functions. |
| * The Uniforum approach:: The 'gettext' family of functions. |
| |
| Message catalogs a la X/Open |
| |
| * The catgets Functions:: The 'catgets' function family. |
| * The message catalog files:: Format of the message catalog files. |
| * The gencat program:: How to generate message catalogs files which |
| can be used by the functions. |
| * Common Usage:: How to use the 'catgets' interface. |
| |
| The Uniforum approach |
| |
| * Message catalogs with gettext:: The 'gettext' family of functions. |
| * Helper programs for gettext:: Programs to handle message catalogs |
| for 'gettext'. |
| |
| Message catalogs with gettext |
| |
| * Translation with gettext:: What has to be done to translate a message. |
| * Locating gettext catalog:: How to determine which catalog to be used. |
| * Advanced gettext functions:: Additional functions for more complicated |
| situations. |
| * Charset conversion in gettext:: How to specify the output character set |
| 'gettext' uses. |
| * GUI program problems:: How to use 'gettext' in GUI programs. |
| * Using gettextized software:: The possibilities of the user to influence |
| the way 'gettext' works. |
| |
| Searching and Sorting |
| |
| * Comparison Functions:: Defining how to compare two objects. |
| Since the sort and search facilities |
| are general, you have to specify the |
| ordering. |
| * Array Search Function:: The 'bsearch' function. |
| * Array Sort Function:: The 'qsort' function. |
| * Search/Sort Example:: An example program. |
| * Hash Search Function:: The 'hsearch' function. |
| * Tree Search Function:: The 'tsearch' function. |
| |
| Pattern Matching |
| |
| * Wildcard Matching:: Matching a wildcard pattern against a single string. |
| * Globbing:: Finding the files that match a wildcard pattern. |
| * Regular Expressions:: Matching regular expressions against strings. |
| * Word Expansion:: Expanding shell variables, nested commands, |
| arithmetic, and wildcards. |
| This is what the shell does with shell commands. |
| |
| Globbing |
| |
| * Calling Glob:: Basic use of 'glob'. |
| * Flags for Globbing:: Flags that enable various options in 'glob'. |
| * More Flags for Globbing:: GNU specific extensions to 'glob'. |
| |
| Regular Expressions |
| |
| * POSIX Regexp Compilation:: Using 'regcomp' to prepare to match. |
| * Flags for POSIX Regexps:: Syntax variations for 'regcomp'. |
| * Matching POSIX Regexps:: Using 'regexec' to match the compiled |
| pattern that you get from 'regcomp'. |
| * Regexp Subexpressions:: Finding which parts of the string were matched. |
| * Subexpression Complications:: Find points of which parts were matched. |
| * Regexp Cleanup:: Freeing storage; reporting errors. |
| |
| Word Expansion |
| |
| * Expansion Stages:: What word expansion does to a string. |
| * Calling Wordexp:: How to call 'wordexp'. |
| * Flags for Wordexp:: Options you can enable in 'wordexp'. |
| * Wordexp Example:: A sample program that does word expansion. |
| * Tilde Expansion:: Details of how tilde expansion works. |
| * Variable Substitution:: Different types of variable substitution. |
| |
| I/O Overview |
| |
| * I/O Concepts:: Some basic information and terminology. |
| * File Names:: How to refer to a file. |
| |
| I/O Concepts |
| |
| * Streams and File Descriptors:: The GNU C Library provides two ways |
| to access the contents of files. |
| * File Position:: The number of bytes from the |
| beginning of the file. |
| |
| File Names |
| |
| * Directories:: Directories contain entries for files. |
| * File Name Resolution:: A file name specifies how to look up a file. |
| * File Name Errors:: Error conditions relating to file names. |
| * File Name Portability:: File name portability and syntax issues. |
| |
| I/O on Streams |
| |
| * Streams:: About the data type representing a stream. |
| * Standard Streams:: Streams to the standard input and output |
| devices are created for you. |
| * Opening Streams:: How to create a stream to talk to a file. |
| * Closing Streams:: Close a stream when you are finished with it. |
| * Streams and Threads:: Issues with streams in threaded programs. |
| * Streams and I18N:: Streams in internationalized applications. |
| * Simple Output:: Unformatted output by characters and lines. |
| * Character Input:: Unformatted input by characters and words. |
| * Line Input:: Reading a line or a record from a stream. |
| * Unreading:: Peeking ahead/pushing back input just read. |
| * Block Input/Output:: Input and output operations on blocks of data. |
| * Formatted Output:: 'printf' and related functions. |
| * Customizing Printf:: You can define new conversion specifiers for |
| 'printf' and friends. |
| * Formatted Input:: 'scanf' and related functions. |
| * EOF and Errors:: How you can tell if an I/O error happens. |
| * Error Recovery:: What you can do about errors. |
| * Binary Streams:: Some systems distinguish between text files |
| and binary files. |
| * File Positioning:: About random-access streams. |
| * Portable Positioning:: Random access on peculiar ISO C systems. |
| * Stream Buffering:: How to control buffering of streams. |
| * Other Kinds of Streams:: Streams that do not necessarily correspond |
| to an open file. |
| * Formatted Messages:: Print strictly formatted messages. |
| |
| Unreading |
| |
| * Unreading Idea:: An explanation of unreading with pictures. |
| * How Unread:: How to call 'ungetc' to do unreading. |
| |
| Formatted Output |
| |
| * Formatted Output Basics:: Some examples to get you started. |
| * Output Conversion Syntax:: General syntax of conversion |
| specifications. |
| * Table of Output Conversions:: Summary of output conversions and |
| what they do. |
| * Integer Conversions:: Details about formatting of integers. |
| * Floating-Point Conversions:: Details about formatting of |
| floating-point numbers. |
| * Other Output Conversions:: Details about formatting of strings, |
| characters, pointers, and the like. |
| * Formatted Output Functions:: Descriptions of the actual functions. |
| * Dynamic Output:: Functions that allocate memory for the output. |
| * Variable Arguments Output:: 'vprintf' and friends. |
| * Parsing a Template String:: What kinds of args does a given template |
| call for? |
| * Example of Parsing:: Sample program using 'parse_printf_format'. |
| |
| Customizing Printf |
| |
| * Registering New Conversions:: Using 'register_printf_function' |
| to register a new output conversion. |
| * Conversion Specifier Options:: The handler must be able to get |
| the options specified in the |
| template when it is called. |
| * Defining the Output Handler:: Defining the handler and arginfo |
| functions that are passed as arguments |
| to 'register_printf_function'. |
| * Printf Extension Example:: How to define a 'printf' |
| handler function. |
| * Predefined Printf Handlers:: Predefined 'printf' handlers. |
| |
| Formatted Input |
| |
| * Formatted Input Basics:: Some basics to get you started. |
| * Input Conversion Syntax:: Syntax of conversion specifications. |
| * Table of Input Conversions:: Summary of input conversions and what they do. |
| * Numeric Input Conversions:: Details of conversions for reading numbers. |
| * String Input Conversions:: Details of conversions for reading strings. |
| * Dynamic String Input:: String conversions that 'malloc' the buffer. |
| * Other Input Conversions:: Details of miscellaneous other conversions. |
| * Formatted Input Functions:: Descriptions of the actual functions. |
| * Variable Arguments Input:: 'vscanf' and friends. |
| |
| Stream Buffering |
| |
| * Buffering Concepts:: Terminology is defined here. |
| * Flushing Buffers:: How to ensure that output buffers are flushed. |
| * Controlling Buffering:: How to specify what kind of buffering to use. |
| |
| Other Kinds of Streams |
| |
| * String Streams:: Streams that get data from or put data in |
| a string or memory buffer. |
| * Custom Streams:: Defining your own streams with an arbitrary |
| input data source and/or output data sink. |
| |
| Custom Streams |
| |
| * Streams and Cookies:: The "cookie" records where to fetch or |
| store data that is read or written. |
| * Hook Functions:: How you should define the four "hook |
| functions" that a custom stream needs. |
| |
| Formatted Messages |
| |
| * Printing Formatted Messages:: The 'fmtmsg' function. |
| * Adding Severity Classes:: Add more severity classes. |
| * Example:: How to use 'fmtmsg' and 'addseverity'. |
| |
| Low-Level I/O |
| |
| * Opening and Closing Files:: How to open and close file |
| descriptors. |
| * I/O Primitives:: Reading and writing data. |
| * File Position Primitive:: Setting a descriptor's file |
| position. |
| * Descriptors and Streams:: Converting descriptor to stream |
| or vice-versa. |
| * Stream/Descriptor Precautions:: Precautions needed if you use both |
| descriptors and streams. |
| * Scatter-Gather:: Fast I/O to discontinuous buffers. |
| * Memory-mapped I/O:: Using files like memory. |
| * Waiting for I/O:: How to check for input or output |
| on multiple file descriptors. |
| * Synchronizing I/O:: Making sure all I/O actions completed. |
| * Asynchronous I/O:: Perform I/O in parallel. |
| * Control Operations:: Various other operations on file |
| descriptors. |
| * Duplicating Descriptors:: Fcntl commands for duplicating |
| file descriptors. |
| * Descriptor Flags:: Fcntl commands for manipulating |
| flags associated with file |
| descriptors. |
| * File Status Flags:: Fcntl commands for manipulating |
| flags associated with open files. |
| * File Locks:: Fcntl commands for implementing |
| file locking. |
| * Interrupt Input:: Getting an asynchronous signal when |
| input arrives. |
| * IOCTLs:: Generic I/O Control operations. |
| |
| Stream/Descriptor Precautions |
| |
| * Linked Channels:: Dealing with channels sharing a file position. |
| * Independent Channels:: Dealing with separately opened, unlinked channels. |
| * Cleaning Streams:: Cleaning a stream makes it safe to use |
| another channel. |
| |
| Asynchronous I/O |
| |
| * Asynchronous Reads/Writes:: Asynchronous Read and Write Operations. |
| * Status of AIO Operations:: Getting the Status of AIO Operations. |
| * Synchronizing AIO Operations:: Getting into a consistent state. |
| * Cancel AIO Operations:: Cancellation of AIO Operations. |
| * Configuration of AIO:: How to optimize the AIO implementation. |
| |
| File Status Flags |
| |
| * Access Modes:: Whether the descriptor can read or write. |
| * Open-time Flags:: Details of 'open'. |
| * Operating Modes:: Special modes to control I/O operations. |
| * Getting File Status Flags:: Fetching and changing these flags. |
| |
| File System Interface |
| |
| * Working Directory:: This is used to resolve relative |
| file names. |
| * Accessing Directories:: Finding out what files a directory |
| contains. |
| * Working with Directory Trees:: Apply actions to all files or a selectable |
| subset of a directory hierarchy. |
| * Hard Links:: Adding alternate names to a file. |
| * Symbolic Links:: A file that "points to" a file name. |
| * Deleting Files:: How to delete a file, and what that means. |
| * Renaming Files:: Changing a file's name. |
| * Creating Directories:: A system call just for creating a directory. |
| * File Attributes:: Attributes of individual files. |
| * Making Special Files:: How to create special files. |
| * Temporary Files:: Naming and creating temporary files. |
| |
| Accessing Directories |
| |
| * Directory Entries:: Format of one directory entry. |
| * Opening a Directory:: How to open a directory stream. |
| * Reading/Closing Directory:: How to read directory entries from the stream. |
| * Simple Directory Lister:: A very simple directory listing program. |
| * Random Access Directory:: Rereading part of the directory |
| already read with the same stream. |
| * Scanning Directory Content:: Get entries for user selected subset of |
| contents in given directory. |
| * Simple Directory Lister Mark II:: Revised version of the program. |
| |
| File Attributes |
| |
| * Attribute Meanings:: The names of the file attributes, |
| and what their values mean. |
| * Reading Attributes:: How to read the attributes of a file. |
| * Testing File Type:: Distinguishing ordinary files, |
| directories, links... |
| * File Owner:: How ownership for new files is determined, |
| and how to change it. |
| * Permission Bits:: How information about a file's access |
| mode is stored. |
| * Access Permission:: How the system decides who can access a file. |
| * Setting Permissions:: How permissions for new files are assigned, |
| and how to change them. |
| * Testing File Access:: How to find out if your process can |
| access a file. |
| * File Times:: About the time attributes of a file. |
| * File Size:: Manually changing the size of a file. |
| |
| Pipes and FIFOs |
| |
| * Creating a Pipe:: Making a pipe with the 'pipe' function. |
| * Pipe to a Subprocess:: Using a pipe to communicate with a |
| child process. |
| * FIFO Special Files:: Making a FIFO special file. |
| * Pipe Atomicity:: When pipe (or FIFO) I/O is atomic. |
| |
| Sockets |
| |
| * Socket Concepts:: Basic concepts you need to know about. |
| * Communication Styles::Stream communication, datagrams and other styles. |
| * Socket Addresses:: How socket names ("addresses") work. |
| * Interface Naming:: Identifying specific network interfaces. |
| * Local Namespace:: Details about the local namespace. |
| * Internet Namespace:: Details about the Internet namespace. |
| * Misc Namespaces:: Other namespaces not documented fully here. |
| * Open/Close Sockets:: Creating sockets and destroying them. |
| * Connections:: Operations on sockets with connection state. |
| * Datagrams:: Operations on datagram sockets. |
| * Inetd:: Inetd is a daemon that starts servers on request. |
| The most convenient way to write a server |
| is to make it work with Inetd. |
| * Socket Options:: Miscellaneous low-level socket options. |
| * Networks Database:: Accessing the database of network names. |
| |
| Socket Addresses |
| |
| * Address Formats:: About 'struct sockaddr'. |
| * Setting Address:: Binding an address to a socket. |
| * Reading Address:: Reading the address of a socket. |
| |
| Local Namespace |
| |
| * Concepts: Local Namespace Concepts. What you need to understand. |
| * Details: Local Namespace Details. Address format, symbolic names, etc. |
| * Example: Local Socket Example. Example of creating a socket. |
| |
| Internet Namespace |
| |
| * Internet Address Formats:: How socket addresses are specified in the |
| Internet namespace. |
| * Host Addresses:: All about host addresses of Internet host. |
| * Ports:: Internet port numbers. |
| * Services Database:: Ports may have symbolic names. |
| * Byte Order:: Different hosts may use different byte |
| ordering conventions; you need to |
| canonicalize host address and port number. |
| * Protocols Database:: Referring to protocols by name. |
| * Inet Example:: Putting it all together. |
| |
| Host Addresses |
| |
| * Abstract Host Addresses:: What a host number consists of. |
| * Data type: Host Address Data Type. Data type for a host number. |
| * Functions: Host Address Functions. Functions to operate on them. |
| * Names: Host Names. Translating host names to host numbers. |
| |
| Open/Close Sockets |
| |
| * Creating a Socket:: How to open a socket. |
| * Closing a Socket:: How to close a socket. |
| * Socket Pairs:: These are created like pipes. |
| |
| Connections |
| |
| * Connecting:: What the client program must do. |
| * Listening:: How a server program waits for requests. |
| * Accepting Connections:: What the server does when it gets a request. |
| * Who is Connected:: Getting the address of the |
| other side of a connection. |
| * Transferring Data:: How to send and receive data. |
| * Byte Stream Example:: An example program: a client for communicating |
| over a byte stream socket in the Internet namespace. |
| * Server Example:: A corresponding server program. |
| * Out-of-Band Data:: This is an advanced feature. |
| |
| Transferring Data |
| |
| * Sending Data:: Sending data with 'send'. |
| * Receiving Data:: Reading data with 'recv'. |
| * Socket Data Options:: Using 'send' and 'recv'. |
| |
| Datagrams |
| |
| * Sending Datagrams:: Sending packets on a datagram socket. |
| * Receiving Datagrams:: Receiving packets on a datagram socket. |
| * Datagram Example:: An example program: packets sent over a |
| datagram socket in the local namespace. |
| * Example Receiver:: Another program, that receives those packets. |
| |
| Inetd |
| |
| * Inetd Servers:: |
| * Configuring Inetd:: |
| |
| Socket Options |
| |
| * Socket Option Functions:: The basic functions for setting and getting |
| socket options. |
| * Socket-Level Options:: Details of the options at the socket level. |
| |
| Low-Level Terminal Interface |
| |
| * Is It a Terminal:: How to determine if a file is a terminal |
| device, and what its name is. |
| * I/O Queues:: About flow control and typeahead. |
| * Canonical or Not:: Two basic styles of input processing. |
| * Terminal Modes:: How to examine and modify flags controlling |
| details of terminal I/O: echoing, |
| signals, editing. Posix. |
| * BSD Terminal Modes:: BSD compatible terminal mode setting |
| * Line Control:: Sending break sequences, clearing |
| terminal buffers ... |
| * Noncanon Example:: How to read single characters without echo. |
| * Pseudo-Terminals:: How to open a pseudo-terminal. |
| |
| Terminal Modes |
| |
| * Mode Data Types:: The data type 'struct termios' and |
| related types. |
| * Mode Functions:: Functions to read and set the terminal |
| attributes. |
| * Setting Modes:: The right way to set terminal attributes |
| reliably. |
| * Input Modes:: Flags controlling low-level input handling. |
| * Output Modes:: Flags controlling low-level output handling. |
| * Control Modes:: Flags controlling serial port behavior. |
| * Local Modes:: Flags controlling high-level input handling. |
| * Line Speed:: How to read and set the terminal line speed. |
| * Special Characters:: Characters that have special effects, |
| and how to change them. |
| * Noncanonical Input:: Controlling how long to wait for input. |
| |
| Special Characters |
| |
| * Editing Characters:: Special characters that terminate lines and |
| delete text, and other editing functions. |
| * Signal Characters:: Special characters that send or raise signals |
| to or for certain classes of processes. |
| * Start/Stop Characters:: Special characters that suspend or resume |
| suspended output. |
| * Other Special:: Other special characters for BSD systems: |
| they can discard output, and print status. |
| |
| Pseudo-Terminals |
| |
| * Allocation:: Allocating a pseudo terminal. |
| * Pseudo-Terminal Pairs:: How to open both sides of a |
| pseudo-terminal in a single operation. |
| |
| Syslog |
| |
| * Overview of Syslog:: Overview of a system's Syslog facility |
| * Submitting Syslog Messages:: Functions to submit messages to Syslog |
| |
| Submitting Syslog Messages |
| |
| * openlog:: Open connection to Syslog |
| * syslog; vsyslog:: Submit message to Syslog |
| * closelog:: Close connection to Syslog |
| * setlogmask:: Cause certain messages to be ignored |
| * Syslog Example:: Example of all of the above |
| |
| Mathematics |
| |
| * Mathematical Constants:: Precise numeric values for often-used |
| constants. |
| * Trig Functions:: Sine, cosine, tangent, and friends. |
| * Inverse Trig Functions:: Arcsine, arccosine, etc. |
| * Exponents and Logarithms:: Also pow and sqrt. |
| * Hyperbolic Functions:: sinh, cosh, tanh, etc. |
| * Special Functions:: Bessel, gamma, erf. |
| * Errors in Math Functions:: Known Maximum Errors in Math Functions. |
| * Pseudo-Random Numbers:: Functions for generating pseudo-random |
| numbers. |
| * FP Function Optimizations:: Fast code or small code. |
| |
| Pseudo-Random Numbers |
| |
| * ISO Random:: 'rand' and friends. |
| * BSD Random:: 'random' and friends. |
| * SVID Random:: 'drand48' and friends. |
| |
| Arithmetic |
| |
| * Integers:: Basic integer types and concepts |
| * Integer Division:: Integer division with guaranteed rounding. |
| * Floating Point Numbers:: Basic concepts. IEEE 754. |
| * Floating Point Classes:: The five kinds of floating-point number. |
| * Floating Point Errors:: When something goes wrong in a calculation. |
| * Rounding:: Controlling how results are rounded. |
| * Control Functions:: Saving and restoring the FPU's state. |
| * Arithmetic Functions:: Fundamental operations provided by the library. |
| * Complex Numbers:: The types. Writing complex constants. |
| * Operations on Complex:: Projection, conjugation, decomposition. |
| * Parsing of Numbers:: Converting strings to numbers. |
| * System V Number Conversion:: An archaic way to convert numbers to strings. |
| |
| Floating Point Errors |
| |
| * FP Exceptions:: IEEE 754 math exceptions and how to detect them. |
| * Infinity and NaN:: Special values returned by calculations. |
| * Status bit operations:: Checking for exceptions after the fact. |
| * Math Error Reporting:: How the math functions report errors. |
| |
| Arithmetic Functions |
| |
| * Absolute Value:: Absolute values of integers and floats. |
| * Normalization Functions:: Extracting exponents and putting them back. |
| * Rounding Functions:: Rounding floats to integers. |
| * Remainder Functions:: Remainders on division, precisely defined. |
| * FP Bit Twiddling:: Sign bit adjustment. Adding epsilon. |
| * FP Comparison Functions:: Comparisons without risk of exceptions. |
| * Misc FP Arithmetic:: Max, min, positive difference, multiply-add. |
| |
| Parsing of Numbers |
| |
| * Parsing of Integers:: Functions for conversion of integer values. |
| * Parsing of Floats:: Functions for conversion of floating-point |
| values. |
| |
| Date and Time |
| |
| * Time Basics:: Concepts and definitions. |
| * Elapsed Time:: Data types to represent elapsed times |
| * Processor And CPU Time:: Time a program has spent executing. |
| * Calendar Time:: Manipulation of "real" dates and times. |
| * Setting an Alarm:: Sending a signal after a specified time. |
| * Sleeping:: Waiting for a period of time. |
| |
| Processor And CPU Time |
| |
| * CPU Time:: The 'clock' function. |
| * Processor Time:: The 'times' function. |
| |
| Calendar Time |
| |
| * Simple Calendar Time:: Facilities for manipulating calendar time. |
| * High-Resolution Calendar:: A time representation with greater precision. |
| * Broken-down Time:: Facilities for manipulating local time. |
| * High Accuracy Clock:: Maintaining a high accuracy system clock. |
| * Formatting Calendar Time:: Converting times to strings. |
| * Parsing Date and Time:: Convert textual time and date information back |
| into broken-down time values. |
| * TZ Variable:: How users specify the time zone. |
| * Time Zone Functions:: Functions to examine or specify the time zone. |
| * Time Functions Example:: An example program showing use of some of |
| the time functions. |
| |
| Parsing Date and Time |
| |
| * Low-Level Time String Parsing:: Interpret string according to given format. |
| * General Time String Parsing:: User-friendly function to parse data and |
| time strings. |
| |
| Resource Usage And Limitation |
| |
| * Resource Usage:: Measuring various resources used. |
| * Limits on Resources:: Specifying limits on resource usage. |
| * Priority:: Reading or setting process run priority. |
| * Memory Resources:: Querying memory available resources. |
| * Processor Resources:: Learn about the processors available. |
| |
| Priority |
| |
| * Absolute Priority:: The first tier of priority. Posix |
| * Realtime Scheduling:: Scheduling among the process nobility |
| * Basic Scheduling Functions:: Get/set scheduling policy, priority |
| * Traditional Scheduling:: Scheduling among the vulgar masses |
| * CPU Affinity:: Limiting execution to certain CPUs |
| |
| Traditional Scheduling |
| |
| * Traditional Scheduling Intro:: |
| * Traditional Scheduling Functions:: |
| |
| Memory Resources |
| |
| * Memory Subsystem:: Overview about traditional Unix memory handling. |
| * Query Memory Parameters:: How to get information about the memory |
| subsystem? |
| |
| Non-Local Exits |
| |
| * Intro: Non-Local Intro. When and how to use these facilities. |
| * Details: Non-Local Details. Functions for non-local exits. |
| * Non-Local Exits and Signals:: Portability issues. |
| * System V contexts:: Complete context control a la System V. |
| |
| Signal Handling |
| |
| * Concepts of Signals:: Introduction to the signal facilities. |
| * Standard Signals:: Particular kinds of signals with |
| standard names and meanings. |
| * Signal Actions:: Specifying what happens when a |
| particular signal is delivered. |
| * Defining Handlers:: How to write a signal handler function. |
| * Interrupted Primitives:: Signal handlers affect use of 'open', |
| 'read', 'write' and other functions. |
| * Generating Signals:: How to send a signal to a process. |
| * Blocking Signals:: Making the system hold signals temporarily. |
| * Waiting for a Signal:: Suspending your program until a signal |
| arrives. |
| * Signal Stack:: Using a Separate Signal Stack. |
| * BSD Signal Handling:: Additional functions for backward |
| compatibility with BSD. |
| |
| Concepts of Signals |
| |
| * Kinds of Signals:: Some examples of what can cause a signal. |
| * Signal Generation:: Concepts of why and how signals occur. |
| * Delivery of Signal:: Concepts of what a signal does to the |
| process. |
| |
| Standard Signals |
| |
| * Program Error Signals:: Used to report serious program errors. |
| * Termination Signals:: Used to interrupt and/or terminate the |
| program. |
| * Alarm Signals:: Used to indicate expiration of timers. |
| * Asynchronous I/O Signals:: Used to indicate input is available. |
| * Job Control Signals:: Signals used to support job control. |
| * Operation Error Signals:: Used to report operational system errors. |
| * Miscellaneous Signals:: Miscellaneous Signals. |
| * Signal Messages:: Printing a message describing a signal. |
| |
| Signal Actions |
| |
| * Basic Signal Handling:: The simple 'signal' function. |
| * Advanced Signal Handling:: The more powerful 'sigaction' function. |
| * Signal and Sigaction:: How those two functions interact. |
| * Sigaction Function Example:: An example of using the sigaction function. |
| * Flags for Sigaction:: Specifying options for signal handling. |
| * Initial Signal Actions:: How programs inherit signal actions. |
| |
| Defining Handlers |
| |
| * Handler Returns:: Handlers that return normally, and what |
| this means. |
| * Termination in Handler:: How handler functions terminate a program. |
| * Longjmp in Handler:: Nonlocal transfer of control out of a |
| signal handler. |
| * Signals in Handler:: What happens when signals arrive while |
| the handler is already occupied. |
| * Merged Signals:: When a second signal arrives before the |
| first is handled. |
| * Nonreentrancy:: Do not call any functions unless you know they |
| are reentrant with respect to signals. |
| * Atomic Data Access:: A single handler can run in the middle of |
| reading or writing a single object. |
| |
| Atomic Data Access |
| |
| * Non-atomic Example:: A program illustrating interrupted access. |
| * Types: Atomic Types. Data types that guarantee no interruption. |
| * Usage: Atomic Usage. Proving that interruption is harmless. |
| |
| Generating Signals |
| |
| * Signaling Yourself:: A process can send a signal to itself. |
| * Signaling Another Process:: Send a signal to another process. |
| * Permission for kill:: Permission for using 'kill'. |
| * Kill Example:: Using 'kill' for Communication. |
| |
| Blocking Signals |
| |
| * Why Block:: The purpose of blocking signals. |
| * Signal Sets:: How to specify which signals to |
| block. |
| * Process Signal Mask:: Blocking delivery of signals to your |
| process during normal execution. |
| * Testing for Delivery:: Blocking to Test for Delivery of |
| a Signal. |
| * Blocking for Handler:: Blocking additional signals while a |
| handler is being run. |
| * Checking for Pending Signals:: Checking for Pending Signals |
| * Remembering a Signal:: How you can get almost the same |
| effect as blocking a signal, by |
| handling it and setting a flag |
| to be tested later. |
| |
| Waiting for a Signal |
| |
| * Using Pause:: The simple way, using 'pause'. |
| * Pause Problems:: Why the simple way is often not very good. |
| * Sigsuspend:: Reliably waiting for a specific signal. |
| |
| BSD Signal Handling |
| |
| * BSD Handler:: BSD Function to Establish a Handler. |
| * Blocking in BSD:: BSD Functions for Blocking Signals. |
| |
| Program Basics |
| |
| * Program Arguments:: Parsing your program's command-line arguments |
| * Environment Variables:: Less direct parameters affecting your program |
| * Auxiliary Vector:: Least direct parameters affecting your program |
| * System Calls:: Requesting service from the system |
| * Program Termination:: Telling the system you're done; return status |
| |
| Program Arguments |
| |
| * Argument Syntax:: By convention, options start with a hyphen. |
| * Parsing Program Arguments:: Ways to parse program options and arguments. |
| |
| Parsing Program Arguments |
| |
| * Getopt:: Parsing program options using 'getopt'. |
| * Argp:: Parsing program options using 'argp_parse'. |
| * Suboptions:: Some programs need more detailed options. |
| * Suboptions Example:: This shows how it could be done for 'mount'. |
| |
| Environment Variables |
| |
| * Environment Access:: How to get and set the values of |
| environment variables. |
| * Standard Environment:: These environment variables have |
| standard interpretations. |
| |
| Program Termination |
| |
| * Normal Termination:: If a program calls 'exit', a |
| process terminates normally. |
| * Exit Status:: The 'exit status' provides information |
| about why the process terminated. |
| * Cleanups on Exit:: A process can run its own cleanup |
| functions upon normal termination. |
| * Aborting a Program:: The 'abort' function causes |
| abnormal program termination. |
| * Termination Internals:: What happens when a process terminates. |
| |
| Processes |
| |
| * Running a Command:: The easy way to run another program. |
| * Process Creation Concepts:: An overview of the hard way to do it. |
| * Process Identification:: How to get the process ID of a process. |
| * Creating a Process:: How to fork a child process. |
| * Executing a File:: How to make a process execute another program. |
| * Process Completion:: How to tell when a child process has completed. |
| * Process Completion Status:: How to interpret the status value |
| returned from a child process. |
| * BSD Wait Functions:: More functions, for backward compatibility. |
| * Process Creation Example:: A complete example program. |
| |
| Job Control |
| |
| * Concepts of Job Control:: Jobs can be controlled by a shell. |
| * Job Control is Optional:: Not all POSIX systems support job control. |
| * Controlling Terminal:: How a process gets its controlling terminal. |
| * Access to the Terminal:: How processes share the controlling terminal. |
| * Orphaned Process Groups:: Jobs left after the user logs out. |
| * Implementing a Shell:: What a shell must do to implement job control. |
| * Functions for Job Control:: Functions to control process groups. |
| |
| Implementing a Shell |
| |
| * Data Structures:: Introduction to the sample shell. |
| * Initializing the Shell:: What the shell must do to take |
| responsibility for job control. |
| * Launching Jobs:: Creating jobs to execute commands. |
| * Foreground and Background:: Putting a job in foreground of background. |
| * Stopped and Terminated Jobs:: Reporting job status. |
| * Continuing Stopped Jobs:: How to continue a stopped job in |
| the foreground or background. |
| * Missing Pieces:: Other parts of the shell. |
| |
| Functions for Job Control |
| |
| * Identifying the Terminal:: Determining the controlling terminal's name. |
| * Process Group Functions:: Functions for manipulating process groups. |
| * Terminal Access Functions:: Functions for controlling terminal access. |
| |
| Name Service Switch |
| |
| * NSS Basics:: What is this NSS good for. |
| * NSS Configuration File:: Configuring NSS. |
| * NSS Module Internals:: How does it work internally. |
| * Extending NSS:: What to do to add services or databases. |
| |
| NSS Configuration File |
| |
| * Services in the NSS configuration:: Service names in the NSS configuration. |
| * Actions in the NSS configuration:: React appropriately to the lookup result. |
| * Notes on NSS Configuration File:: Things to take care about while |
| configuring NSS. |
| |
| NSS Module Internals |
| |
| * NSS Module Names:: Construction of the interface function of |
| the NSS modules. |
| * NSS Modules Interface:: Programming interface in the NSS module |
| functions. |
| |
| Extending NSS |
| |
| * Adding another Service to NSS:: What is to do to add a new service. |
| * NSS Module Function Internals:: Guidelines for writing new NSS |
| service functions. |
| |
| Users and Groups |
| |
| * User and Group IDs:: Each user has a unique numeric ID; |
| likewise for groups. |
| * Process Persona:: The user IDs and group IDs of a process. |
| * Why Change Persona:: Why a program might need to change |
| its user and/or group IDs. |
| * How Change Persona:: Changing the user and group IDs. |
| * Reading Persona:: How to examine the user and group IDs. |
| |
| * Setting User ID:: Functions for setting the user ID. |
| * Setting Groups:: Functions for setting the group IDs. |
| |
| * Enable/Disable Setuid:: Turning setuid access on and off. |
| * Setuid Program Example:: The pertinent parts of one sample program. |
| * Tips for Setuid:: How to avoid granting unlimited access. |
| |
| * Who Logged In:: Getting the name of the user who logged in, |
| or of the real user ID of the current process. |
| |
| * User Accounting Database:: Keeping information about users and various |
| actions in databases. |
| |
| * User Database:: Functions and data structures for |
| accessing the user database. |
| * Group Database:: Functions and data structures for |
| accessing the group database. |
| * Database Example:: Example program showing the use of database |
| inquiry functions. |
| * Netgroup Database:: Functions for accessing the netgroup database. |
| |
| User Accounting Database |
| |
| * Manipulating the Database:: Scanning and modifying the user |
| accounting database. |
| * XPG Functions:: A standardized way for doing the same thing. |
| * Logging In and Out:: Functions from BSD that modify the user |
| accounting database. |
| |
| User Database |
| |
| * User Data Structure:: What each user record contains. |
| * Lookup User:: How to look for a particular user. |
| * Scanning All Users:: Scanning the list of all users, one by one. |
| * Writing a User Entry:: How a program can rewrite a user's record. |
| |
| Group Database |
| |
| * Group Data Structure:: What each group record contains. |
| * Lookup Group:: How to look for a particular group. |
| * Scanning All Groups:: Scanning the list of all groups. |
| |
| Netgroup Database |
| |
| * Netgroup Data:: Data in the Netgroup database and where |
| it comes from. |
| * Lookup Netgroup:: How to look for a particular netgroup. |
| * Netgroup Membership:: How to test for netgroup membership. |
| |
| System Management |
| |
| * Host Identification:: Determining the name of the machine. |
| * Platform Type:: Determining operating system and basic |
| machine type |
| * Filesystem Handling:: Controlling/querying mounts |
| * System Parameters:: Getting and setting various system parameters |
| |
| Filesystem Handling |
| |
| * Mount Information:: What is or could be mounted? |
| * Mount-Unmount-Remount:: Controlling what is mounted and how |
| |
| Mount Information |
| |
| * fstab:: The 'fstab' file |
| * mtab:: The 'mtab' file |
| * Other Mount Information:: Other (non-libc) sources of mount information |
| |
| System Configuration |
| |
| * General Limits:: Constants and functions that describe |
| various process-related limits that have |
| one uniform value for any given machine. |
| * System Options:: Optional POSIX features. |
| * Version Supported:: Version numbers of POSIX.1 and POSIX.2. |
| * Sysconf:: Getting specific configuration values |
| of general limits and system options. |
| * Minimums:: Minimum values for general limits. |
| |
| * Limits for Files:: Size limitations that pertain to individual files. |
| These can vary between file systems |
| or even from file to file. |
| * Options for Files:: Optional features that some files may support. |
| * File Minimums:: Minimum values for file limits. |
| * Pathconf:: Getting the limit values for a particular file. |
| |
| * Utility Limits:: Capacity limits of some POSIX.2 utility programs. |
| * Utility Minimums:: Minimum allowable values of those limits. |
| |
| * String Parameters:: Getting the default search path. |
| |
| Sysconf |
| |
| * Sysconf Definition:: Detailed specifications of 'sysconf'. |
| * Constants for Sysconf:: The list of parameters 'sysconf' can read. |
| * Examples of Sysconf:: How to use 'sysconf' and the parameter |
| macros properly together. |
| |
| Cryptographic Functions |
| |
| * Legal Problems:: This software can get you locked up, or worse. |
| * getpass:: Prompting the user for a password. |
| * crypt:: A one-way function for passwords. |
| * DES Encryption:: Routines for DES encryption. |
| |
| Debugging Support |
| |
| * Backtraces:: Obtaining and printing a back trace of the |
| current stack. |
| |
| POSIX Threads |
| |
| * Thread-specific Data:: Support for creating and |
| managing thread-specific data |
| * Non-POSIX Extensions:: Additional functions to extend |
| POSIX Thread functionality |
| |
| Non-POSIX Extensions |
| |
| * Default Thread Attributes:: Setting default attributes for |
| threads in a process. |
| |
| Internal Probes |
| |
| * Memory Allocation Probes:: Probes in the memory allocation subsystem |
| * Mathematical Function Probes:: Probes in mathematical functions |
| |
| Language Features |
| |
| * Consistency Checking:: Using 'assert' to abort if |
| something "impossible" happens. |
| * Variadic Functions:: Defining functions with varying numbers |
| of args. |
| * Null Pointer Constant:: The macro 'NULL'. |
| * Important Data Types:: Data types for object sizes. |
| * Data Type Measurements:: Parameters of data type representations. |
| |
| Variadic Functions |
| |
| * Why Variadic:: Reasons for making functions take |
| variable arguments. |
| * How Variadic:: How to define and call variadic functions. |
| * Variadic Example:: A complete example. |
| |
| How Variadic |
| |
| * Variadic Prototypes:: How to make a prototype for a function |
| with variable arguments. |
| * Receiving Arguments:: Steps you must follow to access the |
| optional argument values. |
| * How Many Arguments:: How to decide whether there are more arguments. |
| * Calling Variadics:: Things you need to know about calling |
| variable arguments functions. |
| * Argument Macros:: Detailed specification of the macros |
| for accessing variable arguments. |
| |
| Data Type Measurements |
| |
| * Width of Type:: How many bits does an integer type hold? |
| * Range of Type:: What are the largest and smallest values |
| that an integer type can hold? |
| * Floating Type Macros:: Parameters that measure the floating point types. |
| * Structure Measurement:: Getting measurements on structure types. |
| |
| Floating Type Macros |
| |
| * Floating Point Concepts:: Definitions of terminology. |
| * Floating Point Parameters:: Details of specific macros. |
| * IEEE Floating Point:: The measurements for one common |
| representation. |
| |
| Installation |
| |
| * Configuring and compiling:: How to compile and test GNU libc. |
| * Running make install:: How to install it once you've got it |
| compiled. |
| * Tools for Compilation:: You'll need these first. |
| * Linux:: Specific advice for GNU/Linux systems. |
| * Reporting Bugs:: So they'll get fixed. |
| |
| Maintenance |
| |
| * Source Layout:: How to add new functions or header files |
| to the GNU C Library. |
| * Porting:: How to port the GNU C Library to |
| a new machine or operating system. |
| |
| Source Layout |
| |
| * Platform: Adding Platform-specific. Adding platform-specific |
| features. |
| |
| Porting |
| |
| * Hierarchy Conventions:: The layout of the 'sysdeps' hierarchy. |
| * Porting to Unix:: Porting the library to an average |
| Unix-like system. |
| |
| Platform |
| |
| * PowerPC:: Facilities Specific to the PowerPC Architecture |
| |
| |
| File: libc.info, Node: Introduction, Next: Error Reporting, Prev: Top, Up: Top |
| |
| 1 Introduction |
| ************** |
| |
| The C language provides no built-in facilities for performing such |
| common operations as input/output, memory management, string |
| manipulation, and the like. Instead, these facilities are defined in a |
| standard "library", which you compile and link with your programs. |
| |
| The GNU C Library, described in this document, defines all of the |
| library functions that are specified by the ISO C standard, as well as |
| additional features specific to POSIX and other derivatives of the Unix |
| operating system, and extensions specific to GNU systems. |
| |
| The purpose of this manual is to tell you how to use the facilities |
| of the GNU C Library. We have mentioned which features belong to which |
| standards to help you identify things that are potentially non-portable |
| to other systems. But the emphasis in this manual is not on strict |
| portability. |
| |
| * Menu: |
| |
| * Getting Started:: What this manual is for and how to use it. |
| * Standards and Portability:: Standards and sources upon which the GNU |
| C library is based. |
| * Using the Library:: Some practical uses for the library. |
| * Roadmap to the Manual:: Overview of the remaining chapters in |
| this manual. |
| |
| |
| File: libc.info, Node: Getting Started, Next: Standards and Portability, Up: Introduction |
| |
| 1.1 Getting Started |
| =================== |
| |
| This manual is written with the assumption that you are at least |
| somewhat familiar with the C programming language and basic programming |
| concepts. Specifically, familiarity with ISO standard C (*note ISO |
| C::), rather than "traditional" pre-ISO C dialects, is assumed. |
| |
| The GNU C Library includes several "header files", each of which |
| provides definitions and declarations for a group of related facilities; |
| this information is used by the C compiler when processing your program. |
| For example, the header file 'stdio.h' declares facilities for |
| performing input and output, and the header file 'string.h' declares |
| string processing utilities. The organization of this manual generally |
| follows the same division as the header files. |
| |
| If you are reading this manual for the first time, you should read |
| all of the introductory material and skim the remaining chapters. There |
| are a _lot_ of functions in the GNU C Library and it's not realistic to |
| expect that you will be able to remember exactly _how_ to use each and |
| every one of them. It's more important to become generally familiar |
| with the kinds of facilities that the library provides, so that when you |
| are writing your programs you can recognize _when_ to make use of |
| library functions, and _where_ in this manual you can find more specific |
| information about them. |
| |
| |
| File: libc.info, Node: Standards and Portability, Next: Using the Library, Prev: Getting Started, Up: Introduction |
| |
| 1.2 Standards and Portability |
| ============================= |
| |
| This section discusses the various standards and other sources that the |
| GNU C Library is based upon. These sources include the ISO C and POSIX |
| standards, and the System V and Berkeley Unix implementations. |
| |
| The primary focus of this manual is to tell you how to make effective |
| use of the GNU C Library facilities. But if you are concerned about |
| making your programs compatible with these standards, or portable to |
| operating systems other than GNU, this can affect how you use the |
| library. This section gives you an overview of these standards, so that |
| you will know what they are when they are mentioned in other parts of |
| the manual. |
| |
| *Note Library Summary::, for an alphabetical list of the functions |
| and other symbols provided by the library. This list also states which |
| standards each function or symbol comes from. |
| |
| * Menu: |
| |
| * ISO C:: The international standard for the C |
| programming language. |
| * POSIX:: The ISO/IEC 9945 (aka IEEE 1003) standards |
| for operating systems. |
| * Berkeley Unix:: BSD and SunOS. |
| * SVID:: The System V Interface Description. |
| * XPG:: The X/Open Portability Guide. |
| |
| |
| File: libc.info, Node: ISO C, Next: POSIX, Up: Standards and Portability |
| |
| 1.2.1 ISO C |
| ----------- |
| |
| The GNU C Library is compatible with the C standard adopted by the |
| American National Standards Institute (ANSI): 'American National |
| Standard X3.159-1989--"ANSI C"' and later by the International |
| Standardization Organization (ISO): 'ISO/IEC 9899:1990, "Programming |
| languages--C"'. We here refer to the standard as ISO C since this is the |
| more general standard in respect of ratification. The header files and |
| library facilities that make up the GNU C Library are a superset of |
| those specified by the ISO C standard. |
| |
| If you are concerned about strict adherence to the ISO C standard, |
| you should use the '-ansi' option when you compile your programs with |
| the GNU C compiler. This tells the compiler to define _only_ ISO |
| standard features from the library header files, unless you explicitly |
| ask for additional features. *Note Feature Test Macros::, for |
| information on how to do this. |
| |
| Being able to restrict the library to include only ISO C features is |
| important because ISO C puts limitations on what names can be defined by |
| the library implementation, and the GNU extensions don't fit these |
| limitations. *Note Reserved Names::, for more information about these |
| restrictions. |
| |
| This manual does not attempt to give you complete details on the |
| differences between ISO C and older dialects. It gives advice on how to |
| write programs to work portably under multiple C dialects, but does not |
| aim for completeness. |
| |
| |
| File: libc.info, Node: POSIX, Next: Berkeley Unix, Prev: ISO C, Up: Standards and Portability |
| |
| 1.2.2 POSIX (The Portable Operating System Interface) |
| ----------------------------------------------------- |
| |
| The GNU C Library is also compatible with the ISO "POSIX" family of |
| standards, known more formally as the "Portable Operating System |
| Interface for Computer Environments" (ISO/IEC 9945). They were also |
| published as ANSI/IEEE Std 1003. POSIX is derived mostly from various |
| versions of the Unix operating system. |
| |
| The library facilities specified by the POSIX standards are a |
| superset of those required by ISO C; POSIX specifies additional features |
| for ISO C functions, as well as specifying new additional functions. In |
| general, the additional requirements and functionality defined by the |
| POSIX standards are aimed at providing lower-level support for a |
| particular kind of operating system environment, rather than general |
| programming language support which can run in many diverse operating |
| system environments. |
| |
| The GNU C Library implements all of the functions specified in |
| 'ISO/IEC 9945-1:1996, the POSIX System Application Program Interface', |
| commonly referred to as POSIX.1. The primary extensions to the ISO C |
| facilities specified by this standard include file system interface |
| primitives (*note File System Interface::), device-specific terminal |
| control functions (*note Low-Level Terminal Interface::), and process |
| control functions (*note Processes::). |
| |
| Some facilities from 'ISO/IEC 9945-2:1993, the POSIX Shell and |
| Utilities standard' (POSIX.2) are also implemented in the GNU C Library. |
| These include utilities for dealing with regular expressions and other |
| pattern matching facilities (*note Pattern Matching::). |
| |
| * Menu: |
| |
| * POSIX Safety Concepts:: Safety concepts from POSIX. |
| * Unsafe Features:: Features that make functions unsafe. |
| * Conditionally Safe Features:: Features that make functions unsafe |
| in the absence of workarounds. |
| * Other Safety Remarks:: Additional safety features and remarks. |
| |
| |
| File: libc.info, Node: POSIX Safety Concepts, Next: Unsafe Features, Up: POSIX |
| |
| 1.2.2.1 POSIX Safety Concepts |
| ............................. |
| |
| This manual documents various safety properties of GNU C Library |
| functions, in lines that follow their prototypes and look like: |
| |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | |
| |
| The properties are assessed according to the criteria set forth in |
| the POSIX standard for such safety contexts as Thread-, Async-Signal- |
| and Async-Cancel- -Safety. Intuitive definitions of these properties, |
| attempting to capture the meaning of the standard definitions, follow. |
| |
| * 'MT-Safe' or Thread-Safe functions are safe to call in the presence |
| of other threads. MT, in MT-Safe, stands for Multi Thread. |
| |
| Being MT-Safe does not imply a function is atomic, nor that it uses |
| any of the memory synchronization mechanisms POSIX exposes to |
| users. It is even possible that calling MT-Safe functions in |
| sequence does not yield an MT-Safe combination. For example, |
| having a thread call two MT-Safe functions one right after the |
| other does not guarantee behavior equivalent to atomic execution of |
| a combination of both functions, since concurrent calls in other |
| threads may interfere in a destructive way. |
| |
| Whole-program optimizations that could inline functions across |
| library interfaces may expose unsafe reordering, and so performing |
| inlining across the GNU C Library interface is not recommended. |
| The documented MT-Safety status is not guaranteed under |
| whole-program optimization. However, functions defined in |
| user-visible headers are designed to be safe for inlining. |
| |
| * 'AS-Safe' or Async-Signal-Safe functions are safe to call from |
| asynchronous signal handlers. AS, in AS-Safe, stands for |
| Asynchronous Signal. |
| |
| Many functions that are AS-Safe may set 'errno', or modify the |
| floating-point environment, because their doing so does not make |
| them unsuitable for use in signal handlers. However, programs |
| could misbehave should asynchronous signal handlers modify this |
| thread-local state, and the signal handling machinery cannot be |
| counted on to preserve it. Therefore, signal handlers that call |
| functions that may set 'errno' or modify the floating-point |
| environment _must_ save their original values, and restore them |
| before returning. |
| |
| * 'AC-Safe' or Async-Cancel-Safe functions are safe to call when |
| asynchronous cancellation is enabled. AC in AC-Safe stands for |
| Asynchronous Cancellation. |
| |
| The POSIX standard defines only three functions to be AC-Safe, |
| namely 'pthread_cancel', 'pthread_setcancelstate', and |
| 'pthread_setcanceltype'. At present the GNU C Library provides no |
| guarantees beyond these three functions, but does document which |
| functions are presently AC-Safe. This documentation is provided |
| for use by the GNU C Library developers. |
| |
| Just like signal handlers, cancellation cleanup routines must |
| configure the floating point environment they require. The |
| routines cannot assume a floating point environment, particularly |
| when asynchronous cancellation is enabled. If the configuration of |
| the floating point environment cannot be performed atomically then |
| it is also possible that the environment encountered is internally |
| inconsistent. |
| |
| * 'MT-Unsafe', 'AS-Unsafe', 'AC-Unsafe' functions are not safe to |
| call within the safety contexts described above. Calling them |
| within such contexts invokes undefined behavior. |
| |
| Functions not explicitly documented as safe in a safety context |
| should be regarded as Unsafe. |
| |
| * 'Preliminary' safety properties are documented, indicating these |
| properties may _not_ be counted on in future releases of the GNU C |
| Library. |
| |
| Such preliminary properties are the result of an assessment of the |
| properties of our current implementation, rather than of what is |
| mandated and permitted by current and future standards. |
| |
| Although we strive to abide by the standards, in some cases our |
| implementation is safe even when the standard does not demand |
| safety, and in other cases our implementation does not meet the |
| standard safety requirements. The latter are most likely bugs; the |
| former, when marked as 'Preliminary', should not be counted on: |
| future standards may require changes that are not compatible with |
| the additional safety properties afforded by the current |
| implementation. |
| |
| Furthermore, the POSIX standard does not offer a detailed |
| definition of safety. We assume that, by "safe to call", POSIX |
| means that, as long as the program does not invoke undefined |
| behavior, the "safe to call" function behaves as specified, and |
| does not cause other functions to deviate from their specified |
| behavior. We have chosen to use its loose definitions of safety, |
| not because they are the best definitions to use, but because |
| choosing them harmonizes this manual with POSIX. |
| |
| Please keep in mind that these are preliminary definitions and |
| annotations, and certain aspects of the definitions are still under |
| discussion and might be subject to clarification or change. |
| |
| Over time, we envision evolving the preliminary safety notes into |
| stable commitments, as stable as those of our interfaces. As we |
| do, we will remove the 'Preliminary' keyword from safety notes. As |
| long as the keyword remains, however, they are not to be regarded |
| as a promise of future behavior. |
| |
| Other keywords that appear in safety notes are defined in subsequent |
| sections. |
| |
| |
| File: libc.info, Node: Unsafe Features, Next: Conditionally Safe Features, Prev: POSIX Safety Concepts, Up: POSIX |
| |
| 1.2.2.2 Unsafe Features |
| ....................... |
| |
| Functions that are unsafe to call in certain contexts are annotated with |
| keywords that document their features that make them unsafe to call. |
| AS-Unsafe features in this section indicate the functions are never safe |
| to call when asynchronous signals are enabled. AC-Unsafe features |
| indicate they are never safe to call when asynchronous cancellation is |
| enabled. There are no MT-Unsafe marks in this section. |
| |
| * 'lock' |
| |
| Functions marked with 'lock' as an AS-Unsafe feature may be |
| interrupted by a signal while holding a non-recursive lock. If the |
| signal handler calls another such function that takes the same |
| lock, the result is a deadlock. |
| |
| Functions annotated with 'lock' as an AC-Unsafe feature may, if |
| cancelled asynchronously, fail to release a lock that would have |
| been released if their execution had not been interrupted by |
| asynchronous thread cancellation. Once a lock is left taken, |
| attempts to take that lock will block indefinitely. |
| |
| * 'corrupt' |
| |
| Functions marked with 'corrupt' as an AS-Unsafe feature may corrupt |
| data structures and misbehave when they interrupt, or are |
| interrupted by, another such function. Unlike functions marked |
| with 'lock', these take recursive locks to avoid MT-Safety |
| problems, but this is not enough to stop a signal handler from |
| observing a partially-updated data structure. Further corruption |
| may arise from the interrupted function's failure to notice updates |
| made by signal handlers. |
| |
| Functions marked with 'corrupt' as an AC-Unsafe feature may leave |
| data structures in a corrupt, partially updated state. Subsequent |
| uses of the data structure may misbehave. |
| |
| * 'heap' |
| |
| Functions marked with 'heap' may call heap memory management |
| functions from the 'malloc'/'free' family of functions and are only |
| as safe as those functions. This note is thus equivalent to: |
| |
| | AS-Unsafe lock | AC-Unsafe lock fd mem | |
| |
| * 'dlopen' |
| |
| Functions marked with 'dlopen' use the dynamic loader to load |
| shared libraries into the current execution image. This involves |
| opening files, mapping them into memory, allocating additional |
| memory, resolving symbols, applying relocations and more, all of |
| this while holding internal dynamic loader locks. |
| |
| The locks are enough for these functions to be AS- and AC-Unsafe, |
| but other issues may arise. At present this is a placeholder for |
| all potential safety issues raised by 'dlopen'. |
| |
| * 'plugin' |
| |
| Functions annotated with 'plugin' may run code from plugins that |
| may be external to the GNU C Library. Such plugin functions are |
| assumed to be MT-Safe, AS-Unsafe and AC-Unsafe. Examples of such |
| plugins are stack unwinding libraries, name service switch (NSS) |
| and character set conversion (iconv) back-ends. |
| |
| Although the plugins mentioned as examples are all brought in by |
| means of dlopen, the 'plugin' keyword does not imply any direct |
| involvement of the dynamic loader or the 'libdl' interfaces, those |
| are covered by 'dlopen'. For example, if one function loads a |
| module and finds the addresses of some of its functions, while |
| another just calls those already-resolved functions, the former |
| will be marked with 'dlopen', whereas the latter will get the |
| 'plugin'. When a single function takes all of these actions, then |
| it gets both marks. |
| |
| * 'i18n' |
| |
| Functions marked with 'i18n' may call internationalization |
| functions of the 'gettext' family and will be only as safe as those |
| functions. This note is thus equivalent to: |
| |
| | MT-Safe env | AS-Unsafe corrupt heap dlopen | AC-Unsafe corrupt | |
| |
| * 'timer' |
| |
| Functions marked with 'timer' use the 'alarm' function or similar |
| to set a time-out for a system call or a long-running operation. |
| In a multi-threaded program, there is a risk that the time-out |
| signal will be delivered to a different thread, thus failing to |
| interrupt the intended thread. Besides being MT-Unsafe, such |
| functions are always AS-Unsafe, because calling them in signal |
| handlers may interfere with timers set in the interrupted code, and |
| AC-Unsafe, because there is no safe way to guarantee an earlier |
| timer will be reset in case of asynchronous cancellation. |
| |
| |
| File: libc.info, Node: Conditionally Safe Features, Next: Other Safety Remarks, Prev: Unsafe Features, Up: POSIX |
| |
| 1.2.2.3 Conditionally Safe Features |
| ................................... |
| |
| For some features that make functions unsafe to call in certain |
| contexts, there are known ways to avoid the safety problem other than |
| refraining from calling the function altogether. The keywords that |
| follow refer to such features, and each of their definitions indicate |
| how the whole program needs to be constrained in order to remove the |
| safety problem indicated by the keyword. Only when all the reasons that |
| make a function unsafe are observed and addressed, by applying the |
| documented constraints, does the function become safe to call in a |
| context. |
| |
| * 'init' |
| |
| Functions marked with 'init' as an MT-Unsafe feature perform |
| MT-Unsafe initialization when they are first called. |
| |
| Calling such a function at least once in single-threaded mode |
| removes this specific cause for the function to be regarded as |
| MT-Unsafe. If no other cause for that remains, the function can |
| then be safely called after other threads are started. |
| |
| Functions marked with 'init' as an AS- or AC-Unsafe feature use the |
| internal 'libc_once' machinery or similar to initialize internal |
| data structures. |
| |
| If a signal handler interrupts such an initializer, and calls any |
| function that also performs 'libc_once' initialization, it will |
| deadlock if the thread library has been loaded. |
| |
| Furthermore, if an initializer is partially complete before it is |
| canceled or interrupted by a signal whose handler requires the same |
| initialization, some or all of the initialization may be performed |
| more than once, leaking resources or even resulting in corrupt |
| internal data. |
| |
| Applications that need to call functions marked with 'init' as an |
| AS- or AC-Unsafe feature should ensure the initialization is |
| performed before configuring signal handlers or enabling |
| cancellation, so that the AS- and AC-Safety issues related with |
| 'libc_once' do not arise. |
| |
| * 'race' |
| |
| Functions annotated with 'race' as an MT-Safety issue operate on |
| objects in ways that may cause data races or similar forms of |
| destructive interference out of concurrent execution. In some |
| cases, the objects are passed to the functions by users; in others, |
| they are used by the functions to return values to users; in |
| others, they are not even exposed to users. |
| |
| We consider access to objects passed as (indirect) arguments to |
| functions to be data race free. The assurance of data race free |
| objects is the caller's responsibility. We will not mark a |
| function as MT-Unsafe or AS-Unsafe if it misbehaves when users fail |
| to take the measures required by POSIX to avoid data races when |
| dealing with such objects. As a general rule, if a function is |
| documented as reading from an object passed (by reference) to it, |
| or modifying it, users ought to use memory synchronization |
| primitives to avoid data races just as they would should they |
| perform the accesses themselves rather than by calling the library |
| function. 'FILE' streams are the exception to the general rule, in |
| that POSIX mandates the library to guard against data races in many |
| functions that manipulate objects of this specific opaque type. We |
| regard this as a convenience provided to users, rather than as a |
| general requirement whose expectations should extend to other |
| types. |
| |
| In order to remind users that guarding certain arguments is their |
| responsibility, we will annotate functions that take objects of |
| certain types as arguments. We draw the line for objects passed by |
| users as follows: objects whose types are exposed to users, and |
| that users are expected to access directly, such as memory buffers, |
| strings, and various user-visible 'struct' types, do _not_ give |
| reason for functions to be annotated with 'race'. It would be |
| noisy and redundant with the general requirement, and not many |
| would be surprised by the library's lack of internal guards when |
| accessing objects that can be accessed directly by users. |
| |
| As for objects that are opaque or opaque-like, in that they are to |
| be manipulated only by passing them to library functions (e.g., |
| 'FILE', 'DIR', 'obstack', 'iconv_t'), there might be additional |
| expectations as to internal coordination of access by the library. |
| We will annotate, with 'race' followed by a colon and the argument |
| name, functions that take such objects but that do not take care of |
| synchronizing access to them by default. For example, 'FILE' |
| stream 'unlocked' functions will be annotated, but those that |
| perform implicit locking on 'FILE' streams by default will not, |
| even though the implicit locking may be disabled on a per-stream |
| basis. |
| |
| In either case, we will not regard as MT-Unsafe functions that may |
| access user-supplied objects in unsafe ways should users fail to |
| ensure the accesses are well defined. The notion prevails that |
| users are expected to safeguard against data races any |
| user-supplied objects that the library accesses on their behalf. |
| |
| This user responsibility does not apply, however, to objects |
| controlled by the library itself, such as internal objects and |
| static buffers used to return values from certain calls. When the |
| library doesn't guard them against concurrent uses, these cases are |
| regarded as MT-Unsafe and AS-Unsafe (although the 'race' mark under |
| AS-Unsafe will be omitted as redundant with the one under |
| MT-Unsafe). As in the case of user-exposed objects, the mark may |
| be followed by a colon and an identifier. The identifier groups |
| all functions that operate on a certain unguarded object; users may |
| avoid the MT-Safety issues related with unguarded concurrent access |
| to such internal objects by creating a non-recursive mutex related |
| with the identifier, and always holding the mutex when calling any |
| function marked as racy on that identifier, as they would have to |
| should the identifier be an object under user control. The |
| non-recursive mutex avoids the MT-Safety issue, but it trades one |
| AS-Safety issue for another, so use in asynchronous signals remains |
| undefined. |
| |
| When the identifier relates to a static buffer used to hold return |
| values, the mutex must be held for as long as the buffer remains in |
| use by the caller. Many functions that return pointers to static |
| buffers offer reentrant variants that store return values in |
| caller-supplied buffers instead. In some cases, such as 'tmpname', |
| the variant is chosen not by calling an alternate entry point, but |
| by passing a non-'NULL' pointer to the buffer in which the returned |
| values are to be stored. These variants are generally preferable |
| in multi-threaded programs, although some of them are not MT-Safe |
| because of other internal buffers, also documented with 'race' |
| notes. |
| |
| * 'const' |
| |
| Functions marked with 'const' as an MT-Safety issue non-atomically |
| modify internal objects that are better regarded as constant, |
| because a substantial portion of the GNU C Library accesses them |
| without synchronization. Unlike 'race', that causes both readers |
| and writers of internal objects to be regarded as MT-Unsafe and |
| AS-Unsafe, this mark is applied to writers only. Writers remain |
| equally MT- and AS-Unsafe to call, but the then-mandatory constness |
| of objects they modify enables readers to be regarded as MT-Safe |
| and AS-Safe (as long as no other reasons for them to be unsafe |
| remain), since the lack of synchronization is not a problem when |
| the objects are effectively constant. |
| |
| The identifier that follows the 'const' mark will appear by itself |
| as a safety note in readers. Programs that wish to work around |
| this safety issue, so as to call writers, may use a non-recursve |
| 'rwlock' associated with the identifier, and guard _all_ calls to |
| functions marked with 'const' followed by the identifier with a |
| write lock, and _all_ calls to functions marked with the identifier |
| by itself with a read lock. The non-recursive locking removes the |
| MT-Safety problem, but it trades one AS-Safety problem for another, |
| so use in asynchronous signals remains undefined. |
| |
| * 'sig' |
| |
| Functions marked with 'sig' as a MT-Safety issue (that implies an |
| identical AS-Safety issue, omitted for brevity) may temporarily |
| install a signal handler for internal purposes, which may interfere |
| with other uses of the signal, identified after a colon. |
| |
| This safety problem can be worked around by ensuring that no other |
| uses of the signal will take place for the duration of the call. |
| Holding a non-recursive mutex while calling all functions that use |
| the same temporary signal; blocking that signal before the call and |
| resetting its handler afterwards is recommended. |
| |
| There is no safe way to guarantee the original signal handler is |
| restored in case of asynchronous cancellation, therefore so-marked |
| functions are also AC-Unsafe. |
| |
| Besides the measures recommended to work around the MT- and |
| AS-Safety problem, in order to avert the cancellation problem, |
| disabling asynchronous cancellation _and_ installing a cleanup |
| handler to restore the signal to the desired state and to release |
| the mutex are recommended. |
| |
| * 'term' |
| |
| Functions marked with 'term' as an MT-Safety issue may change the |
| terminal settings in the recommended way, namely: call 'tcgetattr', |
| modify some flags, and then call 'tcsetattr'; this creates a window |
| in which changes made by other threads are lost. Thus, functions |
| marked with 'term' are MT-Unsafe. The same window enables changes |
| made by asynchronous signals to be lost. These functions are also |
| AS-Unsafe, but the corresponding mark is omitted as redundant. |
| |
| It is thus advisable for applications using the terminal to avoid |
| concurrent and reentrant interactions with it, by not using it in |
| signal handlers or blocking signals that might use it, and holding |
| a lock while calling these functions and interacting with the |
| terminal. This lock should also be used for mutual exclusion with |
| functions marked with 'race:tcattr(fd)', where FD is a file |
| descriptor for the controlling terminal. The caller may use a |
| single mutex for simplicity, or use one mutex per terminal, even if |
| referenced by different file descriptors. |
| |
| Functions marked with 'term' as an AC-Safety issue are supposed to |
| restore terminal settings to their original state, after |
| temporarily changing them, but they may fail to do so if cancelled. |
| |
| Besides the measures recommended to work around the MT- and |
| AS-Safety problem, in order to avert the cancellation problem, |
| disabling asynchronous cancellation _and_ installing a cleanup |
| handler to restore the terminal settings to the original state and |
| to release the mutex are recommended. |
| |
| |
| File: libc.info, Node: Other Safety Remarks, Prev: Conditionally Safe Features, Up: POSIX |
| |
| 1.2.2.4 Other Safety Remarks |
| ............................ |
| |
| Additional keywords may be attached to functions, indicating features |
| that do not make a function unsafe to call, but that may need to be |
| taken into account in certain classes of programs: |
| |
| * 'locale' |
| |
| Functions annotated with 'locale' as an MT-Safety issue read from |
| the locale object without any form of synchronization. Functions |
| annotated with 'locale' called concurrently with locale changes may |
| behave in ways that do not correspond to any of the locales active |
| during their execution, but an unpredictable mix thereof. |
| |
| We do not mark these functions as MT- or AS-Unsafe, however, |
| because functions that modify the locale object are marked with |
| 'const:locale' and regarded as unsafe. Being unsafe, the latter |
| are not to be called when multiple threads are running or |
| asynchronous signals are enabled, and so the locale can be |
| considered effectively constant in these contexts, which makes the |
| former safe. |
| |
| * 'env' |
| |
| Functions marked with 'env' as an MT-Safety issue access the |
| environment with 'getenv' or similar, without any guards to ensure |
| safety in the presence of concurrent modifications. |
| |
| We do not mark these functions as MT- or AS-Unsafe, however, |
| because functions that modify the environment are all marked with |
| 'const:env' and regarded as unsafe. Being unsafe, the latter are |
| not to be called when multiple threads are running or asynchronous |
| signals are enabled, and so the environment can be considered |
| effectively constant in these contexts, which makes the former |
| safe. |
| |
| * 'hostid' |
| |
| The function marked with 'hostid' as an MT-Safety issue reads from |
| the system-wide data structures that hold the "host ID" of the |
| machine. These data structures cannot generally be modified |
| atomically. Since it is expected that the "host ID" will not |
| normally change, the function that reads from it ('gethostid') is |
| regarded as safe, whereas the function that modifies it |
| ('sethostid') is marked with 'const:hostid', indicating it may |
| require special care if it is to be called. In this specific case, |
| the special care amounts to system-wide (not merely intra-process) |
| coordination. |
| |
| * 'sigintr' |
| |
| Functions marked with 'sigintr' as an MT-Safety issue access the |
| '_sigintr' internal data structure without any guards to ensure |
| safety in the presence of concurrent modifications. |
| |
| We do not mark these functions as MT- or AS-Unsafe, however, |
| because functions that modify the this data structure are all |
| marked with 'const:sigintr' and regarded as unsafe. Being unsafe, |
| the latter are not to be called when multiple threads are running |
| or asynchronous signals are enabled, and so the data structure can |
| be considered effectively constant in these contexts, which makes |
| the former safe. |
| |
| * 'fd' |
| |
| Functions annotated with 'fd' as an AC-Safety issue may leak file |
| descriptors if asynchronous thread cancellation interrupts their |
| execution. |
| |
| Functions that allocate or deallocate file descriptors will |
| generally be marked as such. Even if they attempted to protect the |
| file descriptor allocation and deallocation with cleanup regions, |
| allocating a new descriptor and storing its number where the |
| cleanup region could release it cannot be performed as a single |
| atomic operation. Similarly, releasing the descriptor and taking |
| it out of the data structure normally responsible for releasing it |
| cannot be performed atomically. There will always be a window in |
| which the descriptor cannot be released because it was not stored |
| in the cleanup handler argument yet, or it was already taken out |
| before releasing it. It cannot be taken out after release: an open |
| descriptor could mean either that the descriptor still has to be |
| closed, or that it already did so but the descriptor was |
| reallocated by another thread or signal handler. |
| |
| Such leaks could be internally avoided, with some performance |
| penalty, by temporarily disabling asynchronous thread cancellation. |
| However, since callers of allocation or deallocation functions |
| would have to do this themselves, to avoid the same sort of leak in |
| their own layer, it makes more sense for the library to assume they |
| are taking care of it than to impose a performance penalty that is |
| redundant when the problem is solved in upper layers, and |
| insufficient when it is not. |
| |
| This remark by itself does not cause a function to be regarded as |
| AC-Unsafe. However, cumulative effects of such leaks may pose a |
| problem for some programs. If this is the case, suspending |
| asynchronous cancellation for the duration of calls to such |
| functions is recommended. |
| |
| * 'mem' |
| |
| Functions annotated with 'mem' as an AC-Safety issue may leak |
| memory if asynchronous thread cancellation interrupts their |
| execution. |
| |
| The problem is similar to that of file descriptors: there is no |
| atomic interface to allocate memory and store its address in the |
| argument to a cleanup handler, or to release it and remove its |
| address from that argument, without at least temporarily disabling |
| asynchronous cancellation, which these functions do not do. |
| |
| This remark does not by itself cause a function to be regarded as |
| generally AC-Unsafe. However, cumulative effects of such leaks may |
| be severe enough for some programs that disabling asynchronous |
| cancellation for the duration of calls to such functions may be |
| required. |
| |
| * 'cwd' |
| |
| Functions marked with 'cwd' as an MT-Safety issue may temporarily |
| change the current working directory during their execution, which |
| may cause relative pathnames to be resolved in unexpected ways in |
| other threads or within asynchronous signal or cancellation |
| handlers. |
| |
| This is not enough of a reason to mark so-marked functions as MT- |
| or AS-Unsafe, but when this behavior is optional (e.g., 'nftw' with |
| 'FTW_CHDIR'), avoiding the option may be a good alternative to |
| using full pathnames or file descriptor-relative (e.g. 'openat') |
| system calls. |
| |
| * '!posix' |
| |
| This remark, as an MT-, AS- or AC-Safety note to a function, |
| indicates the safety status of the function is known to differ from |
| the specified status in the POSIX standard. For example, POSIX |
| does not require a function to be Safe, but our implementation is, |
| or vice-versa. |
| |
| For the time being, the absence of this remark does not imply the |
| safety properties we documented are identical to those mandated by |
| POSIX for the corresponding functions. |
| |
| * ':identifier' |
| |
| Annotations may sometimes be followed by identifiers, intended to |
| group several functions that e.g. access the data structures in an |
| unsafe way, as in 'race' and 'const', or to provide more specific |
| information, such as naming a signal in a function marked with |
| 'sig'. It is envisioned that it may be applied to 'lock' and |
| 'corrupt' as well in the future. |
| |
| In most cases, the identifier will name a set of functions, but it |
| may name global objects or function arguments, or identifiable |
| properties or logical components associated with them, with a |
| notation such as e.g. ':buf(arg)' to denote a buffer associated |
| with the argument ARG, or ':tcattr(fd)' to denote the terminal |
| attributes of a file descriptor FD. |
| |
| The most common use for identifiers is to provide logical groups of |
| functions and arguments that need to be protected by the same |
| synchronization primitive in order to ensure safe operation in a |
| given context. |
| |
| * '/condition' |
| |
| Some safety annotations may be conditional, in that they only apply |
| if a boolean expression involving arguments, global variables or |
| even the underlying kernel evaluates evaluates to true. Such |
| conditions as '/hurd' or '/!linux!bsd' indicate the preceding |
| marker only applies when the underlying kernel is the HURD, or when |
| it is neither Linux nor a BSD kernel, respectively. '/!ps' and |
| '/one_per_line' indicate the preceding marker only applies when |
| argument PS is NULL, or global variable ONE_PER_LINE is nonzero. |
| |
| When all marks that render a function unsafe are adorned with such |
| conditions, and none of the named conditions hold, then the |
| function can be regarded as safe. |
| |
| |
| File: libc.info, Node: Berkeley Unix, Next: SVID, Prev: POSIX, Up: Standards and Portability |
| |
| 1.2.3 Berkeley Unix |
| ------------------- |
| |
| The GNU C Library defines facilities from some versions of Unix which |
| are not formally standardized, specifically from the 4.2 BSD, 4.3 BSD, |
| and 4.4 BSD Unix systems (also known as "Berkeley Unix") and from |
| "SunOS" (a popular 4.2 BSD derivative that includes some Unix System V |
| functionality). These systems support most of the ISO C and POSIX |
| facilities, and 4.4 BSD and newer releases of SunOS in fact support them |
| all. |
| |
| The BSD facilities include symbolic links (*note Symbolic Links::), |
| the 'select' function (*note Waiting for I/O::), the BSD signal |
| functions (*note BSD Signal Handling::), and sockets (*note Sockets::). |
| |
| |
| File: libc.info, Node: SVID, Next: XPG, Prev: Berkeley Unix, Up: Standards and Portability |
| |
| 1.2.4 SVID (The System V Interface Description) |
| ----------------------------------------------- |
| |
| The "System V Interface Description" (SVID) is a document describing the |
| AT&T Unix System V operating system. It is to some extent a superset of |
| the POSIX standard (*note POSIX::). |
| |
| The GNU C Library defines most of the facilities required by the SVID |
| that are not also required by the ISO C or POSIX standards, for |
| compatibility with System V Unix and other Unix systems (such as SunOS) |
| which include these facilities. However, many of the more obscure and |
| less generally useful facilities required by the SVID are not included. |
| (In fact, Unix System V itself does not provide them all.) |
| |
| The supported facilities from System V include the methods for |
| inter-process communication and shared memory, the 'hsearch' and |
| 'drand48' families of functions, 'fmtmsg' and several of the |
| mathematical functions. |
| |
| |
| File: libc.info, Node: XPG, Prev: SVID, Up: Standards and Portability |
| |
| 1.2.5 XPG (The X/Open Portability Guide) |
| ---------------------------------------- |
| |
| The X/Open Portability Guide, published by the X/Open Company, Ltd., is |
| a more general standard than POSIX. X/Open owns the Unix copyright and |
| the XPG specifies the requirements for systems which are intended to be |
| a Unix system. |
| |
| The GNU C Library complies to the X/Open Portability Guide, Issue |
| 4.2, with all extensions common to XSI (X/Open System Interface) |
| compliant systems and also all X/Open UNIX extensions. |
| |
| The additions on top of POSIX are mainly derived from functionality |
| available in System V and BSD systems. Some of the really bad mistakes |
| in System V systems were corrected, though. Since fulfilling the XPG |
| standard with the Unix extensions is a precondition for getting the Unix |
| brand chances are good that the functionality is available on commercial |
| systems. |
| |
| |
| File: libc.info, Node: Using the Library, Next: Roadmap to the Manual, Prev: Standards and Portability, Up: Introduction |
| |
| 1.3 Using the Library |
| ===================== |
| |
| This section describes some of the practical issues involved in using |
| the GNU C Library. |
| |
| * Menu: |
| |
| * Header Files:: How to include the header files in your |
| programs. |
| * Macro Definitions:: Some functions in the library may really |
| be implemented as macros. |
| * Reserved Names:: The C standard reserves some names for |
| the library, and some for users. |
| * Feature Test Macros:: How to control what names are defined. |
| |
| |
| File: libc.info, Node: Header Files, Next: Macro Definitions, Up: Using the Library |
| |
| 1.3.1 Header Files |
| ------------------ |
| |
| Libraries for use by C programs really consist of two parts: "header |
| files" that define types and macros and declare variables and functions; |
| and the actual library or "archive" that contains the definitions of the |
| variables and functions. |
| |
| (Recall that in C, a "declaration" merely provides information that a |
| function or variable exists and gives its type. For a function |
| declaration, information about the types of its arguments might be |
| provided as well. The purpose of declarations is to allow the compiler |
| to correctly process references to the declared variables and functions. |
| A "definition", on the other hand, actually allocates storage for a |
| variable or says what a function does.) |
| |
| In order to use the facilities in the GNU C Library, you should be |
| sure that your program source files include the appropriate header |
| files. This is so that the compiler has declarations of these |
| facilities available and can correctly process references to them. Once |
| your program has been compiled, the linker resolves these references to |
| the actual definitions provided in the archive file. |
| |
| Header files are included into a program source file by the |
| '#include' preprocessor directive. The C language supports two forms of |
| this directive; the first, |
| |
| #include "HEADER" |
| |
| is typically used to include a header file HEADER that you write |
| yourself; this would contain definitions and declarations describing the |
| interfaces between the different parts of your particular application. |
| By contrast, |
| |
| #include <file.h> |
| |
| is typically used to include a header file 'file.h' that contains |
| definitions and declarations for a standard library. This file would |
| normally be installed in a standard place by your system administrator. |
| You should use this second form for the C library header files. |
| |
| Typically, '#include' directives are placed at the top of the C |
| source file, before any other code. If you begin your source files with |
| some comments explaining what the code in the file does (a good idea), |
| put the '#include' directives immediately afterwards, following the |
| feature test macro definition (*note Feature Test Macros::). |
| |
| For more information about the use of header files and '#include' |
| directives, *note (cpp.info)Header Files::. |
| |
| The GNU C Library provides several header files, each of which |
| contains the type and macro definitions and variable and function |
| declarations for a group of related facilities. This means that your |
| programs may need to include several header files, depending on exactly |
| which facilities you are using. |
| |
| Some library header files include other library header files |
| automatically. However, as a matter of programming style, you should |
| not rely on this; it is better to explicitly include all the header |
| files required for the library facilities you are using. The GNU C |
| Library header files have been written in such a way that it doesn't |
| matter if a header file is accidentally included more than once; |
| including a header file a second time has no effect. Likewise, if your |
| program needs to include multiple header files, the order in which they |
| are included doesn't matter. |
| |
| *Compatibility Note:* Inclusion of standard header files in any order |
| and any number of times works in any ISO C implementation. However, |
| this has traditionally not been the case in many older C |
| implementations. |
| |
| Strictly speaking, you don't _have to_ include a header file to use a |
| function it declares; you could declare the function explicitly |
| yourself, according to the specifications in this manual. But it is |
| usually better to include the header file because it may define types |
| and macros that are not otherwise available and because it may define |
| more efficient macro replacements for some functions. It is also a sure |
| way to have the correct declaration. |
| |
| |
| File: libc.info, Node: Macro Definitions, Next: Reserved Names, Prev: Header Files, Up: Using the Library |
| |
| 1.3.2 Macro Definitions of Functions |
| ------------------------------------ |
| |
| If we describe something as a function in this manual, it may have a |
| macro definition as well. This normally has no effect on how your |
| program runs--the macro definition does the same thing as the function |
| would. In particular, macro equivalents for library functions evaluate |
| arguments exactly once, in the same way that a function call would. The |
| main reason for these macro definitions is that sometimes they can |
| produce an inline expansion that is considerably faster than an actual |
| function call. |
| |
| Taking the address of a library function works even if it is also |
| defined as a macro. This is because, in this context, the name of the |
| function isn't followed by the left parenthesis that is syntactically |
| necessary to recognize a macro call. |
| |
| You might occasionally want to avoid using the macro definition of a |
| function--perhaps to make your program easier to debug. There are two |
| ways you can do this: |
| |
| * You can avoid a macro definition in a specific use by enclosing the |
| name of the function in parentheses. This works because the name |
| of the function doesn't appear in a syntactic context where it is |
| recognizable as a macro call. |
| |
| * You can suppress any macro definition for a whole source file by |
| using the '#undef' preprocessor directive, unless otherwise stated |
| explicitly in the description of that facility. |
| |
| For example, suppose the header file 'stdlib.h' declares a function |
| named 'abs' with |
| |
| extern int abs (int); |
| |
| and also provides a macro definition for 'abs'. Then, in: |
| |
| #include <stdlib.h> |
| int f (int *i) { return abs (++*i); } |
| |
| the reference to 'abs' might refer to either a macro or a function. On |
| the other hand, in each of the following examples the reference is to a |
| function and not a macro. |
| |
| #include <stdlib.h> |
| int g (int *i) { return (abs) (++*i); } |
| |
| #undef abs |
| int h (int *i) { return abs (++*i); } |
| |
| Since macro definitions that double for a function behave in exactly |
| the same way as the actual function version, there is usually no need |
| for any of these methods. In fact, removing macro definitions usually |
| just makes your program slower. |
| |
| |
| File: libc.info, Node: Reserved Names, Next: Feature Test Macros, Prev: Macro Definitions, Up: Using the Library |
| |
| 1.3.3 Reserved Names |
| -------------------- |
| |
| The names of all library types, macros, variables and functions that |
| come from the ISO C standard are reserved unconditionally; your program |
| *may not* redefine these names. All other library names are reserved if |
| your program explicitly includes the header file that defines or |
| declares them. There are several reasons for these restrictions: |
| |
| * Other people reading your code could get very confused if you were |
| using a function named 'exit' to do something completely different |
| from what the standard 'exit' function does, for example. |
| Preventing this situation helps to make your programs easier to |
| understand and contributes to modularity and maintainability. |
| |
| * It avoids the possibility of a user accidentally redefining a |
| library function that is called by other library functions. If |
| redefinition were allowed, those other functions would not work |
| properly. |
| |
| * It allows the compiler to do whatever special optimizations it |
| pleases on calls to these functions, without the possibility that |
| they may have been redefined by the user. Some library facilities, |
| such as those for dealing with variadic arguments (*note Variadic |
| Functions::) and non-local exits (*note Non-Local Exits::), |
| actually require a considerable amount of cooperation on the part |
| of the C compiler, and with respect to the implementation, it might |
| be easier for the compiler to treat these as built-in parts of the |
| language. |
| |
| In addition to the names documented in this manual, reserved names |
| include all external identifiers (global functions and variables) that |
| begin with an underscore ('_') and all identifiers regardless of use |
| that begin with either two underscores or an underscore followed by a |
| capital letter are reserved names. This is so that the library and |
| header files can define functions, variables, and macros for internal |
| purposes without risk of conflict with names in user programs. |
| |
| Some additional classes of identifier names are reserved for future |
| extensions to the C language or the POSIX.1 environment. While using |
| these names for your own purposes right now might not cause a problem, |
| they do raise the possibility of conflict with future versions of the C |
| or POSIX standards, so you should avoid these names. |
| |
| * Names beginning with a capital 'E' followed a digit or uppercase |
| letter may be used for additional error code names. *Note Error |
| Reporting::. |
| |
| * Names that begin with either 'is' or 'to' followed by a lowercase |
| letter may be used for additional character testing and conversion |
| functions. *Note Character Handling::. |
| |
| * Names that begin with 'LC_' followed by an uppercase letter may be |
| used for additional macros specifying locale attributes. *Note |
| Locales::. |
| |
| * Names of all existing mathematics functions (*note Mathematics::) |
| suffixed with 'f' or 'l' are reserved for corresponding functions |
| that operate on 'float' and 'long double' arguments, respectively. |
| |
| * Names that begin with 'SIG' followed by an uppercase letter are |
| reserved for additional signal names. *Note Standard Signals::. |
| |
| * Names that begin with 'SIG_' followed by an uppercase letter are |
| reserved for additional signal actions. *Note Basic Signal |
| Handling::. |
| |
| * Names beginning with 'str', 'mem', or 'wcs' followed by a lowercase |
| letter are reserved for additional string and array functions. |
| *Note String and Array Utilities::. |
| |
| * Names that end with '_t' are reserved for additional type names. |
| |
| In addition, some individual header files reserve names beyond those |
| that they actually define. You only need to worry about these |
| restrictions if your program includes that particular header file. |
| |
| * The header file 'dirent.h' reserves names prefixed with 'd_'. |
| |
| * The header file 'fcntl.h' reserves names prefixed with 'l_', 'F_', |
| 'O_', and 'S_'. |
| |
| * The header file 'grp.h' reserves names prefixed with 'gr_'. |
| |
| * The header file 'limits.h' reserves names suffixed with '_MAX'. |
| |
| * The header file 'pwd.h' reserves names prefixed with 'pw_'. |
| |
| * The header file 'signal.h' reserves names prefixed with 'sa_' and |
| 'SA_'. |
| |
| * The header file 'sys/stat.h' reserves names prefixed with 'st_' and |
| 'S_'. |
| |
| * The header file 'sys/times.h' reserves names prefixed with 'tms_'. |
| |
| * The header file 'termios.h' reserves names prefixed with 'c_', 'V', |
| 'I', 'O', and 'TC'; and names prefixed with 'B' followed by a |
| digit. |
| |
| |
| File: libc.info, Node: Feature Test Macros, Prev: Reserved Names, Up: Using the Library |
