blob: f397da6542b8109e72abefccc47af8697757f958 [file] [log] [blame]
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