| 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.21. |
| |
| Copyright (C) 1993-2015 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 |
| * a64l: (libc)Encode Binary Data. |
| * abort: (libc)Aborting a Program. |
| * abs: (libc)Absolute Value. |
| * accept: (libc)Accepting Connections. |
| * access: (libc)Testing File Access. |
| * acosf: (libc)Inverse Trig Functions. |
| * acoshf: (libc)Hyperbolic Functions. |
| * acosh: (libc)Hyperbolic Functions. |
| * acoshl: (libc)Hyperbolic Functions. |
| * acos: (libc)Inverse Trig 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. |
| * ALTWERASE: (libc)Local Modes. |
| * ARG_MAX: (libc)General Limits. |
| * argp_error: (libc)Argp Helper Functions. |
| * ARGP_ERR_UNKNOWN: (libc)Argp Parser 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. |
| * asinf: (libc)Inverse Trig Functions. |
| * asinhf: (libc)Hyperbolic Functions. |
| * asinh: (libc)Hyperbolic Functions. |
| * asinhl: (libc)Hyperbolic Functions. |
| * asin: (libc)Inverse Trig Functions. |
| * asinl: (libc)Inverse Trig Functions. |
| * asprintf: (libc)Dynamic Output. |
| * assert: (libc)Consistency Checking. |
| * assert_perror: (libc)Consistency Checking. |
| * atan2f: (libc)Inverse Trig Functions. |
| * atan2: (libc)Inverse Trig Functions. |
| * atan2l: (libc)Inverse Trig Functions. |
| * atanf: (libc)Inverse Trig Functions. |
| * atanhf: (libc)Hyperbolic Functions. |
| * atanh: (libc)Hyperbolic Functions. |
| * atanhl: (libc)Hyperbolic Functions. |
| * atan: (libc)Inverse Trig 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_fd: (libc)Backtraces. |
| * backtrace_symbols: (libc)Backtraces. |
| * basename: (libc)Finding Tokens in a String. |
| * basename: (libc)Finding Tokens in a String. |
| * BC_BASE_MAX: (libc)Utility Limits. |
| * BC_DIM_MAX: (libc)Utility Limits. |
| * bcmp: (libc)String/Array Comparison. |
| * bcopy: (libc)Copying and Concatenation. |
| * BC_SCALE_MAX: (libc)Utility Limits. |
| * BC_STRING_MAX: (libc)Utility Limits. |
| * bind: (libc)Setting Address. |
| * bind_textdomain_codeset: (libc)Charset conversion in gettext. |
| * bindtextdomain: (libc)Locating gettext catalog. |
| * BRKINT: (libc)Input Modes. |
| * brk: (libc)Resizing the Data Segment. |
| * bsearch: (libc)Array Search Function. |
| * btowc: (libc)Converting a Character. |
| * BUFSIZ: (libc)Controlling Buffering. |
| * bzero: (libc)Copying and Concatenation. |
| * cabsf: (libc)Absolute Value. |
| * cabs: (libc)Absolute Value. |
| * cabsl: (libc)Absolute Value. |
| * cacosf: (libc)Inverse Trig Functions. |
| * cacoshf: (libc)Hyperbolic Functions. |
| * cacosh: (libc)Hyperbolic Functions. |
| * cacoshl: (libc)Hyperbolic Functions. |
| * cacos: (libc)Inverse Trig Functions. |
| * cacosl: (libc)Inverse Trig Functions. |
| * calloc: (libc)Allocating Cleared Space. |
| * canonicalize_file_name: (libc)Symbolic Links. |
| * cargf: (libc)Operations on Complex. |
| * carg: (libc)Operations on Complex. |
| * cargl: (libc)Operations on Complex. |
| * casinf: (libc)Inverse Trig Functions. |
| * casinhf: (libc)Hyperbolic Functions. |
| * casinh: (libc)Hyperbolic Functions. |
| * casinhl: (libc)Hyperbolic Functions. |
| * casin: (libc)Inverse Trig Functions. |
| * casinl: (libc)Inverse Trig Functions. |
| * catanf: (libc)Inverse Trig Functions. |
| * catanhf: (libc)Hyperbolic Functions. |
| * catanh: (libc)Hyperbolic Functions. |
| * catanhl: (libc)Hyperbolic Functions. |
| * catan: (libc)Inverse Trig 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. |
| * cbrtf: (libc)Exponents and Logarithms. |
| * cbrt: (libc)Exponents and Logarithms. |
| * cbrtl: (libc)Exponents and Logarithms. |
| * ccosf: (libc)Trig Functions. |
| * ccoshf: (libc)Hyperbolic Functions. |
| * ccosh: (libc)Hyperbolic Functions. |
| * ccoshl: (libc)Hyperbolic Functions. |
| * ccos: (libc)Trig Functions. |
| * ccosl: (libc)Trig Functions. |
| * CCTS_OFLOW: (libc)Control Modes. |
| * ceilf: (libc)Rounding Functions. |
| * ceil: (libc)Rounding Functions. |
| * ceill: (libc)Rounding Functions. |
| * cexpf: (libc)Exponents and Logarithms. |
| * cexp: (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. |
| * CHILD_MAX: (libc)General Limits. |
| * chmod: (libc)Setting Permissions. |
| * chown: (libc)File Owner. |
| * CIGNORE: (libc)Control Modes. |
| * cimagf: (libc)Operations on Complex. |
| * cimag: (libc)Operations on Complex. |
| * cimagl: (libc)Operations on Complex. |
| * clearenv: (libc)Environment Access. |
| * clearerr: (libc)Error Recovery. |
| * clearerr_unlocked: (libc)Error Recovery. |
| * CLK_TCK: (libc)Processor Time. |
| * CLOCAL: (libc)Control Modes. |
| * clock: (libc)CPU Time. |
| * CLOCKS_PER_SEC: (libc)CPU Time. |
| * clog10f: (libc)Exponents and Logarithms. |
| * clog10: (libc)Exponents and Logarithms. |
| * clog10l: (libc)Exponents and Logarithms. |
| * clogf: (libc)Exponents and Logarithms. |
| * clog: (libc)Exponents and Logarithms. |
| * clogl: (libc)Exponents and Logarithms. |
| * closedir: (libc)Reading/Closing Directory. |
| * close: (libc)Opening and Closing Files. |
| * closelog: (libc)closelog. |
| * COLL_WEIGHTS_MAX: (libc)Utility Limits. |
| * _Complex_I: (libc)Complex Numbers. |
| * confstr: (libc)String Parameters. |
| * conjf: (libc)Operations on Complex. |
| * conj: (libc)Operations on Complex. |
| * conjl: (libc)Operations on Complex. |
| * connect: (libc)Connecting. |
| * copysignf: (libc)FP Bit Twiddling. |
| * copysign: (libc)FP Bit Twiddling. |
| * copysignl: (libc)FP Bit Twiddling. |
| * cosf: (libc)Trig Functions. |
| * coshf: (libc)Hyperbolic Functions. |
| * cosh: (libc)Hyperbolic Functions. |
| * coshl: (libc)Hyperbolic Functions. |
| * cos: (libc)Trig Functions. |
| * cosl: (libc)Trig Functions. |
| * cpowf: (libc)Exponents and Logarithms. |
| * cpow: (libc)Exponents and Logarithms. |
| * cpowl: (libc)Exponents and Logarithms. |
| * cprojf: (libc)Operations on Complex. |
| * cproj: (libc)Operations on Complex. |
| * cprojl: (libc)Operations on Complex. |
| * 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. |
| * crealf: (libc)Operations on Complex. |
| * creal: (libc)Operations on Complex. |
| * creall: (libc)Operations on Complex. |
| * creat64: (libc)Opening and Closing Files. |
| * creat: (libc)Opening and Closing Files. |
| * CRTS_IFLOW: (libc)Control Modes. |
| * crypt: (libc)crypt. |
| * crypt_r: (libc)crypt. |
| * CS5: (libc)Control Modes. |
| * CS6: (libc)Control Modes. |
| * CS7: (libc)Control Modes. |
| * CS8: (libc)Control Modes. |
| * csinf: (libc)Trig Functions. |
| * csinhf: (libc)Hyperbolic Functions. |
| * csinh: (libc)Hyperbolic Functions. |
| * csinhl: (libc)Hyperbolic Functions. |
| * csin: (libc)Trig Functions. |
| * csinl: (libc)Trig Functions. |
| * CSIZE: (libc)Control Modes. |
| * csqrtf: (libc)Exponents and Logarithms. |
| * csqrt: (libc)Exponents and Logarithms. |
| * csqrtl: (libc)Exponents and Logarithms. |
| * CSTOPB: (libc)Control Modes. |
| * ctanf: (libc)Trig Functions. |
| * ctanhf: (libc)Hyperbolic Functions. |
| * ctanh: (libc)Hyperbolic Functions. |
| * ctanhl: (libc)Hyperbolic Functions. |
| * ctan: (libc)Trig 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_FAILED: (libc)DES Encryption. |
| * 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. |
| * dremf: (libc)Remainder Functions. |
| * drem: (libc)Remainder Functions. |
| * dreml: (libc)Remainder Functions. |
| * DTTOIF: (libc)Directory Entries. |
| * dup2: (libc)Duplicating Descriptors. |
| * dup: (libc)Duplicating Descriptors. |
| * 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. |
| * EBADFD: (libc)Error Codes. |
| * EBADF: (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. |
| * ecb_crypt: (libc)DES Encryption. |
| * ECHILD: (libc)Error Codes. |
| * ECHOCTL: (libc)Local Modes. |
| * ECHOE: (libc)Local Modes. |
| * ECHOKE: (libc)Local Modes. |
| * ECHOK: (libc)Local Modes. |
| * ECHO: (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. |
| * ecvt: (libc)System V Number Conversion. |
| * ecvt_r: (libc)System V Number Conversion. |
| * EDEADLK: (libc)Error Codes. |
| * EDEADLOCK: (libc)Error Codes. |
| * EDESTADDRREQ: (libc)Error Codes. |
| * EDIED: (libc)Error Codes. |
| * ED: (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. |
| * 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. |
| * 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. |
| * 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. |
| * 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. |
| * erand48: (libc)SVID Random. |
| * erand48_r: (libc)SVID Random. |
| * ERANGE: (libc)Error Codes. |
| * EREMCHG: (libc)Error Codes. |
| * EREMOTEIO: (libc)Error Codes. |
| * EREMOTE: (libc)Error Codes. |
| * ERESTART: (libc)Error Codes. |
| * erfcf: (libc)Special Functions. |
| * erfc: (libc)Special Functions. |
| * erfcl: (libc)Special Functions. |
| * erff: (libc)Special Functions. |
| * ERFKILL: (libc)Error Codes. |
| * erf: (libc)Special Functions. |
| * erfl: (libc)Special Functions. |
| * EROFS: (libc)Error Codes. |
| * ERPCMISMATCH: (libc)Error Codes. |
| * err: (libc)Error Messages. |
| * errno: (libc)Checking for Errors. |
| * error_at_line: (libc)Error Messages. |
| * error: (libc)Error Messages. |
| * errx: (libc)Error Messages. |
| * 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. |
| * ETIMEDOUT: (libc)Error Codes. |
| * ETIME: (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. |
| * execle: (libc)Executing a File. |
| * execl: (libc)Executing a File. |
| * execlp: (libc)Executing a File. |
| * execve: (libc)Executing a File. |
| * execv: (libc)Executing a File. |
| * execvp: (libc)Executing a File. |
| * EXFULL: (libc)Error Codes. |
| * EXIT_FAILURE: (libc)Exit Status. |
| * exit: (libc)Normal Termination. |
| * _exit: (libc)Termination Internals. |
| * _Exit: (libc)Termination Internals. |
| * EXIT_SUCCESS: (libc)Exit Status. |
| * exp10f: (libc)Exponents and Logarithms. |
| * exp10: (libc)Exponents and Logarithms. |
| * exp10l: (libc)Exponents and Logarithms. |
| * exp2f: (libc)Exponents and Logarithms. |
| * exp2: (libc)Exponents and Logarithms. |
| * exp2l: (libc)Exponents and Logarithms. |
| * expf: (libc)Exponents and Logarithms. |
| * exp: (libc)Exponents and Logarithms. |
| * expl: (libc)Exponents and Logarithms. |
| * expm1f: (libc)Exponents and Logarithms. |
| * expm1: (libc)Exponents and Logarithms. |
| * expm1l: (libc)Exponents and Logarithms. |
| * EXPR_NEST_MAX: (libc)Utility Limits. |
| * fabsf: (libc)Absolute Value. |
| * fabs: (libc)Absolute Value. |
| * fabsl: (libc)Absolute Value. |
| * __fbufsize: (libc)Controlling Buffering. |
| * fchdir: (libc)Working Directory. |
| * fchmod: (libc)Setting Permissions. |
| * fchown: (libc)File Owner. |
| * fcloseall: (libc)Closing Streams. |
| * fclose: (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. |
| * FD_CLOEXEC: (libc)Descriptor Flags. |
| * FD_CLR: (libc)Waiting for I/O. |
| * fdimf: (libc)Misc FP Arithmetic. |
| * fdim: (libc)Misc FP Arithmetic. |
| * fdiml: (libc)Misc FP Arithmetic. |
| * FD_ISSET: (libc)Waiting for I/O. |
| * fdopendir: (libc)Opening a Directory. |
| * fdopen: (libc)Descriptors and Streams. |
| * FD_SET: (libc)Waiting for I/O. |
| * FD_SETSIZE: (libc)Waiting for I/O. |
| * F_DUPFD: (libc)Duplicating Descriptors. |
| * FD_ZERO: (libc)Waiting for I/O. |
| * feclearexcept: (libc)Status bit operations. |
| * fedisableexcept: (libc)Control Functions. |
| * feenableexcept: (libc)Control Functions. |
| * fegetenv: (libc)Control Functions. |
| * fegetexceptflag: (libc)Status bit operations. |
| * fegetexcept: (libc)Control Functions. |
| * 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. |
| * F_GETFD: (libc)Descriptor Flags. |
| * F_GETFL: (libc)Getting File Status Flags. |
| * fgetgrent: (libc)Scanning All Groups. |
| * fgetgrent_r: (libc)Scanning All Groups. |
| * F_GETLK: (libc)File Locks. |
| * F_GETOWN: (libc)Interrupt Input. |
| * 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. |
| * FILENAME_MAX: (libc)Limits for Files. |
| * fileno: (libc)Descriptors and Streams. |
| * fileno_unlocked: (libc)Descriptors and Streams. |
| * finitef: (libc)Floating Point Classes. |
| * finite: (libc)Floating Point Classes. |
| * finitel: (libc)Floating Point Classes. |
| * __flbf: (libc)Controlling Buffering. |
| * flockfile: (libc)Streams and Threads. |
| * floorf: (libc)Rounding Functions. |
| * floor: (libc)Rounding Functions. |
| * floorl: (libc)Rounding Functions. |
| * _flushlbf: (libc)Flushing Buffers. |
| * FLUSHO: (libc)Local Modes. |
| * fmaf: (libc)Misc FP Arithmetic. |
| * fma: (libc)Misc FP Arithmetic. |
| * fmal: (libc)Misc FP Arithmetic. |
| * fmaxf: (libc)Misc FP Arithmetic. |
| * fmax: (libc)Misc FP Arithmetic. |
| * fmaxl: (libc)Misc FP Arithmetic. |
| * fmemopen: (libc)String Streams. |
| * fminf: (libc)Misc FP Arithmetic. |
| * fmin: (libc)Misc FP Arithmetic. |
| * fminl: (libc)Misc FP Arithmetic. |
| * fmodf: (libc)Remainder Functions. |
| * fmod: (libc)Remainder Functions. |
| * fmodl: (libc)Remainder Functions. |
| * fmtmsg: (libc)Printing Formatted Messages. |
| * fnmatch: (libc)Wildcard Matching. |
| * F_OFD_GETLK: (libc)Open File Description Locks. |
| * F_OFD_SETLK: (libc)Open File Description Locks. |
| * F_OFD_SETLKW: (libc)Open File Description Locks. |
| * F_OK: (libc)Testing File Access. |
| * fopen64: (libc)Opening Streams. |
| * fopencookie: (libc)Streams and Cookies. |
| * fopen: (libc)Opening Streams. |
| * FOPEN_MAX: (libc)Opening Streams. |
| * fork: (libc)Creating a Process. |
| * forkpty: (libc)Pseudo-Terminal Pairs. |
| * fpathconf: (libc)Pathconf. |
| * fpclassify: (libc)Floating Point Classes. |
| * __fpending: (libc)Controlling Buffering. |
| * FP_ILOGB0: (libc)Exponents and Logarithms. |
| * FP_ILOGBNAN: (libc)Exponents and Logarithms. |
| * fprintf: (libc)Formatted Output Functions. |
| * __fpurge: (libc)Flushing Buffers. |
| * 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. |
| * __freadable: (libc)Opening Streams. |
| * __freading: (libc)Opening Streams. |
| * fread: (libc)Block Input/Output. |
| * fread_unlocked: (libc)Block Input/Output. |
| * free: (libc)Freeing after Malloc. |
| * freopen64: (libc)Opening Streams. |
| * freopen: (libc)Opening Streams. |
| * frexpf: (libc)Normalization Functions. |
| * frexp: (libc)Normalization Functions. |
| * frexpl: (libc)Normalization Functions. |
| * fscanf: (libc)Formatted Input Functions. |
| * fseek: (libc)File Positioning. |
| * fseeko64: (libc)File Positioning. |
| * fseeko: (libc)File Positioning. |
| * F_SETFD: (libc)Descriptor Flags. |
| * F_SETFL: (libc)Getting File Status Flags. |
| * F_SETLK: (libc)File Locks. |
| * F_SETLKW: (libc)File Locks. |
| * __fsetlocking: (libc)Streams and Threads. |
| * F_SETOWN: (libc)Interrupt Input. |
| * 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. |
| * __fwritable: (libc)Opening Streams. |
| * fwrite: (libc)Block Input/Output. |
| * fwrite_unlocked: (libc)Block Input/Output. |
| * __fwriting: (libc)Opening Streams. |
| * fwscanf: (libc)Formatted Input Functions. |
| * gammaf: (libc)Special Functions. |
| * gamma: (libc)Special Functions. |
| * gammal: (libc)Special Functions. |
| * __gconv_end_fct: (libc)glibc iconv Implementation. |
| * __gconv_fct: (libc)glibc iconv Implementation. |
| * __gconv_init_fct: (libc)glibc iconv Implementation. |
| * gcvt: (libc)System V Number Conversion. |
| * getauxval: (libc)Auxiliary Vector. |
| * get_avphys_pages: (libc)Query Memory Parameters. |
| * getchar: (libc)Character Input. |
| * getchar_unlocked: (libc)Character Input. |
| * getc: (libc)Character Input. |
| * getcontext: (libc)System V contexts. |
| * getc_unlocked: (libc)Character Input. |
| * get_current_dir_name: (libc)Working Directory. |
| * 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. |
| * get_nprocs_conf: (libc)Processor Resources. |
| * get_nprocs: (libc)Processor Resources. |
| * 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. |
| * get_phys_pages: (libc)Query Memory Parameters. |
| * 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. |
| * getservbyname: (libc)Services Database. |
| * getservbyport: (libc)Services Database. |
| * getservent: (libc)Services Database. |
| * getsid: (libc)Process Group Functions. |
| * gets: (libc)Line Input. |
| * 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. |
| * getwchar: (libc)Character Input. |
| * getwchar_unlocked: (libc)Character Input. |
| * getwc: (libc)Character Input. |
| * getwc_unlocked: (libc)Character Input. |
| * getwd: (libc)Working Directory. |
| * getw: (libc)Character Input. |
| * glob64: (libc)Calling Glob. |
| * globfree64: (libc)More Flags for Globbing. |
| * globfree: (libc)More Flags for Globbing. |
| * glob: (libc)Calling Glob. |
| * 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. |
| * HUGE_VALF: (libc)Math Error Reporting. |
| * HUGE_VAL: (libc)Math Error Reporting. |
| * HUGE_VALL: (libc)Math Error Reporting. |
| * HUPCL: (libc)Control Modes. |
| * hypotf: (libc)Exponents and Logarithms. |
| * hypot: (libc)Exponents and Logarithms. |
| * hypotl: (libc)Exponents and Logarithms. |
| * ICANON: (libc)Local Modes. |
| * iconv_close: (libc)Generic Conversion Interface. |
| * iconv: (libc)Generic Conversion Interface. |
| * iconv_open: (libc)Generic Conversion Interface. |
| * ICRNL: (libc)Input Modes. |
| * IEXTEN: (libc)Local Modes. |
| * if_freenameindex: (libc)Interface Naming. |
| * if_indextoname: (libc)Interface Naming. |
| * if_nameindex: (libc)Interface Naming. |
| * if_nametoindex: (libc)Interface Naming. |
| * IFNAMSIZ: (libc)Interface Naming. |
| * IFTODT: (libc)Directory Entries. |
| * IGNBRK: (libc)Input Modes. |
| * IGNCR: (libc)Input Modes. |
| * IGNPAR: (libc)Input Modes. |
| * I: (libc)Complex Numbers. |
| * ilogbf: (libc)Exponents and Logarithms. |
| * ilogb: (libc)Exponents and Logarithms. |
| * ilogbl: (libc)Exponents and Logarithms. |
| * _Imaginary_I: (libc)Complex Numbers. |
| * imaxabs: (libc)Absolute Value. |
| * IMAXBEL: (libc)Input Modes. |
| * imaxdiv: (libc)Integer Division. |
| * in6addr_any: (libc)Host Address Data Type. |
| * in6addr_loopback: (libc)Host Address Data Type. |
| * 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. |
| * 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. |
| * INFINITY: (libc)Infinity and NaN. |
| * initgroups: (libc)Setting Groups. |
| * initstate: (libc)BSD Random. |
| * initstate_r: (libc)BSD Random. |
| * INLCR: (libc)Input Modes. |
| * innetgr: (libc)Netgroup Membership. |
| * INPCK: (libc)Input Modes. |
| * ioctl: (libc)IOCTLs. |
| * _IOFBF: (libc)Controlling Buffering. |
| * _IOLBF: (libc)Controlling Buffering. |
| * _IONBF: (libc)Controlling Buffering. |
| * IPPORT_RESERVED: (libc)Ports. |
| * IPPORT_USERRESERVED: (libc)Ports. |
| * 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. |
| * isgreaterequal: (libc)FP Comparison Functions. |
| * isgreater: (libc)FP Comparison Functions. |
| * ISIG: (libc)Local Modes. |
| * isinff: (libc)Floating Point Classes. |
| * isinf: (libc)Floating Point Classes. |
| * isinfl: (libc)Floating Point Classes. |
| * islessequal: (libc)FP Comparison Functions. |
| * islessgreater: (libc)FP Comparison Functions. |
| * isless: (libc)FP Comparison Functions. |
| * islower: (libc)Classification of Characters. |
| * isnanf: (libc)Floating Point Classes. |
| * isnan: (libc)Floating Point Classes. |
| * isnan: (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. |
| * ISTRIP: (libc)Input Modes. |
| * 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. |
| * IXANY: (libc)Input Modes. |
| * IXOFF: (libc)Input Modes. |
| * IXON: (libc)Input Modes. |
| * j0f: (libc)Special Functions. |
| * j0: (libc)Special Functions. |
| * j0l: (libc)Special Functions. |
| * j1f: (libc)Special Functions. |
| * j1: (libc)Special Functions. |
| * j1l: (libc)Special Functions. |
| * jnf: (libc)Special Functions. |
| * jn: (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. |
| * L_ctermid: (libc)Identifying the Terminal. |
| * L_cuserid: (libc)Who Logged In. |
| * ldexpf: (libc)Normalization Functions. |
| * ldexp: (libc)Normalization Functions. |
| * ldexpl: (libc)Normalization Functions. |
| * ldiv: (libc)Integer Division. |
| * lfind: (libc)Array Search Function. |
| * lgammaf: (libc)Special Functions. |
| * lgammaf_r: (libc)Special Functions. |
| * lgamma: (libc)Special Functions. |
| * lgammal: (libc)Special Functions. |
| * lgammal_r: (libc)Special Functions. |
| * lgamma_r: (libc)Special Functions. |
| * LINE_MAX: (libc)Utility Limits. |
| * link: (libc)Hard Links. |
| * LINK_MAX: (libc)Limits for Files. |
| * lio_listio64: (libc)Asynchronous Reads/Writes. |
| * lio_listio: (libc)Asynchronous Reads/Writes. |
| * listen: (libc)Listening. |
| * llabs: (libc)Absolute Value. |
| * lldiv: (libc)Integer Division. |
| * llrintf: (libc)Rounding Functions. |
| * llrint: (libc)Rounding Functions. |
| * llrintl: (libc)Rounding Functions. |
| * llroundf: (libc)Rounding Functions. |
| * llround: (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. |
| * log10f: (libc)Exponents and Logarithms. |
| * log10: (libc)Exponents and Logarithms. |
| * log10l: (libc)Exponents and Logarithms. |
| * log1pf: (libc)Exponents and Logarithms. |
| * log1p: (libc)Exponents and Logarithms. |
| * log1pl: (libc)Exponents and Logarithms. |
| * log2f: (libc)Exponents and Logarithms. |
| * log2: (libc)Exponents and Logarithms. |
| * log2l: (libc)Exponents and Logarithms. |
| * logbf: (libc)Exponents and Logarithms. |
| * logb: (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. |
| * log: (libc)Exponents and Logarithms. |
| * 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. |
| * lrintf: (libc)Rounding Functions. |
| * lrint: (libc)Rounding Functions. |
| * lrintl: (libc)Rounding Functions. |
| * lroundf: (libc)Rounding Functions. |
| * lround: (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. |
| * L_tmpnam: (libc)Temporary Files. |
| * 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. |
| * MAX_CANON: (libc)Limits for Files. |
| * MAX_INPUT: (libc)Limits for Files. |
| * MAXNAMLEN: (libc)Limits for Files. |
| * MAXSYMLINKS: (libc)Symbolic Links. |
| * MB_CUR_MAX: (libc)Selecting the Conversion. |
| * mblen: (libc)Non-reentrant Character Conversion. |
| * MB_LEN_MAX: (libc)Selecting the 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. |
| * MDMBUF: (libc)Control Modes. |
| * 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. |
| * mlockall: (libc)Page Lock Functions. |
| * mlock: (libc)Page Lock Functions. |
| * mmap64: (libc)Memory-mapped I/O. |
| * mmap: (libc)Memory-mapped I/O. |
| * modff: (libc)Rounding Functions. |
| * modf: (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. |
| * MSG_DONTROUTE: (libc)Socket Data Options. |
| * MSG_OOB: (libc)Socket Data Options. |
| * MSG_PEEK: (libc)Socket Data Options. |
| * msync: (libc)Memory-mapped I/O. |
| * mtrace: (libc)Tracing malloc. |
| * munlockall: (libc)Page Lock Functions. |
| * munlock: (libc)Page Lock Functions. |
| * munmap: (libc)Memory-mapped I/O. |
| * muntrace: (libc)Tracing malloc. |
| * NAME_MAX: (libc)Limits for Files. |
| * nanf: (libc)FP Bit Twiddling. |
| * nan: (libc)FP Bit Twiddling. |
| * NAN: (libc)Infinity and NaN. |
| * nanl: (libc)FP Bit Twiddling. |
| * nanosleep: (libc)Sleeping. |
| * NCCS: (libc)Mode Data Types. |
| * nearbyintf: (libc)Rounding Functions. |
| * nearbyint: (libc)Rounding Functions. |
| * nearbyintl: (libc)Rounding Functions. |
| * nextafterf: (libc)FP Bit Twiddling. |
| * nextafter: (libc)FP Bit Twiddling. |
| * nextafterl: (libc)FP Bit Twiddling. |
| * nexttowardf: (libc)FP Bit Twiddling. |
| * nexttoward: (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. |
| * NGROUPS_MAX: (libc)General Limits. |
| * nice: (libc)Traditional Scheduling Functions. |
| * nl_langinfo: (libc)The Elegant and Fast Way. |
| * NOFLSH: (libc)Local Modes. |
| * NOKERNINFO: (libc)Local Modes. |
| * nrand48: (libc)SVID Random. |
| * nrand48_r: (libc)SVID Random. |
| * NSIG: (libc)Standard Signals. |
| * ntohl: (libc)Byte Order. |
| * ntohs: (libc)Byte Order. |
| * ntp_adjtime: (libc)High Accuracy Clock. |
| * ntp_gettime: (libc)High Accuracy Clock. |
| * NULL: (libc)Null Pointer Constant. |
| * O_ACCMODE: (libc)Access Modes. |
| * O_APPEND: (libc)Operating Modes. |
| * O_ASYNC: (libc)Operating Modes. |
| * obstack_1grow_fast: (libc)Extra Fast Growing. |
| * obstack_1grow: (libc)Growing Objects. |
| * obstack_alignment_mask: (libc)Obstacks Data Alignment. |
| * obstack_alloc: (libc)Allocation in an Obstack. |
| * obstack_base: (libc)Status of an Obstack. |
| * obstack_blank_fast: (libc)Extra Fast Growing. |
| * obstack_blank: (libc)Growing Objects. |
| * 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_fast: (libc)Extra Fast Growing. |
| * obstack_int_grow: (libc)Growing Objects. |
| * 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_fast: (libc)Extra Fast Growing. |
| * obstack_ptr_grow: (libc)Growing Objects. |
| * obstack_room: (libc)Extra Fast Growing. |
| * obstack_vprintf: (libc)Variable Arguments Output. |
| * O_CREAT: (libc)Open-time Flags. |
| * O_EXCL: (libc)Open-time Flags. |
| * O_EXEC: (libc)Access Modes. |
| * O_EXLOCK: (libc)Open-time Flags. |
| * offsetof: (libc)Structure Measurement. |
| * O_FSYNC: (libc)Operating Modes. |
| * O_IGNORE_CTTY: (libc)Open-time Flags. |
| * O_NDELAY: (libc)Operating Modes. |
| * on_exit: (libc)Cleanups on Exit. |
| * ONLCR: (libc)Output Modes. |
| * O_NOATIME: (libc)Operating Modes. |
| * O_NOCTTY: (libc)Open-time Flags. |
| * ONOEOT: (libc)Output Modes. |
| * O_NOLINK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Operating Modes. |
| * O_NOTRANS: (libc)Open-time Flags. |
| * open64: (libc)Opening and Closing Files. |
| * opendir: (libc)Opening a Directory. |
| * open: (libc)Opening and Closing Files. |
| * openlog: (libc)openlog. |
| * OPEN_MAX: (libc)General Limits. |
| * open_memstream: (libc)String Streams. |
| * openpty: (libc)Pseudo-Terminal Pairs. |
| * OPOST: (libc)Output Modes. |
| * 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. |
| * OXTABS: (libc)Output Modes. |
| * PA_FLAG_MASK: (libc)Parsing a Template String. |
| * PARENB: (libc)Control Modes. |
| * PARMRK: (libc)Input Modes. |
| * PARODD: (libc)Control Modes. |
| * parse_printf_format: (libc)Parsing a Template String. |
| * pathconf: (libc)Pathconf. |
| * PATH_MAX: (libc)Limits for Files. |
| * _PATH_UTMP: (libc)Manipulating the Database. |
| * _PATH_WTMP: (libc)Manipulating the Database. |
| * pause: (libc)Using Pause. |
| * pclose: (libc)Pipe to a Subprocess. |
| * PENDIN: (libc)Local Modes. |
| * perror: (libc)Error Messages. |
| * 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. |
| * pipe: (libc)Creating a Pipe. |
| * popen: (libc)Pipe to a Subprocess. |
| * _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_memalign: (libc)Aligned Memory Blocks. |
| * _POSIX_NO_TRUNC: (libc)Options for Files. |
| * _POSIX_SAVED_IDS: (libc)System Options. |
| * _POSIX_VDISABLE: (libc)Options for Files. |
| * _POSIX_VERSION: (libc)Version Supported. |
| * pow10f: (libc)Exponents and Logarithms. |
| * pow10: (libc)Exponents and Logarithms. |
| * pow10l: (libc)Exponents and Logarithms. |
| * powf: (libc)Exponents and Logarithms. |
| * pow: (libc)Exponents and Logarithms. |
| * powl: (libc)Exponents and Logarithms. |
| * __ppc_get_timebase_freq: (libc)PowerPC. |
| * __ppc_get_timebase: (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. |
| * pread64: (libc)I/O Primitives. |
| * pread: (libc)I/O Primitives. |
| * printf: (libc)Formatted Output Functions. |
| * printf_size_info: (libc)Predefined Printf Handlers. |
| * printf_size: (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. |
| * P_tmpdir: (libc)Temporary Files. |
| * ptsname: (libc)Allocation. |
| * ptsname_r: (libc)Allocation. |
| * putchar: (libc)Simple Output. |
| * putchar_unlocked: (libc)Simple Output. |
| * putc: (libc)Simple Output. |
| * putc_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. |
| * putwchar: (libc)Simple Output. |
| * putwchar_unlocked: (libc)Simple Output. |
| * putwc: (libc)Simple Output. |
| * putwc_unlocked: (libc)Simple Output. |
| * putw: (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_MAX: (libc)ISO Random. |
| * random: (libc)BSD Random. |
| * random_r: (libc)BSD Random. |
| * rand_r: (libc)ISO Random. |
| * rawmemchr: (libc)Search Functions. |
| * readdir64: (libc)Reading/Closing Directory. |
| * readdir64_r: (libc)Reading/Closing Directory. |
| * readdir: (libc)Reading/Closing Directory. |
| * readdir_r: (libc)Reading/Closing Directory. |
| * read: (libc)I/O Primitives. |
| * readlink: (libc)Symbolic Links. |
| * readv: (libc)Scatter-Gather. |
| * realloc: (libc)Changing Block Size. |
| * realpath: (libc)Symbolic Links. |
| * recvfrom: (libc)Receiving Datagrams. |
| * recv: (libc)Receiving Data. |
| * recvmsg: (libc)Receiving Datagrams. |
| * RE_DUP_MAX: (libc)General Limits. |
| * 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. |
| * remainderf: (libc)Remainder Functions. |
| * remainder: (libc)Remainder Functions. |
| * remainderl: (libc)Remainder Functions. |
| * remove: (libc)Deleting Files. |
| * rename: (libc)Renaming Files. |
| * rewinddir: (libc)Random Access Directory. |
| * rewind: (libc)File Positioning. |
| * rindex: (libc)Search Functions. |
| * rintf: (libc)Rounding Functions. |
| * rint: (libc)Rounding Functions. |
| * rintl: (libc)Rounding Functions. |
| * RLIM_INFINITY: (libc)Limits on Resources. |
| * rmdir: (libc)Deleting Files. |
| * R_OK: (libc)Testing File Access. |
| * roundf: (libc)Rounding Functions. |
| * round: (libc)Rounding Functions. |
| * roundl: (libc)Rounding Functions. |
| * rpmatch: (libc)Yes-or-No Questions. |
| * SA_NOCLDSTOP: (libc)Flags for Sigaction. |
| * SA_ONSTACK: (libc)Flags for Sigaction. |
| * SA_RESTART: (libc)Flags for Sigaction. |
| * sbrk: (libc)Resizing the Data Segment. |
| * scalbf: (libc)Normalization Functions. |
| * scalb: (libc)Normalization Functions. |
| * scalbl: (libc)Normalization Functions. |
| * scalblnf: (libc)Normalization Functions. |
| * scalbln: (libc)Normalization Functions. |
| * scalblnl: (libc)Normalization Functions. |
| * scalbnf: (libc)Normalization Functions. |
| * scalbn: (libc)Normalization Functions. |
| * scalbnl: (libc)Normalization Functions. |
| * scandir64: (libc)Scanning Directory Content. |
| * scandir: (libc)Scanning Directory Content. |
| * scanf: (libc)Formatted Input Functions. |
| * sched_getaffinity: (libc)CPU Affinity. |
| * sched_getparam: (libc)Basic Scheduling Functions. |
| * sched_get_priority_max: (libc)Basic Scheduling Functions. |
| * sched_get_priority_min: (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. |
| * SEEK_CUR: (libc)File Positioning. |
| * seekdir: (libc)Random Access Directory. |
| * SEEK_END: (libc)File Positioning. |
| * SEEK_SET: (libc)File Positioning. |
| * select: (libc)Waiting for I/O. |
| * sem_close: (libc)Semaphores. |
| * semctl: (libc)Semaphores. |
| * sem_destroy: (libc)Semaphores. |
| * semget: (libc)Semaphores. |
| * sem_getvalue: (libc)Semaphores. |
| * sem_init: (libc)Semaphores. |
| * sem_open: (libc)Semaphores. |
| * semop: (libc)Semaphores. |
| * sem_post: (libc)Semaphores. |
| * semtimedop: (libc)Semaphores. |
| * sem_timedwait: (libc)Semaphores. |
| * sem_trywait: (libc)Semaphores. |
| * sem_unlink: (libc)Semaphores. |
| * sem_wait: (libc)Semaphores. |
| * send: (libc)Sending Data. |
| * sendmsg: (libc)Receiving Datagrams. |
| * sendto: (libc)Sending Datagrams. |
| * setbuffer: (libc)Controlling Buffering. |
| * setbuf: (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. |
| * S_IFMT: (libc)Testing File Type. |
| * SIGABRT: (libc)Program Error Signals. |
| * sigaction: (libc)Advanced Signal Handling. |
| * sigaddset: (libc)Signal Sets. |
| * SIGALRM: (libc)Alarm Signals. |
| * sigaltstack: (libc)Signal Stack. |
| * sigblock: (libc)BSD Signal Handling. |
| * SIGBUS: (libc)Program Error Signals. |
| * SIGCHLD: (libc)Job Control Signals. |
| * SIGCLD: (libc)Job Control Signals. |
| * SIGCONT: (libc)Job Control Signals. |
| * sigdelset: (libc)Signal Sets. |
| * sigemptyset: (libc)Signal Sets. |
| * SIGEMT: (libc)Program Error Signals. |
| * SIG_ERR: (libc)Basic Signal Handling. |
| * sigfillset: (libc)Signal Sets. |
| * SIGFPE: (libc)Program Error Signals. |
| * SIGHUP: (libc)Termination Signals. |
| * SIGILL: (libc)Program Error Signals. |
| * SIGINFO: (libc)Miscellaneous Signals. |
| * siginterrupt: (libc)BSD Signal Handling. |
| * SIGINT: (libc)Termination Signals. |
| * SIGIO: (libc)Asynchronous I/O Signals. |
| * SIGIOT: (libc)Program Error Signals. |
| * sigismember: (libc)Signal Sets. |
| * SIGKILL: (libc)Termination Signals. |
| * siglongjmp: (libc)Non-Local Exits and Signals. |
| * SIGLOST: (libc)Operation Error Signals. |
| * sigmask: (libc)BSD Signal Handling. |
| * signal: (libc)Basic Signal Handling. |
| * signbit: (libc)FP Bit Twiddling. |
| * significandf: (libc)Normalization Functions. |
| * significand: (libc)Normalization Functions. |
| * significandl: (libc)Normalization Functions. |
| * sigpause: (libc)BSD Signal Handling. |
| * sigpending: (libc)Checking for Pending Signals. |
| * SIGPIPE: (libc)Operation Error Signals. |
| * SIGPOLL: (libc)Asynchronous I/O Signals. |
| * sigprocmask: (libc)Process Signal Mask. |
| * SIGPROF: (libc)Alarm Signals. |
| * SIGQUIT: (libc)Termination Signals. |
| * SIGSEGV: (libc)Program Error Signals. |
| * sigsetjmp: (libc)Non-Local Exits and Signals. |
| * sigsetmask: (libc)BSD Signal Handling. |
| * sigstack: (libc)Signal Stack. |
| * SIGSTOP: (libc)Job Control Signals. |
| * sigsuspend: (libc)Sigsuspend. |
| * 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. |
| * sincosf: (libc)Trig Functions. |
| * sincos: (libc)Trig Functions. |
| * sincosl: (libc)Trig Functions. |
| * sinf: (libc)Trig Functions. |
| * sinhf: (libc)Hyperbolic Functions. |
| * sinh: (libc)Hyperbolic Functions. |
| * sinhl: (libc)Hyperbolic Functions. |
| * sin: (libc)Trig Functions. |
| * sinl: (libc)Trig Functions. |
| * 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. |
| * sleep: (libc)Sleeping. |
| * snprintf: (libc)Formatted Output Functions. |
| * SOCK_DGRAM: (libc)Communication Styles. |
| * socket: (libc)Creating a Socket. |
| * socketpair: (libc)Socket Pairs. |
| * 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. |
| * sprintf: (libc)Formatted Output Functions. |
| * sqrtf: (libc)Exponents and Logarithms. |
| * sqrt: (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. |
| * SSIZE_MAX: (libc)General Limits. |
| * 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. |
| * strdupa: (libc)Copying and Concatenation. |
| * strdup: (libc)Copying and Concatenation. |
| * STREAM_MAX: (libc)General Limits. |
| * 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. |
| * strndupa: (libc)Copying and Concatenation. |
| * strndup: (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. |
| * strtold: (libc)Parsing of Floats. |
| * strtol: (libc)Parsing of Integers. |
| * 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. |
| * S_TYPEISMQ: (libc)Testing File Type. |
| * S_TYPEISSEM: (libc)Testing File Type. |
| * S_TYPEISSHM: (libc)Testing File Type. |
| * SUN_LEN: (libc)Local Namespace Details. |
| * 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. |
| * tanf: (libc)Trig Functions. |
| * tanhf: (libc)Hyperbolic Functions. |
| * tanh: (libc)Hyperbolic Functions. |
| * tanhl: (libc)Hyperbolic Functions. |
| * tan: (libc)Trig 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. |
| * tgammaf: (libc)Special Functions. |
| * tgamma: (libc)Special Functions. |
| * tgammal: (libc)Special Functions. |
| * timegm: (libc)Broken-down Time. |
| * time: (libc)Simple Calendar Time. |
| * timelocal: (libc)Broken-down Time. |
| * times: (libc)Processor Time. |
| * tmpfile64: (libc)Temporary Files. |
| * tmpfile: (libc)Temporary Files. |
| * TMP_MAX: (libc)Temporary Files. |
| * tmpnam: (libc)Temporary Files. |
| * tmpnam_r: (libc)Temporary Files. |
| * toascii: (libc)Case Conversion. |
| * _tolower: (libc)Case Conversion. |
| * tolower: (libc)Case Conversion. |
| * TOSTOP: (libc)Local Modes. |
| * _toupper: (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. |
| * truncate64: (libc)File Size. |
| * truncate: (libc)File Size. |
| * truncf: (libc)Rounding Functions. |
| * trunc: (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. |
| * TZNAME_MAX: (libc)General Limits. |
| * 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_copy: (libc)Argument Macros. |
| * va_end: (libc)Argument Macros. |
| * valloc: (libc)Aligned Memory Blocks. |
| * vasprintf: (libc)Variable Arguments Output. |
| * va_start: (libc)Argument Macros. |
| * VDISCARD: (libc)Other Special. |
| * VDSUSP: (libc)Signal Characters. |
| * VEOF: (libc)Editing Characters. |
| * VEOL2: (libc)Editing Characters. |
| * VEOL: (libc)Editing Characters. |
| * VERASE: (libc)Editing Characters. |
| * 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. |
| * VINTR: (libc)Signal Characters. |
| * VKILL: (libc)Editing Characters. |
| * vlimit: (libc)Limits on Resources. |
| * VLNEXT: (libc)Other Special. |
| * VMIN: (libc)Noncanonical Input. |
| * vprintf: (libc)Variable Arguments Output. |
| * VQUIT: (libc)Signal Characters. |
| * VREPRINT: (libc)Editing Characters. |
| * vscanf: (libc)Variable Arguments Input. |
| * vsnprintf: (libc)Variable Arguments Output. |
| * vsprintf: (libc)Variable Arguments Output. |
| * vsscanf: (libc)Variable Arguments Input. |
| * VSTART: (libc)Start/Stop Characters. |
| * VSTATUS: (libc)Other Special. |
| * VSTOP: (libc)Start/Stop Characters. |
| * VSUSP: (libc)Signal Characters. |
| * vswprintf: (libc)Variable Arguments Output. |
| * vswscanf: (libc)Variable Arguments Input. |
| * vsyslog: (libc)syslog; vsyslog. |
| * VTIME: (libc)Noncanonical Input. |
| * vtimes: (libc)Resource Usage. |
| * vwarn: (libc)Error Messages. |
| * vwarnx: (libc)Error Messages. |
| * VWERASE: (libc)Editing Characters. |
| * 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. |
| * WCHAR_MAX: (libc)Extended Char Intro. |
| * WCHAR_MIN: (libc)Extended Char Intro. |
| * WCOREDUMP: (libc)Process Completion Status. |
| * 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. |
| * wcstold: (libc)Parsing of Floats. |
| * wcstol: (libc)Parsing of Integers. |
| * 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. |
| * 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. |
| * 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. |
| * W_OK: (libc)Testing File Access. |
| * 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. |
| * WSTOPSIG: (libc)Process Completion Status. |
| * WTERMSIG: (libc)Process Completion Status. |
| * X_OK: (libc)Testing File Access. |
| * y0f: (libc)Special Functions. |
| * y0: (libc)Special Functions. |
| * y0l: (libc)Special Functions. |
| * y1f: (libc)Special Functions. |
| * y1: (libc)Special Functions. |
| * y1l: (libc)Special Functions. |
| * ynf: (libc)Special Functions. |
| * yn: (libc)Special Functions. |
| * ynl: (libc)Special Functions. |
| END-INFO-DIR-ENTRY |
| |
| |
| File: libc.info, Node: Logging In and Out, Prev: XPG Functions, Up: User Accounting Database |
| |
| 30.12.3 Logging In and Out |
| -------------------------- |
| |
| These functions, derived from BSD, are available in the separate |
| 'libutil' library, and declared in 'utmp.h'. |
| |
| Note that the 'ut_user' member of 'struct utmp' is called 'ut_name' |
| in BSD. Therefore, 'ut_name' is defined as an alias for 'ut_user' in |
| 'utmp.h'. |
| |
| -- Function: int login_tty (int FILEDES) |
| Preliminary: | MT-Unsafe race:ttyname | AS-Unsafe heap lock | |
| AC-Unsafe lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function makes FILEDES the controlling terminal of the current |
| process, redirects standard input, standard output and standard |
| error output to this terminal, and closes FILEDES. |
| |
| This function returns '0' on successful completion, and '-1' on |
| error. |
| |
| -- Function: void login (const struct utmp *ENTRY) |
| Preliminary: | MT-Unsafe race:utent sig:ALRM timer | AS-Unsafe lock |
| heap | AC-Unsafe lock corrupt fd mem | *Note POSIX Safety |
| Concepts::. |
| |
| The 'login' functions inserts an entry into the user accounting |
| database. The 'ut_line' member is set to the name of the terminal |
| on standard input. If standard input is not a terminal 'login' |
| uses standard output or standard error output to determine the name |
| of the terminal. If 'struct utmp' has a 'ut_type' member, 'login' |
| sets it to 'USER_PROCESS', and if there is an 'ut_pid' member, it |
| will be set to the process ID of the current process. The |
| remaining entries are copied from ENTRY. |
| |
| A copy of the entry is written to the user accounting log file. |
| |
| -- Function: int logout (const char *UT_LINE) |
| Preliminary: | MT-Unsafe race:utent sig:ALRM timer | AS-Unsafe lock |
| heap | AC-Unsafe lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function modifies the user accounting database to indicate |
| that the user on UT_LINE has logged out. |
| |
| The 'logout' function returns '1' if the entry was successfully |
| written to the database, or '0' on error. |
| |
| -- Function: void logwtmp (const char *UT_LINE, const char *UT_NAME, |
| const char *UT_HOST) |
| Preliminary: | MT-Unsafe sig:ALRM timer | AS-Unsafe | AC-Unsafe fd |
| | *Note POSIX Safety Concepts::. |
| |
| The 'logwtmp' function appends an entry to the user accounting log |
| file, for the current time and the information provided in the |
| UT_LINE, UT_NAME and UT_HOST arguments. |
| |
| *Portability Note:* The BSD 'struct utmp' only has the 'ut_line', |
| 'ut_name', 'ut_host' and 'ut_time' members. Older systems do not even |
| have the 'ut_host' member. |
| |
| |
| File: libc.info, Node: User Database, Next: Group Database, Prev: User Accounting Database, Up: Users and Groups |
| |
| 30.13 User Database |
| =================== |
| |
| This section describes how to search and scan the database of registered |
| users. The database itself is kept in the file '/etc/passwd' on most |
| systems, but on some systems a special network server gives access to |
| it. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: User Data Structure, Next: Lookup User, Up: User Database |
| |
| 30.13.1 The Data Structure that Describes a User |
| ------------------------------------------------ |
| |
| The functions and data structures for accessing the system user database |
| are declared in the header file 'pwd.h'. |
| |
| -- Data Type: struct passwd |
| The 'passwd' data structure is used to hold information about |
| entries in the system user data base. It has at least the |
| following members: |
| |
| 'char *pw_name' |
| The user's login name. |
| |
| 'char *pw_passwd.' |
| The encrypted password string. |
| |
| 'uid_t pw_uid' |
| The user ID number. |
| |
| 'gid_t pw_gid' |
| The user's default group ID number. |
| |
| 'char *pw_gecos' |
| A string typically containing the user's real name, and |
| possibly other information such as a phone number. |
| |
| 'char *pw_dir' |
| The user's home directory, or initial working directory. This |
| might be a null pointer, in which case the interpretation is |
| system-dependent. |
| |
| 'char *pw_shell' |
| The user's default shell, or the initial program run when the |
| user logs in. This might be a null pointer, indicating that |
| the system default should be used. |
| |
| |
| File: libc.info, Node: Lookup User, Next: Scanning All Users, Prev: User Data Structure, Up: User Database |
| |
| 30.13.2 Looking Up One User |
| --------------------------- |
| |
| You can search the system user database for information about a specific |
| user using 'getpwuid' or 'getpwnam'. These functions are declared in |
| 'pwd.h'. |
| |
| -- Function: struct passwd * getpwuid (uid_t UID) |
| Preliminary: | MT-Unsafe race:pwuid locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns a pointer to a statically-allocated structure |
| containing information about the user whose user ID is UID. This |
| structure may be overwritten on subsequent calls to 'getpwuid'. |
| |
| A null pointer value indicates there is no user in the data base |
| with user ID UID. |
| |
| -- Function: int getpwuid_r (uid_t UID, struct passwd *RESULT_BUF, char |
| *BUFFER, size_t BUFLEN, struct passwd **RESULT) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock | |
| AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function is similar to 'getpwuid' in that it returns |
| information about the user whose user ID is UID. However, it fills |
| the user supplied structure pointed to by RESULT_BUF with the |
| information instead of using a static buffer. The first BUFLEN |
| bytes of the additional buffer pointed to by BUFFER are used to |
| contain additional information, normally strings which are pointed |
| to by the elements of the result structure. |
| |
| If a user with ID UID is found, the pointer returned in RESULT |
| points to the record which contains the wanted data (i.e., RESULT |
| contains the value RESULT_BUF). If no user is found or if an error |
| occurred, the pointer returned in RESULT is a null pointer. The |
| function returns zero or an error code. If the buffer BUFFER is |
| too small to contain all the needed information, the error code |
| 'ERANGE' is returned and ERRNO is set to 'ERANGE'. |
| |
| -- Function: struct passwd * getpwnam (const char *NAME) |
| Preliminary: | MT-Unsafe race:pwnam locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns a pointer to a statically-allocated structure |
| containing information about the user whose user name is NAME. |
| This structure may be overwritten on subsequent calls to |
| 'getpwnam'. |
| |
| A null pointer return indicates there is no user named NAME. |
| |
| -- Function: int getpwnam_r (const char *NAME, struct passwd |
| *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd |
| **RESULT) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock | |
| AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function is similar to 'getpwnam' in that is returns |
| information about the user whose user name is NAME. However, like |
| 'getpwuid_r', it fills the user supplied buffers in RESULT_BUF and |
| BUFFER with the information instead of using a static buffer. |
| |
| The return values are the same as for 'getpwuid_r'. |
| |
| |
| File: libc.info, Node: Scanning All Users, Next: Writing a User Entry, Prev: Lookup User, Up: User Database |
| |
| 30.13.3 Scanning the List of All Users |
| -------------------------------------- |
| |
| This section explains how a program can read the list of all users in |
| the system, one user at a time. The functions described here are |
| declared in 'pwd.h'. |
| |
| You can use the 'fgetpwent' function to read user entries from a |
| particular file. |
| |
| -- Function: struct passwd * fgetpwent (FILE *STREAM) |
| Preliminary: | MT-Unsafe race:fpwent | AS-Unsafe corrupt lock | |
| AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. |
| |
| This function reads the next user entry from STREAM and returns a |
| pointer to the entry. The structure is statically allocated and is |
| rewritten on subsequent calls to 'fgetpwent'. You must copy the |
| contents of the structure if you wish to save the information. |
| |
| The stream must correspond to a file in the same format as the |
| standard password database file. |
| |
| -- Function: int fgetpwent_r (FILE *STREAM, struct passwd *RESULT_BUF, |
| char *BUFFER, size_t BUFLEN, struct passwd **RESULT) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock |
| | *Note POSIX Safety Concepts::. |
| |
| This function is similar to 'fgetpwent' in that it reads the next |
| user entry from STREAM. But the result is returned in the |
| structure pointed to by RESULT_BUF. The first BUFLEN bytes of the |
| additional buffer pointed to by BUFFER are used to contain |
| additional information, normally strings which are pointed to by |
| the elements of the result structure. |
| |
| The stream must correspond to a file in the same format as the |
| standard password database file. |
| |
| If the function returns zero RESULT points to the structure with |
| the wanted data (normally this is in RESULT_BUF). If errors |
| occurred the return value is nonzero and RESULT contains a null |
| pointer. |
| |
| The way to scan all the entries in the user database is with |
| 'setpwent', 'getpwent', and 'endpwent'. |
| |
| -- Function: void setpwent (void) |
| Preliminary: | MT-Unsafe race:pwent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function initializes a stream which 'getpwent' and |
| 'getpwent_r' use to read the user database. |
| |
| -- Function: struct passwd * getpwent (void) |
| Preliminary: | MT-Unsafe race:pwent race:pwentbuf locale | |
| AS-Unsafe dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem | |
| *Note POSIX Safety Concepts::. |
| |
| The 'getpwent' function reads the next entry from the stream |
| initialized by 'setpwent'. It returns a pointer to the entry. The |
| structure is statically allocated and is rewritten on subsequent |
| calls to 'getpwent'. You must copy the contents of the structure |
| if you wish to save the information. |
| |
| A null pointer is returned when no more entries are available. |
| |
| -- Function: int getpwent_r (struct passwd *RESULT_BUF, char *BUFFER, |
| size_t BUFLEN, struct passwd **RESULT) |
| Preliminary: | MT-Unsafe race:pwent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function is similar to 'getpwent' in that it returns the next |
| entry from the stream initialized by 'setpwent'. Like |
| 'fgetpwent_r', it uses the user-supplied buffers in RESULT_BUF and |
| BUFFER to return the information requested. |
| |
| The return values are the same as for 'fgetpwent_r'. |
| |
| -- Function: void endpwent (void) |
| Preliminary: | MT-Unsafe race:pwent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function closes the internal stream used by 'getpwent' or |
| 'getpwent_r'. |
| |
| |
| File: libc.info, Node: Writing a User Entry, Prev: Scanning All Users, Up: User Database |
| |
| 30.13.4 Writing a User Entry |
| ---------------------------- |
| |
| -- Function: int putpwent (const struct passwd *P, FILE *STREAM) |
| Preliminary: | MT-Safe locale | AS-Unsafe corrupt | AC-Unsafe lock |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| This function writes the user entry '*P' to the stream STREAM, in |
| the format used for the standard user database file. The return |
| value is zero on success and nonzero on failure. |
| |
| This function exists for compatibility with SVID. We recommend that |
| you avoid using it, because it makes sense only on the assumption |
| that the 'struct passwd' structure has no members except the |
| standard ones; on a system which merges the traditional Unix data |
| base with other extended information about users, adding an entry |
| using this function would inevitably leave out much of the |
| important information. |
| |
| The group and user ID fields are left empty if the group or user |
| name starts with a - or +. |
| |
| The function 'putpwent' is declared in 'pwd.h'. |
| |
| |
| File: libc.info, Node: Group Database, Next: Database Example, Prev: User Database, Up: Users and Groups |
| |
| 30.14 Group Database |
| ==================== |
| |
| This section describes how to search and scan the database of registered |
| groups. The database itself is kept in the file '/etc/group' on most |
| systems, but on some systems a special network service provides access |
| to it. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Group Data Structure, Next: Lookup Group, Up: Group Database |
| |
| 30.14.1 The Data Structure for a Group |
| -------------------------------------- |
| |
| The functions and data structures for accessing the system group |
| database are declared in the header file 'grp.h'. |
| |
| -- Data Type: struct group |
| The 'group' structure is used to hold information about an entry in |
| the system group database. It has at least the following members: |
| |
| 'char *gr_name' |
| The name of the group. |
| |
| 'gid_t gr_gid' |
| The group ID of the group. |
| |
| 'char **gr_mem' |
| A vector of pointers to the names of users in the group. Each |
| user name is a null-terminated string, and the vector itself |
| is terminated by a null pointer. |
| |
| |
| File: libc.info, Node: Lookup Group, Next: Scanning All Groups, Prev: Group Data Structure, Up: Group Database |
| |
| 30.14.2 Looking Up One Group |
| ---------------------------- |
| |
| You can search the group database for information about a specific group |
| using 'getgrgid' or 'getgrnam'. These functions are declared in |
| 'grp.h'. |
| |
| -- Function: struct group * getgrgid (gid_t GID) |
| Preliminary: | MT-Unsafe race:grgid locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns a pointer to a statically-allocated structure |
| containing information about the group whose group ID is GID. This |
| structure may be overwritten by subsequent calls to 'getgrgid'. |
| |
| A null pointer indicates there is no group with ID GID. |
| |
| -- Function: int getgrgid_r (gid_t GID, struct group *RESULT_BUF, char |
| *BUFFER, size_t BUFLEN, struct group **RESULT) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock | |
| AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function is similar to 'getgrgid' in that it returns |
| information about the group whose group ID is GID. However, it |
| fills the user supplied structure pointed to by RESULT_BUF with the |
| information instead of using a static buffer. The first BUFLEN |
| bytes of the additional buffer pointed to by BUFFER are used to |
| contain additional information, normally strings which are pointed |
| to by the elements of the result structure. |
| |
| If a group with ID GID is found, the pointer returned in RESULT |
| points to the record which contains the wanted data (i.e., RESULT |
| contains the value RESULT_BUF). If no group is found or if an |
| error occurred, the pointer returned in RESULT is a null pointer. |
| The function returns zero or an error code. If the buffer BUFFER |
| is too small to contain all the needed information, the error code |
| 'ERANGE' is returned and ERRNO is set to 'ERANGE'. |
| |
| -- Function: struct group * getgrnam (const char *NAME) |
| Preliminary: | MT-Unsafe race:grnam locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns a pointer to a statically-allocated structure |
| containing information about the group whose group name is NAME. |
| This structure may be overwritten by subsequent calls to |
| 'getgrnam'. |
| |
| A null pointer indicates there is no group named NAME. |
| |
| -- Function: int getgrnam_r (const char *NAME, struct group |
| *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group |
| **RESULT) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock | |
| AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function is similar to 'getgrnam' in that is returns |
| information about the group whose group name is NAME. Like |
| 'getgrgid_r', it uses the user supplied buffers in RESULT_BUF and |
| BUFFER, not a static buffer. |
| |
| The return values are the same as for 'getgrgid_r' 'ERANGE'. |
| |
| |
| File: libc.info, Node: Scanning All Groups, Prev: Lookup Group, Up: Group Database |
| |
| 30.14.3 Scanning the List of All Groups |
| --------------------------------------- |
| |
| This section explains how a program can read the list of all groups in |
| the system, one group at a time. The functions described here are |
| declared in 'grp.h'. |
| |
| You can use the 'fgetgrent' function to read group entries from a |
| particular file. |
| |
| -- Function: struct group * fgetgrent (FILE *STREAM) |
| Preliminary: | MT-Unsafe race:fgrent | AS-Unsafe corrupt lock | |
| AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. |
| |
| The 'fgetgrent' function reads the next entry from STREAM. It |
| returns a pointer to the entry. The structure is statically |
| allocated and is overwritten on subsequent calls to 'fgetgrent'. |
| You must copy the contents of the structure if you wish to save the |
| information. |
| |
| The stream must correspond to a file in the same format as the |
| standard group database file. |
| |
| -- Function: int fgetgrent_r (FILE *STREAM, struct group *RESULT_BUF, |
| char *BUFFER, size_t BUFLEN, struct group **RESULT) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock |
| | *Note POSIX Safety Concepts::. |
| |
| This function is similar to 'fgetgrent' in that it reads the next |
| user entry from STREAM. But the result is returned in the |
| structure pointed to by RESULT_BUF. The first BUFLEN bytes of the |
| additional buffer pointed to by BUFFER are used to contain |
| additional information, normally strings which are pointed to by |
| the elements of the result structure. |
| |
| This stream must correspond to a file in the same format as the |
| standard group database file. |
| |
| If the function returns zero RESULT points to the structure with |
| the wanted data (normally this is in RESULT_BUF). If errors |
| occurred the return value is non-zero and RESULT contains a null |
| pointer. |
| |
| The way to scan all the entries in the group database is with |
| 'setgrent', 'getgrent', and 'endgrent'. |
| |
| -- Function: void setgrent (void) |
| Preliminary: | MT-Unsafe race:grent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function initializes a stream for reading from the group data |
| base. You use this stream by calling 'getgrent' or 'getgrent_r'. |
| |
| -- Function: struct group * getgrent (void) |
| Preliminary: | MT-Unsafe race:grent race:grentbuf locale | |
| AS-Unsafe dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem | |
| *Note POSIX Safety Concepts::. |
| |
| The 'getgrent' function reads the next entry from the stream |
| initialized by 'setgrent'. It returns a pointer to the entry. The |
| structure is statically allocated and is overwritten on subsequent |
| calls to 'getgrent'. You must copy the contents of the structure |
| if you wish to save the information. |
| |
| -- Function: int getgrent_r (struct group *RESULT_BUF, char *BUFFER, |
| size_t BUFLEN, struct group **RESULT) |
| Preliminary: | MT-Unsafe race:grent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function is similar to 'getgrent' in that it returns the next |
| entry from the stream initialized by 'setgrent'. Like |
| 'fgetgrent_r', it places the result in user-supplied buffers |
| pointed to RESULT_BUF and BUFFER. |
| |
| If the function returns zero RESULT contains a pointer to the data |
| (normally equal to RESULT_BUF). If errors occurred the return |
| value is non-zero and RESULT contains a null pointer. |
| |
| -- Function: void endgrent (void) |
| Preliminary: | MT-Unsafe race:grent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function closes the internal stream used by 'getgrent' or |
| 'getgrent_r'. |
| |
| |
| File: libc.info, Node: Database Example, Next: Netgroup Database, Prev: Group Database, Up: Users and Groups |
| |
| 30.15 User and Group Database Example |
| ===================================== |
| |
| Here is an example program showing the use of the system database |
| inquiry functions. The program prints some information about the user |
| running the program. |
| |
| |
| #include <grp.h> |
| #include <pwd.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| #include <stdlib.h> |
| |
| int |
| main (void) |
| { |
| uid_t me; |
| struct passwd *my_passwd; |
| struct group *my_group; |
| char **members; |
| |
| /* Get information about the user ID. */ |
| me = getuid (); |
| my_passwd = getpwuid (me); |
| if (!my_passwd) |
| { |
| printf ("Couldn't find out about user %d.\n", (int) me); |
| exit (EXIT_FAILURE); |
| } |
| |
| /* Print the information. */ |
| printf ("I am %s.\n", my_passwd->pw_gecos); |
| printf ("My login name is %s.\n", my_passwd->pw_name); |
| printf ("My uid is %d.\n", (int) (my_passwd->pw_uid)); |
| printf ("My home directory is %s.\n", my_passwd->pw_dir); |
| printf ("My default shell is %s.\n", my_passwd->pw_shell); |
| |
| /* Get information about the default group ID. */ |
| my_group = getgrgid (my_passwd->pw_gid); |
| if (!my_group) |
| { |
| printf ("Couldn't find out about group %d.\n", |
| (int) my_passwd->pw_gid); |
| exit (EXIT_FAILURE); |
| } |
| |
| /* Print the information. */ |
| printf ("My default group is %s (%d).\n", |
| my_group->gr_name, (int) (my_passwd->pw_gid)); |
| printf ("The members of this group are:\n"); |
| members = my_group->gr_mem; |
| while (*members) |
| { |
| printf (" %s\n", *(members)); |
| members++; |
| } |
| |
| return EXIT_SUCCESS; |
| } |
| |
| Here is some output from this program: |
| |
| I am Throckmorton Snurd. |
| My login name is snurd. |
| My uid is 31093. |
| My home directory is /home/fsg/snurd. |
| My default shell is /bin/sh. |
| My default group is guest (12). |
| The members of this group are: |
| friedman |
| tami |
| |
| |
| File: libc.info, Node: Netgroup Database, Prev: Database Example, Up: Users and Groups |
| |
| 30.16 Netgroup Database |
| ======================= |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Netgroup Data, Next: Lookup Netgroup, Up: Netgroup Database |
| |
| 30.16.1 Netgroup Data |
| --------------------- |
| |
| Sometimes it is useful to group users according to other criteria (*note |
| Group Database::). E.g., it is useful to associate a certain group of |
| users with a certain machine. On the other hand grouping of host names |
| is not supported so far. |
| |
| In Sun Microsystems SunOS appeared a new kind of database, the |
| netgroup database. It allows grouping hosts, users, and domains freely, |
| giving them individual names. To be more concrete, a netgroup is a list |
| of triples consisting of a host name, a user name, and a domain name |
| where any of the entries can be a wildcard entry matching all inputs. A |
| last possibility is that names of other netgroups can also be given in |
| the list specifying a netgroup. So one can construct arbitrary |
| hierarchies without loops. |
| |
| Sun's implementation allows netgroups only for the 'nis' or 'nisplus' |
| service, *note Services in the NSS configuration::. The implementation |
| in the GNU C Library has no such restriction. An entry in either of the |
| input services must have the following form: |
| |
| GROUPNAME ( GROUPNAME | (HOSTNAME,USERNAME,domainname) )+ |
| |
| Any of the fields in the triple can be empty which means anything |
| matches. While describing the functions we will see that the opposite |
| case is useful as well. I.e., there may be entries which will not match |
| any input. For entries like this, a name consisting of the single |
| character '-' shall be used. |
| |
| |
| File: libc.info, Node: Lookup Netgroup, Next: Netgroup Membership, Prev: Netgroup Data, Up: Netgroup Database |
| |
| 30.16.2 Looking up one Netgroup |
| ------------------------------- |
| |
| The lookup functions for netgroups are a bit different to all other |
| system database handling functions. Since a single netgroup can contain |
| many entries a two-step process is needed. First a single netgroup is |
| selected and then one can iterate over all entries in this netgroup. |
| These functions are declared in 'netdb.h'. |
| |
| -- Function: int setnetgrent (const char *NETGROUP) |
| Preliminary: | MT-Unsafe race:netgrent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| A call to this function initializes the internal state of the |
| library to allow following calls of the 'getnetgrent' to iterate |
| over all entries in the netgroup with name NETGROUP. |
| |
| When the call is successful (i.e., when a netgroup with this name |
| exists) the return value is '1'. When the return value is '0' no |
| netgroup of this name is known or some other error occurred. |
| |
| It is important to remember that there is only one single state for |
| iterating the netgroups. Even if the programmer uses the |
| 'getnetgrent_r' function the result is not really reentrant since always |
| only one single netgroup at a time can be processed. If the program |
| needs to process more than one netgroup simultaneously she must protect |
| this by using external locking. This problem was introduced in the |
| original netgroups implementation in SunOS and since we must stay |
| compatible it is not possible to change this. |
| |
| Some other functions also use the netgroups state. Currently these |
| are the 'innetgr' function and parts of the implementation of the |
| 'compat' service part of the NSS implementation. |
| |
| -- Function: int getnetgrent (char **HOSTP, char **USERP, char |
| **DOMAINP) |
| Preliminary: | MT-Unsafe race:netgrent race:netgrentbuf locale | |
| AS-Unsafe dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem | |
| *Note POSIX Safety Concepts::. |
| |
| This function returns the next unprocessed entry of the currently |
| selected netgroup. The string pointers, in which addresses are |
| passed in the arguments HOSTP, USERP, and DOMAINP, will contain |
| after a successful call pointers to appropriate strings. If the |
| string in the next entry is empty the pointer has the value 'NULL'. |
| The returned string pointers are only valid if none of the netgroup |
| related functions are called. |
| |
| The return value is '1' if the next entry was successfully read. A |
| value of '0' means no further entries exist or internal errors |
| occurred. |
| |
| -- Function: int getnetgrent_r (char **HOSTP, char **USERP, char |
| **DOMAINP, char *BUFFER, size_t BUFLEN) |
| Preliminary: | MT-Unsafe race:netgrent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function is similar to 'getnetgrent' with only one exception: |
| the strings the three string pointers HOSTP, USERP, and DOMAINP |
| point to, are placed in the buffer of BUFLEN bytes starting at |
| BUFFER. This means the returned values are valid even after other |
| netgroup related functions are called. |
| |
| The return value is '1' if the next entry was successfully read and |
| the buffer contains enough room to place the strings in it. '0' is |
| returned in case no more entries are found, the buffer is too |
| small, or internal errors occurred. |
| |
| This function is a GNU extension. The original implementation in |
| the SunOS libc does not provide this function. |
| |
| -- Function: void endnetgrent (void) |
| Preliminary: | MT-Unsafe race:netgrent | AS-Unsafe dlopen plugin |
| heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX Safety |
| Concepts::. |
| |
| This function frees all buffers which were allocated to process the |
| last selected netgroup. As a result all string pointers returned |
| by calls to 'getnetgrent' are invalid afterwards. |
| |
| |
| File: libc.info, Node: Netgroup Membership, Prev: Lookup Netgroup, Up: Netgroup Database |
| |
| 30.16.3 Testing for Netgroup Membership |
| --------------------------------------- |
| |
| It is often not necessary to scan the whole netgroup since often the |
| only interesting question is whether a given entry is part of the |
| selected netgroup. |
| |
| -- Function: int innetgr (const char *NETGROUP, const char *HOST, const |
| char *USER, const char *DOMAIN) |
| Preliminary: | MT-Unsafe race:netgrent locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function tests whether the triple specified by the parameters |
| HOSTP, USERP, and DOMAINP is part of the netgroup NETGROUP. Using |
| this function has the advantage that |
| |
| 1. no other netgroup function can use the global netgroup state |
| since internal locking is used and |
| 2. the function is implemented more efficiently than successive |
| calls to the other 'set'/'get'/'endnetgrent' functions. |
| |
| Any of the pointers HOSTP, USERP, and DOMAINP can be 'NULL' which |
| means any value is accepted in this position. This is also true |
| for the name '-' which should not match any other string otherwise. |
| |
| The return value is '1' if an entry matching the given triple is |
| found in the netgroup. The return value is '0' if the netgroup |
| itself is not found, the netgroup does not contain the triple or |
| internal errors occurred. |
| |
| |
| File: libc.info, Node: System Management, Next: System Configuration, Prev: Users and Groups, Up: Top |
| |
| 31 System Management |
| ******************** |
| |
| This chapter describes facilities for controlling the system that |
| underlies a process (including the operating system and hardware) and |
| for getting information about it. Anyone can generally use the |
| informational facilities, but usually only a properly privileged process |
| can make changes. |
| |
| * Menu: |
| |
| * 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 |
| |
| To get information on parameters of the system that are built into |
| the system, such as the maximum length of a filename, *note System |
| Configuration::. |
| |
| |
| File: libc.info, Node: Host Identification, Next: Platform Type, Up: System Management |
| |
| 31.1 Host Identification |
| ======================== |
| |
| This section explains how to identify the particular system on which |
| your program is running. First, let's review the various ways computer |
| systems are named, which is a little complicated because of the history |
| of the development of the Internet. |
| |
| Every Unix system (also known as a host) has a host name, whether |
| it's connected to a network or not. In its simplest form, as used |
| before computer networks were an issue, it's just a word like 'chicken'. |
| |
| But any system attached to the Internet or any network like it |
| conforms to a more rigorous naming convention as part of the Domain Name |
| System (DNS). In DNS, every host name is composed of two parts: |
| |
| 1. hostname |
| 2. domain name |
| |
| You will note that "hostname" looks a lot like "host name", but is |
| not the same thing, and that people often incorrectly refer to entire |
| host names as "domain names." |
| |
| In DNS, the full host name is properly called the FQDN (Fully |
| Qualified Domain Name) and consists of the hostname, then a period, then |
| the domain name. The domain name itself usually has multiple components |
| separated by periods. So for example, a system's hostname may be |
| 'chicken' and its domain name might be 'ai.mit.edu', so its FQDN (which |
| is its host name) is 'chicken.ai.mit.edu'. |
| |
| Adding to the confusion, though, is that DNS is not the only name |
| space in which a computer needs to be known. Another name space is the |
| NIS (aka YP) name space. For NIS purposes, there is another domain |
| name, which is called the NIS domain name or the YP domain name. It |
| need not have anything to do with the DNS domain name. |
| |
| Confusing things even more is the fact that in DNS, it is possible |
| for multiple FQDNs to refer to the same system. However, there is |
| always exactly one of them that is the true host name, and it is called |
| the canonical FQDN. |
| |
| In some contexts, the host name is called a "node name." |
| |
| For more information on DNS host naming, see *note Host Names::. |
| |
| Prototypes for these functions appear in 'unistd.h'. |
| |
| The programs 'hostname', 'hostid', and 'domainname' work by calling |
| these functions. |
| |
| -- Function: int gethostname (char *NAME, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns the host name of the system on which it is |
| called, in the array NAME. The SIZE argument specifies the size of |
| this array, in bytes. Note that this is _not_ the DNS hostname. |
| If the system participates in DNS, this is the FQDN (see above). |
| |
| The return value is '0' on success and '-1' on failure. In the GNU |
| C Library, 'gethostname' fails if SIZE is not large enough; then |
| you can try again with a larger array. The following 'errno' error |
| condition is defined for this function: |
| |
| 'ENAMETOOLONG' |
| The SIZE argument is less than the size of the host name plus |
| one. |
| |
| On some systems, there is a symbol for the maximum possible host |
| name length: 'MAXHOSTNAMELEN'. It is defined in 'sys/param.h'. |
| But you can't count on this to exist, so it is cleaner to handle |
| failure and try again. |
| |
| 'gethostname' stores the beginning of the host name in NAME even if |
| the host name won't entirely fit. For some purposes, a truncated |
| host name is good enough. If it is, you can ignore the error code. |
| |
| -- Function: int sethostname (const char *NAME, size_t LENGTH) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'sethostname' function sets the host name of the system that |
| calls it to NAME, a string with length LENGTH. Only privileged |
| processes are permitted to do this. |
| |
| Usually 'sethostname' gets called just once, at system boot time. |
| Often, the program that calls it sets it to the value it finds in |
| the file '/etc/hostname'. |
| |
| Be sure to set the host name to the full host name, not just the |
| DNS hostname (see above). |
| |
| The return value is '0' on success and '-1' on failure. The |
| following 'errno' error condition is defined for this function: |
| |
| 'EPERM' |
| This process cannot set the host name because it is not |
| privileged. |
| |
| -- Function: int getdomainnname (char *NAME, size_t LENGTH) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'getdomainname' returns the NIS (aka YP) domain name of the system |
| on which it is called. Note that this is not the more popular DNS |
| domain name. Get that with 'gethostname'. |
| |
| The specifics of this function are analogous to 'gethostname', |
| above. |
| |
| -- Function: int setdomainname (const char *NAME, size_t LENGTH) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'getdomainname' sets the NIS (aka YP) domain name of the system on |
| which it is called. Note that this is not the more popular DNS |
| domain name. Set that with 'sethostname'. |
| |
| The specifics of this function are analogous to 'sethostname', |
| above. |
| |
| -- Function: long int gethostid (void) |
| Preliminary: | MT-Safe hostid env locale | AS-Unsafe dlopen plugin |
| corrupt heap lock | AC-Unsafe lock corrupt mem fd | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns the "host ID" of the machine the program is |
| running on. By convention, this is usually the primary Internet IP |
| address of that machine, converted to a 'long int'. However, on |
| some systems it is a meaningless but unique number which is |
| hard-coded for each machine. |
| |
| This is not widely used. It arose in BSD 4.2, but was dropped in |
| BSD 4.4. It is not required by POSIX. |
| |
| The proper way to query the IP address is to use 'gethostbyname' on |
| the results of 'gethostname'. For more information on IP |
| addresses, *Note Host Addresses::. |
| |
| -- Function: int sethostid (long int ID) |
| Preliminary: | MT-Unsafe const:hostid | AS-Unsafe | AC-Unsafe |
| corrupt fd | *Note POSIX Safety Concepts::. |
| |
| The 'sethostid' function sets the "host ID" of the host machine to |
| ID. Only privileged processes are permitted to do this. Usually |
| it happens just once, at system boot time. |
| |
| The proper way to establish the primary IP address of a system is |
| to configure the IP address resolver to associate that IP address |
| with the system's host name as returned by 'gethostname'. For |
| example, put a record for the system in '/etc/hosts'. |
| |
| See 'gethostid' above for more information on host ids. |
| |
| The return value is '0' on success and '-1' on failure. The |
| following 'errno' error conditions are defined for this function: |
| |
| 'EPERM' |
| This process cannot set the host name because it is not |
| privileged. |
| |
| 'ENOSYS' |
| The operating system does not support setting the host ID. On |
| some systems, the host ID is a meaningless but unique number |
| hard-coded for each machine. |
| |
| |
| File: libc.info, Node: Platform Type, Next: Filesystem Handling, Prev: Host Identification, Up: System Management |
| |
| 31.2 Platform Type Identification |
| ================================= |
| |
| You can use the 'uname' function to find out some information about the |
| type of computer your program is running on. This function and the |
| associated data type are declared in the header file 'sys/utsname.h'. |
| |
| As a bonus, 'uname' also gives some information identifying the |
| particular system your program is running on. This is the same |
| information which you can get with functions targeted to this purpose |
| described in *note Host Identification::. |
| |
| -- Data Type: struct utsname |
| The 'utsname' structure is used to hold information returned by the |
| 'uname' function. It has the following members: |
| |
| 'char sysname[]' |
| This is the name of the operating system in use. |
| |
| 'char release[]' |
| This is the current release level of the operating system |
| implementation. |
| |
| 'char version[]' |
| This is the current version level within the release of the |
| operating system. |
| |
| 'char machine[]' |
| This is a description of the type of hardware that is in use. |
| |
| Some systems provide a mechanism to interrogate the kernel |
| directly for this information. On systems without such a |
| mechanism, the GNU C Library fills in this field based on the |
| configuration name that was specified when building and |
| installing the library. |
| |
| GNU uses a three-part name to describe a system configuration; |
| the three parts are CPU, MANUFACTURER and SYSTEM-TYPE, and |
| they are separated with dashes. Any possible combination of |
| three names is potentially meaningful, but most such |
| combinations are meaningless in practice and even the |
| meaningful ones are not necessarily supported by any |
| particular GNU program. |
| |
| Since the value in 'machine' is supposed to describe just the |
| hardware, it consists of the first two parts of the |
| configuration name: 'CPU-MANUFACTURER'. For example, it might |
| be one of these: |
| |
| '"sparc-sun"', '"i386-ANYTHING"', '"m68k-hp"', |
| '"m68k-sony"', '"m68k-sun"', '"mips-dec"' |
| |
| 'char nodename[]' |
| This is the host name of this particular computer. In the GNU |
| C Library, the value is the same as that returned by |
| 'gethostname'; see *note Host Identification::. |
| |
| gethostname() is implemented with a call to uname(). |
| |
| 'char domainname[]' |
| This is the NIS or YP domain name. It is the same value |
| returned by 'getdomainname'; see *note Host Identification::. |
| This element is a relatively recent invention and use of it is |
| not as portable as use of the rest of the structure. |
| |
| -- Function: int uname (struct utsname *INFO) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'uname' function fills in the structure pointed to by INFO with |
| information about the operating system and host machine. A |
| non-negative value indicates that the data was successfully stored. |
| |
| '-1' as the value indicates an error. The only error possible is |
| 'EFAULT', which we normally don't mention as it is always a |
| possibility. |
| |
| |
| File: libc.info, Node: Filesystem Handling, Next: System Parameters, Prev: Platform Type, Up: System Management |
| |
| 31.3 Controlling and Querying Mounts |
| ==================================== |
| |
| All files are in filesystems, and before you can access any file, its |
| filesystem must be mounted. Because of Unix's concept of _Everything is |
| a file_, mounting of filesystems is central to doing almost anything. |
| This section explains how to find out what filesystems are currently |
| mounted and what filesystems are available for mounting, and how to |
| change what is mounted. |
| |
| The classic filesystem is the contents of a disk drive. The concept |
| is considerably more abstract, though, and lots of things other than |
| disk drives can be mounted. |
| |
| Some block devices don't correspond to traditional devices like disk |
| drives. For example, a loop device is a block device whose driver uses |
| a regular file in another filesystem as its medium. So if that regular |
| file contains appropriate data for a filesystem, you can by mounting the |
| loop device essentially mount a regular file. |
| |
| Some filesystems aren't based on a device of any kind. The "proc" |
| filesystem, for example, contains files whose data is made up by the |
| filesystem driver on the fly whenever you ask for it. And when you |
| write to it, the data you write causes changes in the system. No data |
| gets stored. |
| |
| * Menu: |
| |
| * Mount Information:: What is or could be mounted? |
| * Mount-Unmount-Remount:: Controlling what is mounted and how |
| |
| |
| File: libc.info, Node: Mount Information, Next: Mount-Unmount-Remount, Up: Filesystem Handling |
| |
| 31.3.1 Mount Information |
| ------------------------ |
| |
| For some programs it is desirable and necessary to access information |
| about whether a certain filesystem is mounted and, if it is, where, or |
| simply to get lists of all the available filesystems. The GNU C Library |
| provides some functions to retrieve this information portably. |
| |
| Traditionally Unix systems have a file named '/etc/fstab' which |
| describes all possibly mounted filesystems. The 'mount' program uses |
| this file to mount at startup time of the system all the necessary |
| filesystems. The information about all the filesystems actually mounted |
| is normally kept in a file named either '/var/run/mtab' or '/etc/mtab'. |
| Both files share the same syntax and it is crucial that this syntax is |
| followed all the time. Therefore it is best to never directly write the |
| files. The functions described in this section can do this and they |
| also provide the functionality to convert the external textual |
| representation to the internal representation. |
| |
| Note that the 'fstab' and 'mtab' files are maintained on a system by |
| _convention_. It is possible for the files not to exist or not to be |
| consistent with what is really mounted or available to mount, if the |
| system's administration policy allows it. But programs that mount and |
| unmount filesystems typically maintain and use these files as described |
| herein. |
| |
| The filenames given above should never be used directly. The |
| portable way to handle these file is to use the macro '_PATH_FSTAB', |
| defined in 'fstab.h', or '_PATH_MNTTAB', defined in 'mntent.h' and |
| 'paths.h', for 'fstab'; and the macro '_PATH_MOUNTED', also defined in |
| 'mntent.h' and 'paths.h', for 'mtab'. There are also two alternate |
| macro names 'FSTAB', 'MNTTAB', and 'MOUNTED' defined but these names are |
| deprecated and kept only for backward compatibility. The names |
| '_PATH_MNTTAB' and '_PATH_MOUNTED' should always be used. |
| |
| * Menu: |
| |
| * fstab:: The 'fstab' file |
| * mtab:: The 'mtab' file |
| * Other Mount Information:: Other (non-libc) sources of mount information |
| |
| |
| File: libc.info, Node: fstab, Next: mtab, Up: Mount Information |
| |
| 31.3.1.1 The 'fstab' file |
| ......................... |
| |
| The internal representation for entries of the file is 'struct fstab', |
| defined in 'fstab.h'. |
| |
| -- Data Type: struct fstab |
| This structure is used with the 'getfsent', 'getfsspec', and |
| 'getfsfile' functions. |
| |
| 'char *fs_spec' |
| This element describes the device from which the filesystem is |
| mounted. Normally this is the name of a special device, such |
| as a hard disk partition, but it could also be a more or less |
| generic string. For "NFS" it would be a hostname and |
| directory name combination. |
| |
| Even though the element is not declared 'const' it shouldn't |
| be modified. The missing 'const' has historic reasons, since |
| this function predates ISO C. The same is true for the other |
| string elements of this structure. |
| |
| 'char *fs_file' |
| This describes the mount point on the local system. I.e., |
| accessing any file in this filesystem has implicitly or |
| explicitly this string as a prefix. |
| |
| 'char *fs_vfstype' |
| This is the type of the filesystem. Depending on what the |
| underlying kernel understands it can be any string. |
| |
| 'char *fs_mntops' |
| This is a string containing options passed to the kernel with |
| the 'mount' call. Again, this can be almost anything. There |
| can be more than one option, separated from the others by a |
| comma. Each option consists of a name and an optional value |
| part, introduced by an '=' character. |
| |
| If the value of this element must be processed it should |
| ideally be done using the 'getsubopt' function; see *note |
| Suboptions::. |
| |
| 'const char *fs_type' |
| This name is poorly chosen. This element points to a string |
| (possibly in the 'fs_mntops' string) which describes the modes |
| with which the filesystem is mounted. 'fstab' defines five |
| macros to describe the possible values: |
| |
| 'FSTAB_RW' |
| The filesystems gets mounted with read and write enabled. |
| 'FSTAB_RQ' |
| The filesystems gets mounted with read and write enabled. |
| Write access is restricted by quotas. |
| 'FSTAB_RO' |
| The filesystem gets mounted read-only. |
| 'FSTAB_SW' |
| This is not a real filesystem, it is a swap device. |
| 'FSTAB_XX' |
| This entry from the 'fstab' file is totally ignored. |
| |
| Testing for equality with these value must happen using |
| 'strcmp' since these are all strings. Comparing the pointer |
| will probably always fail. |
| |
| 'int fs_freq' |
| This element describes the dump frequency in days. |
| |
| 'int fs_passno' |
| This element describes the pass number on parallel dumps. It |
| is closely related to the 'dump' utility used on Unix systems. |
| |
| To read the entire content of the of the 'fstab' file the GNU C |
| Library contains a set of three functions which are designed in the |
| usual way. |
| |
| -- Function: int setfsent (void) |
| Preliminary: | MT-Unsafe race:fsent | AS-Unsafe heap corrupt lock | |
| AC-Unsafe corrupt lock mem fd | *Note POSIX Safety Concepts::. |
| |
| This function makes sure that the internal read pointer for the |
| 'fstab' file is at the beginning of the file. This is done by |
| either opening the file or resetting the read pointer. |
| |
| Since the file handle is internal to the libc this function is not |
| thread-safe. |
| |
| This function returns a non-zero value if the operation was |
| successful and the 'getfs*' functions can be used to read the |
| entries of the file. |
| |
| -- Function: void endfsent (void) |
| Preliminary: | MT-Unsafe race:fsent | AS-Unsafe heap corrupt lock | |
| AC-Unsafe corrupt lock mem fd | *Note POSIX Safety Concepts::. |
| |
| This function makes sure that all resources acquired by a prior |
| call to 'setfsent' (explicitly or implicitly by calling 'getfsent') |
| are freed. |
| |
| -- Function: struct fstab * getfsent (void) |
| Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt heap |
| lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety Concepts::. |
| |
| This function returns the next entry of the 'fstab' file. If this |
| is the first call to any of the functions handling 'fstab' since |
| program start or the last call of 'endfsent', the file will be |
| opened. |
| |
| The function returns a pointer to a variable of type 'struct |
| fstab'. This variable is shared by all threads and therefore this |
| function is not thread-safe. If an error occurred 'getfsent' |
| returns a 'NULL' pointer. |
| |
| -- Function: struct fstab * getfsspec (const char *NAME) |
| Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt heap |
| lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety Concepts::. |
| |
| This function returns the next entry of the 'fstab' file which has |
| a string equal to NAME pointed to by the 'fs_spec' element. Since |
| there is normally exactly one entry for each special device it |
| makes no sense to call this function more than once for the same |
| argument. If this is the first call to any of the functions |
| handling 'fstab' since program start or the last call of |
| 'endfsent', the file will be opened. |
| |
| The function returns a pointer to a variable of type 'struct |
| fstab'. This variable is shared by all threads and therefore this |
| function is not thread-safe. If an error occurred 'getfsent' |
| returns a 'NULL' pointer. |
| |
| -- Function: struct fstab * getfsfile (const char *NAME) |
| Preliminary: | MT-Unsafe race:fsent locale | AS-Unsafe corrupt heap |
| lock | AC-Unsafe corrupt lock mem | *Note POSIX Safety Concepts::. |
| |
| This function returns the next entry of the 'fstab' file which has |
| a string equal to NAME pointed to by the 'fs_file' element. Since |
| there is normally exactly one entry for each mount point it makes |
| no sense to call this function more than once for the same |
| argument. If this is the first call to any of the functions |
| handling 'fstab' since program start or the last call of |
| 'endfsent', the file will be opened. |
| |
| The function returns a pointer to a variable of type 'struct |
| fstab'. This variable is shared by all threads and therefore this |
| function is not thread-safe. If an error occurred 'getfsent' |
| returns a 'NULL' pointer. |
| |
| |
| File: libc.info, Node: mtab, Next: Other Mount Information, Prev: fstab, Up: Mount Information |
| |
| 31.3.1.2 The 'mtab' file |
| ........................ |
| |
| The following functions and data structure access the 'mtab' file. |
| |
| -- Data Type: struct mntent |
| This structure is used with the 'getmntent', 'getmntent_t', |
| 'addmntent', and 'hasmntopt' functions. |
| |
| 'char *mnt_fsname' |
| This element contains a pointer to a string describing the |
| name of the special device from which the filesystem is |
| mounted. It corresponds to the 'fs_spec' element in 'struct |
| fstab'. |
| |
| 'char *mnt_dir' |
| This element points to a string describing the mount point of |
| the filesystem. It corresponds to the 'fs_file' element in |
| 'struct fstab'. |
| |
| 'char *mnt_type' |
| 'mnt_type' describes the filesystem type and is therefore |
| equivalent to 'fs_vfstype' in 'struct fstab'. 'mntent.h' |
| defines a few symbolic names for some of the values this |
| string can have. But since the kernel can support arbitrary |
| filesystems it does not make much sense to give them symbolic |
| names. If one knows the symbol name one also knows the |
| filesystem name. Nevertheless here follows the list of the |
| symbols provided in 'mntent.h'. |
| |
| 'MNTTYPE_IGNORE' |
| This symbol expands to '"ignore"'. The value is sometime |
| used in 'fstab' files to make sure entries are not used |
| without removing them. |
| 'MNTTYPE_NFS' |
| Expands to '"nfs"'. Using this macro sometimes could |
| make sense since it names the default NFS implementation, |
| in case both version 2 and 3 are supported. |
| 'MNTTYPE_SWAP' |
| This symbol expands to '"swap"'. It names the special |
| 'fstab' entry which names one of the possibly multiple |
| swap partitions. |
| |
| 'char *mnt_opts' |
| The element contains a string describing the options used |
| while mounting the filesystem. As for the equivalent element |
| 'fs_mntops' of 'struct fstab' it is best to use the function |
| 'getsubopt' (*note Suboptions::) to access the parts of this |
| string. |
| |
| The 'mntent.h' file defines a number of macros with string |
| values which correspond to some of the options understood by |
| the kernel. There might be many more options which are |
| possible so it doesn't make much sense to rely on these macros |
| but to be consistent here is the list: |
| |
| 'MNTOPT_DEFAULTS' |
| Expands to '"defaults"'. This option should be used |
| alone since it indicates all values for the customizable |
| values are chosen to be the default. |
| 'MNTOPT_RO' |
| Expands to '"ro"'. See the 'FSTAB_RO' value, it means |
| the filesystem is mounted read-only. |
| 'MNTOPT_RW' |
| Expand to '"rw"'. See the 'FSTAB_RW' value, it means the |
| filesystem is mounted with read and write permissions. |
| 'MNTOPT_SUID' |
| Expands to '"suid"'. This means that the SUID bit (*note |
| How Change Persona::) is respected when a program from |
| the filesystem is started. |
| 'MNTOPT_NOSUID' |
| Expands to '"nosuid"'. This is the opposite of |
| 'MNTOPT_SUID', the SUID bit for all files from the |
| filesystem is ignored. |
| 'MNTOPT_NOAUTO' |
| Expands to '"noauto"'. At startup time the 'mount' |
| program will ignore this entry if it is started with the |
| '-a' option to mount all filesystems mentioned in the |
| 'fstab' file. |
| |
| As for the 'FSTAB_*' entries introduced above it is important |
| to use 'strcmp' to check for equality. |
| |
| 'mnt_freq' |
| This elements corresponds to 'fs_freq' and also specifies the |
| frequency in days in which dumps are made. |
| |
| 'mnt_passno' |
| This element is equivalent to 'fs_passno' with the same |
| meaning which is uninteresting for all programs beside 'dump'. |
| |
| For accessing the 'mtab' file there is again a set of three functions |
| to access all entries in a row. Unlike the functions to handle 'fstab' |
| these functions do not access a fixed file and there is even a thread |
| safe variant of the get function. Beside this the GNU C Library |
| contains functions to alter the file and test for specific options. |
| |
| -- Function: FILE * setmntent (const char *FILE, const char *MODE) |
| Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe mem fd |
| lock | *Note POSIX Safety Concepts::. |
| |
| The 'setmntent' function prepares the file named FILE which must be |
| in the format of a 'fstab' and 'mtab' file for the upcoming |
| processing through the other functions of the family. The MODE |
| parameter can be chosen in the way the OPENTYPE parameter for |
| 'fopen' (*note Opening Streams::) can be chosen. If the file is |
| opened for writing the file is also allowed to be empty. |
| |
| If the file was successfully opened 'setmntent' returns a file |
| descriptor for future use. Otherwise the return value is 'NULL' |
| and 'errno' is set accordingly. |
| |
| -- Function: int endmntent (FILE *STREAM) |
| Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock mem |
| fd | *Note POSIX Safety Concepts::. |
| |
| This function takes for the STREAM parameter a file handle which |
| previously was returned from the 'setmntent' call. 'endmntent' |
| closes the stream and frees all resources. |
| |
| The return value is 1 unless an error occurred in which case it is |
| 0. |
| |
| -- Function: struct mntent * getmntent (FILE *STREAM) |
| Preliminary: | MT-Unsafe race:mntentbuf locale | AS-Unsafe corrupt |
| heap init | AC-Unsafe init corrupt lock mem | *Note POSIX Safety |
| Concepts::. |
| |
| The 'getmntent' function takes as the parameter a file handle |
| previously returned by successful call to 'setmntent'. It returns |
| a pointer to a static variable of type 'struct mntent' which is |
| filled with the information from the next entry from the file |
| currently read. |
| |
| The file format used prescribes the use of spaces or tab characters |
| to separate the fields. This makes it harder to use name |
| containing one of these characters (e.g., mount points using |
| spaces). Therefore these characters are encoded in the files and |
| the 'getmntent' function takes care of the decoding while reading |
| the entries back in. ''\040'' is used to encode a space character, |
| ''\011'' to encode a tab character, ''\012'' to encode a newline |
| character, and ''\\'' to encode a backslash. |
| |
| If there was an error or the end of the file is reached the return |
| value is 'NULL'. |
| |
| This function is not thread-safe since all calls to this function |
| return a pointer to the same static variable. 'getmntent_r' should |
| be used in situations where multiple threads access the file. |
| |
| -- Function: struct mntent * getmntent_r (FILE *STREAM, struct mntent |
| *RESULT, char *BUFFER, int BUFSIZE) |
| Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe |
| corrupt lock mem | *Note POSIX Safety Concepts::. |
| |
| The 'getmntent_r' function is the reentrant variant of 'getmntent'. |
| It also returns the next entry from the file and returns a pointer. |
| The actual variable the values are stored in is not static, though. |
| Instead the function stores the values in the variable pointed to |
| by the RESULT parameter. Additional information (e.g., the strings |
| pointed to by the elements of the result) are kept in the buffer of |
| size BUFSIZE pointed to by BUFFER. |
| |
| Escaped characters (space, tab, backslash) are converted back in |
| the same way as it happens for 'getmentent'. |
| |
| The function returns a 'NULL' pointer in error cases. Errors could |
| be: |
| * error while reading the file, |
| * end of file reached, |
| * BUFSIZE is too small for reading a complete new entry. |
| |
| -- Function: int addmntent (FILE *STREAM, const struct mntent *MNT) |
| Preliminary: | MT-Safe race:stream locale | AS-Unsafe corrupt | |
| AC-Unsafe corrupt | *Note POSIX Safety Concepts::. |
| |
| The 'addmntent' function allows adding a new entry to the file |
| previously opened with 'setmntent'. The new entries are always |
| appended. I.e., even if the position of the file descriptor is not |
| at the end of the file this function does not overwrite an existing |
| entry following the current position. |
| |
| The implication of this is that to remove an entry from a file one |
| has to create a new file while leaving out the entry to be removed |
| and after closing the file remove the old one and rename the new |
| file to the chosen name. |
| |
| This function takes care of spaces and tab characters in the names |
| to be written to the file. It converts them and the backslash |
| character into the format describe in the 'getmntent' description |
| above. |
| |
| This function returns 0 in case the operation was successful. |
| Otherwise the return value is 1 and 'errno' is set appropriately. |
| |
| -- Function: char * hasmntopt (const struct mntent *MNT, const char |
| *OPT) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function can be used to check whether the string pointed to by |
| the 'mnt_opts' element of the variable pointed to by MNT contains |
| the option OPT. If this is true a pointer to the beginning of the |
| option in the 'mnt_opts' element is returned. If no such option |
| exists the function returns 'NULL'. |
| |
| This function is useful to test whether a specific option is |
| present but when all options have to be processed one is better off |
| with using the 'getsubopt' function to iterate over all options in |
| the string. |
| |
| |
| File: libc.info, Node: Other Mount Information, Prev: mtab, Up: Mount Information |
| |
| 31.3.1.3 Other (Non-libc) Sources of Mount Information |
| ...................................................... |
| |
| On a system with a Linux kernel and the 'proc' filesystem, you can get |
| information on currently mounted filesystems from the file 'mounts' in |
| the 'proc' filesystem. Its format is similar to that of the 'mtab' |
| file, but represents what is truly mounted without relying on facilities |
| outside the kernel to keep 'mtab' up to date. |
| |
| |
| File: libc.info, Node: Mount-Unmount-Remount, Prev: Mount Information, Up: Filesystem Handling |
| |
| 31.3.2 Mount, Unmount, Remount |
| ------------------------------ |
| |
| This section describes the functions for mounting, unmounting, and |
| remounting filesystems. |
| |
| Only the superuser can mount, unmount, or remount a filesystem. |
| |
| These functions do not access the 'fstab' and 'mtab' files. You |
| should maintain and use these separately. *Note Mount Information::. |
| |
| The symbols in this section are declared in 'sys/mount.h'. |
| |
| -- Function: int mount (const char *SPECIAL_FILE, const char *DIR, |
| const char *FSTYPE, unsigned long int OPTIONS, const void |
| *DATA) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'mount' mounts or remounts a filesystem. The two operations are |
| quite different and are merged rather unnaturally into this one |
| function. The 'MS_REMOUNT' option, explained below, determines |
| whether 'mount' mounts or remounts. |
| |
| For a mount, the filesystem on the block device represented by the |
| device special file named SPECIAL_FILE gets mounted over the mount |
| point DIR. This means that the directory DIR (along with any files |
| in it) is no longer visible; in its place (and still with the name |
| DIR) is the root directory of the filesystem on the device. |
| |
| As an exception, if the filesystem type (see below) is one which is |
| not based on a device (e.g. "proc"), 'mount' instantiates a |
| filesystem and mounts it over DIR and ignores SPECIAL_FILE. |
| |
| For a remount, DIR specifies the mount point where the filesystem |
| to be remounted is (and remains) mounted and SPECIAL_FILE is |
| ignored. Remounting a filesystem means changing the options that |
| control operations on the filesystem while it is mounted. It does |
| not mean unmounting and mounting again. |
| |
| For a mount, you must identify the type of the filesystem as |
| FSTYPE. This type tells the kernel how to access the filesystem |
| and can be thought of as the name of a filesystem driver. The |
| acceptable values are system dependent. On a system with a Linux |
| kernel and the 'proc' filesystem, the list of possible values is in |
| the file 'filesystems' in the 'proc' filesystem (e.g. type 'cat |
| /proc/filesystems' to see the list). With a Linux kernel, the |
| types of filesystems that 'mount' can mount, and their type names, |
| depends on what filesystem drivers are configured into the kernel |
| or loaded as loadable kernel modules. An example of a common value |
| for FSTYPE is 'ext2'. |
| |
| For a remount, 'mount' ignores FSTYPE. |
| |
| OPTIONS specifies a variety of options that apply until the |
| filesystem is unmounted or remounted. The precise meaning of an |
| option depends on the filesystem and with some filesystems, an |
| option may have no effect at all. Furthermore, for some |
| filesystems, some of these options (but never 'MS_RDONLY') can be |
| overridden for individual file accesses via 'ioctl'. |
| |
| OPTIONS is a bit string with bit fields defined using the following |
| mask and masked value macros: |
| |
| 'MS_MGC_MASK' |
| This multibit field contains a magic number. If it does not |
| have the value 'MS_MGC_VAL', 'mount' assumes all the following |
| bits are zero and the DATA argument is a null string, |
| regardless of their actual values. |
| |
| 'MS_REMOUNT' |
| This bit on means to remount the filesystem. Off means to |
| mount it. |
| |
| 'MS_RDONLY' |
| This bit on specifies that no writing to the filesystem shall |
| be allowed while it is mounted. This cannot be overridden by |
| 'ioctl'. This option is available on nearly all filesystems. |
| |
| 'S_IMMUTABLE' |
| This bit on specifies that no writing to the files in the |
| filesystem shall be allowed while it is mounted. This can be |
| overridden for a particular file access by a properly |
| privileged call to 'ioctl'. This option is a relatively new |
| invention and is not available on many filesystems. |
| |
| 'S_APPEND' |
| This bit on specifies that the only file writing that shall be |
| allowed while the filesystem is mounted is appending. Some |
| filesystems allow this to be overridden for a particular |
| process by a properly privileged call to 'ioctl'. This is a |
| relatively new invention and is not available on many |
| filesystems. |
| |
| 'MS_NOSUID' |
| This bit on specifies that Setuid and Setgid permissions on |
| files in the filesystem shall be ignored while it is mounted. |
| |
| 'MS_NOEXEC' |
| This bit on specifies that no files in the filesystem shall be |
| executed while the filesystem is mounted. |
| |
| 'MS_NODEV' |
| This bit on specifies that no device special files in the |
| filesystem shall be accessible while the filesystem is |
| mounted. |
| |
| 'MS_SYNCHRONOUS' |
| This bit on specifies that all writes to the filesystem while |
| it is mounted shall be synchronous; i.e., data shall be synced |
| before each write completes rather than held in the buffer |
| cache. |
| |
| 'MS_MANDLOCK' |
| This bit on specifies that mandatory locks on files shall be |
| permitted while the filesystem is mounted. |
| |
| 'MS_NOATIME' |
| This bit on specifies that access times of files shall not be |
| updated when the files are accessed while the filesystem is |
| mounted. |
| |
| 'MS_NODIRATIME' |
| This bit on specifies that access times of directories shall |
| not be updated when the directories are accessed while the |
| filesystem in mounted. |
| |
| Any bits not covered by the above masks should be set off; |
| otherwise, results are undefined. |
| |
| The meaning of DATA depends on the filesystem type and is |
| controlled entirely by the filesystem driver in the kernel. |
| |
| Example: |
| |
| #include <sys/mount.h> |
| |
| mount("/dev/hdb", "/cdrom", MS_MGC_VAL | MS_RDONLY | MS_NOSUID, ""); |
| |
| mount("/dev/hda2", "/mnt", MS_MGC_VAL | MS_REMOUNT, ""); |
| |
| |
| Appropriate arguments for 'mount' are conventionally recorded in |
| the 'fstab' table. *Note Mount Information::. |
| |
| The return value is zero if the mount or remount is successful. |
| Otherwise, it is '-1' and 'errno' is set appropriately. The values |
| of 'errno' are filesystem dependent, but here is a general list: |
| |
| 'EPERM' |
| The process is not superuser. |
| 'ENODEV' |
| The file system type FSTYPE is not known to the kernel. |
| 'ENOTBLK' |
| The file DEV is not a block device special file. |
| 'EBUSY' |
| |
| * The device is already mounted. |
| |
| * The mount point is busy. (E.g. it is some process' |
| working directory or has a filesystem mounted on it |
| already). |
| |
| * The request is to remount read-only, but there are files |
| open for write. |
| |
| 'EINVAL' |
| |
| * A remount was attempted, but there is no filesystem |
| mounted over the specified mount point. |
| |
| * The supposed filesystem has an invalid superblock. |
| |
| 'EACCES' |
| |
| * The filesystem is inherently read-only (possibly due to a |
| switch on the device) and the process attempted to mount |
| it read/write (by setting the 'MS_RDONLY' bit off). |
| |
| * SPECIAL_FILE or DIR is not accessible due to file |
| permissions. |
| |
| * SPECIAL_FILE is not accessible because it is in a |
| filesystem that is mounted with the 'MS_NODEV' option. |
| |
| 'EM_FILE' |
| The table of dummy devices is full. 'mount' needs to create a |
| dummy device (aka "unnamed" device) if the filesystem being |
| mounted is not one that uses a device. |
| |
| -- Function: int umount2 (const char *FILE, int FLAGS) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'umount2' unmounts a filesystem. |
| |
| You can identify the filesystem to unmount either by the device |
| special file that contains the filesystem or by the mount point. |
| The effect is the same. Specify either as the string FILE. |
| |
| FLAGS contains the one-bit field identified by the following mask |
| macro: |
| |
| 'MNT_FORCE' |
| This bit on means to force the unmounting even if the |
| filesystem is busy, by making it unbusy first. If the bit is |
| off and the filesystem is busy, 'umount2' fails with 'errno' = |
| 'EBUSY'. Depending on the filesystem, this may override all, |
| some, or no busy conditions. |
| |
| All other bits in FLAGS should be set to zero; otherwise, the |
| result is undefined. |
| |
| Example: |
| |
| #include <sys/mount.h> |
| |
| umount2("/mnt", MNT_FORCE); |
| |
| umount2("/dev/hdd1", 0); |
| |
| |
| After the filesystem is unmounted, the directory that was the mount |
| point is visible, as are any files in it. |
| |
| As part of unmounting, 'umount2' syncs the filesystem. |
| |
| If the unmounting is successful, the return value is zero. |
| Otherwise, it is '-1' and 'errno' is set accordingly: |
| |
| 'EPERM' |
| The process is not superuser. |
| 'EBUSY' |
| The filesystem cannot be unmounted because it is busy. E.g. |
| it contains a directory that is some process's working |
| directory or a file that some process has open. With some |
| filesystems in some cases, you can avoid this failure with the |
| 'MNT_FORCE' option. |
| |
| 'EINVAL' |
| FILE validly refers to a file, but that file is neither a |
| mount point nor a device special file of a currently mounted |
| filesystem. |
| |
| This function is not available on all systems. |
| |
| -- Function: int umount (const char *FILE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'umount' does the same thing as 'umount2' with FLAGS set to zeroes. |
| It is more widely available than 'umount2' but since it lacks the |
| possibility to forcefully unmount a filesystem is deprecated when |
| 'umount2' is also available. |
| |
| |
| File: libc.info, Node: System Parameters, Prev: Filesystem Handling, Up: System Management |
| |
| 31.4 System Parameters |
| ====================== |
| |
| This section describes the 'sysctl' function, which gets and sets a |
| variety of system parameters. |
| |
| The symbols used in this section are declared in the file |
| 'sys/sysctl.h'. |
| |
| -- Function: int sysctl (int *NAMES, int NLEN, void *OLDVAL, size_t |
| *OLDLENP, void *NEWVAL, size_t NEWLEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'sysctl' gets or sets a specified system parameter. There are so |
| many of these parameters that it is not practical to list them all |
| here, but here are some examples: |
| |
| * network domain name |
| * paging parameters |
| * network Address Resolution Protocol timeout time |
| * maximum number of files that may be open |
| * root filesystem device |
| * when kernel was built |
| |
| The set of available parameters depends on the kernel configuration |
| and can change while the system is running, particularly when you |
| load and unload loadable kernel modules. |
| |
| The system parameters with which 'syslog' is concerned are arranged |
| in a hierarchical structure like a hierarchical filesystem. To |
| identify a particular parameter, you specify a path through the |
| structure in a way analogous to specifying the pathname of a file. |
| Each component of the path is specified by an integer and each of |
| these integers has a macro defined for it by 'sys/sysctl.h'. NAMES |
| is the path, in the form of an array of integers. Each component |
| of the path is one element of the array, in order. NLEN is the |
| number of components in the path. |
| |
| For example, the first component of the path for all the paging |
| parameters is the value 'CTL_VM'. For the free page thresholds, |
| the second component of the path is 'VM_FREEPG'. So to get the |
| free page threshold values, make NAMES an array containing the two |
| elements 'CTL_VM' and 'VM_FREEPG' and make NLEN = 2. |
| |
| The format of the value of a parameter depends on the parameter. |
| Sometimes it is an integer; sometimes it is an ASCII string; |
| sometimes it is an elaborate structure. In the case of the free |
| page thresholds used in the example above, the parameter value is a |
| structure containing several integers. |
| |
| In any case, you identify a place to return the parameter's value |
| with OLDVAL and specify the amount of storage available at that |
| location as *OLDLENP. *OLDLENP does double duty because it is also |
| the output location that contains the actual length of the returned |
| value. |
| |
| If you don't want the parameter value returned, specify a null |
| pointer for OLDVAL. |
| |
| To set the parameter, specify the address and length of the new |
| value as NEWVAL and NEWLEN. If you don't want to set the |
| parameter, specify a null pointer as NEWVAL. |
| |
| If you get and set a parameter in the same 'sysctl' call, the value |
| returned is the value of the parameter before it was set. |
| |
| Each system parameter has a set of permissions similar to the |
| permissions for a file (including the permissions on directories in |
| its path) that determine whether you may get or set it. For the |
| purposes of these permissions, every parameter is considered to be |
| owned by the superuser and Group 0 so processes with that effective |
| uid or gid may have more access to system parameters. Unlike with |
| files, the superuser does not invariably have full permission to |
| all system parameters, because some of them are designed not to be |
| changed ever. |
| |
| 'sysctl' returns a zero return value if it succeeds. Otherwise, it |
| returns '-1' and sets 'errno' appropriately. Besides the failures |
| that apply to all system calls, the following are the 'errno' codes |
| for all possible failures: |
| |
| 'EPERM' |
| The process is not permitted to access one of the components |
| of the path of the system parameter or is not permitted to |
| access the system parameter itself in the way (read or write) |
| that it requested. |
| 'ENOTDIR' |
| There is no system parameter corresponding to NAME. |
| 'EFAULT' |
| OLDVAL is not null, which means the process wanted to read the |
| parameter, but *OLDLENP is zero, so there is no place to |
| return it. |
| 'EINVAL' |
| * The process attempted to set a system parameter to a |
| value that is not valid for that parameter. |
| * The space provided for the return of the system parameter |
| is not the right size for that parameter. |
| 'ENOMEM' |
| This value may be returned instead of the more correct |
| 'EINVAL' in some cases where the space provided for the return |
| of the system parameter is too small. |
| |
| If you have a Linux kernel with the 'proc' filesystem, you can get |
| and set most of the same parameters by reading and writing to files in |
| the 'sys' directory of the 'proc' filesystem. In the 'sys' directory, |
| the directory structure represents the hierarchical structure of the |
| parameters. E.g. you can display the free page thresholds with |
| cat /proc/sys/vm/freepages |
| |
| Some more traditional and more widely available, though less general, |
| GNU C Library functions for getting and setting some of the same system |
| parameters are: |
| |
| * 'getdomainname', 'setdomainname' |
| * 'gethostname', 'sethostname' (*Note Host Identification::.) |
| * 'uname' (*Note Platform Type::.) |
| * 'bdflush' |
| |
| |
| File: libc.info, Node: System Configuration, Next: Cryptographic Functions, Prev: System Management, Up: Top |
| |
| 32 System Configuration Parameters |
| ********************************** |
| |
| The functions and macros listed in this chapter give information about |
| configuration parameters of the operating system--for example, capacity |
| limits, presence of optional POSIX features, and the default path for |
| executable files (*note String Parameters::). |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: General Limits, Next: System Options, Up: System Configuration |
| |
| 32.1 General Capacity Limits |
| ============================ |
| |
| The POSIX.1 and POSIX.2 standards specify a number of parameters that |
| describe capacity limitations of the system. These limits can be fixed |
| constants for a given operating system, or they can vary from machine to |
| machine. For example, some limit values may be configurable by the |
| system administrator, either at run time or by rebuilding the kernel, |
| and this should not require recompiling application programs. |
| |
| Each of the following limit parameters has a macro that is defined in |
| 'limits.h' only if the system has a fixed, uniform limit for the |
| parameter in question. If the system allows different file systems or |
| files to have different limits, then the macro is undefined; use |
| 'sysconf' to find out the limit that applies at a particular time on a |
| particular machine. *Note Sysconf::. |
| |
| Each of these parameters also has another macro, with a name starting |
| with '_POSIX', which gives the lowest value that the limit is allowed to |
| have on _any_ POSIX system. *Note Minimums::. |
| |
| -- Macro: int ARG_MAX |
| If defined, the unvarying maximum combined length of the ARGV and |
| ENVIRON arguments that can be passed to the 'exec' functions. |
| |
| -- Macro: int CHILD_MAX |
| If defined, the unvarying maximum number of processes that can |
| exist with the same real user ID at any one time. In BSD and GNU, |
| this is controlled by the 'RLIMIT_NPROC' resource limit; *note |
| Limits on Resources::. |
| |
| -- Macro: int OPEN_MAX |
| If defined, the unvarying maximum number of files that a single |
| process can have open simultaneously. In BSD and GNU, this is |
| controlled by the 'RLIMIT_NOFILE' resource limit; *note Limits on |
| Resources::. |
| |
| -- Macro: int STREAM_MAX |
| If defined, the unvarying maximum number of streams that a single |
| process can have open simultaneously. *Note Opening Streams::. |
| |
| -- Macro: int TZNAME_MAX |
| If defined, the unvarying maximum length of a time zone name. |
| *Note Time Zone Functions::. |
| |
| These limit macros are always defined in 'limits.h'. |
| |
| -- Macro: int NGROUPS_MAX |
| The maximum number of supplementary group IDs that one process can |
| have. |
| |
| The value of this macro is actually a lower bound for the maximum. |
| That is, you can count on being able to have that many |
| supplementary group IDs, but a particular machine might let you |
| have even more. You can use 'sysconf' to see whether a particular |
| machine will let you have more (*note Sysconf::). |
| |
| -- Macro: ssize_t SSIZE_MAX |
| The largest value that can fit in an object of type 'ssize_t'. |
| Effectively, this is the limit on the number of bytes that can be |
| read or written in a single operation. |
| |
| This macro is defined in all POSIX systems because this limit is |
| never configurable. |
| |
| -- Macro: int RE_DUP_MAX |
| The largest number of repetitions you are guaranteed is allowed in |
| the construct '\{MIN,MAX\}' in a regular expression. |
| |
| The value of this macro is actually a lower bound for the maximum. |
| That is, you can count on being able to have that many repetitions, |
| but a particular machine might let you have even more. You can use |
| 'sysconf' to see whether a particular machine will let you have |
| more (*note Sysconf::). And even the value that 'sysconf' tells |
| you is just a lower bound--larger values might work. |
| |
| This macro is defined in all POSIX.2 systems, because POSIX.2 says |
| it should always be defined even if there is no specific imposed |
| limit. |
| |
| |
| File: libc.info, Node: System Options, Next: Version Supported, Prev: General Limits, Up: System Configuration |
| |
| 32.2 Overall System Options |
| =========================== |
| |
| POSIX defines certain system-specific options that not all POSIX systems |
| support. Since these options are provided in the kernel, not in the |
| library, simply using the GNU C Library does not guarantee any of these |
| features is supported; it depends on the system you are using. |
| |
| You can test for the availability of a given option using the macros |
| in this section, together with the function 'sysconf'. The macros are |
| defined only if you include 'unistd.h'. |
| |
| For the following macros, if the macro is defined in 'unistd.h', then |
| the option is supported. Otherwise, the option may or may not be |
| supported; use 'sysconf' to find out. *Note Sysconf::. |
| |
| -- Macro: int _POSIX_JOB_CONTROL |
| If this symbol is defined, it indicates that the system supports |
| job control. Otherwise, the implementation behaves as if all |
| processes within a session belong to a single process group. *Note |
| Job Control::. |
| |
| -- Macro: int _POSIX_SAVED_IDS |
| If this symbol is defined, it indicates that the system remembers |
| the effective user and group IDs of a process before it executes an |
| executable file with the set-user-ID or set-group-ID bits set, and |
| that explicitly changing the effective user or group IDs back to |
| these values is permitted. If this option is not defined, then if |
| a nonprivileged process changes its effective user or group ID to |
| the real user or group ID of the process, it can't change it back |
| again. *Note Enable/Disable Setuid::. |
| |
| For the following macros, if the macro is defined in 'unistd.h', then |
| its value indicates whether the option is supported. A value of '-1' |
| means no, and any other value means yes. If the macro is not defined, |
| then the option may or may not be supported; use 'sysconf' to find out. |
| *Note Sysconf::. |
| |
| -- Macro: int _POSIX2_C_DEV |
| If this symbol is defined, it indicates that the system has the |
| POSIX.2 C compiler command, 'c89'. The GNU C Library always |
| defines this as '1', on the assumption that you would not have |
| installed it if you didn't have a C compiler. |
| |
| -- Macro: int _POSIX2_FORT_DEV |
| If this symbol is defined, it indicates that the system has the |
| POSIX.2 Fortran compiler command, 'fort77'. The GNU C Library |
| never defines this, because we don't know what the system has. |
| |
| -- Macro: int _POSIX2_FORT_RUN |
| If this symbol is defined, it indicates that the system has the |
| POSIX.2 'asa' command to interpret Fortran carriage control. The |
| GNU C Library never defines this, because we don't know what the |
| system has. |
| |
| -- Macro: int _POSIX2_LOCALEDEF |
| If this symbol is defined, it indicates that the system has the |
| POSIX.2 'localedef' command. The GNU C Library never defines this, |
| because we don't know what the system has. |
| |
| -- Macro: int _POSIX2_SW_DEV |
| If this symbol is defined, it indicates that the system has the |
| POSIX.2 commands 'ar', 'make', and 'strip'. The GNU C Library |
| always defines this as '1', on the assumption that you had to have |
| 'ar' and 'make' to install the library, and it's unlikely that |
| 'strip' would be absent when those are present. |
| |
| |
| File: libc.info, Node: Version Supported, Next: Sysconf, Prev: System Options, Up: System Configuration |
| |
| 32.3 Which Version of POSIX is Supported |
| ======================================== |
| |
| -- Macro: long int _POSIX_VERSION |
| This constant represents the version of the POSIX.1 standard to |
| which the implementation conforms. For an implementation |
| conforming to the 1995 POSIX.1 standard, the value is the integer |
| '199506L'. |
| |
| '_POSIX_VERSION' is always defined (in 'unistd.h') in any POSIX |
| system. |
| |
| *Usage Note:* Don't try to test whether the system supports POSIX |
| by including 'unistd.h' and then checking whether '_POSIX_VERSION' |
| is defined. On a non-POSIX system, this will probably fail because |
| there is no 'unistd.h'. We do not know of _any_ way you can |
| reliably test at compilation time whether your target system |
| supports POSIX or whether 'unistd.h' exists. |
| |
| -- Macro: long int _POSIX2_C_VERSION |
| This constant represents the version of the POSIX.2 standard which |
| the library and system kernel support. We don't know what value |
| this will be for the first version of the POSIX.2 standard, because |
| the value is based on the year and month in which the standard is |
| officially adopted. |
| |
| The value of this symbol says nothing about the utilities installed |
| on the system. |
| |
| *Usage Note:* You can use this macro to tell whether a POSIX.1 |
| system library supports POSIX.2 as well. Any POSIX.1 system |
| contains 'unistd.h', so include that file and then test 'defined |
| (_POSIX2_C_VERSION)'. |
| |
| |
| File: libc.info, Node: Sysconf, Next: Minimums, Prev: Version Supported, Up: System Configuration |
| |
| 32.4 Using 'sysconf' |
| ==================== |
| |
| When your system has configurable system limits, you can use the |
| 'sysconf' function to find out the value that applies to any particular |
| machine. The function and the associated PARAMETER constants are |
| declared in the header file 'unistd.h'. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Sysconf Definition, Next: Constants for Sysconf, Up: Sysconf |
| |
| 32.4.1 Definition of 'sysconf' |
| ------------------------------ |
| |
| -- Function: long int sysconf (int PARAMETER) |
| Preliminary: | MT-Safe env | AS-Unsafe lock heap | AC-Unsafe lock |
| mem fd | *Note POSIX Safety Concepts::. |
| |
| This function is used to inquire about runtime system parameters. |
| The PARAMETER argument should be one of the '_SC_' symbols listed |
| below. |
| |
| The normal return value from 'sysconf' is the value you requested. |
| A value of '-1' is returned both if the implementation does not |
| impose a limit, and in case of an error. |
| |
| The following 'errno' error conditions are defined for this |
| function: |
| |
| 'EINVAL' |
| The value of the PARAMETER is invalid. |
| |
| |
| File: libc.info, Node: Constants for Sysconf, Next: Examples of Sysconf, Prev: Sysconf Definition, Up: Sysconf |
| |
| 32.4.2 Constants for 'sysconf' Parameters |
| ----------------------------------------- |
| |
| Here are the symbolic constants for use as the PARAMETER argument to |
| 'sysconf'. The values are all integer constants (more specifically, |
| enumeration type values). |
| |
| '_SC_ARG_MAX' |
| Inquire about the parameter corresponding to 'ARG_MAX'. |
| |
| '_SC_CHILD_MAX' |
| Inquire about the parameter corresponding to 'CHILD_MAX'. |
| |
| '_SC_OPEN_MAX' |
| Inquire about the parameter corresponding to 'OPEN_MAX'. |
| |
| '_SC_STREAM_MAX' |
| Inquire about the parameter corresponding to 'STREAM_MAX'. |
| |
| '_SC_TZNAME_MAX' |
| Inquire about the parameter corresponding to 'TZNAME_MAX'. |
| |
| '_SC_NGROUPS_MAX' |
| Inquire about the parameter corresponding to 'NGROUPS_MAX'. |
| |
| '_SC_JOB_CONTROL' |
| Inquire about the parameter corresponding to '_POSIX_JOB_CONTROL'. |
| |
| '_SC_SAVED_IDS' |
| Inquire about the parameter corresponding to '_POSIX_SAVED_IDS'. |
| |
| '_SC_VERSION' |
| Inquire about the parameter corresponding to '_POSIX_VERSION'. |
| |
| '_SC_CLK_TCK' |
| Inquire about the number of clock ticks per second; *note CPU |
| Time::. The corresponding parameter 'CLK_TCK' is obsolete. |
| |
| '_SC_CHARCLASS_NAME_MAX' |
| Inquire about the parameter corresponding to maximal length allowed |
| for a character class name in an extended locale specification. |
| These extensions are not yet standardized and so this option is not |
| standardized as well. |
| |
| '_SC_REALTIME_SIGNALS' |
| Inquire about the parameter corresponding to |
| '_POSIX_REALTIME_SIGNALS'. |
| |
| '_SC_PRIORITY_SCHEDULING' |
| Inquire about the parameter corresponding to |
| '_POSIX_PRIORITY_SCHEDULING'. |
| |
| '_SC_TIMERS' |
| Inquire about the parameter corresponding to '_POSIX_TIMERS'. |
| |
| '_SC_ASYNCHRONOUS_IO' |
| Inquire about the parameter corresponding to |
| '_POSIX_ASYNCHRONOUS_IO'. |
| |
| '_SC_PRIORITIZED_IO' |
| Inquire about the parameter corresponding to |
| '_POSIX_PRIORITIZED_IO'. |
| |
| '_SC_SYNCHRONIZED_IO' |
| Inquire about the parameter corresponding to |
| '_POSIX_SYNCHRONIZED_IO'. |
| |
| '_SC_FSYNC' |
| Inquire about the parameter corresponding to '_POSIX_FSYNC'. |
| |
| '_SC_MAPPED_FILES' |
| Inquire about the parameter corresponding to '_POSIX_MAPPED_FILES'. |
| |
| '_SC_MEMLOCK' |
| Inquire about the parameter corresponding to '_POSIX_MEMLOCK'. |
| |
| '_SC_MEMLOCK_RANGE' |
| Inquire about the parameter corresponding to |
| '_POSIX_MEMLOCK_RANGE'. |
| |
| '_SC_MEMORY_PROTECTION' |
| Inquire about the parameter corresponding to |
| '_POSIX_MEMORY_PROTECTION'. |
| |
| '_SC_MESSAGE_PASSING' |
| Inquire about the parameter corresponding to |
| '_POSIX_MESSAGE_PASSING'. |
| |
| '_SC_SEMAPHORES' |
| Inquire about the parameter corresponding to '_POSIX_SEMAPHORES'. |
| |
| '_SC_SHARED_MEMORY_OBJECTS' |
| Inquire about the parameter corresponding to |
| '_POSIX_SHARED_MEMORY_OBJECTS'. |
| |
| '_SC_AIO_LISTIO_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_AIO_LISTIO_MAX'. |
| |
| '_SC_AIO_MAX' |
| Inquire about the parameter corresponding to '_POSIX_AIO_MAX'. |
| |
| '_SC_AIO_PRIO_DELTA_MAX' |
| Inquire the value by which a process can decrease its asynchronous |
| I/O priority level from its own scheduling priority. This |
| corresponds to the run-time invariant value 'AIO_PRIO_DELTA_MAX'. |
| |
| '_SC_DELAYTIMER_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_DELAYTIMER_MAX'. |
| |
| '_SC_MQ_OPEN_MAX' |
| Inquire about the parameter corresponding to '_POSIX_MQ_OPEN_MAX'. |
| |
| '_SC_MQ_PRIO_MAX' |
| Inquire about the parameter corresponding to '_POSIX_MQ_PRIO_MAX'. |
| |
| '_SC_RTSIG_MAX' |
| Inquire about the parameter corresponding to '_POSIX_RTSIG_MAX'. |
| |
| '_SC_SEM_NSEMS_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_SEM_NSEMS_MAX'. |
| |
| '_SC_SEM_VALUE_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_SEM_VALUE_MAX'. |
| |
| '_SC_SIGQUEUE_MAX' |
| Inquire about the parameter corresponding to '_POSIX_SIGQUEUE_MAX'. |
| |
| '_SC_TIMER_MAX' |
| Inquire about the parameter corresponding to '_POSIX_TIMER_MAX'. |
| |
| '_SC_PII' |
| Inquire about the parameter corresponding to '_POSIX_PII'. |
| |
| '_SC_PII_XTI' |
| Inquire about the parameter corresponding to '_POSIX_PII_XTI'. |
| |
| '_SC_PII_SOCKET' |
| Inquire about the parameter corresponding to '_POSIX_PII_SOCKET'. |
| |
| '_SC_PII_INTERNET' |
| Inquire about the parameter corresponding to '_POSIX_PII_INTERNET'. |
| |
| '_SC_PII_OSI' |
| Inquire about the parameter corresponding to '_POSIX_PII_OSI'. |
| |
| '_SC_SELECT' |
| Inquire about the parameter corresponding to '_POSIX_SELECT'. |
| |
| '_SC_UIO_MAXIOV' |
| Inquire about the parameter corresponding to '_POSIX_UIO_MAXIOV'. |
| |
| '_SC_PII_INTERNET_STREAM' |
| Inquire about the parameter corresponding to |
| '_POSIX_PII_INTERNET_STREAM'. |
| |
| '_SC_PII_INTERNET_DGRAM' |
| Inquire about the parameter corresponding to |
| '_POSIX_PII_INTERNET_DGRAM'. |
| |
| '_SC_PII_OSI_COTS' |
| Inquire about the parameter corresponding to '_POSIX_PII_OSI_COTS'. |
| |
| '_SC_PII_OSI_CLTS' |
| Inquire about the parameter corresponding to '_POSIX_PII_OSI_CLTS'. |
| |
| '_SC_PII_OSI_M' |
| Inquire about the parameter corresponding to '_POSIX_PII_OSI_M'. |
| |
| '_SC_T_IOV_MAX' |
| Inquire the value of the value associated with the 'T_IOV_MAX' |
| variable. |
| |
| '_SC_THREADS' |
| Inquire about the parameter corresponding to '_POSIX_THREADS'. |
| |
| '_SC_THREAD_SAFE_FUNCTIONS' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_SAFE_FUNCTIONS'. |
| |
| '_SC_GETGR_R_SIZE_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_GETGR_R_SIZE_MAX'. |
| |
| '_SC_GETPW_R_SIZE_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_GETPW_R_SIZE_MAX'. |
| |
| '_SC_LOGIN_NAME_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_LOGIN_NAME_MAX'. |
| |
| '_SC_TTY_NAME_MAX' |
| Inquire about the parameter corresponding to '_POSIX_TTY_NAME_MAX'. |
| |
| '_SC_THREAD_DESTRUCTOR_ITERATIONS' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_DESTRUCTOR_ITERATIONS'. |
| |
| '_SC_THREAD_KEYS_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_KEYS_MAX'. |
| |
| '_SC_THREAD_STACK_MIN' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_STACK_MIN'. |
| |
| '_SC_THREAD_THREADS_MAX' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_THREADS_MAX'. |
| |
| '_SC_THREAD_ATTR_STACKADDR' |
| Inquire about the parameter corresponding to |
| a '_POSIX_THREAD_ATTR_STACKADDR'. |
| |
| '_SC_THREAD_ATTR_STACKSIZE' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_ATTR_STACKSIZE'. |
| |
| '_SC_THREAD_PRIORITY_SCHEDULING' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_PRIORITY_SCHEDULING'. |
| |
| '_SC_THREAD_PRIO_INHERIT' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_PRIO_INHERIT'. |
| |
| '_SC_THREAD_PRIO_PROTECT' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_PRIO_PROTECT'. |
| |
| '_SC_THREAD_PROCESS_SHARED' |
| Inquire about the parameter corresponding to |
| '_POSIX_THREAD_PROCESS_SHARED'. |
| |
| '_SC_2_C_DEV' |
| Inquire about whether the system has the POSIX.2 C compiler |
| command, 'c89'. |
| |
| '_SC_2_FORT_DEV' |
| Inquire about whether the system has the POSIX.2 Fortran compiler |
| command, 'fort77'. |
| |
| '_SC_2_FORT_RUN' |
| Inquire about whether the system has the POSIX.2 'asa' command to |
| interpret Fortran carriage control. |
| |
| '_SC_2_LOCALEDEF' |
| Inquire about whether the system has the POSIX.2 'localedef' |
| command. |
| |
| '_SC_2_SW_DEV' |
| Inquire about whether the system has the POSIX.2 commands 'ar', |
| 'make', and 'strip'. |
| |
| '_SC_BC_BASE_MAX' |
| Inquire about the maximum value of 'obase' in the 'bc' utility. |
| |
| '_SC_BC_DIM_MAX' |
| Inquire about the maximum size of an array in the 'bc' utility. |
| |
| '_SC_BC_SCALE_MAX' |
| Inquire about the maximum value of 'scale' in the 'bc' utility. |
| |
| '_SC_BC_STRING_MAX' |
| Inquire about the maximum size of a string constant in the 'bc' |
| utility. |
| |
| '_SC_COLL_WEIGHTS_MAX' |
| Inquire about the maximum number of weights that can necessarily be |
| used in defining the collating sequence for a locale. |
| |
| '_SC_EXPR_NEST_MAX' |
| Inquire about the maximum number of expressions nested within |
| parentheses when using the 'expr' utility. |
| |
| '_SC_LINE_MAX' |
| Inquire about the maximum size of a text line that the POSIX.2 text |
| utilities can handle. |
| |
| '_SC_EQUIV_CLASS_MAX' |
| Inquire about the maximum number of weights that can be assigned to |
| an entry of the 'LC_COLLATE' category 'order' keyword in a locale |
| definition. The GNU C Library does not presently support locale |
| definitions. |
| |
| '_SC_VERSION' |
| Inquire about the version number of POSIX.1 that the library and |
| kernel support. |
| |
| '_SC_2_VERSION' |
| Inquire about the version number of POSIX.2 that the system |
| utilities support. |
| |
| '_SC_PAGESIZE' |
| Inquire about the virtual memory page size of the machine. |
| 'getpagesize' returns the same value (*note Query Memory |
| Parameters::). |
| |
| '_SC_NPROCESSORS_CONF' |
| Inquire about the number of configured processors. |
| |
| '_SC_NPROCESSORS_ONLN' |
| Inquire about the number of processors online. |
| |
| '_SC_PHYS_PAGES' |
| Inquire about the number of physical pages in the system. |
| |
| '_SC_AVPHYS_PAGES' |
| Inquire about the number of available physical pages in the system. |
| |
| '_SC_ATEXIT_MAX' |
| Inquire about the number of functions which can be registered as |
| termination functions for 'atexit'; *note Cleanups on Exit::. |
| |
| '_SC_XOPEN_VERSION' |
| Inquire about the parameter corresponding to '_XOPEN_VERSION'. |
| |
| '_SC_XOPEN_XCU_VERSION' |
| Inquire about the parameter corresponding to '_XOPEN_XCU_VERSION'. |
| |
| '_SC_XOPEN_UNIX' |
| Inquire about the parameter corresponding to '_XOPEN_UNIX'. |
| |
| '_SC_XOPEN_REALTIME' |
| Inquire about the parameter corresponding to '_XOPEN_REALTIME'. |
| |
| '_SC_XOPEN_REALTIME_THREADS' |
| Inquire about the parameter corresponding to |
| '_XOPEN_REALTIME_THREADS'. |
| |
| '_SC_XOPEN_LEGACY' |
| Inquire about the parameter corresponding to '_XOPEN_LEGACY'. |
| |
| '_SC_XOPEN_CRYPT' |
| Inquire about the parameter corresponding to '_XOPEN_CRYPT'. |
| |
| '_SC_XOPEN_ENH_I18N' |
| Inquire about the parameter corresponding to '_XOPEN_ENH_I18N'. |
| |
| '_SC_XOPEN_SHM' |
| Inquire about the parameter corresponding to '_XOPEN_SHM'. |
| |
| '_SC_XOPEN_XPG2' |
| Inquire about the parameter corresponding to '_XOPEN_XPG2'. |
| |
| '_SC_XOPEN_XPG3' |
| Inquire about the parameter corresponding to '_XOPEN_XPG3'. |
| |
| '_SC_XOPEN_XPG4' |
| Inquire about the parameter corresponding to '_XOPEN_XPG4'. |
| |
| '_SC_CHAR_BIT' |
| Inquire about the number of bits in a variable of type 'char'. |
| |
| '_SC_CHAR_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'char'. |
| |
| '_SC_CHAR_MIN' |
| Inquire about the minimum value which can be stored in a variable |
| of type 'char'. |
| |
| '_SC_INT_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'int'. |
| |
| '_SC_INT_MIN' |
| Inquire about the minimum value which can be stored in a variable |
| of type 'int'. |
| |
| '_SC_LONG_BIT' |
| Inquire about the number of bits in a variable of type 'long int'. |
| |
| '_SC_WORD_BIT' |
| Inquire about the number of bits in a variable of a register word. |
| |
| '_SC_MB_LEN_MAX' |
| Inquire the maximum length of a multi-byte representation of a wide |
| character value. |
| |
| '_SC_NZERO' |
| Inquire about the value used to internally represent the zero |
| priority level for the process execution. |
| |
| 'SC_SSIZE_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'ssize_t'. |
| |
| '_SC_SCHAR_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'signed char'. |
| |
| '_SC_SCHAR_MIN' |
| Inquire about the minimum value which can be stored in a variable |
| of type 'signed char'. |
| |
| '_SC_SHRT_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'short int'. |
| |
| '_SC_SHRT_MIN' |
| Inquire about the minimum value which can be stored in a variable |
| of type 'short int'. |
| |
| '_SC_UCHAR_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'unsigned char'. |
| |
| '_SC_UINT_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'unsigned int'. |
| |
| '_SC_ULONG_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'unsigned long int'. |
| |
| '_SC_USHRT_MAX' |
| Inquire about the maximum value which can be stored in a variable |
| of type 'unsigned short int'. |
| |
| '_SC_NL_ARGMAX' |
| Inquire about the parameter corresponding to 'NL_ARGMAX'. |
| |
| '_SC_NL_LANGMAX' |
| Inquire about the parameter corresponding to 'NL_LANGMAX'. |
| |
| '_SC_NL_MSGMAX' |
| Inquire about the parameter corresponding to 'NL_MSGMAX'. |
| |
| '_SC_NL_NMAX' |
| Inquire about the parameter corresponding to 'NL_NMAX'. |
| |
| '_SC_NL_SETMAX' |
| Inquire about the parameter corresponding to 'NL_SETMAX'. |
| |
| '_SC_NL_TEXTMAX' |
| Inquire about the parameter corresponding to 'NL_TEXTMAX'. |
| |
| |
| File: libc.info, Node: Examples of Sysconf, Prev: Constants for Sysconf, Up: Sysconf |
| |
| 32.4.3 Examples of 'sysconf' |
| ---------------------------- |
| |
| We recommend that you first test for a macro definition for the |
| parameter you are interested in, and call 'sysconf' only if the macro is |
| not defined. For example, here is how to test whether job control is |
| supported: |
| |
| int |
| have_job_control (void) |
| { |
| #ifdef _POSIX_JOB_CONTROL |
| return 1; |
| #else |
| int value = sysconf (_SC_JOB_CONTROL); |
| if (value < 0) |
| /* If the system is that badly wedged, |
| there's no use trying to go on. */ |
| fatal (strerror (errno)); |
| return value; |
| #endif |
| } |
| |
| Here is how to get the value of a numeric limit: |
| |
| int |
| get_child_max () |
| { |
| #ifdef CHILD_MAX |
| return CHILD_MAX; |
| #else |
| int value = sysconf (_SC_CHILD_MAX); |
| if (value < 0) |
| fatal (strerror (errno)); |
| return value; |
| #endif |
| } |
| |
| |
| File: libc.info, Node: Minimums, Next: Limits for Files, Prev: Sysconf, Up: System Configuration |
| |
| 32.5 Minimum Values for General Capacity Limits |
| =============================================== |
| |
| Here are the names for the POSIX minimum upper bounds for the system |
| limit parameters. The significance of these values is that you can |
| safely push to these limits without checking whether the particular |
| system you are using can go that far. |
| |
| '_POSIX_AIO_LISTIO_MAX' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of I/O operations that can be specified in a list I/O call. |
| The value of this constant is '2'; thus you can add up to two new |
| entries of the list of outstanding operations. |
| |
| '_POSIX_AIO_MAX' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of outstanding asynchronous I/O operations. The value of |
| this constant is '1'. So you cannot expect that you can issue more |
| than one operation and immediately continue with the normal work, |
| receiving the notifications asynchronously. |
| |
| '_POSIX_ARG_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum combined length of the ARGV and ENVIRON |
| arguments that can be passed to the 'exec' functions. Its value is |
| '4096'. |
| |
| '_POSIX_CHILD_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum number of simultaneous processes per real |
| user ID. Its value is '6'. |
| |
| '_POSIX_NGROUPS_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum number of supplementary group IDs per |
| process. Its value is '0'. |
| |
| '_POSIX_OPEN_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum number of files that a single process can |
| have open simultaneously. Its value is '16'. |
| |
| '_POSIX_SSIZE_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum value that can be stored in an object of type |
| 'ssize_t'. Its value is '32767'. |
| |
| '_POSIX_STREAM_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum number of streams that a single process can |
| have open simultaneously. Its value is '8'. |
| |
| '_POSIX_TZNAME_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the maximum length of a time zone name. Its value is |
| '3'. |
| |
| '_POSIX2_RE_DUP_MAX' |
| The value of this macro is the most restrictive limit permitted by |
| POSIX for the numbers used in the '\{MIN,MAX\}' construct in a |
| regular expression. Its value is '255'. |
| |
| |
| File: libc.info, Node: Limits for Files, Next: Options for Files, Prev: Minimums, Up: System Configuration |
| |
| 32.6 Limits on File System Capacity |
| =================================== |
| |
| The POSIX.1 standard specifies a number of parameters that describe the |
| limitations of the file system. It's possible for the system to have a |
| fixed, uniform limit for a parameter, but this isn't the usual case. On |
| most systems, it's possible for different file systems (and, for some |
| parameters, even different files) to have different maximum limits. For |
| example, this is very likely if you use NFS to mount some of the file |
| systems from other machines. |
| |
| Each of the following macros is defined in 'limits.h' only if the |
| system has a fixed, uniform limit for the parameter in question. If the |
| system allows different file systems or files to have different limits, |
| then the macro is undefined; use 'pathconf' or 'fpathconf' to find out |
| the limit that applies to a particular file. *Note Pathconf::. |
| |
| Each parameter also has another macro, with a name starting with |
| '_POSIX', which gives the lowest value that the limit is allowed to have |
| on _any_ POSIX system. *Note File Minimums::. |
| |
| -- Macro: int LINK_MAX |
| The uniform system limit (if any) for the number of names for a |
| given file. *Note Hard Links::. |
| |
| -- Macro: int MAX_CANON |
| The uniform system limit (if any) for the amount of text in a line |
| of input when input editing is enabled. *Note Canonical or Not::. |
| |
| -- Macro: int MAX_INPUT |
| The uniform system limit (if any) for the total number of |
| characters typed ahead as input. *Note I/O Queues::. |
| |
| -- Macro: int NAME_MAX |
| The uniform system limit (if any) for the length of a file name |
| component, not including the terminating null character. |
| |
| *Portability Note:* On some systems, the GNU C Library defines |
| 'NAME_MAX', but does not actually enforce this limit. |
| |
| -- Macro: int PATH_MAX |
| The uniform system limit (if any) for the length of an entire file |
| name (that is, the argument given to system calls such as 'open'), |
| including the terminating null character. |
| |
| *Portability Note:* The GNU C Library does not enforce this limit |
| even if 'PATH_MAX' is defined. |
| |
| -- Macro: int PIPE_BUF |
| The uniform system limit (if any) for the number of bytes that can |
| be written atomically to a pipe. If multiple processes are writing |
| to the same pipe simultaneously, output from different processes |
| might be interleaved in chunks of this size. *Note Pipes and |
| FIFOs::. |
| |
| These are alternative macro names for some of the same information. |
| |
| -- Macro: int MAXNAMLEN |
| This is the BSD name for 'NAME_MAX'. It is defined in 'dirent.h'. |
| |
| -- Macro: int FILENAME_MAX |
| The value of this macro is an integer constant expression that |
| represents the maximum length of a file name string. It is defined |
| in 'stdio.h'. |
| |
| Unlike 'PATH_MAX', this macro is defined even if there is no actual |
| limit imposed. In such a case, its value is typically a very large |
| number. *This is always the case on GNU/Hurd systems.* |
| |
| *Usage Note:* Don't use 'FILENAME_MAX' as the size of an array in |
| which to store a file name! You can't possibly make an array that |
| big! Use dynamic allocation (*note Memory Allocation::) instead. |
| |
| |
| File: libc.info, Node: Options for Files, Next: File Minimums, Prev: Limits for Files, Up: System Configuration |
| |
| 32.7 Optional Features in File Support |
| ====================================== |
| |
| POSIX defines certain system-specific options in the system calls for |
| operating on files. Some systems support these options and others do |
| not. Since these options are provided in the kernel, not in the |
| library, simply using the GNU C Library does not guarantee that any of |
| these features is supported; it depends on the system you are using. |
| They can also vary between file systems on a single machine. |
| |
| This section describes the macros you can test to determine whether a |
| particular option is supported on your machine. If a given macro is |
| defined in 'unistd.h', then its value says whether the corresponding |
| feature is supported. (A value of '-1' indicates no; any other value |
| indicates yes.) If the macro is undefined, it means particular files |
| may or may not support the feature. |
| |
| Since all the machines that support the GNU C Library also support |
| NFS, one can never make a general statement about whether all file |
| systems support the '_POSIX_CHOWN_RESTRICTED' and '_POSIX_NO_TRUNC' |
| features. So these names are never defined as macros in the GNU C |
| Library. |
| |
| -- Macro: int _POSIX_CHOWN_RESTRICTED |
| If this option is in effect, the 'chown' function is restricted so |
| that the only changes permitted to nonprivileged processes is to |
| change the group owner of a file to either be the effective group |
| ID of the process, or one of its supplementary group IDs. *Note |
| File Owner::. |
| |
| -- Macro: int _POSIX_NO_TRUNC |
| If this option is in effect, file name components longer than |
| 'NAME_MAX' generate an 'ENAMETOOLONG' error. Otherwise, file name |
| components that are too long are silently truncated. |
| |
| -- Macro: unsigned char _POSIX_VDISABLE |
| This option is only meaningful for files that are terminal devices. |
| If it is enabled, then handling for special control characters can |
| be disabled individually. *Note Special Characters::. |
| |
| If one of these macros is undefined, that means that the option might |
| be in effect for some files and not for others. To inquire about a |
| particular file, call 'pathconf' or 'fpathconf'. *Note Pathconf::. |
| |
| |
| File: libc.info, Node: File Minimums, Next: Pathconf, Prev: Options for Files, Up: System Configuration |
| |
| 32.8 Minimum Values for File System Limits |
| ========================================== |
| |
| Here are the names for the POSIX minimum upper bounds for some of the |
| above parameters. The significance of these values is that you can |
| safely push to these limits without checking whether the particular |
| system you are using can go that far. In most cases GNU systems do not |
| have these strict limitations. The actual limit should be requested if |
| necessary. |
| |
| '_POSIX_LINK_MAX' |
| The most restrictive limit permitted by POSIX for the maximum value |
| of a file's link count. The value of this constant is '8'; thus, |
| you can always make up to eight names for a file without running |
| into a system limit. |
| |
| '_POSIX_MAX_CANON' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of bytes in a canonical input line from a terminal device. |
| The value of this constant is '255'. |
| |
| '_POSIX_MAX_INPUT' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of bytes in a terminal device input queue (or typeahead |
| buffer). *Note Input Modes::. The value of this constant is |
| '255'. |
| |
| '_POSIX_NAME_MAX' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of bytes in a file name component. The value of this |
| constant is '14'. |
| |
| '_POSIX_PATH_MAX' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of bytes in a file name. The value of this constant is |
| '256'. |
| |
| '_POSIX_PIPE_BUF' |
| The most restrictive limit permitted by POSIX for the maximum |
| number of bytes that can be written atomically to a pipe. The |
| value of this constant is '512'. |
| |
| 'SYMLINK_MAX' |
| Maximum number of bytes in a symbolic link. |
| |
| 'POSIX_REC_INCR_XFER_SIZE' |
| Recommended increment for file transfer sizes between the |
| 'POSIX_REC_MIN_XFER_SIZE' and 'POSIX_REC_MAX_XFER_SIZE' values. |
| |
| 'POSIX_REC_MAX_XFER_SIZE' |
| Maximum recommended file transfer size. |
| |
| 'POSIX_REC_MIN_XFER_SIZE' |
| Minimum recommended file transfer size. |
| |
| 'POSIX_REC_XFER_ALIGN' |
| Recommended file transfer buffer alignment. |
| |
| |
| File: libc.info, Node: Pathconf, Next: Utility Limits, Prev: File Minimums, Up: System Configuration |
| |
| 32.9 Using 'pathconf' |
| ===================== |
| |
| When your machine allows different files to have different values for a |
| file system parameter, you can use the functions in this section to find |
| out the value that applies to any particular file. |
| |
| These functions and the associated constants for the PARAMETER |
| argument are declared in the header file 'unistd.h'. |
| |
| -- Function: long int pathconf (const char *FILENAME, int PARAMETER) |
| Preliminary: | MT-Safe | AS-Unsafe lock heap | AC-Unsafe lock fd |
| mem | *Note POSIX Safety Concepts::. |
| |
| This function is used to inquire about the limits that apply to the |
| file named FILENAME. |
| |
| The PARAMETER argument should be one of the '_PC_' constants listed |
| below. |
| |
| The normal return value from 'pathconf' is the value you requested. |
| A value of '-1' is returned both if the implementation does not |
| impose a limit, and in case of an error. In the former case, |
| 'errno' is not set, while in the latter case, 'errno' is set to |
| indicate the cause of the problem. So the only way to use this |
| function robustly is to store '0' into 'errno' just before calling |
| it. |
| |
| Besides the usual file name errors (*note File Name Errors::), the |
| following error condition is defined for this function: |
| |
| 'EINVAL' |
| The value of PARAMETER is invalid, or the implementation |
| doesn't support the PARAMETER for the specific file. |
| |
| -- Function: long int fpathconf (int FILEDES, int PARAMETER) |
| Preliminary: | MT-Safe | AS-Unsafe lock heap | AC-Unsafe lock fd |
| mem | *Note POSIX Safety Concepts::. |
| |
| This is just like 'pathconf' except that an open file descriptor is |
| used to specify the file for which information is requested, |
| instead of a file name. |
| |
| The following 'errno' error conditions are defined for this |
| function: |
| |
| 'EBADF' |
| The FILEDES argument is not a valid file descriptor. |
| |
| 'EINVAL' |
| The value of PARAMETER is invalid, or the implementation |
| doesn't support the PARAMETER for the specific file. |
| |
| Here are the symbolic constants that you can use as the PARAMETER |
| argument to 'pathconf' and 'fpathconf'. The values are all integer |
| constants. |
| |
| '_PC_LINK_MAX' |
| Inquire about the value of 'LINK_MAX'. |
| |
| '_PC_MAX_CANON' |
| Inquire about the value of 'MAX_CANON'. |
| |
| '_PC_MAX_INPUT' |
| Inquire about the value of 'MAX_INPUT'. |
| |
| '_PC_NAME_MAX' |
| Inquire about the value of 'NAME_MAX'. |
| |
| '_PC_PATH_MAX' |
| Inquire about the value of 'PATH_MAX'. |
| |
| '_PC_PIPE_BUF' |
| Inquire about the value of 'PIPE_BUF'. |
| |
| '_PC_CHOWN_RESTRICTED' |
| Inquire about the value of '_POSIX_CHOWN_RESTRICTED'. |
| |
| '_PC_NO_TRUNC' |
| Inquire about the value of '_POSIX_NO_TRUNC'. |
| |
| '_PC_VDISABLE' |
| Inquire about the value of '_POSIX_VDISABLE'. |
| |
| '_PC_SYNC_IO' |
| Inquire about the value of '_POSIX_SYNC_IO'. |
| |
| '_PC_ASYNC_IO' |
| Inquire about the value of '_POSIX_ASYNC_IO'. |
| |
| '_PC_PRIO_IO' |
| Inquire about the value of '_POSIX_PRIO_IO'. |
| |
| '_PC_FILESIZEBITS' |
| Inquire about the availability of large files on the filesystem. |
| |
| '_PC_REC_INCR_XFER_SIZE' |
| Inquire about the value of 'POSIX_REC_INCR_XFER_SIZE'. |
| |
| '_PC_REC_MAX_XFER_SIZE' |
| Inquire about the value of 'POSIX_REC_MAX_XFER_SIZE'. |
| |
| '_PC_REC_MIN_XFER_SIZE' |
| Inquire about the value of 'POSIX_REC_MIN_XFER_SIZE'. |
| |
| '_PC_REC_XFER_ALIGN' |
| Inquire about the value of 'POSIX_REC_XFER_ALIGN'. |
| |
| *Portability Note:* On some systems, the GNU C Library does not |
| enforce '_PC_NAME_MAX' or '_PC_PATH_MAX' limits. |
| |
| |
| File: libc.info, Node: Utility Limits, Next: Utility Minimums, Prev: Pathconf, Up: System Configuration |
| |
| 32.10 Utility Program Capacity Limits |
| ===================================== |
| |
| The POSIX.2 standard specifies certain system limits that you can access |
| through 'sysconf' that apply to utility behavior rather than the |
| behavior of the library or the operating system. |
| |
| The GNU C Library defines macros for these limits, and 'sysconf' |
| returns values for them if you ask; but these values convey no |
| meaningful information. They are simply the smallest values that |
| POSIX.2 permits. |
| |
| -- Macro: int BC_BASE_MAX |
| The largest value of 'obase' that the 'bc' utility is guaranteed to |
| support. |
| |
| -- Macro: int BC_DIM_MAX |
| The largest number of elements in one array that the 'bc' utility |
| is guaranteed to support. |
| |
| -- Macro: int BC_SCALE_MAX |
| The largest value of 'scale' that the 'bc' utility is guaranteed to |
| support. |
| |
| -- Macro: int BC_STRING_MAX |
| The largest number of characters in one string constant that the |
| 'bc' utility is guaranteed to support. |
| |
| -- Macro: int COLL_WEIGHTS_MAX |
| The largest number of weights that can necessarily be used in |
| defining the collating sequence for a locale. |
| |
| -- Macro: int EXPR_NEST_MAX |
| The maximum number of expressions that can be nested within |
| parenthesis by the 'expr' utility. |
| |
| -- Macro: int LINE_MAX |
| The largest text line that the text-oriented POSIX.2 utilities can |
| support. (If you are using the GNU versions of these utilities, |
| then there is no actual limit except that imposed by the available |
| virtual memory, but there is no way that the library can tell you |
| this.) |
| |
| -- Macro: int EQUIV_CLASS_MAX |
| The maximum number of weights that can be assigned to an entry of |
| the 'LC_COLLATE' category 'order' keyword in a locale definition. |
| The GNU C Library does not presently support locale definitions. |
| |
| |
| File: libc.info, Node: Utility Minimums, Next: String Parameters, Prev: Utility Limits, Up: System Configuration |
| |
| 32.11 Minimum Values for Utility Limits |
| ======================================= |
| |
| '_POSIX2_BC_BASE_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| value of 'obase' in the 'bc' utility. Its value is '99'. |
| |
| '_POSIX2_BC_DIM_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| size of an array in the 'bc' utility. Its value is '2048'. |
| |
| '_POSIX2_BC_SCALE_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| value of 'scale' in the 'bc' utility. Its value is '99'. |
| |
| '_POSIX2_BC_STRING_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| size of a string constant in the 'bc' utility. Its value is |
| '1000'. |
| |
| '_POSIX2_COLL_WEIGHTS_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| number of weights that can necessarily be used in defining the |
| collating sequence for a locale. Its value is '2'. |
| |
| '_POSIX2_EXPR_NEST_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| number of expressions nested within parenthesis when using the |
| 'expr' utility. Its value is '32'. |
| |
| '_POSIX2_LINE_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| size of a text line that the text utilities can handle. Its value |
| is '2048'. |
| |
| '_POSIX2_EQUIV_CLASS_MAX' |
| The most restrictive limit permitted by POSIX.2 for the maximum |
| number of weights that can be assigned to an entry of the |
| 'LC_COLLATE' category 'order' keyword in a locale definition. Its |
| value is '2'. The GNU C Library does not presently support locale |
| definitions. |
| |
| |
| File: libc.info, Node: String Parameters, Prev: Utility Minimums, Up: System Configuration |
| |
| 32.12 String-Valued Parameters |
| ============================== |
| |
| POSIX.2 defines a way to get string-valued parameters from the operating |
| system with the function 'confstr': |
| |
| -- Function: size_t confstr (int PARAMETER, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function reads the value of a string-valued system parameter, |
| storing the string into LEN bytes of memory space starting at BUF. |
| The PARAMETER argument should be one of the '_CS_' symbols listed |
| below. |
| |
| The normal return value from 'confstr' is the length of the string |
| value that you asked for. If you supply a null pointer for BUF, |
| then 'confstr' does not try to store the string; it just returns |
| its length. A value of '0' indicates an error. |
| |
| If the string you asked for is too long for the buffer (that is, |
| longer than 'LEN - 1'), then 'confstr' stores just that much |
| (leaving room for the terminating null character). You can tell |
| that this has happened because 'confstr' returns a value greater |
| than or equal to LEN. |
| |
| The following 'errno' error conditions are defined for this |
| function: |
| |
| 'EINVAL' |
| The value of the PARAMETER is invalid. |
| |
| Currently there is just one parameter you can read with 'confstr': |
| |
| '_CS_PATH' |
| This parameter's value is the recommended default path for |
| searching for executable files. This is the path that a user has |
| by default just after logging in. |
| |
| '_CS_LFS_CFLAGS' |
| The returned string specifies which additional flags must be given |
| to the C compiler if a source is compiled using the |
| '_LARGEFILE_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| '_CS_LFS_LDFLAGS' |
| The returned string specifies which additional flags must be given |
| to the linker if a source is compiled using the '_LARGEFILE_SOURCE' |
| feature select macro; *note Feature Test Macros::. |
| |
| '_CS_LFS_LIBS' |
| The returned string specifies which additional libraries must be |
| linked to the application if a source is compiled using the |
| '_LARGEFILE_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| '_CS_LFS_LINTFLAGS' |
| The returned string specifies which additional flags must be given |
| to the lint tool if a source is compiled using the |
| '_LARGEFILE_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| '_CS_LFS64_CFLAGS' |
| The returned string specifies which additional flags must be given |
| to the C compiler if a source is compiled using the |
| '_LARGEFILE64_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| '_CS_LFS64_LDFLAGS' |
| The returned string specifies which additional flags must be given |
| to the linker if a source is compiled using the |
| '_LARGEFILE64_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| '_CS_LFS64_LIBS' |
| The returned string specifies which additional libraries must be |
| linked to the application if a source is compiled using the |
| '_LARGEFILE64_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| '_CS_LFS64_LINTFLAGS' |
| The returned string specifies which additional flags must be given |
| to the lint tool if a source is compiled using the |
| '_LARGEFILE64_SOURCE' feature select macro; *note Feature Test |
| Macros::. |
| |
| The way to use 'confstr' without any arbitrary limit on string size |
| is to call it twice: first call it to get the length, allocate the |
| buffer accordingly, and then call 'confstr' again to fill the buffer, |
| like this: |
| |
| char * |
| get_default_path (void) |
| { |
| size_t len = confstr (_CS_PATH, NULL, 0); |
| char *buffer = (char *) xmalloc (len); |
| |
| if (confstr (_CS_PATH, buf, len + 1) == 0) |
| { |
| free (buffer); |
| return NULL; |
| } |
| |
| return buffer; |
| } |
| |
| |
| File: libc.info, Node: Cryptographic Functions, Next: Debugging Support, Prev: System Configuration, Up: Top |
| |
| 33 DES Encryption and Password Handling |
| *************************************** |
| |
| On many systems, it is unnecessary to have any kind of user |
| authentication; for instance, a workstation which is not connected to a |
| network probably does not need any user authentication, because to use |
| the machine an intruder must have physical access. |
| |
| Sometimes, however, it is necessary to be sure that a user is |
| authorized to use some service a machine provides--for instance, to log |
| in as a particular user id (*note Users and Groups::). One traditional |
| way of doing this is for each user to choose a secret "password"; then, |
| the system can ask someone claiming to be a user what the user's |
| password is, and if the person gives the correct password then the |
| system can grant the appropriate privileges. |
| |
| If all the passwords are just stored in a file somewhere, then this |
| file has to be very carefully protected. To avoid this, passwords are |
| run through a "one-way function", a function which makes it difficult to |
| work out what its input was by looking at its output, before storing in |
| the file. |
| |
| The GNU C Library provides a one-way function that is compatible with |
| the behavior of the 'crypt' function introduced in FreeBSD 2.0. It |
| supports two one-way algorithms: one based on the MD5 message-digest |
| algorithm that is compatible with modern BSD systems, and the other |
| based on the Data Encryption Standard (DES) that is compatible with Unix |
| systems. |
| |
| It also provides support for Secure RPC, and some library functions |
| that can be used to perform normal DES encryption. The 'AUTH_DES' |
| authentication flavor in Secure RPC, as provided by the GNU C Library, |
| uses DES and does not comply with FIPS 140-2 nor does any other use of |
| DES within the GNU C Library. It is recommended that Secure RPC should |
| not be used for systems that need to comply with FIPS 140-2 since all |
| flavors of encrypted authentication use normal DES. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Legal Problems, Next: getpass, Up: Cryptographic Functions |
| |
| 33.1 Legal Problems |
| =================== |
| |
| Because of the continuously changing state of the law, it's not possible |
| to provide a definitive survey of the laws affecting cryptography. |
| Instead, this section warns you of some of the known trouble spots; this |
| may help you when you try to find out what the laws of your country are. |
| |
| Some countries require that you have a licence to use, possess, or |
| import cryptography. These countries are believed to include |
| Byelorussia, Burma, India, Indonesia, Israel, Kazakhstan, Pakistan, |
| Russia, and Saudi Arabia. |
| |
| Some countries restrict the transmission of encrypted messages by |
| radio; some telecommunications carriers restrict the transmission of |
| encrypted messages over their network. |
| |
| Many countries have some form of export control for encryption |
| software. The Wassenaar Arrangement is a multilateral agreement between |
| 33 countries (Argentina, Australia, Austria, Belgium, Bulgaria, Canada, |
| the Czech Republic, Denmark, Finland, France, Germany, Greece, Hungary, |
| Ireland, Italy, Japan, Luxembourg, the Netherlands, New Zealand, Norway, |
| Poland, Portugal, the Republic of Korea, Romania, the Russian |
| Federation, the Slovak Republic, Spain, Sweden, Switzerland, Turkey, |
| Ukraine, the United Kingdom and the United States) which restricts some |
| kinds of encryption exports. Different countries apply the arrangement |
| in different ways; some do not allow the exception for certain kinds of |
| "public domain" software (which would include this library), some only |
| restrict the export of software in tangible form, and others impose |
| significant additional restrictions. |
| |
| The United States has additional rules. This software would |
| generally be exportable under 15 CFR 740.13(e), which permits exports of |
| "encryption source code" which is "publicly available" and which is "not |
| subject to an express agreement for the payment of a licensing fee or |
| royalty for commercial production or sale of any product developed with |
| the source code" to most countries. |
| |
| The rules in this area are continuously changing. If you know of any |
| information in this manual that is out-of-date, please report it to the |
| bug database. *Note Reporting Bugs::. |
| |
| |
| File: libc.info, Node: getpass, Next: crypt, Prev: Legal Problems, Up: Cryptographic Functions |
| |
| 33.2 Reading Passwords |
| ====================== |
| |
| When reading in a password, it is desirable to avoid displaying it on |
| the screen, to help keep it secret. The following function handles this |
| in a convenient way. |
| |
| -- Function: char * getpass (const char *PROMPT) |
| Preliminary: | MT-Unsafe term | AS-Unsafe heap lock corrupt | |
| AC-Unsafe term lock corrupt | *Note POSIX Safety Concepts::. |
| |
| 'getpass' outputs PROMPT, then reads a string in from the terminal |
| without echoing it. It tries to connect to the real terminal, |
| '/dev/tty', if possible, to encourage users not to put plaintext |
| passwords in files; otherwise, it uses 'stdin' and 'stderr'. |
| 'getpass' also disables the INTR, QUIT, and SUSP characters on the |
| terminal using the 'ISIG' terminal attribute (*note Local Modes::). |
| The terminal is flushed before and after 'getpass', so that |
| characters of a mistyped password are not accidentally visible. |
| |
| In other C libraries, 'getpass' may only return the first |
| 'PASS_MAX' bytes of a password. The GNU C Library has no limit, so |
| 'PASS_MAX' is undefined. |
| |
| The prototype for this function is in 'unistd.h'. 'PASS_MAX' would |
| be defined in 'limits.h'. |
| |
| This precise set of operations may not suit all possible situations. |
| In this case, it is recommended that users write their own 'getpass' |
| substitute. For instance, a very simple substitute is as follows: |
| |
| |
| #include <termios.h> |
| #include <stdio.h> |
| |
| ssize_t |
| my_getpass (char **lineptr, size_t *n, FILE *stream) |
| { |
| struct termios old, new; |
| int nread; |
| |
| /* Turn echoing off and fail if we can't. */ |
| if (tcgetattr (fileno (stream), &old) != 0) |
| return -1; |
| new = old; |
| new.c_lflag &= ~ECHO; |
| if (tcsetattr (fileno (stream), TCSAFLUSH, &new) != 0) |
| return -1; |
| |
| /* Read the password. */ |
| nread = getline (lineptr, n, stream); |
| |
| /* Restore terminal. */ |
| (void) tcsetattr (fileno (stream), TCSAFLUSH, &old); |
| |
| return nread; |
| } |
| |
| The substitute takes the same parameters as 'getline' (*note Line |
| Input::); the user must print any prompt desired. |
| |
| |
| File: libc.info, Node: crypt, Next: DES Encryption, Prev: getpass, Up: Cryptographic Functions |
| |
| 33.3 Encrypting Passwords |
| ========================= |
| |
| -- Function: char * crypt (const char *KEY, const char *SALT) |
| Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock heap |
| dlopen | AC-Unsafe lock mem | *Note POSIX Safety Concepts::. |
| |
| The 'crypt' function takes a password, KEY, as a string, and a SALT |
| character array which is described below, and returns a printable |
| ASCII string which starts with another salt. It is believed that, |
| given the output of the function, the best way to find a KEY that |
| will produce that output is to guess values of KEY until the |
| original value of KEY is found. |
| |
| The SALT parameter does two things. Firstly, it selects which |
| algorithm is used, the MD5-based one or the DES-based one. |
| Secondly, it makes life harder for someone trying to guess |
| passwords against a file containing many passwords; without a SALT, |
| an intruder can make a guess, run 'crypt' on it once, and compare |
| the result with all the passwords. With a SALT, the intruder must |
| run 'crypt' once for each different salt. |
| |
| For the MD5-based algorithm, the SALT should consist of the string |
| '$1$', followed by up to 8 characters, terminated by either another |
| '$' or the end of the string. The result of 'crypt' will be the |
| SALT, followed by a '$' if the salt didn't end with one, followed |
| by 22 characters from the alphabet './0-9A-Za-z', up to 34 |
| characters total. Every character in the KEY is significant. |
| |
| For the DES-based algorithm, the SALT should consist of two |
| characters from the alphabet './0-9A-Za-z', and the result of |
| 'crypt' will be those two characters followed by 11 more from the |
| same alphabet, 13 in total. Only the first 8 characters in the KEY |
| are significant. |
| |
| The MD5-based algorithm has no limit on the useful length of the |
| password used, and is slightly more secure. It is therefore |
| preferred over the DES-based algorithm. |
| |
| When the user enters their password for the first time, the SALT |
| should be set to a new string which is reasonably random. To |
| verify a password against the result of a previous call to 'crypt', |
| pass the result of the previous call as the SALT. |
| |
| The following short program is an example of how to use 'crypt' the |
| first time a password is entered. Note that the SALT generation is just |
| barely acceptable; in particular, it is not unique between machines, and |
| in many applications it would not be acceptable to let an attacker know |
| what time the user's password was last set. |
| |
| |
| #include <stdio.h> |
| #include <time.h> |
| #include <unistd.h> |
| #include <crypt.h> |
| |
| int |
| main(void) |
| { |
| unsigned long seed[2]; |
| char salt[] = "$1$........"; |
| const char *const seedchars = |
| "./0123456789ABCDEFGHIJKLMNOPQRST" |
| "UVWXYZabcdefghijklmnopqrstuvwxyz"; |
| char *password; |
| int i; |
| |
| /* Generate a (not very) random seed. |
| You should do it better than this... */ |
| seed[0] = time(NULL); |
| seed[1] = getpid() ^ (seed[0] >> 14 & 0x30000); |
| |
| /* Turn it into printable characters from 'seedchars'. */ |
| for (i = 0; i < 8; i++) |
| salt[3+i] = seedchars[(seed[i/5] >> (i%5)*6) & 0x3f]; |
| |
| /* Read in the user's password and encrypt it. */ |
| password = crypt(getpass("Password:"), salt); |
| |
| /* Print the results. */ |
| puts(password); |
| return 0; |
| } |
| |
| The next program shows how to verify a password. It prompts the user |
| for a password and prints "Access granted." if the user types 'GNU libc |
| manual'. |
| |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <crypt.h> |
| |
| int |
| main(void) |
| { |
| /* Hashed form of "GNU libc manual". */ |
| const char *const pass = "$1$/iSaq7rB$EoUw5jJPPvAPECNaaWzMK/"; |
| |
| char *result; |
| int ok; |
| |
| /* Read in the user's password and encrypt it, |
| passing the expected password in as the salt. */ |
| result = crypt(getpass("Password:"), pass); |
| |
| /* Test the result. */ |
| ok = strcmp (result, pass) == 0; |
| |
| puts(ok ? "Access granted." : "Access denied."); |
| return ok ? 0 : 1; |
| } |
| |
| -- Function: char * crypt_r (const char *KEY, const char *SALT, struct |
| crypt_data * DATA) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt lock heap dlopen | |
| AC-Unsafe lock mem | *Note POSIX Safety Concepts::. |
| |
| The 'crypt_r' function does the same thing as 'crypt', but takes an |
| extra parameter which includes space for its result (among other |
| things), so it can be reentrant. 'data->initialized' must be |
| cleared to zero before the first time 'crypt_r' is called. |
| |
| The 'crypt_r' function is a GNU extension. |
| |
| The 'crypt' and 'crypt_r' functions are prototyped in the header |
| 'crypt.h'. |
| |
| |
| File: libc.info, Node: DES Encryption, Prev: crypt, Up: Cryptographic Functions |
| |
| 33.4 DES Encryption |
| =================== |
| |
| The Data Encryption Standard is described in the US Government Federal |
| Information Processing Standards (FIPS) 46-3 published by the National |
| Institute of Standards and Technology. The DES has been very thoroughly |
| analyzed since it was developed in the late 1970s, and no new |
| significant flaws have been found. |
| |
| However, the DES uses only a 56-bit key (plus 8 parity bits), and a |
| machine has been built in 1998 which can search through all possible |
| keys in about 6 days, which cost about US$200000; faster searches would |
| be possible with more money. This makes simple DES insecure for most |
| purposes, and NIST no longer permits new US government systems to use |
| simple DES. |
| |
| For serious encryption functionality, it is recommended that one of |
| the many free encryption libraries be used instead of these routines. |
| |
| The DES is a reversible operation which takes a 64-bit block and a |
| 64-bit key, and produces another 64-bit block. Usually the bits are |
| numbered so that the most-significant bit, the first bit, of each block |
| is numbered 1. |
| |
| Under that numbering, every 8th bit of the key (the 8th, 16th, and so |
| on) is not used by the encryption algorithm itself. But the key must |
| have odd parity; that is, out of bits 1 through 8, and 9 through 16, and |
| so on, there must be an odd number of '1' bits, and this completely |
| specifies the unused bits. |
| |
| -- Function: void setkey (const char *KEY) |
| Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock | |
| AC-Unsafe lock | *Note POSIX Safety Concepts::. |
| |
| The 'setkey' function sets an internal data structure to be an |
| expanded form of KEY. KEY is specified as an array of 64 bits each |
| stored in a 'char', the first bit is 'key[0]' and the 64th bit is |
| 'key[63]'. The KEY should have the correct parity. |
| |
| -- Function: void encrypt (char *BLOCK, int EDFLAG) |
| Preliminary: | MT-Unsafe race:crypt | AS-Unsafe corrupt lock | |
| AC-Unsafe lock | *Note POSIX Safety Concepts::. |
| |
| The 'encrypt' function encrypts BLOCK if EDFLAG is 0, otherwise it |
| decrypts BLOCK, using a key previously set by 'setkey'. The result |
| is placed in BLOCK. |
| |
| Like 'setkey', BLOCK is specified as an array of 64 bits each |
| stored in a 'char', but there are no parity bits in BLOCK. |
| |
| -- Function: void setkey_r (const char *KEY, struct crypt_data * DATA) |
| -- Function: void encrypt_r (char *BLOCK, int EDFLAG, struct crypt_data |
| * DATA) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt lock | AC-Unsafe lock | |
| *Note POSIX Safety Concepts::. |
| |
| These are reentrant versions of 'setkey' and 'encrypt'. The only |
| difference is the extra parameter, which stores the expanded |
| version of KEY. Before calling 'setkey_r' the first time, |
| 'data->initialized' must be cleared to zero. |
| |
| The 'setkey_r' and 'encrypt_r' functions are GNU extensions. |
| 'setkey', 'encrypt', 'setkey_r', and 'encrypt_r' are defined in |
| 'crypt.h'. |
| |
| -- Function: int ecb_crypt (char *KEY, char *BLOCKS, unsigned LEN, |
| unsigned MODE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The function 'ecb_crypt' encrypts or decrypts one or more blocks |
| using DES. Each block is encrypted independently. |
| |
| The BLOCKS and the KEY are stored packed in 8-bit bytes, so that |
| the first bit of the key is the most-significant bit of 'key[0]' |
| and the 63rd bit of the key is stored as the least-significant bit |
| of 'key[7]'. The KEY should have the correct parity. |
| |
| LEN is the number of bytes in BLOCKS. It should be a multiple of 8 |
| (so that there is a whole number of blocks to encrypt). LEN is |
| limited to a maximum of 'DES_MAXDATA' bytes. |
| |
| The result of the encryption replaces the input in BLOCKS. |
| |
| The MODE parameter is the bitwise OR of two of the following: |
| |
| 'DES_ENCRYPT' |
| This constant, used in the MODE parameter, specifies that |
| BLOCKS is to be encrypted. |
| |
| 'DES_DECRYPT' |
| This constant, used in the MODE parameter, specifies that |
| BLOCKS is to be decrypted. |
| |
| 'DES_HW' |
| This constant, used in the MODE parameter, asks to use a |
| hardware device. If no hardware device is available, |
| encryption happens anyway, but in software. |
| |
| 'DES_SW' |
| This constant, used in the MODE parameter, specifies that no |
| hardware device is to be used. |
| |
| The result of the function will be one of these values: |
| |
| 'DESERR_NONE' |
| The encryption succeeded. |
| |
| 'DESERR_NOHWDEVICE' |
| The encryption succeeded, but there was no hardware device |
| available. |
| |
| 'DESERR_HWERROR' |
| The encryption failed because of a hardware problem. |
| |
| 'DESERR_BADPARAM' |
| The encryption failed because of a bad parameter, for instance |
| LEN is not a multiple of 8 or LEN is larger than |
| 'DES_MAXDATA'. |
| |
| -- Function: int DES_FAILED (int ERR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns 1 if ERR is a 'success' result code from |
| 'ecb_crypt' or 'cbc_crypt', and 0 otherwise. |
| |
| -- Function: int cbc_crypt (char *KEY, char *BLOCKS, unsigned LEN, |
| unsigned MODE, char *IVEC) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The function 'cbc_crypt' encrypts or decrypts one or more blocks |
| using DES in Cipher Block Chaining mode. |
| |
| For encryption in CBC mode, each block is exclusive-ored with IVEC |
| before being encrypted, then IVEC is replaced with the result of |
| the encryption, then the next block is processed. Decryption is |
| the reverse of this process. |
| |
| This has the advantage that blocks which are the same before being |
| encrypted are very unlikely to be the same after being encrypted, |
| making it much harder to detect patterns in the data. |
| |
| Usually, IVEC is set to 8 random bytes before encryption starts. |
| Then the 8 random bytes are transmitted along with the encrypted |
| data (without themselves being encrypted), and passed back in as |
| IVEC for decryption. Another possibility is to set IVEC to 8 |
| zeroes initially, and have the first the block encrypted consist of |
| 8 random bytes. |
| |
| Otherwise, all the parameters are similar to those for 'ecb_crypt'. |
| |
| -- Function: void des_setparity (char *KEY) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The function 'des_setparity' changes the 64-bit KEY, stored packed |
| in 8-bit bytes, to have odd parity by altering the low bits of each |
| byte. |
| |
| The 'ecb_crypt', 'cbc_crypt', and 'des_setparity' functions and their |
| accompanying macros are all defined in the header 'rpc/des_crypt.h'. |
| |
| |
| File: libc.info, Node: Debugging Support, Next: POSIX Threads, Prev: Cryptographic Functions, Up: Top |
| |
| 34 Debugging support |
| ******************** |
| |
| Applications are usually debugged using dedicated debugger programs. |
| But sometimes this is not possible and, in any case, it is useful to |
| provide the developer with as much information as possible at the time |
| the problems are experienced. For this reason a few functions are |
| provided which a program can use to help the developer more easily |
| locate the problem. |
| |
| * Menu: |
| |
| * Backtraces:: Obtaining and printing a back trace of the |
| current stack. |
| |
| |
| File: libc.info, Node: Backtraces, Up: Debugging Support |
| |
| 34.1 Backtraces |
| =============== |
| |
| A "backtrace" is a list of the function calls that are currently active |
| in a thread. The usual way to inspect a backtrace of a program is to |
| use an external debugger such as gdb. However, sometimes it is useful |
| to obtain a backtrace programmatically from within a program, e.g., for |
| the purposes of logging or diagnostics. |
| |
| The header file 'execinfo.h' declares three functions that obtain and |
| manipulate backtraces of the current thread. |
| |
| -- Function: int backtrace (void **BUFFER, int SIZE) |
| Preliminary: | MT-Safe | AS-Unsafe init heap dlopen plugin lock | |
| AC-Unsafe init mem lock fd | *Note POSIX Safety Concepts::. |
| |
| The 'backtrace' function obtains a backtrace for the current |
| thread, as a list of pointers, and places the information into |
| BUFFER. The argument SIZE should be the number of 'void *' |
| elements that will fit into BUFFER. The return value is the actual |
| number of entries of BUFFER that are obtained, and is at most SIZE. |
| |
| The pointers placed in BUFFER are actually return addresses |
| obtained by inspecting the stack, one return address per stack |
| frame. |
| |
| Note that certain compiler optimizations may interfere with |
| obtaining a valid backtrace. Function inlining causes the inlined |
| function to not have a stack frame; tail call optimization replaces |
| one stack frame with another; frame pointer elimination will stop |
| 'backtrace' from interpreting the stack contents correctly. |
| |
| -- Function: char ** backtrace_symbols (void *const *BUFFER, int SIZE) |
| Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem lock | |
| *Note POSIX Safety Concepts::. |
| |
| The 'backtrace_symbols' function translates the information |
| obtained from the 'backtrace' function into an array of strings. |
| The argument BUFFER should be a pointer to an array of addresses |
| obtained via the 'backtrace' function, and SIZE is the number of |
| entries in that array (the return value of 'backtrace'). |
| |
| The return value is a pointer to an array of strings, which has |
| SIZE entries just like the array BUFFER. Each string contains a |
| printable representation of the corresponding element of BUFFER. |
| It includes the function name (if this can be determined), an |
| offset into the function, and the actual return address (in |
| hexadecimal). |
| |
| Currently, the function name and offset only be obtained on systems |
| that use the ELF binary format for programs and libraries. On |
| other systems, only the hexadecimal return address will be present. |
| Also, you may need to pass additional flags to the linker to make |
| the function names available to the program. (For example, on |
| systems using GNU ld, you must pass ('-rdynamic'.) |
| |
| The return value of 'backtrace_symbols' is a pointer obtained via |
| the 'malloc' function, and it is the responsibility of the caller |
| to 'free' that pointer. Note that only the return value need be |
| freed, not the individual strings. |
| |
| The return value is 'NULL' if sufficient memory for the strings |
| cannot be obtained. |
| |
| -- Function: void backtrace_symbols_fd (void *const *BUFFER, int SIZE, |
| int FD) |
| Preliminary: | MT-Safe | AS-Safe | AC-Unsafe lock | *Note POSIX |
| Safety Concepts::. |
| |
| The 'backtrace_symbols_fd' function performs the same translation |
| as the function 'backtrace_symbols' function. Instead of returning |
| the strings to the caller, it writes the strings to the file |
| descriptor FD, one per line. It does not use the 'malloc' |
| function, and can therefore be used in situations where that |
| function might fail. |
| |
| The following program illustrates the use of these functions. Note |
| that the array to contain the return addresses returned by 'backtrace' |
| is allocated on the stack. Therefore code like this can be used in |
| situations where the memory handling via 'malloc' does not work anymore |
| (in which case the 'backtrace_symbols' has to be replaced by a |
| 'backtrace_symbols_fd' call as well). The number of return addresses is |
| normally not very large. Even complicated programs rather seldom have a |
| nesting level of more than, say, 50 and with 200 possible entries |
| probably all programs should be covered. |
| |
| |
| #include <execinfo.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| /* Obtain a backtrace and print it to 'stdout'. */ |
| void |
| print_trace (void) |
| { |
| void *array[10]; |
| size_t size; |
| char **strings; |
| size_t i; |
| |
| size = backtrace (array, 10); |
| strings = backtrace_symbols (array, size); |
| |
| printf ("Obtained %zd stack frames.\n", size); |
| |
| for (i = 0; i < size; i++) |
| printf ("%s\n", strings[i]); |
| |
| free (strings); |
| } |
| |
| /* A dummy function to make the backtrace more interesting. */ |
| void |
| dummy_function (void) |
| { |
| print_trace (); |
| } |
| |
| int |
| main (void) |
| { |
| dummy_function (); |
| return 0; |
| } |
| |
| |
| File: libc.info, Node: POSIX Threads, Next: Internal Probes, Prev: Debugging Support, Up: Top |
| |
| 35 POSIX Threads |
| **************** |
| |
| This chapter describes the GNU C Library POSIX Thread implementation. |
| |
| * Menu: |
| |
| * Thread-specific Data:: Support for creating and |
| managing thread-specific data |
| * Non-POSIX Extensions:: Additional functions to extend |
| POSIX Thread functionality |
| |
| |
| File: libc.info, Node: Thread-specific Data, Next: Non-POSIX Extensions, Up: POSIX Threads |
| |
| 35.1 Thread-specific Data |
| ========================= |
| |
| The GNU C Library implements functions to allow users to create and |
| manage data specific to a thread. Such data may be destroyed at thread |
| exit, if a destructor is provided. The following functions are defined: |
| |
| -- Function: int pthread_key_create (pthread_key_t *KEY, void |
| (*DESTRUCTOR)(void*)) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Create a thread-specific data key for the calling thread, |
| referenced by KEY. |
| |
| Objects declared with the C++11 'thread_local' keyword are |
| destroyed before thread-specific data, so they should not be used |
| in thread-specific data destructors or even as members of the |
| thread-specific data, since the latter is passed as an argument to |
| the destructor function. |
| |
| -- Function: int pthread_key_delete (pthread_key_t KEY) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Destroy the thread-specific data KEY in the calling thread. The |
| destructor for the thread-specific data is not called during |
| destruction, nor is it called during thread exit. |
| |
| -- Function: void *pthread_getspecific (pthread_key_t KEY) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Return the thread-specific data associated with KEY in the calling |
| thread. |
| |
| -- Function: int pthread_setspecific (pthread_key_t KEY, const void |
| *VALUE) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt heap | AC-Unsafe corrupt |
| mem | *Note POSIX Safety Concepts::. |
| |
| Associate the thread-specific VALUE with KEY in the calling thread. |
| |
| |
| File: libc.info, Node: Non-POSIX Extensions, Prev: Thread-specific Data, Up: POSIX Threads |
| |
| 35.2 Non-POSIX Extensions |
| ========================= |
| |
| In addition to implementing the POSIX API for threads, the GNU C Library |
| provides additional functions and interfaces to provide functionality |
| not specified in the standard. |
| |
| * Menu: |
| |
| * Default Thread Attributes:: Setting default attributes for |
| threads in a process. |
| |
| |
| File: libc.info, Node: Default Thread Attributes, Up: Non-POSIX Extensions |
| |
| 35.2.1 Setting Process-wide defaults for thread attributes |
| ---------------------------------------------------------- |
| |
| The GNU C Library provides non-standard API functions to set and get the |
| default attributes used in the creation of threads in a process. |
| |
| -- Function: int pthread_getattr_default_np (pthread_attr_t *ATTR) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| Get the default attribute values and set ATTR to match. This |
| function returns 0 on success and a non-zero error code on failure. |
| |
| -- Function: int pthread_setattr_default_np (pthread_attr_t *ATTR) |
| Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock mem | |
| *Note POSIX Safety Concepts::. |
| |
| Set the default attribute values to match the values in ATTR. The |
| function returns 0 on success and a non-zero error code on failure. |
| The following error codes are defined for this function: |
| |
| 'EINVAL' |
| At least one of the values in ATTR does not qualify as valid |
| for the attributes or the stack address is set in the |
| attribute. |
| 'ENOMEM' |
| The system does not have sufficient memory. |
| |
| |
| File: libc.info, Node: Internal Probes, Next: Language Features, Prev: POSIX Threads, Up: Top |
| |
| 36 Internal probes |
| ****************** |
| |
| In order to aid in debugging and monitoring internal behavior, the GNU C |
| Library exposes nearly-zero-overhead SystemTap probes marked with the |
| 'libc' provider. |
| |
| These probes are not part of the GNU C Library stable ABI, and they |
| are subject to change or removal across releases. Our only promise with |
| regard to them is that, if we find a need to remove or modify the |
| arguments of a probe, the modified probe will have a different name, so |
| that program monitors relying on the old probe will not get unexpected |
| arguments. |
| |
| * Menu: |
| |
| * Memory Allocation Probes:: Probes in the memory allocation subsystem |
| * Mathematical Function Probes:: Probes in mathematical functions |
| * Non-local Goto Probes:: Probes in setjmp and longjmp |
| |
| |
| File: libc.info, Node: Memory Allocation Probes, Next: Mathematical Function Probes, Up: Internal Probes |
| |
| 36.1 Memory Allocation Probes |
| ============================= |
| |
| These probes are designed to signal relatively unusual situations within |
| the virtual memory subsystem of the GNU C Library. |
| |
| -- Probe: memory_sbrk_more (void *$ARG1, size_t $ARG2) |
| This probe is triggered after the main arena is extended by calling |
| 'sbrk'. Argument $ARG1 is the additional size requested to 'sbrk', |
| and $ARG2 is the pointer that marks the end of the 'sbrk' area, |
| returned in response to the request. |
| |
| -- Probe: memory_sbrk_less (void *$ARG1, size_t $ARG2) |
| This probe is triggered after the size of the main arena is |
| decreased by calling 'sbrk'. Argument $ARG1 is the size released |
| by 'sbrk' (the positive value, rather than the negative value |
| passed to 'sbrk'), and $ARG2 is the pointer that marks the end of |
| the 'sbrk' area, returned in response to the request. |
| |
| -- Probe: memory_heap_new (void *$ARG1, size_t $ARG2) |
| This probe is triggered after a new heap is 'mmap'ed. Argument |
| $ARG1 is a pointer to the base of the memory area, where the |
| 'heap_info' data structure is held, and $ARG2 is the size of the |
| heap. |
| |
| -- Probe: memory_heap_free (void *$ARG1, size_t $ARG2) |
| This probe is triggered _before_ (unlike the other sbrk and heap |
| probes) a heap is completely removed via 'munmap'. Argument $ARG1 |
| is a pointer to the heap, and $ARG2 is the size of the heap. |
| |
| -- Probe: memory_heap_more (void *$ARG1, size_t $ARG2) |
| This probe is triggered after a trailing portion of an 'mmap'ed |
| heap is extended. Argument $ARG1 is a pointer to the heap, and |
| $ARG2 is the new size of the heap. |
| |
| -- Probe: memory_heap_less (void *$ARG1, size_t $ARG2) |
| This probe is triggered after a trailing portion of an 'mmap'ed |
| heap is released. Argument $ARG1 is a pointer to the heap, and |
| $ARG2 is the new size of the heap. |
| |
| -- Probe: memory_malloc_retry (size_t $ARG1) |
| -- Probe: memory_realloc_retry (size_t $ARG1, void *$ARG2) |
| -- Probe: memory_memalign_retry (size_t $ARG1, size_t $ARG2) |
| -- Probe: memory_calloc_retry (size_t $ARG1) |
| These probes are triggered when the corresponding functions fail to |
| obtain the requested amount of memory from the arena in use, before |
| they call 'arena_get_retry' to select an alternate arena in which |
| to retry the allocation. Argument $ARG1 is the amount of memory |
| requested by the user; in the 'calloc' case, that is the total size |
| computed from both function arguments. In the 'realloc' case, |
| $ARG2 is the pointer to the memory area being resized. In the |
| 'memalign' case, $ARG2 is the alignment to be used for the request, |
| which may be stricter than the value passed to the 'memalign' |
| function. A 'memalign' probe is also used by functions |
| 'posix_memalign, valloc' and 'pvalloc'. |
| |
| Note that the argument order does _not_ match that of the |
| corresponding two-argument functions, so that in all of these |
| probes the user-requested allocation size is in $ARG1. |
| |
| -- Probe: memory_arena_retry (size_t $ARG1, void *$ARG2) |
| This probe is triggered within 'arena_get_retry' (the function |
| called to select the alternate arena in which to retry an |
| allocation that failed on the first attempt), before the selection |
| of an alternate arena. This probe is redundant, but much easier to |
| use when it's not important to determine which of the various |
| memory allocation functions is failing to allocate on the first |
| try. Argument $ARG1 is the same as in the function-specific |
| probes, except for extra room for padding introduced by functions |
| that have to ensure stricter alignment. Argument $ARG2 is the |
| arena in which allocation failed. |
| |
| -- Probe: memory_arena_new (void *$ARG1, size_t $ARG2) |
| This probe is triggered when 'malloc' allocates and initializes an |
| additional arena (not the main arena), but before the arena is |
| assigned to the running thread or inserted into the internal linked |
| list of arenas. The arena's 'malloc_state' internal data structure |
| is located at $ARG1, within a newly-allocated heap big enough to |
| hold at least $ARG2 bytes. |
| |
| -- Probe: memory_arena_reuse (void *$ARG1, void *$ARG2) |
| This probe is triggered when 'malloc' has just selected an existing |
| arena to reuse, and (temporarily) reserved it for exclusive use. |
| Argument $ARG1 is a pointer to the newly-selected arena, and $ARG2 |
| is a pointer to the arena previously used by that thread. |
| |
| This occurs within 'reused_arena', right after the mutex mentioned |
| in probe 'memory_arena_reuse_wait' is acquired; argument $ARG1 will |
| point to the same arena. In this configuration, this will usually |
| only occur once per thread. The exception is when a thread first |
| selected the main arena, but a subsequent allocation from it fails: |
| then, and only then, may we switch to another arena to retry that |
| allocations, and for further allocations within that thread. |
| |
| -- Probe: memory_arena_reuse_wait (void *$ARG1, void *$ARG2, void |
| *$ARG3) |
| This probe is triggered when 'malloc' is about to wait for an arena |
| to become available for reuse. Argument $ARG1 holds a pointer to |
| the mutex the thread is going to wait on, $ARG2 is a pointer to a |
| newly-chosen arena to be reused, and $ARG3 is a pointer to the |
| arena previously used by that thread. |
| |
| This occurs within 'reused_arena', when a thread first tries to |
| allocate memory or needs a retry after a failure to allocate from |
| the main arena, there isn't any free arena, the maximum number of |
| arenas has been reached, and an existing arena was chosen for |
| reuse, but its mutex could not be immediately acquired. The mutex |
| in $ARG1 is the mutex of the selected arena. |
| |
| -- Probe: memory_arena_reuse_free_list (void *$ARG1) |
| This probe is triggered when 'malloc' has chosen an arena that is |
| in the free list for use by a thread, within the 'get_free_list' |
| function. The argument $ARG1 holds a pointer to the selected |
| arena. |
| |
| -- Probe: memory_mallopt (int $ARG1, int $ARG2) |
| This probe is triggered when function 'mallopt' is called to change |
| 'malloc' internal configuration parameters, before any change to |
| the parameters is made. The arguments $ARG1 and $ARG2 are the ones |
| passed to the 'mallopt' function. |
| |
| -- Probe: memory_mallopt_mxfast (int $ARG1, int $ARG2) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_MXFAST', and the requested |
| value is in an acceptable range. Argument $ARG1 is the requested |
| value, and $ARG2 is the previous value of this 'malloc' parameter. |
| |
| -- Probe: memory_mallopt_trim_threshold (int $ARG1, int $ARG2, int |
| $ARG3) |
| This probe is triggere shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_TRIM_THRESHOLD'. Argument |
| $ARG1 is the requested value, $ARG2 is the previous value of this |
| 'malloc' parameter, and $ARG3 is nonzero if dynamic threshold |
| adjustment was already disabled. |
| |
| -- Probe: memory_mallopt_top_pad (int $ARG1, int $ARG2, int $ARG3) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_TOP_PAD'. Argument $ARG1 is |
| the requested value, $ARG2 is the previous value of this 'malloc' |
| parameter, and $ARG3 is nonzero if dynamic threshold adjustment was |
| already disabled. |
| |
| -- Probe: memory_mallopt_mmap_threshold (int $ARG1, int $ARG2, int |
| $ARG3) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_MMAP_THRESHOLD', and the |
| requested value is in an acceptable range. Argument $ARG1 is the |
| requested value, $ARG2 is the previous value of this 'malloc' |
| parameter, and $ARG3 is nonzero if dynamic threshold adjustment was |
| already disabled. |
| |
| -- Probe: memory_mallopt_mmap_max (int $ARG1, int $ARG2, int $ARG3) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_MMAP_MAX'. Argument $ARG1 |
| is the requested value, $ARG2 is the previous value of this |
| 'malloc' parameter, and $ARG3 is nonzero if dynamic threshold |
| adjustment was already disabled. |
| |
| -- Probe: memory_mallopt_check_action (int $ARG1, int $ARG2) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_CHECK_ACTION'. Argument |
| $ARG1 is the requested value, and $ARG2 is the previous value of |
| this 'malloc' parameter. |
| |
| -- Probe: memory_mallopt_perturb (int $ARG1, int $ARG2) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_PERTURB'. Argument $ARG1 is |
| the requested value, and $ARG2 is the previous value of this |
| 'malloc' parameter. |
| |
| -- Probe: memory_mallopt_arena_test (int $ARG1, int $ARG2) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_ARENA_TEST', and the |
| requested value is in an acceptable range. Argument $ARG1 is the |
| requested value, and $ARG2 is the previous value of this 'malloc' |
| parameter. |
| |
| -- Probe: memory_mallopt_arena_max (int $ARG1, int $ARG2) |
| This probe is triggered shortly after the 'memory_mallopt' probe, |
| when the parameter to be changed is 'M_ARENA_MAX', and the |
| requested value is in an acceptable range. Argument $ARG1 is the |
| requested value, and $ARG2 is the previous value of this 'malloc' |
| parameter. |
| |
| -- Probe: memory_mallopt_free_dyn_thresholds (int $ARG1, int $ARG2) |
| This probe is triggered when function 'free' decides to adjust the |
| dynamic brk/mmap thresholds. Argument $ARG1 and $ARG2 are the |
| adjusted mmap and trim thresholds, respectively. |
| |
| |
| File: libc.info, Node: Mathematical Function Probes, Next: Non-local Goto Probes, Prev: Memory Allocation Probes, Up: Internal Probes |
| |
| 36.2 Mathematical Function Probes |
| ================================= |
| |
| Some mathematical functions fall back to multiple precision arithmetic |
| for some inputs to get last bit precision for their return values. This |
| multiple precision fallback is much slower than the default algorithms |
| and may have a significant impact on application performance. The |
| systemtap probe markers described in this section may help you determine |
| if your application calls mathematical functions with inputs that may |
| result in multiple-precision arithmetic. |
| |
| Unless explicitly mentioned otherwise, a precision of 1 implies 24 |
| bits of precision in the mantissa of the multiple precision number. |
| Hence, a precision level of 32 implies 768 bits of precision in the |
| mantissa. |
| |
| -- Probe: slowexp_p6 (double $ARG1, double $ARG2) |
| This probe is triggered when the 'exp' function is called with an |
| input that results in multiple precision computation with precision |
| 6. Argument $ARG1 is the input value and $ARG2 is the computed |
| output. |
| |
| -- Probe: slowexp_p32 (double $ARG1, double $ARG2) |
| This probe is triggered when the 'exp' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input value and $ARG2 is the computed |
| output. |
| |
| -- Probe: slowpow_p10 (double $ARG1, double $ARG2, double $ARG3, double |
| $ARG4) |
| This probe is triggered when the 'pow' function is called with |
| inputs that result in multiple precision computation with precision |
| 10. Arguments $ARG1 and $ARG2 are the input values, '$arg3' is the |
| value computed in the fast phase of the algorithm and '$arg4' is |
| the final accurate value. |
| |
| -- Probe: slowpow_p32 (double $ARG1, double $ARG2, double $ARG3, double |
| $ARG4) |
| This probe is triggered when the 'pow' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Arguments $ARG1 and $ARG2 are the input values, '$arg3' is the |
| value computed in the fast phase of the algorithm and '$arg4' is |
| the final accurate value. |
| |
| -- Probe: slowlog (int $ARG1, double $ARG2, double $ARG3) |
| This probe is triggered when the 'log' function is called with an |
| input that results in multiple precision computation. Argument |
| $ARG1 is the precision with which the computation succeeded. |
| Argument $ARG2 is the input and $ARG3 is the computed output. |
| |
| -- Probe: slowlog_inexact (int $ARG1, double $ARG2, double $ARG3) |
| This probe is triggered when the 'log' function is called with an |
| input that results in multiple precision computation and none of |
| the multiple precision computations result in an accurate result. |
| Argument $ARG1 is the maximum precision with which computations |
| were performed. Argument $ARG2 is the input and $ARG3 is the |
| computed output. |
| |
| -- Probe: slowatan2 (int $ARG1, double $ARG2, double $ARG3, double |
| $ARG4) |
| This probe is triggered when the 'atan2' function is called with an |
| input that results in multiple precision computation. Argument |
| $ARG1 is the precision with which computation succeeded. Arguments |
| $ARG2 and $ARG3 are inputs to the 'atan2' function and $ARG4 is the |
| computed result. |
| |
| -- Probe: slowatan2_inexact (int $ARG1, double $ARG2, double $ARG3, |
| double $ARG4) |
| This probe is triggered when the 'atan' function is called with an |
| input that results in multiple precision computation and none of |
| the multiple precision computations result in an accurate result. |
| Argument $ARG1 is the maximum precision with which computations |
| were performed. Arguments $ARG2 and $ARG3 are inputs to the |
| 'atan2' function and $ARG4 is the computed result. |
| |
| -- Probe: slowatan (int $ARG1, double $ARG2, double $ARG3) |
| This probe is triggered when the 'atan' function is called with an |
| input that results in multiple precision computation. Argument |
| $ARG1 is the precision with which computation succeeded. Argument |
| $ARG2 is the input to the 'atan' function and $ARG3 is the computed |
| result. |
| |
| -- Probe: slowatan_inexact (int $ARG1, double $ARG2, double $ARG3) |
| This probe is triggered when the 'atan' function is called with an |
| input that results in multiple precision computation and none of |
| the multiple precision computations result in an accurate result. |
| Argument $ARG1 is the maximum precision with which computations |
| were performed. Argument $ARG2 is the input to the 'atan' function |
| and $ARG3 is the computed result. |
| |
| -- Probe: slowtan (double $ARG1, double $ARG2) |
| This probe is triggered when the 'tan' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function and $ARG2 is the |
| computed result. |
| |
| -- Probe: slowasin (double $ARG1, double $ARG2) |
| This probe is triggered when the 'asin' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function and $ARG2 is the |
| computed result. |
| |
| -- Probe: slowacos (double $ARG1, double $ARG2) |
| This probe is triggered when the 'acos' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function and $ARG2 is the |
| computed result. |
| |
| -- Probe: slowsin (double $ARG1, double $ARG2) |
| This probe is triggered when the 'sin' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function and $ARG2 is the |
| computed result. |
| |
| -- Probe: slowcos (double $ARG1, double $ARG2) |
| This probe is triggered when the 'cos' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function and $ARG2 is the |
| computed result. |
| |
| -- Probe: slowsin_dx (double $ARG1, double $ARG2, double $ARG3) |
| This probe is triggered when the 'sin' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function, $ARG2 is the |
| error bound of $ARG1 and $ARG3 is the computed result. |
| |
| -- Probe: slowcos_dx (double $ARG1, double $ARG2, double $ARG3) |
| This probe is triggered when the 'cos' function is called with an |
| input that results in multiple precision computation with precision |
| 32. Argument $ARG1 is the input to the function, $ARG2 is the |
| error bound of $ARG1 and $ARG3 is the computed result. |
| |
| |
| File: libc.info, Node: Non-local Goto Probes, Prev: Mathematical Function Probes, Up: Internal Probes |
| |
| 36.3 Non-local Goto Probes |
| ========================== |
| |
| These probes are used to signal calls to 'setjmp', 'sigsetjmp', |
| 'longjmp' or 'siglongjmp'. |
| |
| -- Probe: setjmp (void *$ARG1, int $ARG2, void *$ARG3) |
| This probe is triggered whenever 'setjmp' or 'sigsetjmp' is called. |
| Argument $ARG1 is a pointer to the 'jmp_buf' passed as the first |
| argument of 'setjmp' or 'sigsetjmp', $ARG2 is the second argument |
| of 'sigsetjmp' or zero if this is a call to 'setjmp' and $ARG3 is a |
| pointer to the return address that will be stored in the 'jmp_buf'. |
| |
| -- Probe: longjmp (void *$ARG1, int $ARG2, void *$ARG3) |
| This probe is triggered whenever 'longjmp' or 'siglongjmp' is |
| called. Argument $ARG1 is a pointer to the 'jmp_buf' passed as the |
| first argument of 'longjmp' or 'siglongjmp', $ARG2 is the return |
| value passed as the second argument of 'longjmp' or 'siglongjmp' |
| and $ARG3 is a pointer to the return address 'longjmp' or |
| 'siglongjmp' will return to. |
| |
| The 'longjmp' probe is triggered at a point where the registers |
| have not yet been restored to the values in the 'jmp_buf' and |
| unwinding will show a call stack including the caller of 'longjmp' |
| or 'siglongjmp'. |
| |
| -- Probe: longjmp_target (void *$ARG1, int $ARG2, void *$ARG3) |
| This probe is triggered under the same conditions and with the same |
| arguments as the 'longjmp' probe. |
| |
| The 'longjmp_target' probe is triggered at a point where the |
| registers have been restored to the values in the 'jmp_buf' and |
| unwinding will show a call stack including the caller of 'setjmp' |
| or 'sigsetjmp'. |
| |
| |
| File: libc.info, Node: Language Features, Next: Library Summary, Prev: Internal Probes, Up: Top |
| |
| Appendix A C Language Facilities in the Library |
| *********************************************** |
| |
| Some of the facilities implemented by the C library really should be |
| thought of as parts of the C language itself. These facilities ought to |
| be documented in the C Language Manual, not in the library manual; but |
| since we don't have the language manual yet, and documentation for these |
| features has been written, we are publishing it here. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Consistency Checking, Next: Variadic Functions, Up: Language Features |
| |
| A.1 Explicitly Checking Internal Consistency |
| ============================================ |
| |
| When you're writing a program, it's often a good idea to put in checks |
| at strategic places for "impossible" errors or violations of basic |
| assumptions. These kinds of checks are helpful in debugging problems |
| with the interfaces between different parts of the program, for example. |
| |
| The 'assert' macro, defined in the header file 'assert.h', provides a |
| convenient way to abort the program while printing a message about where |
| in the program the error was detected. |
| |
| Once you think your program is debugged, you can disable the error |
| checks performed by the 'assert' macro by recompiling with the macro |
| 'NDEBUG' defined. This means you don't actually have to change the |
| program source code to disable these checks. |
| |
| But disabling these consistency checks is undesirable unless they |
| make the program significantly slower. All else being equal, more error |
| checking is good no matter who is running the program. A wise user |
| would rather have a program crash, visibly, than have it return nonsense |
| without indicating anything might be wrong. |
| |
| -- Macro: void assert (int EXPRESSION) |
| Preliminary: | MT-Safe | AS-Unsafe heap corrupt | AC-Unsafe mem |
| lock corrupt | *Note POSIX Safety Concepts::. |
| |
| Verify the programmer's belief that EXPRESSION is nonzero at this |
| point in the program. |
| |
| If 'NDEBUG' is not defined, 'assert' tests the value of EXPRESSION. |
| If it is false (zero), 'assert' aborts the program (*note Aborting |
| a Program::) after printing a message of the form: |
| |
| FILE:LINENUM: FUNCTION: Assertion `EXPRESSION' failed. |
| |
| on the standard error stream 'stderr' (*note Standard Streams::). |
| The filename and line number are taken from the C preprocessor |
| macros '__FILE__' and '__LINE__' and specify where the call to |
| 'assert' was made. When using the GNU C compiler, the name of the |
| function which calls 'assert' is taken from the built-in variable |
| '__PRETTY_FUNCTION__'; with older compilers, the function name and |
| following colon are omitted. |
| |
| If the preprocessor macro 'NDEBUG' is defined before 'assert.h' is |
| included, the 'assert' macro is defined to do absolutely nothing. |
| |
| *Warning:* Even the argument expression EXPRESSION is not evaluated |
| if 'NDEBUG' is in effect. So never use 'assert' with arguments |
| that involve side effects. For example, 'assert (++i > 0);' is a |
| bad idea, because 'i' will not be incremented if 'NDEBUG' is |
| defined. |
| |
| Sometimes the "impossible" condition you want to check for is an |
| error return from an operating system function. Then it is useful to |
| display not only where the program crashes, but also what error was |
| returned. The 'assert_perror' macro makes this easy. |
| |
| -- Macro: void assert_perror (int ERRNUM) |
| Preliminary: | MT-Safe | AS-Unsafe heap corrupt | AC-Unsafe mem |
| lock corrupt | *Note POSIX Safety Concepts::. |
| |
| Similar to 'assert', but verifies that ERRNUM is zero. |
| |
| If 'NDEBUG' is not defined, 'assert_perror' tests the value of |
| ERRNUM. If it is nonzero, 'assert_perror' aborts the program after |
| printing a message of the form: |
| |
| FILE:LINENUM: FUNCTION: ERROR TEXT |
| |
| on the standard error stream. The file name, line number, and |
| function name are as for 'assert'. The error text is the result of |
| 'strerror (ERRNUM)'. *Note Error Messages::. |
| |
| Like 'assert', if 'NDEBUG' is defined before 'assert.h' is |
| included, the 'assert_perror' macro does absolutely nothing. It |
| does not evaluate the argument, so ERRNUM should not have any side |
| effects. It is best for ERRNUM to be just a simple variable |
| reference; often it will be 'errno'. |
| |
| This macro is a GNU extension. |
| |
| *Usage note:* The 'assert' facility is designed for detecting |
| _internal inconsistency_; it is not suitable for reporting invalid input |
| or improper usage by the _user_ of the program. |
| |
| The information in the diagnostic messages printed by the 'assert' |
| and 'assert_perror' macro is intended to help you, the programmer, track |
| down the cause of a bug, but is not really useful for telling a user of |
| your program why his or her input was invalid or why a command could not |
| be carried out. What's more, your program should not abort when given |
| invalid input, as 'assert' would do--it should exit with nonzero status |
| (*note Exit Status::) after printing its error messages, or perhaps read |
| another command or move on to the next input file. |
| |
| *Note Error Messages::, for information on printing error messages |
| for problems that _do not_ represent bugs in the program. |
| |
| |
| File: libc.info, Node: Variadic Functions, Next: Null Pointer Constant, Prev: Consistency Checking, Up: Language Features |
| |
| A.2 Variadic Functions |
| ====================== |
| |
| ISO C defines a syntax for declaring a function to take a variable |
| number or type of arguments. (Such functions are referred to as |
| "varargs functions" or "variadic functions".) However, the language |
| itself provides no mechanism for such functions to access their |
| non-required arguments; instead, you use the variable arguments macros |
| defined in 'stdarg.h'. |
| |
| This section describes how to declare variadic functions, how to |
| write them, and how to call them properly. |
| |
| *Compatibility Note:* Many older C dialects provide a similar, but |
| incompatible, mechanism for defining functions with variable numbers of |
| arguments, using 'varargs.h'. |
| |
| * Menu: |
| |
| * Why Variadic:: Reasons for making functions take |
| variable arguments. |
| * How Variadic:: How to define and call variadic functions. |
| * Variadic Example:: A complete example. |
| |
| |
| File: libc.info, Node: Why Variadic, Next: How Variadic, Up: Variadic Functions |
| |
| A.2.1 Why Variadic Functions are Used |
| ------------------------------------- |
| |
| Ordinary C functions take a fixed number of arguments. When you define |
| a function, you specify the data type for each argument. Every call to |
| the function should supply the expected number of arguments, with types |
| that can be converted to the specified ones. Thus, if the function |
| 'foo' is declared with 'int foo (int, char *);' then you must call it |
| with two arguments, a number (any kind will do) and a string pointer. |
| |
| But some functions perform operations that can meaningfully accept an |
| unlimited number of arguments. |
| |
| In some cases a function can handle any number of values by operating |
| on all of them as a block. For example, consider a function that |
| allocates a one-dimensional array with 'malloc' to hold a specified set |
| of values. This operation makes sense for any number of values, as long |
| as the length of the array corresponds to that number. Without |
| facilities for variable arguments, you would have to define a separate |
| function for each possible array size. |
| |
| The library function 'printf' (*note Formatted Output::) is an |
| example of another class of function where variable arguments are |
| useful. This function prints its arguments (which can vary in type as |
| well as number) under the control of a format template string. |
| |
| These are good reasons to define a "variadic" function which can |
| handle as many arguments as the caller chooses to pass. |
| |
| Some functions such as 'open' take a fixed set of arguments, but |
| occasionally ignore the last few. Strict adherence to ISO C requires |
| these functions to be defined as variadic; in practice, however, the GNU |
| C compiler and most other C compilers let you define such a function to |
| take a fixed set of arguments--the most it can ever use--and then only |
| _declare_ the function as variadic (or not declare its arguments at |
| all!). |
| |
| |
| File: libc.info, Node: How Variadic, Next: Variadic Example, Prev: Why Variadic, Up: Variadic Functions |
| |
| A.2.2 How Variadic Functions are Defined and Used |
| ------------------------------------------------- |
| |
| Defining and using a variadic function involves three steps: |
| |
| * _Define_ the function as variadic, using an ellipsis ('...') in the |
| argument list, and using special macros to access the variable |
| arguments. *Note Receiving Arguments::. |
| |
| * _Declare_ the function as variadic, using a prototype with an |
| ellipsis ('...'), in all the files which call it. *Note Variadic |
| Prototypes::. |
| |
| * _Call_ the function by writing the fixed arguments followed by the |
| additional variable arguments. *Note Calling Variadics::. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Variadic Prototypes, Next: Receiving Arguments, Up: How Variadic |
| |
| A.2.2.1 Syntax for Variable Arguments |
| ..................................... |
| |
| A function that accepts a variable number of arguments must be declared |
| with a prototype that says so. You write the fixed arguments as usual, |
| and then tack on '...' to indicate the possibility of additional |
| arguments. The syntax of ISO C requires at least one fixed argument |
| before the '...'. For example, |
| |
| int |
| func (const char *a, int b, ...) |
| { |
| ... |
| } |
| |
| defines a function 'func' which returns an 'int' and takes two required |
| arguments, a 'const char *' and an 'int'. These are followed by any |
| number of anonymous arguments. |
| |
| *Portability note:* For some C compilers, the last required argument |
| must not be declared 'register' in the function definition. |
| Furthermore, this argument's type must be "self-promoting": that is, the |
| default promotions must not change its type. This rules out array and |
| function types, as well as 'float', 'char' (whether signed or not) and 'short int' |
| (whether signed or not). This is actually an ISO C requirement. |
| |
| |
| File: libc.info, Node: Receiving Arguments, Next: How Many Arguments, Prev: Variadic Prototypes, Up: How Variadic |
| |
| A.2.2.2 Receiving the Argument Values |
| ..................................... |
| |
| Ordinary fixed arguments have individual names, and you can use these |
| names to access their values. But optional arguments have no |
| names--nothing but '...'. How can you access them? |
| |
| The only way to access them is sequentially, in the order they were |
| written, and you must use special macros from 'stdarg.h' in the |
| following three step process: |
| |
| 1. You initialize an argument pointer variable of type 'va_list' using |
| 'va_start'. The argument pointer when initialized points to the |
| first optional argument. |
| |
| 2. You access the optional arguments by successive calls to 'va_arg'. |
| The first call to 'va_arg' gives you the first optional argument, |
| the next call gives you the second, and so on. |
| |
| You can stop at any time if you wish to ignore any remaining |
| optional arguments. It is perfectly all right for a function to |
| access fewer arguments than were supplied in the call, but you will |
| get garbage values if you try to access too many arguments. |
| |
| 3. You indicate that you are finished with the argument pointer |
| variable by calling 'va_end'. |
| |
| (In practice, with most C compilers, calling 'va_end' does nothing. |
| This is always true in the GNU C compiler. But you might as well |
| call 'va_end' just in case your program is someday compiled with a |
| peculiar compiler.) |
| |
| *Note Argument Macros::, for the full definitions of 'va_start', |
| 'va_arg' and 'va_end'. |
| |
| Steps 1 and 3 must be performed in the function that accepts the |
| optional arguments. However, you can pass the 'va_list' variable as an |
| argument to another function and perform all or part of step 2 there. |
| |
| You can perform the entire sequence of three steps multiple times |
| within a single function invocation. If you want to ignore the optional |
| arguments, you can do these steps zero times. |
| |
| You can have more than one argument pointer variable if you like. |
| You can initialize each variable with 'va_start' when you wish, and then |
| you can fetch arguments with each argument pointer as you wish. Each |
| argument pointer variable will sequence through the same set of argument |
| values, but at its own pace. |
| |
| *Portability note:* With some compilers, once you pass an argument |
| pointer value to a subroutine, you must not keep using the same argument |
| pointer value after that subroutine returns. For full portability, you |
| should just pass it to 'va_end'. This is actually an ISO C requirement, |
| but most ANSI C compilers work happily regardless. |
| |
| |
| File: libc.info, Node: How Many Arguments, Next: Calling Variadics, Prev: Receiving Arguments, Up: How Variadic |
| |
| A.2.2.3 How Many Arguments Were Supplied |
| ........................................ |
| |
| There is no general way for a function to determine the number and type |
| of the optional arguments it was called with. So whoever designs the |
| function typically designs a convention for the caller to specify the |
| number and type of arguments. It is up to you to define an appropriate |
| calling convention for each variadic function, and write all calls |
| accordingly. |
| |
| One kind of calling convention is to pass the number of optional |
| arguments as one of the fixed arguments. This convention works provided |
| all of the optional arguments are of the same type. |
| |
| A similar alternative is to have one of the required arguments be a |
| bit mask, with a bit for each possible purpose for which an optional |
| argument might be supplied. You would test the bits in a predefined |
| sequence; if the bit is set, fetch the value of the next argument, |
| otherwise use a default value. |
| |
| A required argument can be used as a pattern to specify both the |
| number and types of the optional arguments. The format string argument |
| to 'printf' is one example of this (*note Formatted Output Functions::). |
| |
| Another possibility is to pass an "end marker" value as the last |
| optional argument. For example, for a function that manipulates an |
| arbitrary number of pointer arguments, a null pointer might indicate the |
| end of the argument list. (This assumes that a null pointer isn't |
| otherwise meaningful to the function.) The 'execl' function works in |
| just this way; see *note Executing a File::. |
| |
| |
| File: libc.info, Node: Calling Variadics, Next: Argument Macros, Prev: How Many Arguments, Up: How Variadic |
| |
| A.2.2.4 Calling Variadic Functions |
| .................................. |
| |
| You don't have to do anything special to call a variadic function. Just |
| put the arguments (required arguments, followed by optional ones) inside |
| parentheses, separated by commas, as usual. But you must declare the |
| function with a prototype and know how the argument values are |
| converted. |
| |
| In principle, functions that are _defined_ to be variadic must also |
| be _declared_ to be variadic using a function prototype whenever you |
| call them. (*Note Variadic Prototypes::, for how.) This is because |
| some C compilers use a different calling convention to pass the same set |
| of argument values to a function depending on whether that function |
| takes variable arguments or fixed arguments. |
| |
| In practice, the GNU C compiler always passes a given set of argument |
| types in the same way regardless of whether they are optional or |
| required. So, as long as the argument types are self-promoting, you can |
| safely omit declaring them. Usually it is a good idea to declare the |
| argument types for variadic functions, and indeed for all functions. |
| But there are a few functions which it is extremely convenient not to |
| have to declare as variadic--for example, 'open' and 'printf'. |
| |
| Since the prototype doesn't specify types for optional arguments, in |
| a call to a variadic function the "default argument promotions" are |
| performed on the optional argument values. This means the objects of |
| type 'char' or 'short int' (whether signed or not) are promoted to |
| either 'int' or 'unsigned int', as appropriate; and that objects of type |
| 'float' are promoted to type 'double'. So, if the caller passes a |
| 'char' as an optional argument, it is promoted to an 'int', and the |
| function can access it with 'va_arg (AP, int)'. |
| |
| Conversion of the required arguments is controlled by the function |
| prototype in the usual way: the argument expression is converted to the |
| declared argument type as if it were being assigned to a variable of |
| that type. |
| |
| |
| File: libc.info, Node: Argument Macros, Prev: Calling Variadics, Up: How Variadic |
| |
| A.2.2.5 Argument Access Macros |
| .............................. |
| |
| Here are descriptions of the macros used to retrieve variable arguments. |
| These macros are defined in the header file 'stdarg.h'. |
| |
| -- Data Type: va_list |
| The type 'va_list' is used for argument pointer variables. |
| |
| -- Macro: void va_start (va_list AP, LAST-REQUIRED) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro initializes the argument pointer variable AP to point to |
| the first of the optional arguments of the current function; |
| LAST-REQUIRED must be the last required argument to the function. |
| |
| -- Macro: TYPE va_arg (va_list AP, TYPE) |
| Preliminary: | MT-Safe race:ap | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The 'va_arg' macro returns the value of the next optional argument, |
| and modifies the value of AP to point to the subsequent argument. |
| Thus, successive uses of 'va_arg' return successive optional |
| arguments. |
| |
| The type of the value returned by 'va_arg' is TYPE as specified in |
| the call. TYPE must be a self-promoting type (not 'char' or 'short |
| int' or 'float') that matches the type of the actual argument. |
| |
| -- Macro: void va_end (va_list AP) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This ends the use of AP. After a 'va_end' call, further 'va_arg' |
| calls with the same AP may not work. You should invoke 'va_end' |
| before returning from the function in which 'va_start' was invoked |
| with the same AP argument. |
| |
| In the GNU C Library, 'va_end' does nothing, and you need not ever |
| use it except for reasons of portability. |
| |
| Sometimes it is necessary to parse the list of parameters more than |
| once or one wants to remember a certain position in the parameter list. |
| To do this, one will have to make a copy of the current value of the |
| argument. But 'va_list' is an opaque type and one cannot necessarily |
| assign the value of one variable of type 'va_list' to another variable |
| of the same type. |
| |
| -- Macro: void va_copy (va_list DEST, va_list SRC) |
| -- Macro: void __va_copy (va_list DEST, va_list SRC) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'va_copy' macro allows copying of objects of type 'va_list' |
| even if this is not an integral type. The argument pointer in DEST |
| is initialized to point to the same argument as the pointer in SRC. |
| |
| This macro was added in ISO C99. When building for strict |
| conformance to ISO C90 ('gcc -ansi'), it is not available. The |
| macro '__va_copy' is available as a GNU extension in any standards |
| mode; before GCC 3.0, it was the only macro for this functionality. |
| |
| If you want to use 'va_copy' and be portable to pre-C99 systems, you |
| should always be prepared for the possibility that this macro will not |
| be available. On architectures where a simple assignment is invalid, |
| hopefully 'va_copy' _will_ be available, so one should always write |
| something like this if concerned about pre-C99 portability: |
| |
| { |
| va_list ap, save; |
| ... |
| #ifdef va_copy |
| va_copy (save, ap); |
| #else |
| save = ap; |
| #endif |
| ... |
| } |
| |
| |
| File: libc.info, Node: Variadic Example, Prev: How Variadic, Up: Variadic Functions |
| |
| A.2.3 Example of a Variadic Function |
| ------------------------------------ |
| |
| Here is a complete sample function that accepts a variable number of |
| arguments. The first argument to the function is the count of remaining |
| arguments, which are added up and the result returned. While trivial, |
| this function is sufficient to illustrate how to use the variable |
| arguments facility. |
| |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| int |
| add_em_up (int count,...) |
| { |
| va_list ap; |
| int i, sum; |
| |
| va_start (ap, count); /* Initialize the argument list. */ |
| |
| sum = 0; |
| for (i = 0; i < count; i++) |
| sum += va_arg (ap, int); /* Get the next argument value. */ |
| |
| va_end (ap); /* Clean up. */ |
| return sum; |
| } |
| |
| int |
| main (void) |
| { |
| /* This call prints 16. */ |
| printf ("%d\n", add_em_up (3, 5, 5, 6)); |
| |
| /* This call prints 55. */ |
| printf ("%d\n", add_em_up (10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); |
| |
| return 0; |
| } |
| |
| |
| File: libc.info, Node: Null Pointer Constant, Next: Important Data Types, Prev: Variadic Functions, Up: Language Features |
| |
| A.3 Null Pointer Constant |
| ========================= |
| |
| The null pointer constant is guaranteed not to point to any real object. |
| You can assign it to any pointer variable since it has type 'void *'. |
| The preferred way to write a null pointer constant is with 'NULL'. |
| |
| -- Macro: void * NULL |
| This is a null pointer constant. |
| |
| You can also use '0' or '(void *)0' as a null pointer constant, but |
| using 'NULL' is cleaner because it makes the purpose of the constant |
| more evident. |
| |
| If you use the null pointer constant as a function argument, then for |
| complete portability you should make sure that the function has a |
| prototype declaration. Otherwise, if the target machine has two |
| different pointer representations, the compiler won't know which |
| representation to use for that argument. You can avoid the problem by |
| explicitly casting the constant to the proper pointer type, but we |
| recommend instead adding a prototype for the function you are calling. |
| |
| |
| File: libc.info, Node: Important Data Types, Next: Data Type Measurements, Prev: Null Pointer Constant, Up: Language Features |
| |
| A.4 Important Data Types |
| ======================== |
| |
| The result of subtracting two pointers in C is always an integer, but |
| the precise data type varies from C compiler to C compiler. Likewise, |
| the data type of the result of 'sizeof' also varies between compilers. |
| ISO defines standard aliases for these two types, so you can refer to |
| them in a portable fashion. They are defined in the header file |
| 'stddef.h'. |
| |
| -- Data Type: ptrdiff_t |
| This is the signed integer type of the result of subtracting two |
| pointers. For example, with the declaration 'char *p1, *p2;', the |
| expression 'p2 - p1' is of type 'ptrdiff_t'. This will probably be |
| one of the standard signed integer types ('short int', 'int' or |
| 'long int'), but might be a nonstandard type that exists only for |
| this purpose. |
| |
| -- Data Type: size_t |
| This is an unsigned integer type used to represent the sizes of |
| objects. The result of the 'sizeof' operator is of this type, and |
| functions such as 'malloc' (*note Unconstrained Allocation::) and |
| 'memcpy' (*note Copying and Concatenation::) accept arguments of |
| this type to specify object sizes. On systems using the GNU C |
| Library, this will be 'unsigned int' or 'unsigned long int'. |
| |
| *Usage Note:* 'size_t' is the preferred way to declare any |
| arguments or variables that hold the size of an object. |
| |
| *Compatibility Note:* Implementations of C before the advent of ISO C |
| generally used 'unsigned int' for representing object sizes and 'int' |
| for pointer subtraction results. They did not necessarily define either |
| 'size_t' or 'ptrdiff_t'. Unix systems did define 'size_t', in |
| 'sys/types.h', but the definition was usually a signed type. |
| |
| |
| File: libc.info, Node: Data Type Measurements, Prev: Important Data Types, Up: Language Features |
| |
| A.5 Data Type Measurements |
| ========================== |
| |
| Most of the time, if you choose the proper C data type for each object |
| in your program, you need not be concerned with just how it is |
| represented or how many bits it uses. When you do need such |
| information, the C language itself does not provide a way to get it. |
| The header files 'limits.h' and 'float.h' contain macros which give you |
| this information in full detail. |
| |
| * Menu: |
| |
| * 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. |
| |
| |
| File: libc.info, Node: Width of Type, Next: Range of Type, Up: Data Type Measurements |
| |
| A.5.1 Computing the Width of an Integer Data Type |
| ------------------------------------------------- |
| |
| The most common reason that a program needs to know how many bits are in |
| an integer type is for using an array of 'long int' as a bit vector. |
| You can access the bit at index N with |
| |
| vector[N / LONGBITS] & (1 << (N % LONGBITS)) |
| |
| provided you define 'LONGBITS' as the number of bits in a 'long int'. |
| |
| There is no operator in the C language that can give you the number |
| of bits in an integer data type. But you can compute it from the macro |
| 'CHAR_BIT', defined in the header file 'limits.h'. |
| |
| 'CHAR_BIT' |
| This is the number of bits in a 'char'--eight, on most systems. |
| The value has type 'int'. |
| |
| You can compute the number of bits in any data type TYPE like this: |
| |
| sizeof (TYPE) * CHAR_BIT |
| |
| |
| File: libc.info, Node: Range of Type, Next: Floating Type Macros, Prev: Width of Type, Up: Data Type Measurements |
| |
| A.5.2 Range of an Integer Type |
| ------------------------------ |
| |
| Suppose you need to store an integer value which can range from zero to |
| one million. Which is the smallest type you can use? There is no |
| general rule; it depends on the C compiler and target machine. You can |
| use the 'MIN' and 'MAX' macros in 'limits.h' to determine which type |
| will work. |
| |
| Each signed integer type has a pair of macros which give the smallest |
| and largest values that it can hold. Each unsigned integer type has one |
| such macro, for the maximum value; the minimum value is, of course, |
| zero. |
| |
| The values of these macros are all integer constant expressions. The |
| 'MAX' and 'MIN' macros for 'char' and 'short int' types have values of |
| type 'int'. The 'MAX' and 'MIN' macros for the other types have values |
| of the same type described by the macro--thus, 'ULONG_MAX' has type |
| 'unsigned long int'. |
| |
| 'SCHAR_MIN' |
| |
| This is the minimum value that can be represented by a |
| 'signed char'. |
| |
| 'SCHAR_MAX' |
| 'UCHAR_MAX' |
| |
| These are the maximum values that can be represented by a 'signed char' |
| and 'unsigned char', respectively. |
| |
| 'CHAR_MIN' |
| |
| This is the minimum value that can be represented by a 'char'. |
| It's equal to 'SCHAR_MIN' if 'char' is signed, or zero otherwise. |
| |
| 'CHAR_MAX' |
| |
| This is the maximum value that can be represented by a 'char'. |
| It's equal to 'SCHAR_MAX' if 'char' is signed, or 'UCHAR_MAX' |
| otherwise. |
| |
| 'SHRT_MIN' |
| |
| This is the minimum value that can be represented by a |
| 'signed short int'. On most machines that the GNU C Library runs |
| on, 'short' integers are 16-bit quantities. |
| |
| 'SHRT_MAX' |
| 'USHRT_MAX' |
| |
| These are the maximum values that can be represented by a 'signed short int' |
| and 'unsigned short int', respectively. |
| |
| 'INT_MIN' |
| |
| This is the minimum value that can be represented by a |
| 'signed int'. On most machines that the GNU C Library runs on, an |
| 'int' is a 32-bit quantity. |
| |
| 'INT_MAX' |
| 'UINT_MAX' |
| |
| These are the maximum values that can be represented by, |
| respectively, the type 'signed int' and the type 'unsigned int'. |
| |
| 'LONG_MIN' |
| |
| This is the minimum value that can be represented by a |
| 'signed long int'. On most machines that the GNU C Library runs |
| on, 'long' integers are 32-bit quantities, the same size as 'int'. |
| |
| 'LONG_MAX' |
| 'ULONG_MAX' |
| |
| These are the maximum values that can be represented by a 'signed long int' |
| and 'unsigned long int', respectively. |
| |
| 'LLONG_MIN' |
| |
| This is the minimum value that can be represented by a |
| 'signed long long int'. On most machines that the GNU C Library |
| runs on, 'long long' integers are 64-bit quantities. |
| |
| 'LLONG_MAX' |
| 'ULLONG_MAX' |
| |
| These are the maximum values that can be represented by a 'signed |
| long long int' and 'unsigned long long int', respectively. |
| |
| 'LONG_LONG_MIN' |
| 'LONG_LONG_MAX' |
| 'ULONG_LONG_MAX' |
| These are obsolete names for 'LLONG_MIN', 'LLONG_MAX', and |
| 'ULLONG_MAX'. They are only available if '_GNU_SOURCE' is defined |
| (*note Feature Test Macros::). In GCC versions prior to 3.0, these |
| were the only names available. |
| |
| 'WCHAR_MAX' |
| |
| This is the maximum value that can be represented by a 'wchar_t'. |
| *Note Extended Char Intro::. |
| |
| The header file 'limits.h' also defines some additional constants |
| that parameterize various operating system and file system limits. |
| These constants are described in *note System Configuration::. |
| |
| |
| File: libc.info, Node: Floating Type Macros, Next: Structure Measurement, Prev: Range of Type, Up: Data Type Measurements |
| |
| A.5.3 Floating Type Macros |
| -------------------------- |
| |
| The specific representation of floating point numbers varies from |
| machine to machine. Because floating point numbers are represented |
| internally as approximate quantities, algorithms for manipulating |
| floating point data often need to take account of the precise details of |
| the machine's floating point representation. |
| |
| Some of the functions in the C library itself need this information; |
| for example, the algorithms for printing and reading floating point |
| numbers (*note I/O on Streams::) and for calculating trigonometric and |
| irrational functions (*note Mathematics::) use it to avoid round-off |
| error and loss of accuracy. User programs that implement numerical |
| analysis techniques also often need this information in order to |
| minimize or compute error bounds. |
| |
| The header file 'float.h' describes the format used by your machine. |
| |
| * Menu: |
| |
| * Floating Point Concepts:: Definitions of terminology. |
| * Floating Point Parameters:: Details of specific macros. |
| * IEEE Floating Point:: The measurements for one common |
| representation. |
| |
| |
| File: libc.info, Node: Floating Point Concepts, Next: Floating Point Parameters, Up: Floating Type Macros |
| |
| A.5.3.1 Floating Point Representation Concepts |
| .............................................. |
| |
| This section introduces the terminology for describing floating point |
| representations. |
| |
| You are probably already familiar with most of these concepts in |
| terms of scientific or exponential notation for floating point numbers. |
| For example, the number '123456.0' could be expressed in exponential |
| notation as '1.23456e+05', a shorthand notation indicating that the |
| mantissa '1.23456' is multiplied by the base '10' raised to power '5'. |
| |
| More formally, the internal representation of a floating point number |
| can be characterized in terms of the following parameters: |
| |
| * The "sign" is either '-1' or '1'. |
| |
| * The "base" or "radix" for exponentiation, an integer greater than |
| '1'. This is a constant for a particular representation. |
| |
| * The "exponent" to which the base is raised. The upper and lower |
| bounds of the exponent value are constants for a particular |
| representation. |
| |
| Sometimes, in the actual bits representing the floating point |
| number, the exponent is "biased" by adding a constant to it, to |
| make it always be represented as an unsigned quantity. This is |
| only important if you have some reason to pick apart the bit fields |
| making up the floating point number by hand, which is something for |
| which the GNU C Library provides no support. So this is ignored in |
| the discussion that follows. |
| |
| * The "mantissa" or "significand" is an unsigned integer which is a |
| part of each floating point number. |
| |
| * The "precision" of the mantissa. If the base of the representation |
| is B, then the precision is the number of base-B digits in the |
| mantissa. This is a constant for a particular representation. |
| |
| Many floating point representations have an implicit "hidden bit" |
| in the mantissa. This is a bit which is present virtually in the |
| mantissa, but not stored in memory because its value is always 1 in |
| a normalized number. The precision figure (see above) includes any |
| hidden bits. |
| |
| Again, the GNU C Library provides no facilities for dealing with |
| such low-level aspects of the representation. |
| |
| The mantissa of a floating point number represents an implicit |
| fraction whose denominator is the base raised to the power of the |
| precision. Since the largest representable mantissa is one less than |
| this denominator, the value of the fraction is always strictly less than |
| '1'. The mathematical value of a floating point number is then the |
| product of this fraction, the sign, and the base raised to the exponent. |
| |
| We say that the floating point number is "normalized" if the fraction |
| is at least '1/B', where B is the base. In other words, the mantissa |
| would be too large to fit if it were multiplied by the base. |
| Non-normalized numbers are sometimes called "denormal"; they contain |
| less precision than the representation normally can hold. |
| |
| If the number is not normalized, then you can subtract '1' from the |
| exponent while multiplying the mantissa by the base, and get another |
| floating point number with the same value. "Normalization" consists of |
| doing this repeatedly until the number is normalized. Two distinct |
| normalized floating point numbers cannot be equal in value. |
| |
| (There is an exception to this rule: if the mantissa is zero, it is |
| considered normalized. Another exception happens on certain machines |
| where the exponent is as small as the representation can hold. Then it |
| is impossible to subtract '1' from the exponent, so a number may be |
| normalized even if its fraction is less than '1/B'.) |
| |
| |
| File: libc.info, Node: Floating Point Parameters, Next: IEEE Floating Point, Prev: Floating Point Concepts, Up: Floating Type Macros |
| |
| A.5.3.2 Floating Point Parameters |
| ................................. |
| |
| These macro definitions can be accessed by including the header file |
| 'float.h' in your program. |
| |
| Macro names starting with 'FLT_' refer to the 'float' type, while |
| names beginning with 'DBL_' refer to the 'double' type and names |
| beginning with 'LDBL_' refer to the 'long double' type. (If GCC does |
| not support 'long double' as a distinct data type on a target machine |
| then the values for the 'LDBL_' constants are equal to the corresponding |
| constants for the 'double' type.) |
| |
| Of these macros, only 'FLT_RADIX' is guaranteed to be a constant |
| expression. The other macros listed here cannot be reliably used in |
| places that require constant expressions, such as '#if' preprocessing |
| directives or in the dimensions of static arrays. |
| |
| Although the ISO C standard specifies minimum and maximum values for |
| most of these parameters, the GNU C implementation uses whatever values |
| describe the floating point representation of the target machine. So in |
| principle GNU C actually satisfies the ISO C requirements only if the |
| target machine is suitable. In practice, all the machines currently |
| supported are suitable. |
| |
| 'FLT_ROUNDS' |
| This value characterizes the rounding mode for floating point |
| addition. The following values indicate standard rounding modes: |
| |
| '-1' |
| The mode is indeterminable. |
| '0' |
| Rounding is towards zero. |
| '1' |
| Rounding is to the nearest number. |
| '2' |
| Rounding is towards positive infinity. |
| '3' |
| Rounding is towards negative infinity. |
| |
| Any other value represents a machine-dependent nonstandard rounding |
| mode. |
| |
| On most machines, the value is '1', in accordance with the IEEE |
| standard for floating point. |
| |
| Here is a table showing how certain values round for each possible |
| value of 'FLT_ROUNDS', if the other aspects of the representation |
| match the IEEE single-precision standard. |
| |
| 0 1 2 3 |
| 1.00000003 1.0 1.0 1.00000012 1.0 |
| 1.00000007 1.0 1.00000012 1.00000012 1.0 |
| -1.00000003 -1.0 -1.0 -1.0 -1.00000012 |
| -1.00000007 -1.0 -1.00000012 -1.0 -1.00000012 |
| |
| 'FLT_RADIX' |
| This is the value of the base, or radix, of the exponent |
| representation. This is guaranteed to be a constant expression, |
| unlike the other macros described in this section. The value is 2 |
| on all machines we know of except the IBM 360 and derivatives. |
| |
| 'FLT_MANT_DIG' |
| This is the number of base-'FLT_RADIX' digits in the floating point |
| mantissa for the 'float' data type. The following expression |
| yields '1.0' (even though mathematically it should not) due to the |
| limited number of mantissa digits: |
| |
| float radix = FLT_RADIX; |
| |
| 1.0f + 1.0f / radix / radix / ... / radix |
| |
| where 'radix' appears 'FLT_MANT_DIG' times. |
| |
| 'DBL_MANT_DIG' |
| 'LDBL_MANT_DIG' |
| This is the number of base-'FLT_RADIX' digits in the floating point |
| mantissa for the data types 'double' and 'long double', |
| respectively. |
| |
| 'FLT_DIG' |
| |
| This is the number of decimal digits of precision for the 'float' |
| data type. Technically, if P and B are the precision and base |
| (respectively) for the representation, then the decimal precision Q |
| is the maximum number of decimal digits such that any floating |
| point number with Q base 10 digits can be rounded to a floating |
| point number with P base B digits and back again, without change to |
| the Q decimal digits. |
| |
| The value of this macro is supposed to be at least '6', to satisfy |
| ISO C. |
| |
| 'DBL_DIG' |
| 'LDBL_DIG' |
| |
| These are similar to 'FLT_DIG', but for the data types 'double' and |
| 'long double', respectively. The values of these macros are |
| supposed to be at least '10'. |
| |
| 'FLT_MIN_EXP' |
| This is the smallest possible exponent value for type 'float'. |
| More precisely, is the minimum negative integer such that the value |
| 'FLT_RADIX' raised to this power minus 1 can be represented as a |
| normalized floating point number of type 'float'. |
| |
| 'DBL_MIN_EXP' |
| 'LDBL_MIN_EXP' |
| |
| These are similar to 'FLT_MIN_EXP', but for the data types 'double' |
| and 'long double', respectively. |
| |
| 'FLT_MIN_10_EXP' |
| This is the minimum negative integer such that '10' raised to this |
| power minus 1 can be represented as a normalized floating point |
| number of type 'float'. This is supposed to be '-37' or even less. |
| |
| 'DBL_MIN_10_EXP' |
| 'LDBL_MIN_10_EXP' |
| These are similar to 'FLT_MIN_10_EXP', but for the data types |
| 'double' and 'long double', respectively. |
| |
| 'FLT_MAX_EXP' |
| This is the largest possible exponent value for type 'float'. More |
| precisely, this is the maximum positive integer such that value |
| 'FLT_RADIX' raised to this power minus 1 can be represented as a |
| floating point number of type 'float'. |
| |
| 'DBL_MAX_EXP' |
| 'LDBL_MAX_EXP' |
| These are similar to 'FLT_MAX_EXP', but for the data types 'double' |
| and 'long double', respectively. |
| |
| 'FLT_MAX_10_EXP' |
| This is the maximum positive integer such that '10' raised to this |
| power minus 1 can be represented as a normalized floating point |
| number of type 'float'. This is supposed to be at least '37'. |
| |
| 'DBL_MAX_10_EXP' |
| 'LDBL_MAX_10_EXP' |
| These are similar to 'FLT_MAX_10_EXP', but for the data types |
| 'double' and 'long double', respectively. |
| |
| 'FLT_MAX' |
| |
| The value of this macro is the maximum number representable in type |
| 'float'. It is supposed to be at least '1E+37'. The value has |
| type 'float'. |
| |
| The smallest representable number is '- FLT_MAX'. |
| |
| 'DBL_MAX' |
| 'LDBL_MAX' |
| |
| These are similar to 'FLT_MAX', but for the data types 'double' and |
| 'long double', respectively. The type of the macro's value is the |
| same as the type it describes. |
| |
| 'FLT_MIN' |
| |
| The value of this macro is the minimum normalized positive floating |
| point number that is representable in type 'float'. It is supposed |
| to be no more than '1E-37'. |
| |
| 'DBL_MIN' |
| 'LDBL_MIN' |
| |
| These are similar to 'FLT_MIN', but for the data types 'double' and |
| 'long double', respectively. The type of the macro's value is the |
| same as the type it describes. |
| |
| 'FLT_EPSILON' |
| |
| This is the difference between 1 and the smallest floating point |
| number of type 'float' that is greater than 1. It's supposed to be |
| no greater than '1E-5'. |
| |
| 'DBL_EPSILON' |
| 'LDBL_EPSILON' |
| |
| These are similar to 'FLT_EPSILON', but for the data types 'double' |
| and 'long double', respectively. The type of the macro's value is |
| the same as the type it describes. The values are not supposed to |
| be greater than '1E-9'. |
| |
| |
| File: libc.info, Node: IEEE Floating Point, Prev: Floating Point Parameters, Up: Floating Type Macros |
| |
| A.5.3.3 IEEE Floating Point |
| ........................... |
| |
| Here is an example showing how the floating type measurements come out |
| for the most common floating point representation, specified by the |
| 'IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE Std |
| 754-1985)'. Nearly all computers designed since the 1980s use this |
| format. |
| |
| The IEEE single-precision float representation uses a base of 2. |
| There is a sign bit, a mantissa with 23 bits plus one hidden bit (so the |
| total precision is 24 base-2 digits), and an 8-bit exponent that can |
| represent values in the range -125 to 128, inclusive. |
| |
| So, for an implementation that uses this representation for the |
| 'float' data type, appropriate values for the corresponding parameters |
| are: |
| |
| FLT_RADIX 2 |
| FLT_MANT_DIG 24 |
| FLT_DIG 6 |
| FLT_MIN_EXP -125 |
| FLT_MIN_10_EXP -37 |
| FLT_MAX_EXP 128 |
| FLT_MAX_10_EXP +38 |
| FLT_MIN 1.17549435E-38F |
| FLT_MAX 3.40282347E+38F |
| FLT_EPSILON 1.19209290E-07F |
| |
| Here are the values for the 'double' data type: |
| |
| DBL_MANT_DIG 53 |
| DBL_DIG 15 |
| DBL_MIN_EXP -1021 |
| DBL_MIN_10_EXP -307 |
| DBL_MAX_EXP 1024 |
| DBL_MAX_10_EXP 308 |
| DBL_MAX 1.7976931348623157E+308 |
| DBL_MIN 2.2250738585072014E-308 |
| DBL_EPSILON 2.2204460492503131E-016 |
| |
| |
| File: libc.info, Node: Structure Measurement, Prev: Floating Type Macros, Up: Data Type Measurements |
| |
| A.5.4 Structure Field Offset Measurement |
| ---------------------------------------- |
| |
| You can use 'offsetof' to measure the location within a structure type |
| of a particular structure member. |
| |
| -- Macro: size_t offsetof (TYPE, MEMBER) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This expands to an integer constant expression that is the offset |
| of the structure member named MEMBER in the structure type TYPE. |
| For example, 'offsetof (struct s, elem)' is the offset, in bytes, |
| of the member 'elem' in a 'struct s'. |
| |
| This macro won't work if MEMBER is a bit field; you get an error |
| from the C compiler in that case. |
| |
| |
| File: libc.info, Node: Library Summary, Next: Installation, Prev: Language Features, Up: Top |
| |
| Appendix B Summary of Library Facilities |
| **************************************** |
| |
| This appendix is a complete list of the facilities declared within the |
| header files supplied with the GNU C Library. Each entry also lists the |
| standard or other source from which each facility is derived, and tells |
| you where in the manual you can find more information about how to use |
| it. |
| |
| 'long int a64l (const char *STRING)' |
| |
| 'stdlib.h' (XPG): *note Encode Binary Data::. |
| |
| 'void abort (void)' |
| |
| 'stdlib.h' (ISO): *note Aborting a Program::. |
| |
| 'int abs (int NUMBER)' |
| |
| 'stdlib.h' (ISO): *note Absolute Value::. |
| |
| 'int accept (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR)' |
| |
| 'sys/socket.h' (BSD): *note Accepting Connections::. |
| |
| 'int access (const char *FILENAME, int HOW)' |
| |
| 'unistd.h' (POSIX.1): *note Testing File Access::. |
| |
| 'ACCOUNTING' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'double acos (double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'float acosf (float X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'double acosh (double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'float acoshf (float X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double acoshl (long double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double acosl (long double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'int addmntent (FILE *STREAM, const struct mntent *MNT)' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'int adjtime (const struct timeval *DELTA, struct timeval *OLDDELTA)' |
| |
| 'sys/time.h' (BSD): *note High-Resolution Calendar::. |
| |
| 'int adjtimex (struct timex *TIMEX)' |
| |
| 'sys/timex.h' (GNU): *note High-Resolution Calendar::. |
| |
| 'AF_FILE' |
| |
| 'sys/socket.h' (GNU): *note Address Formats::. |
| |
| 'AF_INET' |
| |
| 'sys/socket.h' (BSD): *note Address Formats::. |
| |
| 'AF_INET6' |
| |
| 'sys/socket.h' (IPv6 Basic API): *note Address Formats::. |
| |
| 'AF_LOCAL' |
| |
| 'sys/socket.h' (POSIX): *note Address Formats::. |
| |
| 'AF_UNIX' |
| |
| 'sys/socket.h' (BSD, Unix98): *note Address Formats::. |
| |
| 'AF_UNSPEC' |
| |
| 'sys/socket.h' (BSD): *note Address Formats::. |
| |
| 'int aio_cancel (int FILDES, struct aiocb *AIOCBP)' |
| |
| 'aio.h' (POSIX.1b): *note Cancel AIO Operations::. |
| |
| 'int aio_cancel64 (int FILDES, struct aiocb64 *AIOCBP)' |
| |
| 'aio.h' (Unix98): *note Cancel AIO Operations::. |
| |
| 'int aio_error (const struct aiocb *AIOCBP)' |
| |
| 'aio.h' (POSIX.1b): *note Status of AIO Operations::. |
| |
| 'int aio_error64 (const struct aiocb64 *AIOCBP)' |
| |
| 'aio.h' (Unix98): *note Status of AIO Operations::. |
| |
| 'int aio_fsync (int OP, struct aiocb *AIOCBP)' |
| |
| 'aio.h' (POSIX.1b): *note Synchronizing AIO Operations::. |
| |
| 'int aio_fsync64 (int OP, struct aiocb64 *AIOCBP)' |
| |
| 'aio.h' (Unix98): *note Synchronizing AIO Operations::. |
| |
| 'void aio_init (const struct aioinit *INIT)' |
| |
| 'aio.h' (GNU): *note Configuration of AIO::. |
| |
| 'int aio_read (struct aiocb *AIOCBP)' |
| |
| 'aio.h' (POSIX.1b): *note Asynchronous Reads/Writes::. |
| |
| 'int aio_read64 (struct aiocb64 *AIOCBP)' |
| |
| 'aio.h' (Unix98): *note Asynchronous Reads/Writes::. |
| |
| 'ssize_t aio_return (struct aiocb *AIOCBP)' |
| |
| 'aio.h' (POSIX.1b): *note Status of AIO Operations::. |
| |
| 'ssize_t aio_return64 (struct aiocb64 *AIOCBP)' |
| |
| 'aio.h' (Unix98): *note Status of AIO Operations::. |
| |
| 'int aio_suspend (const struct aiocb *const LIST[], int NENT, const struct timespec *TIMEOUT)' |
| |
| 'aio.h' (POSIX.1b): *note Synchronizing AIO Operations::. |
| |
| 'int aio_suspend64 (const struct aiocb64 *const LIST[], int NENT, const struct timespec *TIMEOUT)' |
| |
| 'aio.h' (Unix98): *note Synchronizing AIO Operations::. |
| |
| 'int aio_write (struct aiocb *AIOCBP)' |
| |
| 'aio.h' (POSIX.1b): *note Asynchronous Reads/Writes::. |
| |
| 'int aio_write64 (struct aiocb64 *AIOCBP)' |
| |
| 'aio.h' (Unix98): *note Asynchronous Reads/Writes::. |
| |
| 'unsigned int alarm (unsigned int SECONDS)' |
| |
| 'unistd.h' (POSIX.1): *note Setting an Alarm::. |
| |
| 'void * aligned_alloc (size_t ALIGNMENT, size_t SIZE)' |
| |
| 'stdlib.h' (stdlib.h): *note Aligned Memory Blocks::. |
| |
| 'void * alloca (size_t SIZE)' |
| |
| 'stdlib.h' (GNU, BSD): *note Variable Size Automatic::. |
| |
| 'int alphasort (const struct dirent **A, const struct dirent **B)' |
| |
| 'dirent.h' (BSD/SVID): *note Scanning Directory Content::. |
| |
| 'int alphasort64 (const struct dirent64 **A, const struct dirent **B)' |
| |
| 'dirent.h' (GNU): *note Scanning Directory Content::. |
| |
| 'tcflag_t ALTWERASE' |
| |
| 'termios.h' (BSD): *note Local Modes::. |
| |
| 'int ARG_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'error_t argp_err_exit_status' |
| |
| 'argp.h' (GNU): *note Argp Global Variables::. |
| |
| 'void argp_error (const struct argp_state *STATE, const char *FMT, ...)' |
| |
| 'argp.h' (GNU): *note Argp Helper Functions::. |
| |
| 'int ARGP_ERR_UNKNOWN' |
| |
| 'argp.h' (GNU): *note Argp Parser Functions::. |
| |
| 'void argp_failure (const struct argp_state *STATE, int STATUS, int ERRNUM, const char *FMT, ...)' |
| |
| 'argp.h' (GNU): *note Argp Helper Functions::. |
| |
| 'void argp_help (const struct argp *ARGP, FILE *STREAM, unsigned FLAGS, char *NAME)' |
| |
| 'argp.h' (GNU): *note Argp Help::. |
| |
| 'ARGP_IN_ORDER' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'ARGP_KEY_ARG' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_ARGS' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_END' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_ERROR' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_FINI' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_HELP_ARGS_DOC' |
| |
| 'argp.h' (GNU): *note Argp Help Filter Keys::. |
| |
| 'ARGP_KEY_HELP_DUP_ARGS_NOTE' |
| |
| 'argp.h' (GNU): *note Argp Help Filter Keys::. |
| |
| 'ARGP_KEY_HELP_EXTRA' |
| |
| 'argp.h' (GNU): *note Argp Help Filter Keys::. |
| |
| 'ARGP_KEY_HELP_HEADER' |
| |
| 'argp.h' (GNU): *note Argp Help Filter Keys::. |
| |
| 'ARGP_KEY_HELP_POST_DOC' |
| |
| 'argp.h' (GNU): *note Argp Help Filter Keys::. |
| |
| 'ARGP_KEY_HELP_PRE_DOC' |
| |
| 'argp.h' (GNU): *note Argp Help Filter Keys::. |
| |
| 'ARGP_KEY_INIT' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_NO_ARGS' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_KEY_SUCCESS' |
| |
| 'argp.h' (GNU): *note Argp Special Keys::. |
| |
| 'ARGP_LONG_ONLY' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'ARGP_NO_ARGS' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'ARGP_NO_ERRS' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'ARGP_NO_EXIT' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'ARGP_NO_HELP' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'error_t argp_parse (const struct argp *ARGP, int ARGC, char **ARGV, unsigned FLAGS, int *ARG_INDEX, void *INPUT)' |
| |
| 'argp.h' (GNU): *note Suboptions: Argp. |
| |
| 'ARGP_PARSE_ARGV0' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'const char * argp_program_bug_address' |
| |
| 'argp.h' (GNU): *note Argp Global Variables::. |
| |
| 'const char * argp_program_version' |
| |
| 'argp.h' (GNU): *note Argp Global Variables::. |
| |
| 'argp_program_version_hook' |
| |
| 'argp.h' (GNU): *note Argp Global Variables::. |
| |
| 'ARGP_SILENT' |
| |
| 'argp.h' (GNU): *note Argp Flags::. |
| |
| 'void argp_state_help (const struct argp_state *STATE, FILE *STREAM, unsigned FLAGS)' |
| |
| 'argp.h' (GNU): *note Argp Helper Functions::. |
| |
| 'void argp_usage (const struct argp_state *STATE)' |
| |
| 'argp.h' (GNU): *note Argp Helper Functions::. |
| |
| 'error_t argz_add (char **ARGZ, size_t *ARGZ_LEN, const char *STR)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'error_t argz_add_sep (char **ARGZ, size_t *ARGZ_LEN, const char *STR, int DELIM)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'error_t argz_append (char **ARGZ, size_t *ARGZ_LEN, const char *BUF, size_t BUF_LEN)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'size_t argz_count (const char *ARGZ, size_t ARG_LEN)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'error_t argz_create (char *const ARGV[], char **ARGZ, size_t *ARGZ_LEN)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'error_t argz_create_sep (const char *STRING, int SEP, char **ARGZ, size_t *ARGZ_LEN)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'void argz_delete (char **ARGZ, size_t *ARGZ_LEN, char *ENTRY)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'void argz_extract (const char *ARGZ, size_t ARGZ_LEN, char **ARGV)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'error_t argz_insert (char **ARGZ, size_t *ARGZ_LEN, char *BEFORE, const char *ENTRY)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'char * argz_next (const char *ARGZ, size_t ARGZ_LEN, const char *ENTRY)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'error_t argz_replace (char **ARGZ, size_t *ARGZ_LEN, const char *STR, const char *WITH, unsigned *REPLACE_COUNT)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'void argz_stringify (char *ARGZ, size_t LEN, int SEP)' |
| |
| 'argz.h' (GNU): *note Argz Functions::. |
| |
| 'char * asctime (const struct tm *BROKENTIME)' |
| |
| 'time.h' (ISO): *note Formatting Calendar Time::. |
| |
| 'char * asctime_r (const struct tm *BROKENTIME, char *BUFFER)' |
| |
| 'time.h' (POSIX.1c): *note Formatting Calendar Time::. |
| |
| 'double asin (double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'float asinf (float X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'double asinh (double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'float asinhf (float X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double asinhl (long double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double asinl (long double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'int asprintf (char **PTR, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (GNU): *note Dynamic Output::. |
| |
| 'void assert (int EXPRESSION)' |
| |
| 'assert.h' (ISO): *note Consistency Checking::. |
| |
| 'void assert_perror (int ERRNUM)' |
| |
| 'assert.h' (GNU): *note Consistency Checking::. |
| |
| 'double atan (double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'double atan2 (double Y, double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'float atan2f (float Y, float X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'long double atan2l (long double Y, long double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'float atanf (float X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'double atanh (double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'float atanhf (float X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double atanhl (long double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double atanl (long double X)' |
| |
| 'math.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'int atexit (void (*FUNCTION) (void))' |
| |
| 'stdlib.h' (ISO): *note Cleanups on Exit::. |
| |
| 'double atof (const char *STRING)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Floats::. |
| |
| 'int atoi (const char *STRING)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'long int atol (const char *STRING)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'long long int atoll (const char *STRING)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'B0' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B110' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B115200' |
| |
| 'termios.h' (GNU): *note Line Speed::. |
| |
| 'B1200' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B134' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B150' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B1800' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B19200' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B200' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B230400' |
| |
| 'termios.h' (GNU): *note Line Speed::. |
| |
| 'B2400' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B300' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B38400' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B460800' |
| |
| 'termios.h' (GNU): *note Line Speed::. |
| |
| 'B4800' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B50' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B57600' |
| |
| 'termios.h' (GNU): *note Line Speed::. |
| |
| 'B600' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B75' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'B9600' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'int backtrace (void **BUFFER, int SIZE)' |
| |
| 'execinfo.h' (GNU): *note Backtraces::. |
| |
| 'char ** backtrace_symbols (void *const *BUFFER, int SIZE)' |
| |
| 'execinfo.h' (GNU): *note Backtraces::. |
| |
| 'void backtrace_symbols_fd (void *const *BUFFER, int SIZE, int FD)' |
| |
| 'execinfo.h' (GNU): *note Backtraces::. |
| |
| 'char * basename (const char *FILENAME)' |
| |
| 'string.h' (GNU): *note Finding Tokens in a String::. |
| |
| 'char * basename (const char *PATH)' |
| |
| 'libgen.h' (XPG): *note Finding Tokens in a String::. |
| |
| 'int BC_BASE_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'int BC_DIM_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'int bcmp (const void *A1, const void *A2, size_t SIZE)' |
| |
| 'string.h' (BSD): *note String/Array Comparison::. |
| |
| 'void bcopy (const void *FROM, void *TO, size_t SIZE)' |
| |
| 'string.h' (BSD): *note Copying and Concatenation::. |
| |
| 'int BC_SCALE_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'int BC_STRING_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'int bind (int SOCKET, struct sockaddr *ADDR, socklen_t LENGTH)' |
| |
| 'sys/socket.h' (BSD): *note Setting Address::. |
| |
| 'char * bindtextdomain (const char *DOMAINNAME, const char *DIRNAME)' |
| |
| 'libintl.h' (GNU): *note Locating gettext catalog::. |
| |
| 'char * bind_textdomain_codeset (const char *DOMAINNAME, const char *CODESET)' |
| |
| 'libintl.h' (GNU): *note Charset conversion in gettext::. |
| |
| 'blkcnt64_t' |
| |
| 'sys/types.h' (Unix98): *note Attribute Meanings::. |
| |
| 'blkcnt_t' |
| |
| 'sys/types.h' (Unix98): *note Attribute Meanings::. |
| |
| 'BOOT_TIME' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'BOOT_TIME' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int brk (void *ADDR)' |
| |
| 'unistd.h' (BSD): *note Resizing the Data Segment::. |
| |
| 'tcflag_t BRKINT' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'void * bsearch (const void *KEY, const void *ARRAY, size_t COUNT, size_t SIZE, comparison_fn_t COMPARE)' |
| |
| 'stdlib.h' (ISO): *note Array Search Function::. |
| |
| 'wint_t btowc (int C)' |
| |
| 'wchar.h' (ISO): *note Converting a Character::. |
| |
| 'int BUFSIZ' |
| |
| 'stdio.h' (ISO): *note Controlling Buffering::. |
| |
| 'void bzero (void *BLOCK, size_t SIZE)' |
| |
| 'string.h' (BSD): *note Copying and Concatenation::. |
| |
| 'double cabs (complex double Z)' |
| |
| 'complex.h' (ISO): *note Absolute Value::. |
| |
| 'float cabsf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Absolute Value::. |
| |
| 'long double cabsl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Absolute Value::. |
| |
| 'complex double cacos (complex double Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex float cacosf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex double cacosh (complex double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex float cacoshf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double cacoshl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double cacosl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'void * calloc (size_t COUNT, size_t ELTSIZE)' |
| |
| 'malloc.h', 'stdlib.h' (ISO): *note Allocating Cleared Space::. |
| |
| 'char * canonicalize_file_name (const char *NAME)' |
| |
| 'stdlib.h' (GNU): *note Symbolic Links::. |
| |
| 'double carg (complex double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'float cargf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'long double cargl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'complex double casin (complex double Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex float casinf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex double casinh (complex double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex float casinhf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double casinhl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double casinl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex double catan (complex double Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex float catanf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'complex double catanh (complex double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex float catanhf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double catanhl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double catanl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Inverse Trig Functions::. |
| |
| 'nl_catd catopen (const char *CAT_NAME, int FLAG)' |
| |
| 'nl_types.h' (X/Open): *note The catgets Functions::. |
| |
| 'int cbc_crypt (char *KEY, char *BLOCKS, unsigned LEN, unsigned MODE, char *IVEC)' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'double cbrt (double X)' |
| |
| 'math.h' (BSD): *note Exponents and Logarithms::. |
| |
| 'float cbrtf (float X)' |
| |
| 'math.h' (BSD): *note Exponents and Logarithms::. |
| |
| 'long double cbrtl (long double X)' |
| |
| 'math.h' (BSD): *note Exponents and Logarithms::. |
| |
| 'complex double ccos (complex double Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'complex float ccosf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'complex double ccosh (complex double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex float ccoshf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double ccoshl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double ccosl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'cc_t' |
| |
| 'termios.h' (POSIX.1): *note Mode Data Types::. |
| |
| 'tcflag_t CCTS_OFLOW' |
| |
| 'termios.h' (BSD): *note Control Modes::. |
| |
| 'double ceil (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'float ceilf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double ceill (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'complex double cexp (complex double Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex float cexpf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex long double cexpl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'speed_t cfgetispeed (const struct termios *TERMIOS-P)' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'speed_t cfgetospeed (const struct termios *TERMIOS-P)' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'void cfmakeraw (struct termios *TERMIOS-P)' |
| |
| 'termios.h' (BSD): *note Noncanonical Input::. |
| |
| 'void cfree (void *PTR)' |
| |
| 'stdlib.h' (Sun): *note Freeing after Malloc::. |
| |
| 'int cfsetispeed (struct termios *TERMIOS-P, speed_t SPEED)' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'int cfsetospeed (struct termios *TERMIOS-P, speed_t SPEED)' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'int cfsetspeed (struct termios *TERMIOS-P, speed_t SPEED)' |
| |
| 'termios.h' (BSD): *note Line Speed::. |
| |
| 'CHAR_BIT' |
| |
| 'limits.h' (ISO): *note Width of Type::. |
| |
| 'CHAR_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'CHAR_MIN' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'int chdir (const char *FILENAME)' |
| |
| 'unistd.h' (POSIX.1): *note Working Directory::. |
| |
| 'int CHILD_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'int chmod (const char *FILENAME, mode_t MODE)' |
| |
| 'sys/stat.h' (POSIX.1): *note Setting Permissions::. |
| |
| 'int chown (const char *FILENAME, uid_t OWNER, gid_t GROUP)' |
| |
| 'unistd.h' (POSIX.1): *note File Owner::. |
| |
| 'tcflag_t CIGNORE' |
| |
| 'termios.h' (BSD): *note Control Modes::. |
| |
| 'double cimag (complex double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'float cimagf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'long double cimagl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'int clearenv (void)' |
| |
| 'stdlib.h' (GNU): *note Environment Access::. |
| |
| 'void clearerr (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Error Recovery::. |
| |
| 'void clearerr_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Error Recovery::. |
| |
| 'int CLK_TCK' |
| |
| 'time.h' (POSIX.1): *note Processor Time::. |
| |
| 'tcflag_t CLOCAL' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'clock_t clock (void)' |
| |
| 'time.h' (ISO): *note CPU Time::. |
| |
| 'int CLOCKS_PER_SEC' |
| |
| 'time.h' (ISO): *note CPU Time::. |
| |
| 'clock_t' |
| |
| 'time.h' (ISO): *note CPU Time::. |
| |
| 'complex double clog (complex double Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex double clog10 (complex double Z)' |
| |
| 'complex.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'complex float clog10f (complex float Z)' |
| |
| 'complex.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'complex long double clog10l (complex long double Z)' |
| |
| 'complex.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'complex float clogf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex long double clogl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'int close (int FILEDES)' |
| |
| 'unistd.h' (POSIX.1): *note Opening and Closing Files::. |
| |
| 'int closedir (DIR *DIRSTREAM)' |
| |
| 'dirent.h' (POSIX.1): *note Reading/Closing Directory::. |
| |
| 'void closelog (void)' |
| |
| 'syslog.h' (BSD): *note closelog::. |
| |
| 'int COLL_WEIGHTS_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'size_t confstr (int PARAMETER, char *BUF, size_t LEN)' |
| |
| 'unistd.h' (POSIX.2): *note String Parameters::. |
| |
| 'complex double conj (complex double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'complex float conjf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'complex long double conjl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'int connect (int SOCKET, struct sockaddr *ADDR, socklen_t LENGTH)' |
| |
| 'sys/socket.h' (BSD): *note Connecting::. |
| |
| 'cookie_close_function_t' |
| |
| 'stdio.h' (GNU): *note Hook Functions::. |
| |
| 'cookie_io_functions_t' |
| |
| 'stdio.h' (GNU): *note Streams and Cookies::. |
| |
| 'cookie_read_function_t' |
| |
| 'stdio.h' (GNU): *note Hook Functions::. |
| |
| 'cookie_seek_function_t' |
| |
| 'stdio.h' (GNU): *note Hook Functions::. |
| |
| 'cookie_write_function_t' |
| |
| 'stdio.h' (GNU): *note Hook Functions::. |
| |
| 'double copysign (double X, double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'float copysignf (float X, float Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'long double copysignl (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'double cos (double X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'float cosf (float X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'double cosh (double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'float coshf (float X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double coshl (long double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double cosl (long double X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'complex double cpow (complex double BASE, complex double POWER)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex float cpowf (complex float BASE, complex float POWER)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex long double cpowl (complex long double BASE, complex long double POWER)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex double cproj (complex double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'complex float cprojf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'complex long double cprojl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'void CPU_CLR (int CPU, cpu_set_t *SET)' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'int CPU_ISSET (int CPU, const cpu_set_t *SET)' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'void CPU_SET (int CPU, cpu_set_t *SET)' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'int CPU_SETSIZE' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'cpu_set_t' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'void CPU_ZERO (cpu_set_t *SET)' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'tcflag_t CREAD' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'double creal (complex double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'float crealf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'long double creall (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Operations on Complex::. |
| |
| 'int creat (const char *FILENAME, mode_t MODE)' |
| |
| 'fcntl.h' (POSIX.1): *note Opening and Closing Files::. |
| |
| 'int creat64 (const char *FILENAME, mode_t MODE)' |
| |
| 'fcntl.h' (Unix98): *note Opening and Closing Files::. |
| |
| 'tcflag_t CRTS_IFLOW' |
| |
| 'termios.h' (BSD): *note Control Modes::. |
| |
| 'char * crypt (const char *KEY, const char *SALT)' |
| |
| 'crypt.h' (BSD, SVID): *note crypt::. |
| |
| 'char * crypt_r (const char *KEY, const char *SALT, struct crypt_data * DATA)' |
| |
| 'crypt.h' (GNU): *note crypt::. |
| |
| 'tcflag_t CS5' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'tcflag_t CS6' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'tcflag_t CS7' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'tcflag_t CS8' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'complex double csin (complex double Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'complex float csinf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'complex double csinh (complex double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex float csinhf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double csinhl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double csinl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'tcflag_t CSIZE' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| '_CS_LFS64_CFLAGS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS64_LDFLAGS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS64_LIBS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS64_LINTFLAGS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS_CFLAGS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS_LDFLAGS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS_LIBS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_LFS_LINTFLAGS' |
| |
| 'unistd.h' (Unix98): *note String Parameters::. |
| |
| '_CS_PATH' |
| |
| 'unistd.h' (POSIX.2): *note String Parameters::. |
| |
| 'complex double csqrt (complex double Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex float csqrtf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'complex long double csqrtl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'tcflag_t CSTOPB' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'complex double ctan (complex double Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'complex float ctanf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'complex double ctanh (complex double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex float ctanhf (complex float Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double ctanhl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'complex long double ctanl (complex long double Z)' |
| |
| 'complex.h' (ISO): *note Trig Functions::. |
| |
| 'char * ctermid (char *STRING)' |
| |
| 'stdio.h' (POSIX.1): *note Identifying the Terminal::. |
| |
| 'char * ctime (const time_t *TIME)' |
| |
| 'time.h' (ISO): *note Formatting Calendar Time::. |
| |
| 'char * ctime_r (const time_t *TIME, char *BUFFER)' |
| |
| 'time.h' (POSIX.1c): *note Formatting Calendar Time::. |
| |
| 'char * cuserid (char *STRING)' |
| |
| 'stdio.h' (POSIX.1): *note Who Logged In::. |
| |
| 'int daylight' |
| |
| 'time.h' (SVID): *note Time Zone Functions::. |
| |
| 'DBL_DIG' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_EPSILON' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MANT_DIG' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MAX' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MAX_10_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MAX_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MIN' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MIN_10_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'DBL_MIN_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'char * dcgettext (const char *DOMAINNAME, const char *MSGID, int CATEGORY)' |
| |
| 'libintl.h' (GNU): *note Translation with gettext::. |
| |
| 'char * dcngettext (const char *DOMAIN, const char *MSGID1, const char *MSGID2, unsigned long int N, int CATEGORY)' |
| |
| 'libintl.h' (GNU): *note Advanced gettext functions::. |
| |
| 'DEAD_PROCESS' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'DEAD_PROCESS' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| '_DEFAULT_SOURCE' |
| |
| (GNU): *note Feature Test Macros::. |
| |
| 'DES_DECRYPT' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DES_ENCRYPT' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DESERR_BADPARAM' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DESERR_HWERROR' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DESERR_NOHWDEVICE' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DESERR_NONE' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'int DES_FAILED (int ERR)' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DES_HW' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'void des_setparity (char *KEY)' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'DES_SW' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'dev_t' |
| |
| 'sys/types.h' (POSIX.1): *note Attribute Meanings::. |
| |
| 'char * dgettext (const char *DOMAINNAME, const char *MSGID)' |
| |
| 'libintl.h' (GNU): *note Translation with gettext::. |
| |
| 'double difftime (time_t TIME1, time_t TIME0)' |
| |
| 'time.h' (ISO): *note Elapsed Time::. |
| |
| 'DIR' |
| |
| 'dirent.h' (POSIX.1): *note Opening a Directory::. |
| |
| 'int dirfd (DIR *DIRSTREAM)' |
| |
| 'dirent.h' (GNU): *note Opening a Directory::. |
| |
| 'char * dirname (char *PATH)' |
| |
| 'libgen.h' (XPG): *note Finding Tokens in a String::. |
| |
| 'div_t div (int NUMERATOR, int DENOMINATOR)' |
| |
| 'stdlib.h' (ISO): *note Integer Division::. |
| |
| 'div_t' |
| |
| 'stdlib.h' (ISO): *note Integer Division::. |
| |
| 'char * dngettext (const char *DOMAIN, const char *MSGID1, const char *MSGID2, unsigned long int N)' |
| |
| 'libintl.h' (GNU): *note Advanced gettext functions::. |
| |
| 'double drand48 (void)' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int drand48_r (struct drand48_data *BUFFER, double *RESULT)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'double drem (double NUMERATOR, double DENOMINATOR)' |
| |
| 'math.h' (BSD): *note Remainder Functions::. |
| |
| 'float dremf (float NUMERATOR, float DENOMINATOR)' |
| |
| 'math.h' (BSD): *note Remainder Functions::. |
| |
| 'long double dreml (long double NUMERATOR, long double DENOMINATOR)' |
| |
| 'math.h' (BSD): *note Remainder Functions::. |
| |
| 'mode_t DTTOIF (int DTYPE)' |
| |
| 'dirent.h' (BSD): *note Directory Entries::. |
| |
| 'int dup (int OLD)' |
| |
| 'unistd.h' (POSIX.1): *note Duplicating Descriptors::. |
| |
| 'int dup2 (int OLD, int NEW)' |
| |
| 'unistd.h' (POSIX.1): *note Duplicating Descriptors::. |
| |
| 'int E2BIG' |
| |
| 'errno.h' (POSIX.1: Argument list too long): *note Error Codes::. |
| |
| 'int EACCES' |
| |
| 'errno.h' (POSIX.1: Permission denied): *note Error Codes::. |
| |
| 'int EADDRINUSE' |
| |
| 'errno.h' (BSD: Address already in use): *note Error Codes::. |
| |
| 'int EADDRNOTAVAIL' |
| |
| 'errno.h' (BSD: Cannot assign requested address): *note Error |
| Codes::. |
| |
| 'int EADV' |
| |
| 'errno.h' (Linux???: Advertise error): *note Error Codes::. |
| |
| 'int EAFNOSUPPORT' |
| |
| 'errno.h' (BSD: Address family not supported by protocol): *note |
| Error Codes::. |
| |
| 'int EAGAIN' |
| |
| 'errno.h' (POSIX.1: Resource temporarily unavailable): *note Error |
| Codes::. |
| |
| 'int EALREADY' |
| |
| 'errno.h' (BSD: Operation already in progress): *note Error |
| Codes::. |
| |
| 'int EAUTH' |
| |
| 'errno.h' (BSD: Authentication error): *note Error Codes::. |
| |
| 'int EBACKGROUND' |
| |
| 'errno.h' (GNU: Inappropriate operation for background process): |
| *note Error Codes::. |
| |
| 'int EBADE' |
| |
| 'errno.h' (Linux???: Invalid exchange): *note Error Codes::. |
| |
| 'int EBADF' |
| |
| 'errno.h' (POSIX.1: Bad file descriptor): *note Error Codes::. |
| |
| 'int EBADFD' |
| |
| 'errno.h' (Linux???: File descriptor in bad state): *note Error |
| Codes::. |
| |
| 'int EBADMSG' |
| |
| 'errno.h' (XOPEN: Bad message): *note Error Codes::. |
| |
| 'int EBADR' |
| |
| 'errno.h' (Linux???: Invalid request descriptor): *note Error |
| Codes::. |
| |
| 'int EBADRPC' |
| |
| 'errno.h' (BSD: RPC struct is bad): *note Error Codes::. |
| |
| 'int EBADRQC' |
| |
| 'errno.h' (Linux???: Invalid request code): *note Error Codes::. |
| |
| 'int EBADSLT' |
| |
| 'errno.h' (Linux???: Invalid slot): *note Error Codes::. |
| |
| 'int EBFONT' |
| |
| 'errno.h' (Linux???: Bad font file format): *note Error Codes::. |
| |
| 'int EBUSY' |
| |
| 'errno.h' (POSIX.1: Device or resource busy): *note Error Codes::. |
| |
| 'int ECANCELED' |
| |
| 'errno.h' (POSIX.1: Operation canceled): *note Error Codes::. |
| |
| 'int ecb_crypt (char *KEY, char *BLOCKS, unsigned LEN, unsigned MODE)' |
| |
| 'rpc/des_crypt.h' (SUNRPC): *note DES Encryption::. |
| |
| 'int ECHILD' |
| |
| 'errno.h' (POSIX.1: No child processes): *note Error Codes::. |
| |
| 'tcflag_t ECHO' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'tcflag_t ECHOCTL' |
| |
| 'termios.h' (BSD): *note Local Modes::. |
| |
| 'tcflag_t ECHOE' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'tcflag_t ECHOK' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'tcflag_t ECHOKE' |
| |
| 'termios.h' (BSD): *note Local Modes::. |
| |
| 'tcflag_t ECHONL' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'tcflag_t ECHOPRT' |
| |
| 'termios.h' (BSD): *note Local Modes::. |
| |
| 'int ECHRNG' |
| |
| 'errno.h' (Linux???: Channel number out of range): *note Error |
| Codes::. |
| |
| 'int ECOMM' |
| |
| 'errno.h' (Linux???: Communication error on send): *note Error |
| Codes::. |
| |
| 'int ECONNABORTED' |
| |
| 'errno.h' (BSD: Software caused connection abort): *note Error |
| Codes::. |
| |
| 'int ECONNREFUSED' |
| |
| 'errno.h' (BSD: Connection refused): *note Error Codes::. |
| |
| 'int ECONNRESET' |
| |
| 'errno.h' (BSD: Connection reset by peer): *note Error Codes::. |
| |
| 'char * ecvt (double VALUE, int NDIGIT, int *DECPT, int *NEG)' |
| |
| 'stdlib.h' (SVID, Unix98): *note System V Number Conversion::. |
| |
| 'int ecvt_r (double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN)' |
| |
| 'stdlib.h' (GNU): *note System V Number Conversion::. |
| |
| 'int ED' |
| |
| 'errno.h' (GNU: ?): *note Error Codes::. |
| |
| 'int EDEADLK' |
| |
| 'errno.h' (POSIX.1: Resource deadlock avoided): *note Error |
| Codes::. |
| |
| 'int EDEADLOCK' |
| |
| 'errno.h' (Linux???: File locking deadlock error): *note Error |
| Codes::. |
| |
| 'int EDESTADDRREQ' |
| |
| 'errno.h' (BSD: Destination address required): *note Error Codes::. |
| |
| 'int EDIED' |
| |
| 'errno.h' (GNU: Translator died): *note Error Codes::. |
| |
| 'int EDOM' |
| |
| 'errno.h' (ISO: Numerical argument out of domain): *note Error |
| Codes::. |
| |
| 'int EDOTDOT' |
| |
| 'errno.h' (Linux???: RFS specific error): *note Error Codes::. |
| |
| 'int EDQUOT' |
| |
| 'errno.h' (BSD: Disk quota exceeded): *note Error Codes::. |
| |
| 'int EEXIST' |
| |
| 'errno.h' (POSIX.1: File exists): *note Error Codes::. |
| |
| 'int EFAULT' |
| |
| 'errno.h' (POSIX.1: Bad address): *note Error Codes::. |
| |
| 'int EFBIG' |
| |
| 'errno.h' (POSIX.1: File too large): *note Error Codes::. |
| |
| 'int EFTYPE' |
| |
| 'errno.h' (BSD: Inappropriate file type or format): *note Error |
| Codes::. |
| |
| 'int EGRATUITOUS' |
| |
| 'errno.h' (GNU: Gratuitous error): *note Error Codes::. |
| |
| 'int EGREGIOUS' |
| |
| 'errno.h' (GNU: You really blew it this time): *note Error Codes::. |
| |
| 'int EHOSTDOWN' |
| |
| 'errno.h' (BSD: Host is down): *note Error Codes::. |
| |
| 'int EHOSTUNREACH' |
| |
| 'errno.h' (BSD: No route to host): *note Error Codes::. |
| |
| 'int EHWPOISON' |
| |
| 'errno.h' (Linux: Memory page has hardware error): *note Error |
| Codes::. |
| |
| 'int EIDRM' |
| |
| 'errno.h' (XOPEN: Identifier removed): *note Error Codes::. |
| |
| 'int EIEIO' |
| |
| 'errno.h' (GNU: Computer bought the farm): *note Error Codes::. |
| |
| 'int EILSEQ' |
| |
| 'errno.h' (ISO: Invalid or incomplete multibyte or wide character): |
| *note Error Codes::. |
| |
| 'int EINPROGRESS' |
| |
| 'errno.h' (BSD: Operation now in progress): *note Error Codes::. |
| |
| 'int EINTR' |
| |
| 'errno.h' (POSIX.1: Interrupted system call): *note Error Codes::. |
| |
| 'int EINVAL' |
| |
| 'errno.h' (POSIX.1: Invalid argument): *note Error Codes::. |
| |
| 'int EIO' |
| |
| 'errno.h' (POSIX.1: Input/output error): *note Error Codes::. |
| |
| 'int EISCONN' |
| |
| 'errno.h' (BSD: Transport endpoint is already connected): *note |
| Error Codes::. |
| |
| 'int EISDIR' |
| |
| 'errno.h' (POSIX.1: Is a directory): *note Error Codes::. |
| |
| 'int EISNAM' |
| |
| 'errno.h' (Linux???: Is a named type file): *note Error Codes::. |
| |
| 'int EKEYEXPIRED' |
| |
| 'errno.h' (Linux: Key has expired): *note Error Codes::. |
| |
| 'int EKEYREJECTED' |
| |
| 'errno.h' (Linux: Key was rejected by service): *note Error |
| Codes::. |
| |
| 'int EKEYREVOKED' |
| |
| 'errno.h' (Linux: Key has been revoked): *note Error Codes::. |
| |
| 'int EL2HLT' |
| |
| 'errno.h' (Obsolete: Level 2 halted): *note Error Codes::. |
| |
| 'int EL2NSYNC' |
| |
| 'errno.h' (Obsolete: Level 2 not synchronized): *note Error |
| Codes::. |
| |
| 'int EL3HLT' |
| |
| 'errno.h' (Obsolete: Level 3 halted): *note Error Codes::. |
| |
| 'int EL3RST' |
| |
| 'errno.h' (Obsolete: Level 3 reset): *note Error Codes::. |
| |
| 'int ELIBACC' |
| |
| 'errno.h' (Linux???: Can not access a needed shared library): *note |
| Error Codes::. |
| |
| 'int ELIBBAD' |
| |
| 'errno.h' (Linux???: Accessing a corrupted shared library): *note |
| Error Codes::. |
| |
| 'int ELIBEXEC' |
| |
| 'errno.h' (Linux???: Cannot exec a shared library directly): *note |
| Error Codes::. |
| |
| 'int ELIBMAX' |
| |
| 'errno.h' (Linux???: Attempting to link in too many shared |
| libraries): *note Error Codes::. |
| |
| 'int ELIBSCN' |
| |
| 'errno.h' (Linux???: .lib section in a.out corrupted): *note Error |
| Codes::. |
| |
| 'int ELNRNG' |
| |
| 'errno.h' (Linux???: Link number out of range): *note Error |
| Codes::. |
| |
| 'int ELOOP' |
| |
| 'errno.h' (BSD: Too many levels of symbolic links): *note Error |
| Codes::. |
| |
| 'int EMEDIUMTYPE' |
| |
| 'errno.h' (Linux???: Wrong medium type): *note Error Codes::. |
| |
| 'int EMFILE' |
| |
| 'errno.h' (POSIX.1: Too many open files): *note Error Codes::. |
| |
| 'int EMLINK' |
| |
| 'errno.h' (POSIX.1: Too many links): *note Error Codes::. |
| |
| 'EMPTY' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'EMPTY' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int EMSGSIZE' |
| |
| 'errno.h' (BSD: Message too long): *note Error Codes::. |
| |
| 'int EMULTIHOP' |
| |
| 'errno.h' (XOPEN: Multihop attempted): *note Error Codes::. |
| |
| 'int ENAMETOOLONG' |
| |
| 'errno.h' (POSIX.1: File name too long): *note Error Codes::. |
| |
| 'int ENAVAIL' |
| |
| 'errno.h' (Linux???: No XENIX semaphores available): *note Error |
| Codes::. |
| |
| 'void encrypt (char *BLOCK, int EDFLAG)' |
| |
| 'crypt.h' (BSD, SVID): *note DES Encryption::. |
| |
| 'void encrypt_r (char *BLOCK, int EDFLAG, struct crypt_data * DATA)' |
| |
| 'crypt.h' (GNU): *note DES Encryption::. |
| |
| 'void endfsent (void)' |
| |
| 'fstab.h' (BSD): *note fstab::. |
| |
| 'void endgrent (void)' |
| |
| 'grp.h' (SVID, BSD): *note Scanning All Groups::. |
| |
| 'void endhostent (void)' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'int endmntent (FILE *STREAM)' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'void endnetent (void)' |
| |
| 'netdb.h' (BSD): *note Networks Database::. |
| |
| 'void endnetgrent (void)' |
| |
| 'netdb.h' (BSD): *note Lookup Netgroup::. |
| |
| 'void endprotoent (void)' |
| |
| 'netdb.h' (BSD): *note Protocols Database::. |
| |
| 'void endpwent (void)' |
| |
| 'pwd.h' (SVID, BSD): *note Scanning All Users::. |
| |
| 'void endservent (void)' |
| |
| 'netdb.h' (BSD): *note Services Database::. |
| |
| 'void endutent (void)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'void endutxent (void)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int ENEEDAUTH' |
| |
| 'errno.h' (BSD: Need authenticator): *note Error Codes::. |
| |
| 'int ENETDOWN' |
| |
| 'errno.h' (BSD: Network is down): *note Error Codes::. |
| |
| 'int ENETRESET' |
| |
| 'errno.h' (BSD: Network dropped connection on reset): *note Error |
| Codes::. |
| |
| 'int ENETUNREACH' |
| |
| 'errno.h' (BSD: Network is unreachable): *note Error Codes::. |
| |
| 'int ENFILE' |
| |
| 'errno.h' (POSIX.1: Too many open files in system): *note Error |
| Codes::. |
| |
| 'int ENOANO' |
| |
| 'errno.h' (Linux???: No anode): *note Error Codes::. |
| |
| 'int ENOBUFS' |
| |
| 'errno.h' (BSD: No buffer space available): *note Error Codes::. |
| |
| 'int ENOCSI' |
| |
| 'errno.h' (Linux???: No CSI structure available): *note Error |
| Codes::. |
| |
| 'int ENODATA' |
| |
| 'errno.h' (XOPEN: No data available): *note Error Codes::. |
| |
| 'int ENODEV' |
| |
| 'errno.h' (POSIX.1: No such device): *note Error Codes::. |
| |
| 'int ENOENT' |
| |
| 'errno.h' (POSIX.1: No such file or directory): *note Error |
| Codes::. |
| |
| 'int ENOEXEC' |
| |
| 'errno.h' (POSIX.1: Exec format error): *note Error Codes::. |
| |
| 'int ENOKEY' |
| |
| 'errno.h' (Linux: Required key not available): *note Error Codes::. |
| |
| 'int ENOLCK' |
| |
| 'errno.h' (POSIX.1: No locks available): *note Error Codes::. |
| |
| 'int ENOLINK' |
| |
| 'errno.h' (XOPEN: Link has been severed): *note Error Codes::. |
| |
| 'int ENOMEDIUM' |
| |
| 'errno.h' (Linux???: No medium found): *note Error Codes::. |
| |
| 'int ENOMEM' |
| |
| 'errno.h' (POSIX.1: Cannot allocate memory): *note Error Codes::. |
| |
| 'int ENOMSG' |
| |
| 'errno.h' (XOPEN: No message of desired type): *note Error Codes::. |
| |
| 'int ENONET' |
| |
| 'errno.h' (Linux???: Machine is not on the network): *note Error |
| Codes::. |
| |
| 'int ENOPKG' |
| |
| 'errno.h' (Linux???: Package not installed): *note Error Codes::. |
| |
| 'int ENOPROTOOPT' |
| |
| 'errno.h' (BSD: Protocol not available): *note Error Codes::. |
| |
| 'int ENOSPC' |
| |
| 'errno.h' (POSIX.1: No space left on device): *note Error Codes::. |
| |
| 'int ENOSR' |
| |
| 'errno.h' (XOPEN: Out of streams resources): *note Error Codes::. |
| |
| 'int ENOSTR' |
| |
| 'errno.h' (XOPEN: Device not a stream): *note Error Codes::. |
| |
| 'int ENOSYS' |
| |
| 'errno.h' (POSIX.1: Function not implemented): *note Error Codes::. |
| |
| 'int ENOTBLK' |
| |
| 'errno.h' (BSD: Block device required): *note Error Codes::. |
| |
| 'int ENOTCONN' |
| |
| 'errno.h' (BSD: Transport endpoint is not connected): *note Error |
| Codes::. |
| |
| 'int ENOTDIR' |
| |
| 'errno.h' (POSIX.1: Not a directory): *note Error Codes::. |
| |
| 'int ENOTEMPTY' |
| |
| 'errno.h' (POSIX.1: Directory not empty): *note Error Codes::. |
| |
| 'int ENOTNAM' |
| |
| 'errno.h' (Linux???: Not a XENIX named type file): *note Error |
| Codes::. |
| |
| 'int ENOTRECOVERABLE' |
| |
| 'errno.h' (Linux: State not recoverable): *note Error Codes::. |
| |
| 'int ENOTSOCK' |
| |
| 'errno.h' (BSD: Socket operation on non-socket): *note Error |
| Codes::. |
| |
| 'int ENOTSUP' |
| |
| 'errno.h' (POSIX.1: Not supported): *note Error Codes::. |
| |
| 'int ENOTTY' |
| |
| 'errno.h' (POSIX.1: Inappropriate ioctl for device): *note Error |
| Codes::. |
| |
| 'int ENOTUNIQ' |
| |
| 'errno.h' (Linux???: Name not unique on network): *note Error |
| Codes::. |
| |
| 'char ** environ' |
| |
| 'unistd.h' (POSIX.1): *note Environment Access::. |
| |
| 'error_t envz_add (char **ENVZ, size_t *ENVZ_LEN, const char *NAME, const char *VALUE)' |
| |
| 'envz.h' (GNU): *note Envz Functions::. |
| |
| 'char * envz_entry (const char *ENVZ, size_t ENVZ_LEN, const char *NAME)' |
| |
| 'envz.h' (GNU): *note Envz Functions::. |
| |
| 'char * envz_get (const char *ENVZ, size_t ENVZ_LEN, const char *NAME)' |
| |
| 'envz.h' (GNU): *note Envz Functions::. |
| |
| 'error_t envz_merge (char **ENVZ, size_t *ENVZ_LEN, const char *ENVZ2, size_t ENVZ2_LEN, int OVERRIDE)' |
| |
| 'envz.h' (GNU): *note Envz Functions::. |
| |
| 'void envz_strip (char **ENVZ, size_t *ENVZ_LEN)' |
| |
| 'envz.h' (GNU): *note Envz Functions::. |
| |
| 'int ENXIO' |
| |
| 'errno.h' (POSIX.1: No such device or address): *note Error |
| Codes::. |
| |
| 'int EOF' |
| |
| 'stdio.h' (ISO): *note EOF and Errors::. |
| |
| 'int EOPNOTSUPP' |
| |
| 'errno.h' (BSD: Operation not supported): *note Error Codes::. |
| |
| 'int EOVERFLOW' |
| |
| 'errno.h' (XOPEN: Value too large for defined data type): *note |
| Error Codes::. |
| |
| 'int EOWNERDEAD' |
| |
| 'errno.h' (Linux: Owner died): *note Error Codes::. |
| |
| 'int EPERM' |
| |
| 'errno.h' (POSIX.1: Operation not permitted): *note Error Codes::. |
| |
| 'int EPFNOSUPPORT' |
| |
| 'errno.h' (BSD: Protocol family not supported): *note Error |
| Codes::. |
| |
| 'int EPIPE' |
| |
| 'errno.h' (POSIX.1: Broken pipe): *note Error Codes::. |
| |
| 'int EPROCLIM' |
| |
| 'errno.h' (BSD: Too many processes): *note Error Codes::. |
| |
| 'int EPROCUNAVAIL' |
| |
| 'errno.h' (BSD: RPC bad procedure for program): *note Error |
| Codes::. |
| |
| 'int EPROGMISMATCH' |
| |
| 'errno.h' (BSD: RPC program version wrong): *note Error Codes::. |
| |
| 'int EPROGUNAVAIL' |
| |
| 'errno.h' (BSD: RPC program not available): *note Error Codes::. |
| |
| 'int EPROTO' |
| |
| 'errno.h' (XOPEN: Protocol error): *note Error Codes::. |
| |
| 'int EPROTONOSUPPORT' |
| |
| 'errno.h' (BSD: Protocol not supported): *note Error Codes::. |
| |
| 'int EPROTOTYPE' |
| |
| 'errno.h' (BSD: Protocol wrong type for socket): *note Error |
| Codes::. |
| |
| 'int EQUIV_CLASS_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'double erand48 (unsigned short int XSUBI[3])' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int erand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, double *RESULT)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'int ERANGE' |
| |
| 'errno.h' (ISO: Numerical result out of range): *note Error |
| Codes::. |
| |
| 'int EREMCHG' |
| |
| 'errno.h' (Linux???: Remote address changed): *note Error Codes::. |
| |
| 'int EREMOTE' |
| |
| 'errno.h' (BSD: Object is remote): *note Error Codes::. |
| |
| 'int EREMOTEIO' |
| |
| 'errno.h' (Linux???: Remote I/O error): *note Error Codes::. |
| |
| 'int ERESTART' |
| |
| 'errno.h' (Linux???: Interrupted system call should be restarted): |
| *note Error Codes::. |
| |
| 'double erf (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'double erfc (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float erfcf (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double erfcl (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float erff (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'int ERFKILL' |
| |
| 'errno.h' (Linux: Operation not possible due to RF-kill): *note |
| Error Codes::. |
| |
| 'long double erfl (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'int EROFS' |
| |
| 'errno.h' (POSIX.1: Read-only file system): *note Error Codes::. |
| |
| 'int ERPCMISMATCH' |
| |
| 'errno.h' (BSD: RPC version wrong): *note Error Codes::. |
| |
| 'void err (int STATUS, const char *FORMAT, ...)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'volatile int errno' |
| |
| 'errno.h' (ISO): *note Checking for Errors::. |
| |
| 'void error (int STATUS, int ERRNUM, const char *FORMAT, ...)' |
| |
| 'error.h' (GNU): *note Error Messages::. |
| |
| 'void error_at_line (int STATUS, int ERRNUM, const char *FNAME, unsigned int LINENO, const char *FORMAT, ...)' |
| |
| 'error.h' (GNU): *note Error Messages::. |
| |
| 'unsigned int error_message_count' |
| |
| 'error.h' (GNU): *note Error Messages::. |
| |
| 'int error_one_per_line' |
| |
| 'error.h' (GNU): *note Error Messages::. |
| |
| 'void errx (int STATUS, const char *FORMAT, ...)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'int ESHUTDOWN' |
| |
| 'errno.h' (BSD: Cannot send after transport endpoint shutdown): |
| *note Error Codes::. |
| |
| 'int ESOCKTNOSUPPORT' |
| |
| 'errno.h' (BSD: Socket type not supported): *note Error Codes::. |
| |
| 'int ESPIPE' |
| |
| 'errno.h' (POSIX.1: Illegal seek): *note Error Codes::. |
| |
| 'int ESRCH' |
| |
| 'errno.h' (POSIX.1: No such process): *note Error Codes::. |
| |
| 'int ESRMNT' |
| |
| 'errno.h' (Linux???: Srmount error): *note Error Codes::. |
| |
| 'int ESTALE' |
| |
| 'errno.h' (BSD: Stale file handle): *note Error Codes::. |
| |
| 'int ESTRPIPE' |
| |
| 'errno.h' (Linux???: Streams pipe error): *note Error Codes::. |
| |
| 'int ETIME' |
| |
| 'errno.h' (XOPEN: Timer expired): *note Error Codes::. |
| |
| 'int ETIMEDOUT' |
| |
| 'errno.h' (BSD: Connection timed out): *note Error Codes::. |
| |
| 'int ETOOMANYREFS' |
| |
| 'errno.h' (BSD: Too many references: cannot splice): *note Error |
| Codes::. |
| |
| 'int ETXTBSY' |
| |
| 'errno.h' (BSD: Text file busy): *note Error Codes::. |
| |
| 'int EUCLEAN' |
| |
| 'errno.h' (Linux???: Structure needs cleaning): *note Error |
| Codes::. |
| |
| 'int EUNATCH' |
| |
| 'errno.h' (Linux???: Protocol driver not attached): *note Error |
| Codes::. |
| |
| 'int EUSERS' |
| |
| 'errno.h' (BSD: Too many users): *note Error Codes::. |
| |
| 'int EWOULDBLOCK' |
| |
| 'errno.h' (BSD: Operation would block): *note Error Codes::. |
| |
| 'int EXDEV' |
| |
| 'errno.h' (POSIX.1: Invalid cross-device link): *note Error |
| Codes::. |
| |
| 'int execl (const char *FILENAME, const char *ARG0, ...)' |
| |
| 'unistd.h' (POSIX.1): *note Executing a File::. |
| |
| 'int execle (const char *FILENAME, const char *ARG0, ..., char *const ENV[])' |
| |
| 'unistd.h' (POSIX.1): *note Executing a File::. |
| |
| 'int execlp (const char *FILENAME, const char *ARG0, ...)' |
| |
| 'unistd.h' (POSIX.1): *note Executing a File::. |
| |
| 'int execv (const char *FILENAME, char *const ARGV[])' |
| |
| 'unistd.h' (POSIX.1): *note Executing a File::. |
| |
| 'int execve (const char *FILENAME, char *const ARGV[], char *const ENV[])' |
| |
| 'unistd.h' (POSIX.1): *note Executing a File::. |
| |
| 'int execvp (const char *FILENAME, char *const ARGV[])' |
| |
| 'unistd.h' (POSIX.1): *note Executing a File::. |
| |
| 'int EXFULL' |
| |
| 'errno.h' (Linux???: Exchange full): *note Error Codes::. |
| |
| 'void exit (int STATUS)' |
| |
| 'stdlib.h' (ISO): *note Normal Termination::. |
| |
| 'void _Exit (int STATUS)' |
| |
| 'stdlib.h' (ISO): *note Termination Internals::. |
| |
| 'void _exit (int STATUS)' |
| |
| 'unistd.h' (POSIX.1): *note Termination Internals::. |
| |
| 'int EXIT_FAILURE' |
| |
| 'stdlib.h' (ISO): *note Exit Status::. |
| |
| 'int EXIT_SUCCESS' |
| |
| 'stdlib.h' (ISO): *note Exit Status::. |
| |
| 'double exp (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double exp10 (double X)' |
| |
| 'math.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'float exp10f (float X)' |
| |
| 'math.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'long double exp10l (long double X)' |
| |
| 'math.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'double exp2 (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float exp2f (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double exp2l (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float expf (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double expl (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double expm1 (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float expm1f (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double expm1l (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'int EXPR_NEST_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'double fabs (double NUMBER)' |
| |
| 'math.h' (ISO): *note Absolute Value::. |
| |
| 'float fabsf (float NUMBER)' |
| |
| 'math.h' (ISO): *note Absolute Value::. |
| |
| 'long double fabsl (long double NUMBER)' |
| |
| 'math.h' (ISO): *note Absolute Value::. |
| |
| 'size_t __fbufsize (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Controlling Buffering::. |
| |
| 'int fchdir (int FILEDES)' |
| |
| 'unistd.h' (XPG): *note Working Directory::. |
| |
| 'int fchmod (int FILEDES, mode_t MODE)' |
| |
| 'sys/stat.h' (BSD): *note Setting Permissions::. |
| |
| 'int fchown (int FILEDES, uid_t OWNER, gid_t GROUP)' |
| |
| 'unistd.h' (BSD): *note File Owner::. |
| |
| 'int fclose (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Closing Streams::. |
| |
| 'int fcloseall (void)' |
| |
| 'stdio.h' (GNU): *note Closing Streams::. |
| |
| 'int fcntl (int FILEDES, int COMMAND, ...)' |
| |
| 'fcntl.h' (POSIX.1): *note Control Operations::. |
| |
| 'char * fcvt (double VALUE, int NDIGIT, int *DECPT, int *NEG)' |
| |
| 'stdlib.h' (SVID, Unix98): *note System V Number Conversion::. |
| |
| 'int fcvt_r (double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN)' |
| |
| 'stdlib.h' (SVID, Unix98): *note System V Number Conversion::. |
| |
| 'int fdatasync (int FILDES)' |
| |
| 'unistd.h' (POSIX): *note Synchronizing I/O::. |
| |
| 'int FD_CLOEXEC' |
| |
| 'fcntl.h' (POSIX.1): *note Descriptor Flags::. |
| |
| 'void FD_CLR (int FILEDES, fd_set *SET)' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'double fdim (double X, double Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'float fdimf (float X, float Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'long double fdiml (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'int FD_ISSET (int FILEDES, const fd_set *SET)' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'FILE * fdopen (int FILEDES, const char *OPENTYPE)' |
| |
| 'stdio.h' (POSIX.1): *note Descriptors and Streams::. |
| |
| 'DIR * fdopendir (int FD)' |
| |
| 'dirent.h' (GNU): *note Opening a Directory::. |
| |
| 'fd_set' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'void FD_SET (int FILEDES, fd_set *SET)' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'int FD_SETSIZE' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'int F_DUPFD' |
| |
| 'fcntl.h' (POSIX.1): *note Duplicating Descriptors::. |
| |
| 'void FD_ZERO (fd_set *SET)' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'int feclearexcept (int EXCEPTS)' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int fedisableexcept (int EXCEPTS)' |
| |
| 'fenv.h' (GNU): *note Control Functions::. |
| |
| 'FE_DIVBYZERO' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'FE_DOWNWARD' |
| |
| 'fenv.h' (ISO): *note Rounding::. |
| |
| 'int feenableexcept (int EXCEPTS)' |
| |
| 'fenv.h' (GNU): *note Control Functions::. |
| |
| 'int fegetenv (fenv_t *ENVP)' |
| |
| 'fenv.h' (ISO): *note Control Functions::. |
| |
| 'int fegetexcept (void)' |
| |
| 'fenv.h' (GNU): *note Control Functions::. |
| |
| 'int fegetexceptflag (fexcept_t *FLAGP, int EXCEPTS)' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int fegetround (void)' |
| |
| 'fenv.h' (ISO): *note Rounding::. |
| |
| 'int feholdexcept (fenv_t *ENVP)' |
| |
| 'fenv.h' (ISO): *note Control Functions::. |
| |
| 'FE_INEXACT' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'FE_INVALID' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int feof (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note EOF and Errors::. |
| |
| 'int feof_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note EOF and Errors::. |
| |
| 'FE_OVERFLOW' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int feraiseexcept (int EXCEPTS)' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int ferror (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note EOF and Errors::. |
| |
| 'int ferror_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note EOF and Errors::. |
| |
| 'int fesetenv (const fenv_t *ENVP)' |
| |
| 'fenv.h' (ISO): *note Control Functions::. |
| |
| 'int fesetexceptflag (const fexcept_t *FLAGP, int EXCEPTS)' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int fesetround (int ROUND)' |
| |
| 'fenv.h' (ISO): *note Rounding::. |
| |
| 'int fetestexcept (int EXCEPTS)' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'FE_TONEAREST' |
| |
| 'fenv.h' (ISO): *note Rounding::. |
| |
| 'FE_TOWARDZERO' |
| |
| 'fenv.h' (ISO): *note Rounding::. |
| |
| 'FE_UNDERFLOW' |
| |
| 'fenv.h' (ISO): *note Status bit operations::. |
| |
| 'int feupdateenv (const fenv_t *ENVP)' |
| |
| 'fenv.h' (ISO): *note Control Functions::. |
| |
| 'FE_UPWARD' |
| |
| 'fenv.h' (ISO): *note Rounding::. |
| |
| 'int fflush (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Flushing Buffers::. |
| |
| 'int fflush_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Flushing Buffers::. |
| |
| 'int fgetc (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Character Input::. |
| |
| 'int fgetc_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Character Input::. |
| |
| 'int F_GETFD' |
| |
| 'fcntl.h' (POSIX.1): *note Descriptor Flags::. |
| |
| 'int F_GETFL' |
| |
| 'fcntl.h' (POSIX.1): *note Getting File Status Flags::. |
| |
| 'struct group * fgetgrent (FILE *STREAM)' |
| |
| 'grp.h' (SVID): *note Scanning All Groups::. |
| |
| 'int fgetgrent_r (FILE *STREAM, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT)' |
| |
| 'grp.h' (GNU): *note Scanning All Groups::. |
| |
| 'int F_GETLK' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'int F_GETOWN' |
| |
| 'fcntl.h' (BSD): *note Interrupt Input::. |
| |
| 'int fgetpos (FILE *STREAM, fpos_t *POSITION)' |
| |
| 'stdio.h' (ISO): *note Portable Positioning::. |
| |
| 'int fgetpos64 (FILE *STREAM, fpos64_t *POSITION)' |
| |
| 'stdio.h' (Unix98): *note Portable Positioning::. |
| |
| 'struct passwd * fgetpwent (FILE *STREAM)' |
| |
| 'pwd.h' (SVID): *note Scanning All Users::. |
| |
| 'int fgetpwent_r (FILE *STREAM, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT)' |
| |
| 'pwd.h' (GNU): *note Scanning All Users::. |
| |
| 'char * fgets (char *S, int COUNT, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Line Input::. |
| |
| 'char * fgets_unlocked (char *S, int COUNT, FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Line Input::. |
| |
| 'wint_t fgetwc (FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note Character Input::. |
| |
| 'wint_t fgetwc_unlocked (FILE *STREAM)' |
| |
| 'wchar.h' (GNU): *note Character Input::. |
| |
| 'wchar_t * fgetws (wchar_t *WS, int COUNT, FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note Line Input::. |
| |
| 'wchar_t * fgetws_unlocked (wchar_t *WS, int COUNT, FILE *STREAM)' |
| |
| 'wchar.h' (GNU): *note Line Input::. |
| |
| 'FILE' |
| |
| 'stdio.h' (ISO): *note Streams::. |
| |
| 'int FILENAME_MAX' |
| |
| 'stdio.h' (ISO): *note Limits for Files::. |
| |
| 'int fileno (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX.1): *note Descriptors and Streams::. |
| |
| 'int fileno_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Descriptors and Streams::. |
| |
| 'int finite (double X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int finitef (float X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int finitel (long double X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int __flbf (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Controlling Buffering::. |
| |
| 'void flockfile (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Streams and Threads::. |
| |
| 'double floor (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'float floorf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double floorl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'FLT_DIG' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_EPSILON' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MANT_DIG' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MAX' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MAX_10_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MAX_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MIN' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MIN_10_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_MIN_EXP' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_RADIX' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'FLT_ROUNDS' |
| |
| 'float.h' (ISO): *note Floating Point Parameters::. |
| |
| 'void _flushlbf (void)' |
| |
| 'stdio_ext.h' (GNU): *note Flushing Buffers::. |
| |
| 'tcflag_t FLUSHO' |
| |
| 'termios.h' (BSD): *note Local Modes::. |
| |
| 'double fma (double X, double Y, double Z)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'float fmaf (float X, float Y, float Z)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'long double fmal (long double X, long double Y, long double Z)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'double fmax (double X, double Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'float fmaxf (float X, float Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'long double fmaxl (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'FILE * fmemopen (void *BUF, size_t SIZE, const char *OPENTYPE)' |
| |
| 'stdio.h' (GNU): *note String Streams::. |
| |
| 'double fmin (double X, double Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'float fminf (float X, float Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'long double fminl (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note Misc FP Arithmetic::. |
| |
| 'double fmod (double NUMERATOR, double DENOMINATOR)' |
| |
| 'math.h' (ISO): *note Remainder Functions::. |
| |
| 'float fmodf (float NUMERATOR, float DENOMINATOR)' |
| |
| 'math.h' (ISO): *note Remainder Functions::. |
| |
| 'long double fmodl (long double NUMERATOR, long double DENOMINATOR)' |
| |
| 'math.h' (ISO): *note Remainder Functions::. |
| |
| 'int fmtmsg (long int CLASSIFICATION, const char *LABEL, int SEVERITY, const char *TEXT, const char *ACTION, const char *TAG)' |
| |
| 'fmtmsg.h' (XPG): *note Printing Formatted Messages::. |
| |
| 'int fnmatch (const char *PATTERN, const char *STRING, int FLAGS)' |
| |
| 'fnmatch.h' (POSIX.2): *note Wildcard Matching::. |
| |
| 'FNM_CASEFOLD' |
| |
| 'fnmatch.h' (GNU): *note Wildcard Matching::. |
| |
| 'FNM_EXTMATCH' |
| |
| 'fnmatch.h' (GNU): *note Wildcard Matching::. |
| |
| 'FNM_FILE_NAME' |
| |
| 'fnmatch.h' (GNU): *note Wildcard Matching::. |
| |
| 'FNM_LEADING_DIR' |
| |
| 'fnmatch.h' (GNU): *note Wildcard Matching::. |
| |
| 'FNM_NOESCAPE' |
| |
| 'fnmatch.h' (POSIX.2): *note Wildcard Matching::. |
| |
| 'FNM_PATHNAME' |
| |
| 'fnmatch.h' (POSIX.2): *note Wildcard Matching::. |
| |
| 'FNM_PERIOD' |
| |
| 'fnmatch.h' (POSIX.2): *note Wildcard Matching::. |
| |
| 'int F_OFD_SETLK' |
| |
| 'fcntl.h' (POSIX.1): *note Open File Description Locks::. |
| |
| 'int F_OFD_SETLKW' |
| |
| 'fcntl.h' (POSIX.1): *note Open File Description Locks::. |
| |
| 'int F_OK' |
| |
| 'unistd.h' (POSIX.1): *note Testing File Access::. |
| |
| 'FILE * fopen (const char *FILENAME, const char *OPENTYPE)' |
| |
| 'stdio.h' (ISO): *note Opening Streams::. |
| |
| 'FILE * fopen64 (const char *FILENAME, const char *OPENTYPE)' |
| |
| 'stdio.h' (Unix98): *note Opening Streams::. |
| |
| 'FILE * fopencookie (void *COOKIE, const char *OPENTYPE, cookie_io_functions_t IO-FUNCTIONS)' |
| |
| 'stdio.h' (GNU): *note Streams and Cookies::. |
| |
| 'int FOPEN_MAX' |
| |
| 'stdio.h' (ISO): *note Opening Streams::. |
| |
| 'pid_t fork (void)' |
| |
| 'unistd.h' (POSIX.1): *note Creating a Process::. |
| |
| 'int forkpty (int *AMASTER, char *NAME, const struct termios *TERMP, const struct winsize *WINP)' |
| |
| 'pty.h' (BSD): *note Pseudo-Terminal Pairs::. |
| |
| 'long int fpathconf (int FILEDES, int PARAMETER)' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| 'int fpclassify (_float-type_ X)' |
| |
| 'math.h' (ISO): *note Floating Point Classes::. |
| |
| 'FPE_DECOVF_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_FLTDIV_FAULT' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_FLTDIV_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_FLTOVF_FAULT' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_FLTOVF_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_FLTUND_FAULT' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_FLTUND_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_INTDIV_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'FPE_INTOVF_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'size_t __fpending (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Controlling Buffering::. |
| |
| 'FPE_SUBRNG_TRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'int FP_ILOGB0' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'int FP_ILOGBNAN' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'fpos64_t' |
| |
| 'stdio.h' (Unix98): *note Portable Positioning::. |
| |
| 'fpos_t' |
| |
| 'stdio.h' (ISO): *note Portable Positioning::. |
| |
| 'int fprintf (FILE *STREAM, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (ISO): *note Formatted Output Functions::. |
| |
| 'void __fpurge (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Flushing Buffers::. |
| |
| 'int fputc (int C, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Simple Output::. |
| |
| 'int fputc_unlocked (int C, FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Simple Output::. |
| |
| 'int fputs (const char *S, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Simple Output::. |
| |
| 'int fputs_unlocked (const char *S, FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Simple Output::. |
| |
| 'wint_t fputwc (wchar_t WC, FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note Simple Output::. |
| |
| 'wint_t fputwc_unlocked (wchar_t WC, FILE *STREAM)' |
| |
| 'wchar.h' (POSIX): *note Simple Output::. |
| |
| 'int fputws (const wchar_t *WS, FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note Simple Output::. |
| |
| 'int fputws_unlocked (const wchar_t *WS, FILE *STREAM)' |
| |
| 'wchar.h' (GNU): *note Simple Output::. |
| |
| 'F_RDLCK' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'size_t fread (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Block Input/Output::. |
| |
| 'int __freadable (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Opening Streams::. |
| |
| 'int __freading (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Opening Streams::. |
| |
| 'size_t fread_unlocked (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Block Input/Output::. |
| |
| 'void free (void *PTR)' |
| |
| 'malloc.h', 'stdlib.h' (ISO): *note Freeing after Malloc::. |
| |
| '__free_hook' |
| |
| 'malloc.h' (GNU): *note Hooks for Malloc::. |
| |
| 'FILE * freopen (const char *FILENAME, const char *OPENTYPE, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Opening Streams::. |
| |
| 'FILE * freopen64 (const char *FILENAME, const char *OPENTYPE, FILE *STREAM)' |
| |
| 'stdio.h' (Unix98): *note Opening Streams::. |
| |
| 'double frexp (double VALUE, int *EXPONENT)' |
| |
| 'math.h' (ISO): *note Normalization Functions::. |
| |
| 'float frexpf (float VALUE, int *EXPONENT)' |
| |
| 'math.h' (ISO): *note Normalization Functions::. |
| |
| 'long double frexpl (long double VALUE, int *EXPONENT)' |
| |
| 'math.h' (ISO): *note Normalization Functions::. |
| |
| 'int fscanf (FILE *STREAM, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (ISO): *note Formatted Input Functions::. |
| |
| 'int fseek (FILE *STREAM, long int OFFSET, int WHENCE)' |
| |
| 'stdio.h' (ISO): *note File Positioning::. |
| |
| 'int fseeko (FILE *STREAM, off_t OFFSET, int WHENCE)' |
| |
| 'stdio.h' (Unix98): *note File Positioning::. |
| |
| 'int fseeko64 (FILE *STREAM, off64_t OFFSET, int WHENCE)' |
| |
| 'stdio.h' (Unix98): *note File Positioning::. |
| |
| 'int F_SETFD' |
| |
| 'fcntl.h' (POSIX.1): *note Descriptor Flags::. |
| |
| 'int F_SETFL' |
| |
| 'fcntl.h' (POSIX.1): *note Getting File Status Flags::. |
| |
| 'int F_SETLK' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'int F_SETLKW' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'int __fsetlocking (FILE *STREAM, int TYPE)' |
| |
| 'stdio_ext.h' (GNU): *note Streams and Threads::. |
| |
| 'int F_SETOWN' |
| |
| 'fcntl.h' (BSD): *note Interrupt Input::. |
| |
| 'int fsetpos (FILE *STREAM, const fpos_t *POSITION)' |
| |
| 'stdio.h' (ISO): *note Portable Positioning::. |
| |
| 'int fsetpos64 (FILE *STREAM, const fpos64_t *POSITION)' |
| |
| 'stdio.h' (Unix98): *note Portable Positioning::. |
| |
| 'int fstat (int FILEDES, struct stat *BUF)' |
| |
| 'sys/stat.h' (POSIX.1): *note Reading Attributes::. |
| |
| 'int fstat64 (int FILEDES, struct stat64 *BUF)' |
| |
| 'sys/stat.h' (Unix98): *note Reading Attributes::. |
| |
| 'int fsync (int FILDES)' |
| |
| 'unistd.h' (POSIX): *note Synchronizing I/O::. |
| |
| 'long int ftell (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note File Positioning::. |
| |
| 'off_t ftello (FILE *STREAM)' |
| |
| 'stdio.h' (Unix98): *note File Positioning::. |
| |
| 'off64_t ftello64 (FILE *STREAM)' |
| |
| 'stdio.h' (Unix98): *note File Positioning::. |
| |
| 'int ftruncate (int FD, off_t LENGTH)' |
| |
| 'unistd.h' (POSIX): *note File Size::. |
| |
| 'int ftruncate64 (int ID, off64_t LENGTH)' |
| |
| 'unistd.h' (Unix98): *note File Size::. |
| |
| 'int ftrylockfile (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Streams and Threads::. |
| |
| 'int ftw (const char *FILENAME, __ftw_func_t FUNC, int DESCRIPTORS)' |
| |
| 'ftw.h' (SVID): *note Working with Directory Trees::. |
| |
| 'int ftw64 (const char *FILENAME, __ftw64_func_t FUNC, int DESCRIPTORS)' |
| |
| 'ftw.h' (Unix98): *note Working with Directory Trees::. |
| |
| '__ftw64_func_t' |
| |
| 'ftw.h' (GNU): *note Working with Directory Trees::. |
| |
| '__ftw_func_t' |
| |
| 'ftw.h' (GNU): *note Working with Directory Trees::. |
| |
| 'F_UNLCK' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'void funlockfile (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Streams and Threads::. |
| |
| 'int futimes (int FD, const struct timeval TVP[2])' |
| |
| 'sys/time.h' (BSD): *note File Times::. |
| |
| 'int fwide (FILE *STREAM, int MODE)' |
| |
| 'wchar.h' (ISO): *note Streams and I18N::. |
| |
| 'int fwprintf (FILE *STREAM, const wchar_t *TEMPLATE, ...)' |
| |
| 'wchar.h' (ISO): *note Formatted Output Functions::. |
| |
| 'int __fwritable (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Opening Streams::. |
| |
| 'size_t fwrite (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Block Input/Output::. |
| |
| 'size_t fwrite_unlocked (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Block Input/Output::. |
| |
| 'int __fwriting (FILE *STREAM)' |
| |
| 'stdio_ext.h' (GNU): *note Opening Streams::. |
| |
| 'F_WRLCK' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'int fwscanf (FILE *STREAM, const wchar_t *TEMPLATE, ...)' |
| |
| 'wchar.h' (ISO): *note Formatted Input Functions::. |
| |
| 'double gamma (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float gammaf (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double gammal (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'void (*__gconv_end_fct) (struct gconv_step *)' |
| |
| 'gconv.h' (GNU): *note glibc iconv Implementation::. |
| |
| 'int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *, const char **, const char *, size_t *, int)' |
| |
| 'gconv.h' (GNU): *note glibc iconv Implementation::. |
| |
| 'int (*__gconv_init_fct) (struct __gconv_step *)' |
| |
| 'gconv.h' (GNU): *note glibc iconv Implementation::. |
| |
| 'char * gcvt (double VALUE, int NDIGIT, char *BUF)' |
| |
| 'stdlib.h' (SVID, Unix98): *note System V Number Conversion::. |
| |
| 'unsigned long int getauxval (unsigned long int TYPE)' |
| |
| 'sys/auxv.h' (sys/auxv.h): *note Auxiliary Vector::. |
| |
| 'long int get_avphys_pages (void)' |
| |
| 'sys/sysinfo.h' (GNU): *note Query Memory Parameters::. |
| |
| 'int getc (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Character Input::. |
| |
| 'int getchar (void)' |
| |
| 'stdio.h' (ISO): *note Character Input::. |
| |
| 'int getchar_unlocked (void)' |
| |
| 'stdio.h' (POSIX): *note Character Input::. |
| |
| 'int getcontext (ucontext_t *UCP)' |
| |
| 'ucontext.h' (SVID): *note System V contexts::. |
| |
| 'int getc_unlocked (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Character Input::. |
| |
| 'char * get_current_dir_name (void)' |
| |
| 'unistd.h' (GNU): *note Working Directory::. |
| |
| 'char * getcwd (char *BUFFER, size_t SIZE)' |
| |
| 'unistd.h' (POSIX.1): *note Working Directory::. |
| |
| 'struct tm * getdate (const char *STRING)' |
| |
| 'time.h' (Unix98): *note General Time String Parsing::. |
| |
| 'getdate_err' |
| |
| 'time.h' (Unix98): *note General Time String Parsing::. |
| |
| 'int getdate_r (const char *STRING, struct tm *TP)' |
| |
| 'time.h' (GNU): *note General Time String Parsing::. |
| |
| 'ssize_t getdelim (char **LINEPTR, size_t *N, int DELIMITER, FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Line Input::. |
| |
| 'int getdomainnname (char *NAME, size_t LENGTH)' |
| |
| 'unistd.h' (???): *note Host Identification::. |
| |
| 'gid_t getegid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Reading Persona::. |
| |
| 'char * getenv (const char *NAME)' |
| |
| 'stdlib.h' (ISO): *note Environment Access::. |
| |
| 'uid_t geteuid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Reading Persona::. |
| |
| 'struct fstab * getfsent (void)' |
| |
| 'fstab.h' (BSD): *note fstab::. |
| |
| 'struct fstab * getfsfile (const char *NAME)' |
| |
| 'fstab.h' (BSD): *note fstab::. |
| |
| 'struct fstab * getfsspec (const char *NAME)' |
| |
| 'fstab.h' (BSD): *note fstab::. |
| |
| 'gid_t getgid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Reading Persona::. |
| |
| 'struct group * getgrent (void)' |
| |
| 'grp.h' (SVID, BSD): *note Scanning All Groups::. |
| |
| 'int getgrent_r (struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT)' |
| |
| 'grp.h' (GNU): *note Scanning All Groups::. |
| |
| 'struct group * getgrgid (gid_t GID)' |
| |
| 'grp.h' (POSIX.1): *note Lookup Group::. |
| |
| 'int getgrgid_r (gid_t GID, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT)' |
| |
| 'grp.h' (POSIX.1c): *note Lookup Group::. |
| |
| 'struct group * getgrnam (const char *NAME)' |
| |
| 'grp.h' (SVID, BSD): *note Lookup Group::. |
| |
| 'int getgrnam_r (const char *NAME, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT)' |
| |
| 'grp.h' (POSIX.1c): *note Lookup Group::. |
| |
| 'int getgrouplist (const char *USER, gid_t GROUP, gid_t *GROUPS, int *NGROUPS)' |
| |
| 'grp.h' (BSD): *note Setting Groups::. |
| |
| 'int getgroups (int COUNT, gid_t *GROUPS)' |
| |
| 'unistd.h' (POSIX.1): *note Reading Persona::. |
| |
| 'struct hostent * gethostbyaddr (const void *ADDR, socklen_t LENGTH, int FORMAT)' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'int gethostbyaddr_r (const void *ADDR, socklen_t LENGTH, int FORMAT, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int *restrict H_ERRNOP)' |
| |
| 'netdb.h' (GNU): *note Host Names::. |
| |
| 'struct hostent * gethostbyname (const char *NAME)' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'struct hostent * gethostbyname2 (const char *NAME, int AF)' |
| |
| 'netdb.h' (IPv6 Basic API): *note Host Names::. |
| |
| 'int gethostbyname2_r (const char *NAME, int AF, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int *restrict H_ERRNOP)' |
| |
| 'netdb.h' (GNU): *note Host Names::. |
| |
| 'int gethostbyname_r (const char *restrict NAME, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int *restrict H_ERRNOP)' |
| |
| 'netdb.h' (GNU): *note Host Names::. |
| |
| 'struct hostent * gethostent (void)' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'long int gethostid (void)' |
| |
| 'unistd.h' (BSD): *note Host Identification::. |
| |
| 'int gethostname (char *NAME, size_t SIZE)' |
| |
| 'unistd.h' (BSD): *note Host Identification::. |
| |
| 'int getitimer (int WHICH, struct itimerval *OLD)' |
| |
| 'sys/time.h' (BSD): *note Setting an Alarm::. |
| |
| 'ssize_t getline (char **LINEPTR, size_t *N, FILE *STREAM)' |
| |
| 'stdio.h' (GNU): *note Line Input::. |
| |
| 'int getloadavg (double LOADAVG[], int NELEM)' |
| |
| 'stdlib.h' (BSD): *note Processor Resources::. |
| |
| 'char * getlogin (void)' |
| |
| 'unistd.h' (POSIX.1): *note Who Logged In::. |
| |
| 'struct mntent * getmntent (FILE *STREAM)' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'struct mntent * getmntent_r (FILE *STREAM, struct mntent *RESULT, char *BUFFER, int BUFSIZE)' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'struct netent * getnetbyaddr (uint32_t NET, int TYPE)' |
| |
| 'netdb.h' (BSD): *note Networks Database::. |
| |
| 'struct netent * getnetbyname (const char *NAME)' |
| |
| 'netdb.h' (BSD): *note Networks Database::. |
| |
| 'struct netent * getnetent (void)' |
| |
| 'netdb.h' (BSD): *note Networks Database::. |
| |
| 'int getnetgrent (char **HOSTP, char **USERP, char **DOMAINP)' |
| |
| 'netdb.h' (BSD): *note Lookup Netgroup::. |
| |
| 'int getnetgrent_r (char **HOSTP, char **USERP, char **DOMAINP, char *BUFFER, size_t BUFLEN)' |
| |
| 'netdb.h' (GNU): *note Lookup Netgroup::. |
| |
| 'int get_nprocs (void)' |
| |
| 'sys/sysinfo.h' (GNU): *note Processor Resources::. |
| |
| 'int get_nprocs_conf (void)' |
| |
| 'sys/sysinfo.h' (GNU): *note Processor Resources::. |
| |
| 'int getopt (int ARGC, char *const *ARGV, const char *OPTIONS)' |
| |
| 'unistd.h' (POSIX.2): *note Using Getopt::. |
| |
| 'int getopt_long (int ARGC, char *const *ARGV, const char *SHORTOPTS, const struct option *LONGOPTS, int *INDEXPTR)' |
| |
| 'getopt.h' (GNU): *note Getopt Long Options::. |
| |
| 'int getopt_long_only (int ARGC, char *const *ARGV, const char *SHORTOPTS, const struct option *LONGOPTS, int *INDEXPTR)' |
| |
| 'getopt.h' (GNU): *note Getopt Long Options::. |
| |
| 'int getpagesize (void)' |
| |
| 'unistd.h' (BSD): *note Query Memory Parameters::. |
| |
| 'char * getpass (const char *PROMPT)' |
| |
| 'unistd.h' (BSD): *note getpass::. |
| |
| 'int getpeername (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH-PTR)' |
| |
| 'sys/socket.h' (BSD): *note Who is Connected::. |
| |
| 'int getpgid (pid_t PID)' |
| |
| 'unistd.h' (POSIX.1): *note Process Group Functions::. |
| |
| 'pid_t getpgrp (void)' |
| |
| 'unistd.h' (POSIX.1): *note Process Group Functions::. |
| |
| 'long int get_phys_pages (void)' |
| |
| 'sys/sysinfo.h' (GNU): *note Query Memory Parameters::. |
| |
| 'pid_t getpid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Process Identification::. |
| |
| 'pid_t getppid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Process Identification::. |
| |
| 'int getpriority (int CLASS, int ID)' |
| |
| 'sys/resource.h' (BSD,POSIX): *note Traditional Scheduling |
| Functions::. |
| |
| 'struct protoent * getprotobyname (const char *NAME)' |
| |
| 'netdb.h' (BSD): *note Protocols Database::. |
| |
| 'struct protoent * getprotobynumber (int PROTOCOL)' |
| |
| 'netdb.h' (BSD): *note Protocols Database::. |
| |
| 'struct protoent * getprotoent (void)' |
| |
| 'netdb.h' (BSD): *note Protocols Database::. |
| |
| 'int getpt (void)' |
| |
| 'stdlib.h' (GNU): *note Allocation::. |
| |
| 'struct passwd * getpwent (void)' |
| |
| 'pwd.h' (POSIX.1): *note Scanning All Users::. |
| |
| 'int getpwent_r (struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT)' |
| |
| 'pwd.h' (GNU): *note Scanning All Users::. |
| |
| 'struct passwd * getpwnam (const char *NAME)' |
| |
| 'pwd.h' (POSIX.1): *note Lookup User::. |
| |
| 'int getpwnam_r (const char *NAME, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT)' |
| |
| 'pwd.h' (POSIX.1c): *note Lookup User::. |
| |
| 'struct passwd * getpwuid (uid_t UID)' |
| |
| 'pwd.h' (POSIX.1): *note Lookup User::. |
| |
| 'int getpwuid_r (uid_t UID, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT)' |
| |
| 'pwd.h' (POSIX.1c): *note Lookup User::. |
| |
| 'int getrlimit (int RESOURCE, struct rlimit *RLP)' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'int getrlimit64 (int RESOURCE, struct rlimit64 *RLP)' |
| |
| 'sys/resource.h' (Unix98): *note Limits on Resources::. |
| |
| 'int getrusage (int PROCESSES, struct rusage *RUSAGE)' |
| |
| 'sys/resource.h' (BSD): *note Resource Usage::. |
| |
| 'char * gets (char *S)' |
| |
| 'stdio.h' (ISO): *note Line Input::. |
| |
| 'struct servent * getservbyname (const char *NAME, const char *PROTO)' |
| |
| 'netdb.h' (BSD): *note Services Database::. |
| |
| 'struct servent * getservbyport (int PORT, const char *PROTO)' |
| |
| 'netdb.h' (BSD): *note Services Database::. |
| |
| 'struct servent * getservent (void)' |
| |
| 'netdb.h' (BSD): *note Services Database::. |
| |
| 'pid_t getsid (pid_t PID)' |
| |
| 'unistd.h' (SVID): *note Process Group Functions::. |
| |
| 'int getsockname (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH-PTR)' |
| |
| 'sys/socket.h' (BSD): *note Reading Address::. |
| |
| 'int getsockopt (int SOCKET, int LEVEL, int OPTNAME, void *OPTVAL, socklen_t *OPTLEN-PTR)' |
| |
| 'sys/socket.h' (BSD): *note Socket Option Functions::. |
| |
| 'int getsubopt (char **OPTIONP, char *const *TOKENS, char **VALUEP)' |
| |
| 'stdlib.h' (stdlib.h): *note Suboptions Example: Suboptions. |
| |
| 'char * gettext (const char *MSGID)' |
| |
| 'libintl.h' (GNU): *note Translation with gettext::. |
| |
| 'int gettimeofday (struct timeval *TP, struct timezone *TZP)' |
| |
| 'sys/time.h' (BSD): *note High-Resolution Calendar::. |
| |
| 'uid_t getuid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Reading Persona::. |
| |
| 'mode_t getumask (void)' |
| |
| 'sys/stat.h' (GNU): *note Setting Permissions::. |
| |
| 'struct utmp * getutent (void)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'int getutent_r (struct utmp *BUFFER, struct utmp **RESULT)' |
| |
| 'utmp.h' (GNU): *note Manipulating the Database::. |
| |
| 'struct utmp * getutid (const struct utmp *ID)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'int getutid_r (const struct utmp *ID, struct utmp *BUFFER, struct utmp **RESULT)' |
| |
| 'utmp.h' (GNU): *note Manipulating the Database::. |
| |
| 'struct utmp * getutline (const struct utmp *LINE)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'int getutline_r (const struct utmp *LINE, struct utmp *BUFFER, struct utmp **RESULT)' |
| |
| 'utmp.h' (GNU): *note Manipulating the Database::. |
| |
| 'int getutmp (const struct utmpx *UTMPX, struct utmp *UTMP)' |
| |
| 'utmp.h' (GNU): *note XPG Functions::. |
| |
| 'int getutmpx (const struct utmp *UTMP, struct utmpx *UTMPX)' |
| |
| 'utmp.h' (GNU): *note XPG Functions::. |
| |
| 'struct utmpx * getutxent (void)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'struct utmpx * getutxid (const struct utmpx *ID)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'struct utmpx * getutxline (const struct utmpx *LINE)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int getw (FILE *STREAM)' |
| |
| 'stdio.h' (SVID): *note Character Input::. |
| |
| 'wint_t getwc (FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note Character Input::. |
| |
| 'wint_t getwchar (void)' |
| |
| 'wchar.h' (ISO): *note Character Input::. |
| |
| 'wint_t getwchar_unlocked (void)' |
| |
| 'wchar.h' (GNU): *note Character Input::. |
| |
| 'wint_t getwc_unlocked (FILE *STREAM)' |
| |
| 'wchar.h' (GNU): *note Character Input::. |
| |
| 'char * getwd (char *BUFFER)' |
| |
| 'unistd.h' (BSD): *note Working Directory::. |
| |
| 'gid_t' |
| |
| 'sys/types.h' (POSIX.1): *note Reading Persona::. |
| |
| 'int glob (const char *PATTERN, int FLAGS, int (*ERRFUNC) (const char *FILENAME, int ERROR-CODE), glob_t *VECTOR-PTR)' |
| |
| 'glob.h' (POSIX.2): *note Calling Glob::. |
| |
| 'int glob64 (const char *PATTERN, int FLAGS, int (*ERRFUNC) (const char *FILENAME, int ERROR-CODE), glob64_t *VECTOR-PTR)' |
| |
| 'glob.h' (GNU): *note Calling Glob::. |
| |
| 'glob64_t' |
| |
| 'glob.h' (GNU): *note Calling Glob::. |
| |
| 'GLOB_ABORTED' |
| |
| 'glob.h' (POSIX.2): *note Calling Glob::. |
| |
| 'GLOB_ALTDIRFUNC' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_APPEND' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'GLOB_BRACE' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_DOOFFS' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'GLOB_ERR' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'void globfree (glob_t *PGLOB)' |
| |
| 'glob.h' (POSIX.2): *note More Flags for Globbing::. |
| |
| 'void globfree64 (glob64_t *PGLOB)' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_MAGCHAR' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_MARK' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'GLOB_NOCHECK' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'GLOB_NOESCAPE' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'GLOB_NOMAGIC' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_NOMATCH' |
| |
| 'glob.h' (POSIX.2): *note Calling Glob::. |
| |
| 'GLOB_NOSORT' |
| |
| 'glob.h' (POSIX.2): *note Flags for Globbing::. |
| |
| 'GLOB_NOSPACE' |
| |
| 'glob.h' (POSIX.2): *note Calling Glob::. |
| |
| 'GLOB_ONLYDIR' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_PERIOD' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'glob_t' |
| |
| 'glob.h' (POSIX.2): *note Calling Glob::. |
| |
| 'GLOB_TILDE' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'GLOB_TILDE_CHECK' |
| |
| 'glob.h' (GNU): *note More Flags for Globbing::. |
| |
| 'struct tm * gmtime (const time_t *TIME)' |
| |
| 'time.h' (ISO): *note Broken-down Time::. |
| |
| 'struct tm * gmtime_r (const time_t *TIME, struct tm *RESULTP)' |
| |
| 'time.h' (POSIX.1c): *note Broken-down Time::. |
| |
| '_GNU_SOURCE' |
| |
| (GNU): *note Feature Test Macros::. |
| |
| 'int grantpt (int FILEDES)' |
| |
| 'stdlib.h' (SVID, XPG4.2): *note Allocation::. |
| |
| 'int gsignal (int SIGNUM)' |
| |
| 'signal.h' (SVID): *note Signaling Yourself::. |
| |
| 'int gtty (int FILEDES, struct sgttyb *ATTRIBUTES)' |
| |
| 'sgtty.h' (BSD): *note BSD Terminal Modes::. |
| |
| 'char * hasmntopt (const struct mntent *MNT, const char *OPT)' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'int hcreate (size_t NEL)' |
| |
| 'search.h' (SVID): *note Hash Search Function::. |
| |
| 'int hcreate_r (size_t NEL, struct hsearch_data *HTAB)' |
| |
| 'search.h' (GNU): *note Hash Search Function::. |
| |
| 'void hdestroy (void)' |
| |
| 'search.h' (SVID): *note Hash Search Function::. |
| |
| 'void hdestroy_r (struct hsearch_data *HTAB)' |
| |
| 'search.h' (GNU): *note Hash Search Function::. |
| |
| 'HOST_NOT_FOUND' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'ENTRY * hsearch (ENTRY ITEM, ACTION ACTION)' |
| |
| 'search.h' (SVID): *note Hash Search Function::. |
| |
| 'int hsearch_r (ENTRY ITEM, ACTION ACTION, ENTRY **RETVAL, struct hsearch_data *HTAB)' |
| |
| 'search.h' (GNU): *note Hash Search Function::. |
| |
| 'uint32_t htonl (uint32_t HOSTLONG)' |
| |
| 'netinet/in.h' (BSD): *note Byte Order::. |
| |
| 'uint16_t htons (uint16_t HOSTSHORT)' |
| |
| 'netinet/in.h' (BSD): *note Byte Order::. |
| |
| 'double HUGE_VAL' |
| |
| 'math.h' (ISO): *note Math Error Reporting::. |
| |
| 'float HUGE_VALF' |
| |
| 'math.h' (ISO): *note Math Error Reporting::. |
| |
| 'long double HUGE_VALL' |
| |
| 'math.h' (ISO): *note Math Error Reporting::. |
| |
| 'tcflag_t HUPCL' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'double hypot (double X, double Y)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float hypotf (float X, float Y)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double hypotl (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'tcflag_t ICANON' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'size_t iconv (iconv_t CD, char **INBUF, size_t *INBYTESLEFT, char **OUTBUF, size_t *OUTBYTESLEFT)' |
| |
| 'iconv.h' (XPG2): *note Generic Conversion Interface::. |
| |
| 'int iconv_close (iconv_t CD)' |
| |
| 'iconv.h' (XPG2): *note Generic Conversion Interface::. |
| |
| 'iconv_t iconv_open (const char *TOCODE, const char *FROMCODE)' |
| |
| 'iconv.h' (XPG2): *note Generic Conversion Interface::. |
| |
| 'iconv_t' |
| |
| 'iconv.h' (XPG2): *note Generic Conversion Interface::. |
| |
| 'tcflag_t ICRNL' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'tcflag_t IEXTEN' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'void if_freenameindex (struct if_nameindex *PTR)' |
| |
| 'net/if.h' (IPv6 basic API): *note Interface Naming::. |
| |
| 'char * if_indextoname (unsigned int IFINDEX, char *IFNAME)' |
| |
| 'net/if.h' (IPv6 basic API): *note Interface Naming::. |
| |
| 'struct if_nameindex * if_nameindex (void)' |
| |
| 'net/if.h' (IPv6 basic API): *note Interface Naming::. |
| |
| 'unsigned int if_nametoindex (const char *IFNAME)' |
| |
| 'net/if.h' (IPv6 basic API): *note Interface Naming::. |
| |
| 'size_t IFNAMSIZ' |
| |
| 'net/if.h' (net/if.h): *note Interface Naming::. |
| |
| 'int IFTODT (mode_t MODE)' |
| |
| 'dirent.h' (BSD): *note Directory Entries::. |
| |
| 'tcflag_t IGNBRK' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'tcflag_t IGNCR' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'tcflag_t IGNPAR' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'int ilogb (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'int ilogbf (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'int ilogbl (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'intmax_t imaxabs (intmax_t NUMBER)' |
| |
| 'inttypes.h' (ISO): *note Absolute Value::. |
| |
| 'tcflag_t IMAXBEL' |
| |
| 'termios.h' (BSD): *note Input Modes::. |
| |
| 'imaxdiv_t imaxdiv (intmax_t NUMERATOR, intmax_t DENOMINATOR)' |
| |
| 'inttypes.h' (ISO): *note Integer Division::. |
| |
| 'imaxdiv_t' |
| |
| 'inttypes.h' (ISO): *note Integer Division::. |
| |
| 'struct in6_addr in6addr_any' |
| |
| 'netinet/in.h' (IPv6 basic API): *note Host Address Data Type::. |
| |
| 'struct in6_addr in6addr_loopback' |
| |
| 'netinet/in.h' (IPv6 basic API): *note Host Address Data Type::. |
| |
| 'uint32_t INADDR_ANY' |
| |
| 'netinet/in.h' (BSD): *note Host Address Data Type::. |
| |
| 'uint32_t INADDR_BROADCAST' |
| |
| 'netinet/in.h' (BSD): *note Host Address Data Type::. |
| |
| 'uint32_t INADDR_LOOPBACK' |
| |
| 'netinet/in.h' (BSD): *note Host Address Data Type::. |
| |
| 'uint32_t INADDR_NONE' |
| |
| 'netinet/in.h' (BSD): *note Host Address Data Type::. |
| |
| 'char * index (const char *STRING, int C)' |
| |
| 'string.h' (BSD): *note Search Functions::. |
| |
| 'uint32_t inet_addr (const char *NAME)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'int inet_aton (const char *NAME, struct in_addr *ADDR)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'uint32_t inet_lnaof (struct in_addr ADDR)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'struct in_addr inet_makeaddr (uint32_t NET, uint32_t LOCAL)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'uint32_t inet_netof (struct in_addr ADDR)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'uint32_t inet_network (const char *NAME)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'char * inet_ntoa (struct in_addr ADDR)' |
| |
| 'arpa/inet.h' (BSD): *note Host Address Functions::. |
| |
| 'const char * inet_ntop (int AF, const void *CP, char *BUF, socklen_t LEN)' |
| |
| 'arpa/inet.h' (IPv6 basic API): *note Host Address Functions::. |
| |
| 'int inet_pton (int AF, const char *CP, void *BUF)' |
| |
| 'arpa/inet.h' (IPv6 basic API): *note Host Address Functions::. |
| |
| 'float INFINITY' |
| |
| 'math.h' (ISO): *note Infinity and NaN::. |
| |
| 'int initgroups (const char *USER, gid_t GROUP)' |
| |
| 'grp.h' (BSD): *note Setting Groups::. |
| |
| 'INIT_PROCESS' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'INIT_PROCESS' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'char * initstate (unsigned int SEED, char *STATE, size_t SIZE)' |
| |
| 'stdlib.h' (BSD): *note BSD Random::. |
| |
| 'int initstate_r (unsigned int SEED, char *restrict STATEBUF, size_t STATELEN, struct random_data *restrict BUF)' |
| |
| 'stdlib.h' (GNU): *note BSD Random::. |
| |
| 'tcflag_t INLCR' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'int innetgr (const char *NETGROUP, const char *HOST, const char *USER, const char *DOMAIN)' |
| |
| 'netdb.h' (BSD): *note Netgroup Membership::. |
| |
| 'ino64_t' |
| |
| 'sys/types.h' (Unix98): *note Attribute Meanings::. |
| |
| 'ino_t' |
| |
| 'sys/types.h' (POSIX.1): *note Attribute Meanings::. |
| |
| 'tcflag_t INPCK' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'INT_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'INT_MIN' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'int ioctl (int FILEDES, int COMMAND, ...)' |
| |
| 'sys/ioctl.h' (BSD): *note IOCTLs::. |
| |
| 'int _IOFBF' |
| |
| 'stdio.h' (ISO): *note Controlling Buffering::. |
| |
| 'int _IOLBF' |
| |
| 'stdio.h' (ISO): *note Controlling Buffering::. |
| |
| 'int _IONBF' |
| |
| 'stdio.h' (ISO): *note Controlling Buffering::. |
| |
| 'int IPPORT_RESERVED' |
| |
| 'netinet/in.h' (BSD): *note Ports::. |
| |
| 'int IPPORT_USERRESERVED' |
| |
| 'netinet/in.h' (BSD): *note Ports::. |
| |
| 'int isalnum (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int isalpha (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int isascii (int C)' |
| |
| 'ctype.h' (SVID, BSD): *note Classification of Characters::. |
| |
| 'int isatty (int FILEDES)' |
| |
| 'unistd.h' (POSIX.1): *note Is It a Terminal::. |
| |
| 'int isblank (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int iscntrl (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int isdigit (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int isfinite (_float-type_ X)' |
| |
| 'math.h' (ISO): *note Floating Point Classes::. |
| |
| 'int isgraph (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int isgreater (_real-floating_ X, _real-floating_ Y)' |
| |
| 'math.h' (ISO): *note FP Comparison Functions::. |
| |
| 'int isgreaterequal (_real-floating_ X, _real-floating_ Y)' |
| |
| 'math.h' (ISO): *note FP Comparison Functions::. |
| |
| 'tcflag_t ISIG' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'int isinf (double X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int isinff (float X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int isinfl (long double X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int isless (_real-floating_ X, _real-floating_ Y)' |
| |
| 'math.h' (ISO): *note FP Comparison Functions::. |
| |
| 'int islessequal (_real-floating_ X, _real-floating_ Y)' |
| |
| 'math.h' (ISO): *note FP Comparison Functions::. |
| |
| 'int islessgreater (_real-floating_ X, _real-floating_ Y)' |
| |
| 'math.h' (ISO): *note FP Comparison Functions::. |
| |
| 'int islower (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int isnan (double X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int isnan (_float-type_ X)' |
| |
| 'math.h' (ISO): *note Floating Point Classes::. |
| |
| 'int isnanf (float X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int isnanl (long double X)' |
| |
| 'math.h' (BSD): *note Floating Point Classes::. |
| |
| 'int isnormal (_float-type_ X)' |
| |
| 'math.h' (ISO): *note Floating Point Classes::. |
| |
| '_ISOC99_SOURCE' |
| |
| (GNU): *note Feature Test Macros::. |
| |
| 'int isprint (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int ispunct (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int issignaling (_float-type_ X)' |
| |
| 'math.h' (GNU): *note Floating Point Classes::. |
| |
| 'int isspace (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'tcflag_t ISTRIP' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'int isunordered (_real-floating_ X, _real-floating_ Y)' |
| |
| 'math.h' (ISO): *note FP Comparison Functions::. |
| |
| 'int isupper (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'int iswalnum (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswalpha (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswblank (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswcntrl (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswctype (wint_t WC, wctype_t DESC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswdigit (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswgraph (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswlower (wint_t WC)' |
| |
| 'ctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswprint (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswpunct (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswspace (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswupper (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int iswxdigit (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int isxdigit (int C)' |
| |
| 'ctype.h' (ISO): *note Classification of Characters::. |
| |
| 'ITIMER_PROF' |
| |
| 'sys/time.h' (BSD): *note Setting an Alarm::. |
| |
| 'ITIMER_REAL' |
| |
| 'sys/time.h' (BSD): *note Setting an Alarm::. |
| |
| 'ITIMER_VIRTUAL' |
| |
| 'sys/time.h' (BSD): *note Setting an Alarm::. |
| |
| 'tcflag_t IXANY' |
| |
| 'termios.h' (BSD): *note Input Modes::. |
| |
| 'tcflag_t IXOFF' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'tcflag_t IXON' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'double j0 (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float j0f (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double j0l (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'double j1 (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float j1f (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double j1l (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'jmp_buf' |
| |
| 'setjmp.h' (ISO): *note Non-Local Details::. |
| |
| 'double jn (int N, double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float jnf (int N, float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double jnl (int N, long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long int jrand48 (unsigned short int XSUBI[3])' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int jrand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, long int *RESULT)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'int kill (pid_t PID, int SIGNUM)' |
| |
| 'signal.h' (POSIX.1): *note Signaling Another Process::. |
| |
| 'int killpg (int PGID, int SIGNUM)' |
| |
| 'signal.h' (BSD): *note Signaling Another Process::. |
| |
| 'char * l64a (long int N)' |
| |
| 'stdlib.h' (XPG): *note Encode Binary Data::. |
| |
| 'long int labs (long int NUMBER)' |
| |
| 'stdlib.h' (ISO): *note Absolute Value::. |
| |
| 'LANG' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'LC_ALL' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'LC_COLLATE' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'LC_CTYPE' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'LC_MESSAGES' |
| |
| 'locale.h' (XOPEN): *note Locale Categories::. |
| |
| 'LC_MONETARY' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'LC_NUMERIC' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'void lcong48 (unsigned short int PARAM[7])' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int lcong48_r (unsigned short int PARAM[7], struct drand48_data *BUFFER)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'int L_ctermid' |
| |
| 'stdio.h' (POSIX.1): *note Identifying the Terminal::. |
| |
| 'LC_TIME' |
| |
| 'locale.h' (ISO): *note Locale Categories::. |
| |
| 'int L_cuserid' |
| |
| 'stdio.h' (POSIX.1): *note Who Logged In::. |
| |
| 'double ldexp (double VALUE, int EXPONENT)' |
| |
| 'math.h' (ISO): *note Normalization Functions::. |
| |
| 'float ldexpf (float VALUE, int EXPONENT)' |
| |
| 'math.h' (ISO): *note Normalization Functions::. |
| |
| 'long double ldexpl (long double VALUE, int EXPONENT)' |
| |
| 'math.h' (ISO): *note Normalization Functions::. |
| |
| 'ldiv_t ldiv (long int NUMERATOR, long int DENOMINATOR)' |
| |
| 'stdlib.h' (ISO): *note Integer Division::. |
| |
| 'ldiv_t' |
| |
| 'stdlib.h' (ISO): *note Integer Division::. |
| |
| 'void * lfind (const void *KEY, const void *BASE, size_t *NMEMB, size_t SIZE, comparison_fn_t COMPAR)' |
| |
| 'search.h' (SVID): *note Array Search Function::. |
| |
| 'double lgamma (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float lgammaf (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float lgammaf_r (float X, int *SIGNP)' |
| |
| 'math.h' (XPG): *note Special Functions::. |
| |
| 'long double lgammal (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double lgammal_r (long double X, int *SIGNP)' |
| |
| 'math.h' (XPG): *note Special Functions::. |
| |
| 'double lgamma_r (double X, int *SIGNP)' |
| |
| 'math.h' (XPG): *note Special Functions::. |
| |
| 'L_INCR' |
| |
| 'sys/file.h' (BSD): *note File Positioning::. |
| |
| 'int LINE_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Limits::. |
| |
| 'int link (const char *OLDNAME, const char *NEWNAME)' |
| |
| 'unistd.h' (POSIX.1): *note Hard Links::. |
| |
| 'int LINK_MAX' |
| |
| 'limits.h', '(optional)' (POSIX.1): *note Limits for Files::. |
| |
| 'int lio_listio (int MODE, struct aiocb *const LIST[], int NENT, struct sigevent *SIG)' |
| |
| 'aio.h' (POSIX.1b): *note Asynchronous Reads/Writes::. |
| |
| 'int lio_listio64 (int MODE, struct aiocb64 *const LIST[], int NENT, struct sigevent *SIG)' |
| |
| 'aio.h' (Unix98): *note Asynchronous Reads/Writes::. |
| |
| 'int listen (int SOCKET, int N)' |
| |
| 'sys/socket.h' (BSD): *note Listening::. |
| |
| 'long long int llabs (long long int NUMBER)' |
| |
| 'stdlib.h' (ISO): *note Absolute Value::. |
| |
| 'lldiv_t lldiv (long long int NUMERATOR, long long int DENOMINATOR)' |
| |
| 'stdlib.h' (ISO): *note Integer Division::. |
| |
| 'lldiv_t' |
| |
| 'stdlib.h' (ISO): *note Integer Division::. |
| |
| 'LLONG_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'LLONG_MIN' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'long long int llrint (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long long int llrintf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long long int llrintl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long long int llround (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long long int llroundf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long long int llroundl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'struct lconv * localeconv (void)' |
| |
| 'locale.h' (ISO): *note The Lame Way to Locale Data::. |
| |
| 'struct tm * localtime (const time_t *TIME)' |
| |
| 'time.h' (ISO): *note Broken-down Time::. |
| |
| 'struct tm * localtime_r (const time_t *TIME, struct tm *RESULTP)' |
| |
| 'time.h' (POSIX.1c): *note Broken-down Time::. |
| |
| 'double log (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double log10 (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float log10f (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double log10l (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double log1p (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float log1pf (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double log1pl (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double log2 (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float log2f (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double log2l (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double logb (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float logbf (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double logbl (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float logf (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'void login (const struct utmp *ENTRY)' |
| |
| 'utmp.h' (BSD): *note Logging In and Out::. |
| |
| 'LOGIN_PROCESS' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'LOGIN_PROCESS' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int login_tty (int FILEDES)' |
| |
| 'utmp.h' (BSD): *note Logging In and Out::. |
| |
| 'long double logl (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'int logout (const char *UT_LINE)' |
| |
| 'utmp.h' (BSD): *note Logging In and Out::. |
| |
| 'void logwtmp (const char *UT_LINE, const char *UT_NAME, const char *UT_HOST)' |
| |
| 'utmp.h' (BSD): *note Logging In and Out::. |
| |
| 'void longjmp (jmp_buf STATE, int VALUE)' |
| |
| 'setjmp.h' (ISO): *note Non-Local Details::. |
| |
| 'LONG_LONG_MAX' |
| |
| 'limits.h' (GNU): *note Range of Type::. |
| |
| 'LONG_LONG_MIN' |
| |
| 'limits.h' (GNU): *note Range of Type::. |
| |
| 'LONG_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'LONG_MIN' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'long int lrand48 (void)' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int lrand48_r (struct drand48_data *BUFFER, long int *RESULT)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'long int lrint (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long int lrintf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long int lrintl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long int lround (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long int lroundf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long int lroundl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'void * lsearch (const void *KEY, void *BASE, size_t *NMEMB, size_t SIZE, comparison_fn_t COMPAR)' |
| |
| 'search.h' (SVID): *note Array Search Function::. |
| |
| 'off_t lseek (int FILEDES, off_t OFFSET, int WHENCE)' |
| |
| 'unistd.h' (POSIX.1): *note File Position Primitive::. |
| |
| 'off64_t lseek64 (int FILEDES, off64_t OFFSET, int WHENCE)' |
| |
| 'unistd.h' (Unix98): *note File Position Primitive::. |
| |
| 'L_SET' |
| |
| 'sys/file.h' (BSD): *note File Positioning::. |
| |
| 'int lstat (const char *FILENAME, struct stat *BUF)' |
| |
| 'sys/stat.h' (BSD): *note Reading Attributes::. |
| |
| 'int lstat64 (const char *FILENAME, struct stat64 *BUF)' |
| |
| 'sys/stat.h' (Unix98): *note Reading Attributes::. |
| |
| 'int L_tmpnam' |
| |
| 'stdio.h' (ISO): *note Temporary Files::. |
| |
| 'int lutimes (const char *FILENAME, const struct timeval TVP[2])' |
| |
| 'sys/time.h' (BSD): *note File Times::. |
| |
| 'L_XTND' |
| |
| 'sys/file.h' (BSD): *note File Positioning::. |
| |
| 'int madvise (void *ADDR, size_t LENGTH, int ADVICE)' |
| |
| 'sys/mman.h' (POSIX): *note Memory-mapped I/O::. |
| |
| 'void makecontext (ucontext_t *UCP, void (*FUNC) (void), int ARGC, ...)' |
| |
| 'ucontext.h' (SVID): *note System V contexts::. |
| |
| 'struct mallinfo mallinfo (void)' |
| |
| 'malloc.h' (SVID): *note Statistics of Malloc::. |
| |
| 'void * malloc (size_t SIZE)' |
| |
| 'malloc.h', 'stdlib.h' (ISO): *note Basic Allocation::. |
| |
| '__malloc_hook' |
| |
| 'malloc.h' (GNU): *note Hooks for Malloc::. |
| |
| '__malloc_initialize_hook' |
| |
| 'malloc.h' (GNU): *note Hooks for Malloc::. |
| |
| 'int MAX_CANON' |
| |
| 'limits.h' (POSIX.1): *note Limits for Files::. |
| |
| 'int MAX_INPUT' |
| |
| 'limits.h' (POSIX.1): *note Limits for Files::. |
| |
| 'int MAXNAMLEN' |
| |
| 'dirent.h' (BSD): *note Limits for Files::. |
| |
| 'int MAXSYMLINKS' |
| |
| 'sys/param.h' (BSD): *note Symbolic Links::. |
| |
| 'int MB_CUR_MAX' |
| |
| 'stdlib.h' (ISO): *note Selecting the Conversion::. |
| |
| 'int mblen (const char *STRING, size_t SIZE)' |
| |
| 'stdlib.h' (ISO): *note Non-reentrant Character Conversion::. |
| |
| 'int MB_LEN_MAX' |
| |
| 'limits.h' (ISO): *note Selecting the Conversion::. |
| |
| 'size_t mbrlen (const char *restrict S, size_t N, mbstate_t *PS)' |
| |
| 'wchar.h' (ISO): *note Converting a Character::. |
| |
| 'size_t mbrtowc (wchar_t *restrict PWC, const char *restrict S, size_t N, mbstate_t *restrict PS)' |
| |
| 'wchar.h' (ISO): *note Converting a Character::. |
| |
| 'int mbsinit (const mbstate_t *PS)' |
| |
| 'wchar.h' (ISO): *note Keeping the state::. |
| |
| 'size_t mbsnrtowcs (wchar_t *restrict DST, const char **restrict SRC, size_t NMC, size_t LEN, mbstate_t *restrict PS)' |
| |
| 'wchar.h' (GNU): *note Converting Strings::. |
| |
| 'size_t mbsrtowcs (wchar_t *restrict DST, const char **restrict SRC, size_t LEN, mbstate_t *restrict PS)' |
| |
| 'wchar.h' (ISO): *note Converting Strings::. |
| |
| 'mbstate_t' |
| |
| 'wchar.h' (ISO): *note Keeping the state::. |
| |
| 'size_t mbstowcs (wchar_t *WSTRING, const char *STRING, size_t SIZE)' |
| |
| 'stdlib.h' (ISO): *note Non-reentrant String Conversion::. |
| |
| 'int mbtowc (wchar_t *restrict RESULT, const char *restrict STRING, size_t SIZE)' |
| |
| 'stdlib.h' (ISO): *note Non-reentrant Character Conversion::. |
| |
| 'int mcheck (void (*ABORTFN) (enum mcheck_status STATUS))' |
| |
| 'mcheck.h' (GNU): *note Heap Consistency Checking::. |
| |
| 'tcflag_t MDMBUF' |
| |
| 'termios.h' (BSD): *note Control Modes::. |
| |
| 'void * memalign (size_t BOUNDARY, size_t SIZE)' |
| |
| 'malloc.h' (BSD): *note Aligned Memory Blocks::. |
| |
| '__memalign_hook' |
| |
| 'malloc.h' (GNU): *note Hooks for Malloc::. |
| |
| 'void * memccpy (void *restrict TO, const void *restrict FROM, int C, size_t SIZE)' |
| |
| 'string.h' (SVID): *note Copying and Concatenation::. |
| |
| 'void * memchr (const void *BLOCK, int C, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'int memcmp (const void *A1, const void *A2, size_t SIZE)' |
| |
| 'string.h' (ISO): *note String/Array Comparison::. |
| |
| 'void * memcpy (void *restrict TO, const void *restrict FROM, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'void * memfrob (void *MEM, size_t LENGTH)' |
| |
| 'string.h' (GNU): *note Trivial Encryption::. |
| |
| 'void * memmem (const void *HAYSTACK, size_t HAYSTACK-LEN, |
| const void *NEEDLE, size_t NEEDLE-LEN)' |
| |
| 'string.h' (GNU): *note Search Functions::. |
| |
| 'void * memmove (void *TO, const void *FROM, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'void * mempcpy (void *restrict TO, const void *restrict FROM, size_t SIZE)' |
| |
| 'string.h' (GNU): *note Copying and Concatenation::. |
| |
| 'void * memrchr (const void *BLOCK, int C, size_t SIZE)' |
| |
| 'string.h' (GNU): *note Search Functions::. |
| |
| 'void * memset (void *BLOCK, int C, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'int mkdir (const char *FILENAME, mode_t MODE)' |
| |
| 'sys/stat.h' (POSIX.1): *note Creating Directories::. |
| |
| 'char * mkdtemp (char *TEMPLATE)' |
| |
| 'stdlib.h' (BSD): *note Temporary Files::. |
| |
| 'int mkfifo (const char *FILENAME, mode_t MODE)' |
| |
| 'sys/stat.h' (POSIX.1): *note FIFO Special Files::. |
| |
| 'int mknod (const char *FILENAME, mode_t MODE, dev_t DEV)' |
| |
| 'sys/stat.h' (BSD): *note Making Special Files::. |
| |
| 'int mkstemp (char *TEMPLATE)' |
| |
| 'stdlib.h' (BSD): *note Temporary Files::. |
| |
| 'char * mktemp (char *TEMPLATE)' |
| |
| 'stdlib.h' (Unix): *note Temporary Files::. |
| |
| 'time_t mktime (struct tm *BROKENTIME)' |
| |
| 'time.h' (ISO): *note Broken-down Time::. |
| |
| 'int mlock (const void *ADDR, size_t LEN)' |
| |
| 'sys/mman.h' (POSIX.1b): *note Page Lock Functions::. |
| |
| 'int mlockall (int FLAGS)' |
| |
| 'sys/mman.h' (POSIX.1b): *note Page Lock Functions::. |
| |
| 'void * mmap (void *ADDRESS, size_t LENGTH, int PROTECT, int FLAGS, int FILEDES, off_t OFFSET)' |
| |
| 'sys/mman.h' (POSIX): *note Memory-mapped I/O::. |
| |
| 'void * mmap64 (void *ADDRESS, size_t LENGTH, int PROTECT, int FLAGS, int FILEDES, off64_t OFFSET)' |
| |
| 'sys/mman.h' (LFS): *note Memory-mapped I/O::. |
| |
| 'mode_t' |
| |
| 'sys/types.h' (POSIX.1): *note Attribute Meanings::. |
| |
| 'double modf (double VALUE, double *INTEGER-PART)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'float modff (float VALUE, float *INTEGER-PART)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double modfl (long double VALUE, long double *INTEGER-PART)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'int mount (const char *SPECIAL_FILE, const char *DIR, const char *FSTYPE, unsigned long int OPTIONS, const void *DATA)' |
| |
| 'sys/mount.h' (SVID, BSD): *note Mount-Unmount-Remount::. |
| |
| 'long int mrand48 (void)' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int mrand48_r (struct drand48_data *BUFFER, long int *RESULT)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'void * mremap (void *ADDRESS, size_t LENGTH, size_t NEW_LENGTH, int FLAG)' |
| |
| 'sys/mman.h' (GNU): *note Memory-mapped I/O::. |
| |
| 'int MSG_DONTROUTE' |
| |
| 'sys/socket.h' (BSD): *note Socket Data Options::. |
| |
| 'int MSG_OOB' |
| |
| 'sys/socket.h' (BSD): *note Socket Data Options::. |
| |
| 'int MSG_PEEK' |
| |
| 'sys/socket.h' (BSD): *note Socket Data Options::. |
| |
| 'int msync (void *ADDRESS, size_t LENGTH, int FLAGS)' |
| |
| 'sys/mman.h' (POSIX): *note Memory-mapped I/O::. |
| |
| 'void mtrace (void)' |
| |
| 'mcheck.h' (GNU): *note Tracing malloc::. |
| |
| 'int munlock (const void *ADDR, size_t LEN)' |
| |
| 'sys/mman.h' (POSIX.1b): *note Page Lock Functions::. |
| |
| 'int munlockall (void)' |
| |
| 'sys/mman.h' (POSIX.1b): *note Page Lock Functions::. |
| |
| 'int munmap (void *ADDR, size_t LENGTH)' |
| |
| 'sys/mman.h' (POSIX): *note Memory-mapped I/O::. |
| |
| 'void muntrace (void)' |
| |
| 'mcheck.h' (GNU): *note Tracing malloc::. |
| |
| 'int NAME_MAX' |
| |
| 'limits.h' (POSIX.1): *note Limits for Files::. |
| |
| 'double nan (const char *TAGP)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'float NAN' |
| |
| 'math.h' (GNU): *note Infinity and NaN::. |
| |
| 'float nanf (const char *TAGP)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'long double nanl (const char *TAGP)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'int nanosleep (const struct timespec *REQUESTED_TIME, struct timespec *REMAINING)' |
| |
| 'time.h' (POSIX.1): *note Sleeping::. |
| |
| 'int NCCS' |
| |
| 'termios.h' (POSIX.1): *note Mode Data Types::. |
| |
| 'double nearbyint (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'float nearbyintf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double nearbyintl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'NEW_TIME' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'NEW_TIME' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'double nextafter (double X, double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'float nextafterf (float X, float Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'long double nextafterl (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'double nexttoward (double X, long double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'float nexttowardf (float X, long double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'long double nexttowardl (long double X, long double Y)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'int nftw (const char *FILENAME, __nftw_func_t FUNC, int DESCRIPTORS, int FLAG)' |
| |
| 'ftw.h' (XPG4.2): *note Working with Directory Trees::. |
| |
| 'int nftw64 (const char *FILENAME, __nftw64_func_t FUNC, int DESCRIPTORS, int FLAG)' |
| |
| 'ftw.h' (Unix98): *note Working with Directory Trees::. |
| |
| '__nftw64_func_t' |
| |
| 'ftw.h' (GNU): *note Working with Directory Trees::. |
| |
| '__nftw_func_t' |
| |
| 'ftw.h' (GNU): *note Working with Directory Trees::. |
| |
| 'char * ngettext (const char *MSGID1, const char *MSGID2, unsigned long int N)' |
| |
| 'libintl.h' (GNU): *note Advanced gettext functions::. |
| |
| 'int NGROUPS_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'int nice (int INCREMENT)' |
| |
| 'unistd.h' (BSD): *note Traditional Scheduling Functions::. |
| |
| 'nlink_t' |
| |
| 'sys/types.h' (POSIX.1): *note Attribute Meanings::. |
| |
| 'char * nl_langinfo (nl_item ITEM)' |
| |
| 'langinfo.h' (XOPEN): *note The Elegant and Fast Way::. |
| |
| 'NO_ADDRESS' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'tcflag_t NOFLSH' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'tcflag_t NOKERNINFO' |
| |
| 'termios.h', '(optional)' (BSD): *note Local Modes::. |
| |
| 'NO_RECOVERY' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'long int nrand48 (unsigned short int XSUBI[3])' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int nrand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, long int *RESULT)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'int NSIG' |
| |
| 'signal.h' (BSD): *note Standard Signals::. |
| |
| 'uint32_t ntohl (uint32_t NETLONG)' |
| |
| 'netinet/in.h' (BSD): *note Byte Order::. |
| |
| 'uint16_t ntohs (uint16_t NETSHORT)' |
| |
| 'netinet/in.h' (BSD): *note Byte Order::. |
| |
| 'int ntp_adjtime (struct timex *TPTR)' |
| |
| 'sys/timex.h' (GNU): *note High Accuracy Clock::. |
| |
| 'int ntp_gettime (struct ntptimeval *TPTR)' |
| |
| 'sys/timex.h' (GNU): *note High Accuracy Clock::. |
| |
| 'void * NULL' |
| |
| 'stddef.h' (ISO): *note Null Pointer Constant::. |
| |
| 'int O_ACCMODE' |
| |
| 'fcntl.h' (POSIX.1): *note Access Modes::. |
| |
| 'int O_APPEND' |
| |
| 'fcntl.h' (POSIX.1): *note Operating Modes::. |
| |
| 'int O_ASYNC' |
| |
| 'fcntl.h' (BSD): *note Operating Modes::. |
| |
| 'void obstack_1grow (struct obstack *OBSTACK-PTR, char C)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'void obstack_1grow_fast (struct obstack *OBSTACK-PTR, char C)' |
| |
| 'obstack.h' (GNU): *note Extra Fast Growing::. |
| |
| 'int obstack_alignment_mask (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Obstacks Data Alignment::. |
| |
| 'void * obstack_alloc (struct obstack *OBSTACK-PTR, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Allocation in an Obstack::. |
| |
| 'obstack_alloc_failed_handler' |
| |
| 'obstack.h' (GNU): *note Preparing for Obstacks::. |
| |
| 'void * obstack_base (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Status of an Obstack::. |
| |
| 'void obstack_blank (struct obstack *OBSTACK-PTR, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'void obstack_blank_fast (struct obstack *OBSTACK-PTR, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Extra Fast Growing::. |
| |
| 'int obstack_chunk_size (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Obstack Chunks::. |
| |
| 'void * obstack_copy (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Allocation in an Obstack::. |
| |
| 'void * obstack_copy0 (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Allocation in an Obstack::. |
| |
| 'void * obstack_finish (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'void obstack_free (struct obstack *OBSTACK-PTR, void *OBJECT)' |
| |
| 'obstack.h' (GNU): *note Freeing Obstack Objects::. |
| |
| 'void obstack_grow (struct obstack *OBSTACK-PTR, void *DATA, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'void obstack_grow0 (struct obstack *OBSTACK-PTR, void *DATA, int SIZE)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'int obstack_init (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Preparing for Obstacks::. |
| |
| 'void obstack_int_grow (struct obstack *OBSTACK-PTR, int DATA)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'void obstack_int_grow_fast (struct obstack *OBSTACK-PTR, int DATA)' |
| |
| 'obstack.h' (GNU): *note Extra Fast Growing::. |
| |
| 'void * obstack_next_free (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Status of an Obstack::. |
| |
| 'int obstack_object_size (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'int obstack_object_size (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Status of an Obstack::. |
| |
| 'int obstack_printf (struct obstack *OBSTACK, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (GNU): *note Dynamic Output::. |
| |
| 'void obstack_ptr_grow (struct obstack *OBSTACK-PTR, void *DATA)' |
| |
| 'obstack.h' (GNU): *note Growing Objects::. |
| |
| 'void obstack_ptr_grow_fast (struct obstack *OBSTACK-PTR, void *DATA)' |
| |
| 'obstack.h' (GNU): *note Extra Fast Growing::. |
| |
| 'int obstack_room (struct obstack *OBSTACK-PTR)' |
| |
| 'obstack.h' (GNU): *note Extra Fast Growing::. |
| |
| 'int obstack_vprintf (struct obstack *OBSTACK, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (GNU): *note Variable Arguments Output::. |
| |
| 'int O_CREAT' |
| |
| 'fcntl.h' (POSIX.1): *note Open-time Flags::. |
| |
| 'int O_EXCL' |
| |
| 'fcntl.h' (POSIX.1): *note Open-time Flags::. |
| |
| 'int O_EXEC' |
| |
| 'fcntl.h', '(optional)' (GNU): *note Access Modes::. |
| |
| 'int O_EXLOCK' |
| |
| 'fcntl.h', '(optional)' (BSD): *note Open-time Flags::. |
| |
| 'off64_t' |
| |
| 'sys/types.h' (Unix98): *note File Position Primitive::. |
| |
| 'size_t offsetof (TYPE, MEMBER)' |
| |
| 'stddef.h' (ISO): *note Structure Measurement::. |
| |
| 'off_t' |
| |
| 'sys/types.h' (POSIX.1): *note File Position Primitive::. |
| |
| 'int O_FSYNC' |
| |
| 'fcntl.h' (BSD): *note Operating Modes::. |
| |
| 'int O_IGNORE_CTTY' |
| |
| 'fcntl.h', '(optional)' (GNU): *note Open-time Flags::. |
| |
| 'OLD_TIME' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'OLD_TIME' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int O_NDELAY' |
| |
| 'fcntl.h' (BSD): *note Operating Modes::. |
| |
| 'int on_exit (void (*FUNCTION)(int STATUS, void *ARG), void *ARG)' |
| |
| 'stdlib.h' (SunOS): *note Cleanups on Exit::. |
| |
| 'tcflag_t ONLCR' |
| |
| 'termios.h' (POSIX.1): *note Output Modes::. |
| |
| 'int O_NOATIME' |
| |
| 'fcntl.h' (GNU): *note Operating Modes::. |
| |
| 'int O_NOCTTY' |
| |
| 'fcntl.h' (POSIX.1): *note Open-time Flags::. |
| |
| 'tcflag_t ONOEOT' |
| |
| 'termios.h', '(optional)' (BSD): *note Output Modes::. |
| |
| 'int O_NOLINK' |
| |
| 'fcntl.h', '(optional)' (GNU): *note Open-time Flags::. |
| |
| 'int O_NONBLOCK' |
| |
| 'fcntl.h' (POSIX.1): *note Open-time Flags::. |
| |
| 'int O_NONBLOCK' |
| |
| 'fcntl.h' (POSIX.1): *note Operating Modes::. |
| |
| 'int O_NOTRANS' |
| |
| 'fcntl.h', '(optional)' (GNU): *note Open-time Flags::. |
| |
| 'int open (const char *FILENAME, int FLAGS[, mode_t MODE])' |
| |
| 'fcntl.h' (POSIX.1): *note Opening and Closing Files::. |
| |
| 'int open64 (const char *FILENAME, int FLAGS[, mode_t MODE])' |
| |
| 'fcntl.h' (Unix98): *note Opening and Closing Files::. |
| |
| 'DIR * opendir (const char *DIRNAME)' |
| |
| 'dirent.h' (POSIX.1): *note Opening a Directory::. |
| |
| 'void openlog (const char *IDENT, int OPTION, int FACILITY)' |
| |
| 'syslog.h' (BSD): *note openlog::. |
| |
| 'int OPEN_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'FILE * open_memstream (char **PTR, size_t *SIZELOC)' |
| |
| 'stdio.h' (GNU): *note String Streams::. |
| |
| 'int openpty (int *AMASTER, int *ASLAVE, char *NAME, const struct termios *TERMP, const struct winsize *WINP)' |
| |
| 'pty.h' (BSD): *note Pseudo-Terminal Pairs::. |
| |
| 'tcflag_t OPOST' |
| |
| 'termios.h' (POSIX.1): *note Output Modes::. |
| |
| 'char * optarg' |
| |
| 'unistd.h' (POSIX.2): *note Using Getopt::. |
| |
| 'int opterr' |
| |
| 'unistd.h' (POSIX.2): *note Using Getopt::. |
| |
| 'int optind' |
| |
| 'unistd.h' (POSIX.2): *note Using Getopt::. |
| |
| 'OPTION_ALIAS' |
| |
| 'argp.h' (GNU): *note Argp Option Flags::. |
| |
| 'OPTION_ARG_OPTIONAL' |
| |
| 'argp.h' (GNU): *note Argp Option Flags::. |
| |
| 'OPTION_DOC' |
| |
| 'argp.h' (GNU): *note Argp Option Flags::. |
| |
| 'OPTION_HIDDEN' |
| |
| 'argp.h' (GNU): *note Argp Option Flags::. |
| |
| 'OPTION_NO_USAGE' |
| |
| 'argp.h' (GNU): *note Argp Option Flags::. |
| |
| 'int optopt' |
| |
| 'unistd.h' (POSIX.2): *note Using Getopt::. |
| |
| 'int O_RDONLY' |
| |
| 'fcntl.h' (POSIX.1): *note Access Modes::. |
| |
| 'int O_RDWR' |
| |
| 'fcntl.h' (POSIX.1): *note Access Modes::. |
| |
| 'int O_READ' |
| |
| 'fcntl.h', '(optional)' (GNU): *note Access Modes::. |
| |
| 'int O_SHLOCK' |
| |
| 'fcntl.h', '(optional)' (BSD): *note Open-time Flags::. |
| |
| 'int O_SYNC' |
| |
| 'fcntl.h' (BSD): *note Operating Modes::. |
| |
| 'int O_TRUNC' |
| |
| 'fcntl.h' (POSIX.1): *note Open-time Flags::. |
| |
| 'int O_WRITE' |
| |
| 'fcntl.h', '(optional)' (GNU): *note Access Modes::. |
| |
| 'int O_WRONLY' |
| |
| 'fcntl.h' (POSIX.1): *note Access Modes::. |
| |
| 'tcflag_t OXTABS' |
| |
| 'termios.h', '(optional)' (BSD): *note Output Modes::. |
| |
| 'PA_CHAR' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_DOUBLE' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_FLAG_LONG' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_FLAG_LONG_DOUBLE' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_FLAG_LONG_LONG' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'int PA_FLAG_MASK' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_FLAG_PTR' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_FLAG_SHORT' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_FLOAT' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_INT' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_LAST' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_POINTER' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'tcflag_t PARENB' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'tcflag_t PARMRK' |
| |
| 'termios.h' (POSIX.1): *note Input Modes::. |
| |
| 'tcflag_t PARODD' |
| |
| 'termios.h' (POSIX.1): *note Control Modes::. |
| |
| 'size_t parse_printf_format (const char *TEMPLATE, size_t N, int *ARGTYPES)' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'PA_STRING' |
| |
| 'printf.h' (GNU): *note Parsing a Template String::. |
| |
| 'long int pathconf (const char *FILENAME, int PARAMETER)' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| 'int PATH_MAX' |
| |
| 'limits.h' (POSIX.1): *note Limits for Files::. |
| |
| 'int pause (void)' |
| |
| 'unistd.h' (POSIX.1): *note Using Pause::. |
| |
| '_PC_ASYNC_IO' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_CHOWN_RESTRICTED' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_FILESIZEBITS' |
| |
| 'unistd.h' (LFS): *note Pathconf::. |
| |
| '_PC_LINK_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| 'int pclose (FILE *STREAM)' |
| |
| 'stdio.h' (POSIX.2, SVID, BSD): *note Pipe to a Subprocess::. |
| |
| '_PC_MAX_CANON' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_MAX_INPUT' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_NAME_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_NO_TRUNC' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_PATH_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_PIPE_BUF' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_PRIO_IO' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_REC_INCR_XFER_SIZE' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_REC_MAX_XFER_SIZE' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_REC_MIN_XFER_SIZE' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_REC_XFER_ALIGN' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_SYNC_IO' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| '_PC_VDISABLE' |
| |
| 'unistd.h' (POSIX.1): *note Pathconf::. |
| |
| 'tcflag_t PENDIN' |
| |
| 'termios.h' (BSD): *note Local Modes::. |
| |
| 'void perror (const char *MESSAGE)' |
| |
| 'stdio.h' (ISO): *note Error Messages::. |
| |
| 'int PF_FILE' |
| |
| 'sys/socket.h' (GNU): *note Local Namespace Details::. |
| |
| 'int PF_INET' |
| |
| 'sys/socket.h' (BSD): *note Internet Namespace::. |
| |
| 'int PF_INET6' |
| |
| 'sys/socket.h' (X/Open): *note Internet Namespace::. |
| |
| 'int PF_LOCAL' |
| |
| 'sys/socket.h' (POSIX): *note Local Namespace Details::. |
| |
| 'int PF_UNIX' |
| |
| 'sys/socket.h' (BSD): *note Local Namespace Details::. |
| |
| 'pid_t' |
| |
| 'sys/types.h' (POSIX.1): *note Process Identification::. |
| |
| 'int pipe (int FILEDES[2])' |
| |
| 'unistd.h' (POSIX.1): *note Creating a Pipe::. |
| |
| 'int PIPE_BUF' |
| |
| 'limits.h' (POSIX.1): *note Limits for Files::. |
| |
| 'FILE * popen (const char *COMMAND, const char *MODE)' |
| |
| 'stdio.h' (POSIX.2, SVID, BSD): *note Pipe to a Subprocess::. |
| |
| '_POSIX2_BC_BASE_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| '_POSIX2_BC_DIM_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| '_POSIX2_BC_SCALE_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| '_POSIX2_BC_STRING_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| 'int _POSIX2_C_DEV' |
| |
| 'unistd.h' (POSIX.2): *note System Options::. |
| |
| '_POSIX2_COLL_WEIGHTS_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| 'long int _POSIX2_C_VERSION' |
| |
| 'unistd.h' (POSIX.2): *note Version Supported::. |
| |
| '_POSIX2_EQUIV_CLASS_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| '_POSIX2_EXPR_NEST_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| 'int _POSIX2_FORT_DEV' |
| |
| 'unistd.h' (POSIX.2): *note System Options::. |
| |
| 'int _POSIX2_FORT_RUN' |
| |
| 'unistd.h' (POSIX.2): *note System Options::. |
| |
| '_POSIX2_LINE_MAX' |
| |
| 'limits.h' (POSIX.2): *note Utility Minimums::. |
| |
| 'int _POSIX2_LOCALEDEF' |
| |
| 'unistd.h' (POSIX.2): *note System Options::. |
| |
| '_POSIX2_RE_DUP_MAX' |
| |
| 'limits.h' (POSIX.2): *note Minimums::. |
| |
| 'int _POSIX2_SW_DEV' |
| |
| 'unistd.h' (POSIX.2): *note System Options::. |
| |
| '_POSIX_AIO_LISTIO_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| '_POSIX_AIO_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| '_POSIX_ARG_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| '_POSIX_CHILD_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| 'int _POSIX_CHOWN_RESTRICTED' |
| |
| 'unistd.h' (POSIX.1): *note Options for Files::. |
| |
| '_POSIX_C_SOURCE' |
| |
| (POSIX.2): *note Feature Test Macros::. |
| |
| 'int _POSIX_JOB_CONTROL' |
| |
| 'unistd.h' (POSIX.1): *note System Options::. |
| |
| '_POSIX_LINK_MAX' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| '_POSIX_MAX_CANON' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| '_POSIX_MAX_INPUT' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'int posix_memalign (void **MEMPTR, size_t ALIGNMENT, size_t SIZE)' |
| |
| 'stdlib.h' (POSIX): *note Aligned Memory Blocks::. |
| |
| '_POSIX_NAME_MAX' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| '_POSIX_NGROUPS_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| 'int _POSIX_NO_TRUNC' |
| |
| 'unistd.h' (POSIX.1): *note Options for Files::. |
| |
| '_POSIX_OPEN_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| '_POSIX_PATH_MAX' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| '_POSIX_PIPE_BUF' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'POSIX_REC_INCR_XFER_SIZE' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'POSIX_REC_MAX_XFER_SIZE' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'POSIX_REC_MIN_XFER_SIZE' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'POSIX_REC_XFER_ALIGN' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'int _POSIX_SAVED_IDS' |
| |
| 'unistd.h' (POSIX.1): *note System Options::. |
| |
| '_POSIX_SOURCE' |
| |
| (POSIX.1): *note Feature Test Macros::. |
| |
| '_POSIX_SSIZE_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| '_POSIX_STREAM_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| '_POSIX_TZNAME_MAX' |
| |
| 'limits.h' (POSIX.1): *note Minimums::. |
| |
| 'unsigned char _POSIX_VDISABLE' |
| |
| 'unistd.h' (POSIX.1): *note Options for Files::. |
| |
| 'long int _POSIX_VERSION' |
| |
| 'unistd.h' (POSIX.1): *note Version Supported::. |
| |
| 'double pow (double BASE, double POWER)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'double pow10 (double X)' |
| |
| 'math.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'float pow10f (float X)' |
| |
| 'math.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'long double pow10l (long double X)' |
| |
| 'math.h' (GNU): *note Exponents and Logarithms::. |
| |
| 'float powf (float BASE, float POWER)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double powl (long double BASE, long double POWER)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'ssize_t pread (int FILEDES, void *BUFFER, size_t SIZE, off_t OFFSET)' |
| |
| 'unistd.h' (Unix98): *note I/O Primitives::. |
| |
| 'ssize_t pread64 (int FILEDES, void *BUFFER, size_t SIZE, off64_t OFFSET)' |
| |
| 'unistd.h' (Unix98): *note I/O Primitives::. |
| |
| 'int printf (const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (ISO): *note Formatted Output Functions::. |
| |
| 'printf_arginfo_function' |
| |
| 'printf.h' (GNU): *note Defining the Output Handler::. |
| |
| 'printf_function' |
| |
| 'printf.h' (GNU): *note Defining the Output Handler::. |
| |
| 'int printf_size (FILE *FP, const struct printf_info *INFO, const void *const *ARGS)' |
| |
| 'printf.h' (GNU): *note Predefined Printf Handlers::. |
| |
| 'int printf_size_info (const struct printf_info *INFO, size_t N, int *ARGTYPES)' |
| |
| 'printf.h' (GNU): *note Predefined Printf Handlers::. |
| |
| 'PRIO_MAX' |
| |
| 'sys/resource.h' (BSD): *note Traditional Scheduling Functions::. |
| |
| 'PRIO_MIN' |
| |
| 'sys/resource.h' (BSD): *note Traditional Scheduling Functions::. |
| |
| 'PRIO_PGRP' |
| |
| 'sys/resource.h' (BSD): *note Traditional Scheduling Functions::. |
| |
| 'PRIO_PROCESS' |
| |
| 'sys/resource.h' (BSD): *note Traditional Scheduling Functions::. |
| |
| 'PRIO_USER' |
| |
| 'sys/resource.h' (BSD): *note Traditional Scheduling Functions::. |
| |
| 'char * program_invocation_name' |
| |
| 'errno.h' (GNU): *note Error Messages::. |
| |
| 'char * program_invocation_short_name' |
| |
| 'errno.h' (GNU): *note Error Messages::. |
| |
| 'void psignal (int SIGNUM, const char *MESSAGE)' |
| |
| 'signal.h' (BSD): *note Signal Messages::. |
| |
| 'int pthread_getattr_default_np (pthread_attr_t *ATTR)' |
| |
| 'pthread.h' (GNU): *note Default Thread Attributes::. |
| |
| 'void *pthread_getspecific (pthread_key_t KEY)' |
| |
| 'pthread.h' (POSIX): *note Thread-specific Data::. |
| |
| 'int pthread_key_create (pthread_key_t *KEY, void (*DESTRUCTOR)(void*))' |
| |
| 'pthread.h' (POSIX): *note Thread-specific Data::. |
| |
| 'int pthread_key_delete (pthread_key_t KEY)' |
| |
| 'pthread.h' (POSIX): *note Thread-specific Data::. |
| |
| 'int pthread_setattr_default_np (pthread_attr_t *ATTR)' |
| |
| 'pthread.h' (GNU): *note Default Thread Attributes::. |
| |
| 'int pthread_setspecific (pthread_key_t KEY, const void *VALUE)' |
| |
| 'pthread.h' (POSIX): *note Thread-specific Data::. |
| |
| 'char * P_tmpdir' |
| |
| 'stdio.h' (SVID): *note Temporary Files::. |
| |
| 'ptrdiff_t' |
| |
| 'stddef.h' (ISO): *note Important Data Types::. |
| |
| 'char * ptsname (int FILEDES)' |
| |
| 'stdlib.h' (SVID, XPG4.2): *note Allocation::. |
| |
| 'int ptsname_r (int FILEDES, char *BUF, size_t LEN)' |
| |
| 'stdlib.h' (GNU): *note Allocation::. |
| |
| 'int putc (int C, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note Simple Output::. |
| |
| 'int putchar (int C)' |
| |
| 'stdio.h' (ISO): *note Simple Output::. |
| |
| 'int putchar_unlocked (int C)' |
| |
| 'stdio.h' (POSIX): *note Simple Output::. |
| |
| 'int putc_unlocked (int C, FILE *STREAM)' |
| |
| 'stdio.h' (POSIX): *note Simple Output::. |
| |
| 'int putenv (char *STRING)' |
| |
| 'stdlib.h' (SVID): *note Environment Access::. |
| |
| 'int putpwent (const struct passwd *P, FILE *STREAM)' |
| |
| 'pwd.h' (SVID): *note Writing a User Entry::. |
| |
| 'int puts (const char *S)' |
| |
| 'stdio.h' (ISO): *note Simple Output::. |
| |
| 'struct utmp * pututline (const struct utmp *UTMP)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'struct utmpx * pututxline (const struct utmpx *UTMP)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int putw (int W, FILE *STREAM)' |
| |
| 'stdio.h' (SVID): *note Simple Output::. |
| |
| 'wint_t putwc (wchar_t WC, FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note Simple Output::. |
| |
| 'wint_t putwchar (wchar_t WC)' |
| |
| 'wchar.h' (ISO): *note Simple Output::. |
| |
| 'wint_t putwchar_unlocked (wchar_t WC)' |
| |
| 'wchar.h' (GNU): *note Simple Output::. |
| |
| 'wint_t putwc_unlocked (wchar_t WC, FILE *STREAM)' |
| |
| 'wchar.h' (GNU): *note Simple Output::. |
| |
| 'ssize_t pwrite (int FILEDES, const void *BUFFER, size_t SIZE, off_t OFFSET)' |
| |
| 'unistd.h' (Unix98): *note I/O Primitives::. |
| |
| 'ssize_t pwrite64 (int FILEDES, const void *BUFFER, size_t SIZE, off64_t OFFSET)' |
| |
| 'unistd.h' (Unix98): *note I/O Primitives::. |
| |
| 'char * qecvt (long double VALUE, int NDIGIT, int *DECPT, int *NEG)' |
| |
| 'stdlib.h' (GNU): *note System V Number Conversion::. |
| |
| 'int qecvt_r (long double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN)' |
| |
| 'stdlib.h' (GNU): *note System V Number Conversion::. |
| |
| 'char * qfcvt (long double VALUE, int NDIGIT, int *DECPT, int *NEG)' |
| |
| 'stdlib.h' (GNU): *note System V Number Conversion::. |
| |
| 'int qfcvt_r (long double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN)' |
| |
| 'stdlib.h' (GNU): *note System V Number Conversion::. |
| |
| 'char * qgcvt (long double VALUE, int NDIGIT, char *BUF)' |
| |
| 'stdlib.h' (GNU): *note System V Number Conversion::. |
| |
| 'void qsort (void *ARRAY, size_t COUNT, size_t SIZE, comparison_fn_t COMPARE)' |
| |
| 'stdlib.h' (ISO): *note Array Sort Function::. |
| |
| 'int raise (int SIGNUM)' |
| |
| 'signal.h' (ISO): *note Signaling Yourself::. |
| |
| 'int rand (void)' |
| |
| 'stdlib.h' (ISO): *note ISO Random::. |
| |
| 'int RAND_MAX' |
| |
| 'stdlib.h' (ISO): *note ISO Random::. |
| |
| 'long int random (void)' |
| |
| 'stdlib.h' (BSD): *note BSD Random::. |
| |
| 'int random_r (struct random_data *restrict BUF, int32_t *restrict RESULT)' |
| |
| 'stdlib.h' (GNU): *note BSD Random::. |
| |
| 'int rand_r (unsigned int *SEED)' |
| |
| 'stdlib.h' (POSIX.1): *note ISO Random::. |
| |
| 'void * rawmemchr (const void *BLOCK, int C)' |
| |
| 'string.h' (GNU): *note Search Functions::. |
| |
| 'ssize_t read (int FILEDES, void *BUFFER, size_t SIZE)' |
| |
| 'unistd.h' (POSIX.1): *note I/O Primitives::. |
| |
| 'struct dirent * readdir (DIR *DIRSTREAM)' |
| |
| 'dirent.h' (POSIX.1): *note Reading/Closing Directory::. |
| |
| 'struct dirent64 * readdir64 (DIR *DIRSTREAM)' |
| |
| 'dirent.h' (LFS): *note Reading/Closing Directory::. |
| |
| 'int readdir64_r (DIR *DIRSTREAM, struct dirent64 *ENTRY, struct dirent64 **RESULT)' |
| |
| 'dirent.h' (LFS): *note Reading/Closing Directory::. |
| |
| 'int readdir_r (DIR *DIRSTREAM, struct dirent *ENTRY, struct dirent **RESULT)' |
| |
| 'dirent.h' (GNU): *note Reading/Closing Directory::. |
| |
| 'ssize_t readlink (const char *FILENAME, char *BUFFER, size_t SIZE)' |
| |
| 'unistd.h' (BSD): *note Symbolic Links::. |
| |
| 'ssize_t readv (int FILEDES, const struct iovec *VECTOR, int COUNT)' |
| |
| 'sys/uio.h' (BSD): *note Scatter-Gather::. |
| |
| 'void * realloc (void *PTR, size_t NEWSIZE)' |
| |
| 'malloc.h', 'stdlib.h' (ISO): *note Changing Block Size::. |
| |
| '__realloc_hook' |
| |
| 'malloc.h' (GNU): *note Hooks for Malloc::. |
| |
| 'char * realpath (const char *restrict NAME, char *restrict RESOLVED)' |
| |
| 'stdlib.h' (XPG): *note Symbolic Links::. |
| |
| 'ssize_t recv (int SOCKET, void *BUFFER, size_t SIZE, int FLAGS)' |
| |
| 'sys/socket.h' (BSD): *note Receiving Data::. |
| |
| 'ssize_t recvfrom (int SOCKET, void *BUFFER, size_t SIZE, int FLAGS, struct sockaddr *ADDR, socklen_t *LENGTH-PTR)' |
| |
| 'sys/socket.h' (BSD): *note Receiving Datagrams::. |
| |
| 'ssize_t recvmsg (int SOCKET, struct msghdr *MESSAGE, int FLAGS)' |
| |
| 'sys/socket.h' (BSD): *note Receiving Datagrams::. |
| |
| 'int RE_DUP_MAX' |
| |
| 'limits.h' (POSIX.2): *note General Limits::. |
| |
| '_REENTRANT' |
| |
| (GNU): *note Feature Test Macros::. |
| |
| 'REG_BADBR' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_BADPAT' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_BADRPT' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'int regcomp (regex_t *restrict COMPILED, const char *restrict PATTERN, int CFLAGS)' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_EBRACE' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_EBRACK' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_ECOLLATE' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_ECTYPE' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_EESCAPE' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_EPAREN' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_ERANGE' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'size_t regerror (int ERRCODE, const regex_t *restrict COMPILED, char *restrict BUFFER, size_t LENGTH)' |
| |
| 'regex.h' (POSIX.2): *note Regexp Cleanup::. |
| |
| 'REG_ESPACE' |
| |
| 'regex.h' (POSIX.2): *note Matching POSIX Regexps::. |
| |
| 'REG_ESPACE' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_ESUBREG' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'int regexec (const regex_t *restrict COMPILED, const char *restrict STRING, size_t NMATCH, regmatch_t MATCHPTR[restrict], int EFLAGS)' |
| |
| 'regex.h' (POSIX.2): *note Matching POSIX Regexps::. |
| |
| 'regex_t' |
| |
| 'regex.h' (POSIX.2): *note POSIX Regexp Compilation::. |
| |
| 'REG_EXTENDED' |
| |
| 'regex.h' (POSIX.2): *note Flags for POSIX Regexps::. |
| |
| 'void regfree (regex_t *COMPILED)' |
| |
| 'regex.h' (POSIX.2): *note Regexp Cleanup::. |
| |
| 'REG_ICASE' |
| |
| 'regex.h' (POSIX.2): *note Flags for POSIX Regexps::. |
| |
| 'int register_printf_function (int SPEC, printf_function HANDLER-FUNCTION, printf_arginfo_function ARGINFO-FUNCTION)' |
| |
| 'printf.h' (GNU): *note Registering New Conversions::. |
| |
| 'regmatch_t' |
| |
| 'regex.h' (POSIX.2): *note Regexp Subexpressions::. |
| |
| 'REG_NEWLINE' |
| |
| 'regex.h' (POSIX.2): *note Flags for POSIX Regexps::. |
| |
| 'REG_NOMATCH' |
| |
| 'regex.h' (POSIX.2): *note Matching POSIX Regexps::. |
| |
| 'REG_NOSUB' |
| |
| 'regex.h' (POSIX.2): *note Flags for POSIX Regexps::. |
| |
| 'REG_NOTBOL' |
| |
| 'regex.h' (POSIX.2): *note Matching POSIX Regexps::. |
| |
| 'REG_NOTEOL' |
| |
| 'regex.h' (POSIX.2): *note Matching POSIX Regexps::. |
| |
| 'regoff_t' |
| |
| 'regex.h' (POSIX.2): *note Regexp Subexpressions::. |
| |
| 'double remainder (double NUMERATOR, double DENOMINATOR)' |
| |
| 'math.h' (BSD): *note Remainder Functions::. |
| |
| 'float remainderf (float NUMERATOR, float DENOMINATOR)' |
| |
| 'math.h' (BSD): *note Remainder Functions::. |
| |
| 'long double remainderl (long double NUMERATOR, long double DENOMINATOR)' |
| |
| 'math.h' (BSD): *note Remainder Functions::. |
| |
| 'int remove (const char *FILENAME)' |
| |
| 'stdio.h' (ISO): *note Deleting Files::. |
| |
| 'int rename (const char *OLDNAME, const char *NEWNAME)' |
| |
| 'stdio.h' (ISO): *note Renaming Files::. |
| |
| 'void rewind (FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note File Positioning::. |
| |
| 'void rewinddir (DIR *DIRSTREAM)' |
| |
| 'dirent.h' (POSIX.1): *note Random Access Directory::. |
| |
| 'char * rindex (const char *STRING, int C)' |
| |
| 'string.h' (BSD): *note Search Functions::. |
| |
| 'double rint (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'float rintf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double rintl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'rlim_t RLIM_INFINITY' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_AS' |
| |
| 'sys/resource.h' (Unix98): *note Limits on Resources::. |
| |
| 'RLIMIT_CORE' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_CPU' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_DATA' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_FSIZE' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_MEMLOCK' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_NOFILE' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_NPROC' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_RSS' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIMIT_STACK' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'RLIM_NLIMITS' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'int rmdir (const char *FILENAME)' |
| |
| 'unistd.h' (POSIX.1): *note Deleting Files::. |
| |
| 'int R_OK' |
| |
| 'unistd.h' (POSIX.1): *note Testing File Access::. |
| |
| 'double round (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'float roundf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double roundl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'int rpmatch (const char *RESPONSE)' |
| |
| 'stdlib.h' (stdlib.h): *note Yes-or-No Questions::. |
| |
| 'RUN_LVL' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'RUN_LVL' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'RUSAGE_CHILDREN' |
| |
| 'sys/resource.h' (BSD): *note Resource Usage::. |
| |
| 'RUSAGE_SELF' |
| |
| 'sys/resource.h' (BSD): *note Resource Usage::. |
| |
| 'int SA_NOCLDSTOP' |
| |
| 'signal.h' (POSIX.1): *note Flags for Sigaction::. |
| |
| 'int SA_ONSTACK' |
| |
| 'signal.h' (BSD): *note Flags for Sigaction::. |
| |
| 'int SA_RESTART' |
| |
| 'signal.h' (BSD): *note Flags for Sigaction::. |
| |
| 'void *sbrk (ptrdiff_t DELTA)' |
| |
| 'unistd.h' (BSD): *note Resizing the Data Segment::. |
| |
| '_SC_2_C_DEV' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_2_FORT_DEV' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_2_FORT_RUN' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_2_LOCALEDEF' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_2_SW_DEV' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_2_VERSION' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_AIO_LISTIO_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_AIO_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_AIO_PRIO_DELTA_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| 'double scalb (double VALUE, double EXPONENT)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'float scalbf (float VALUE, float EXPONENT)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'long double scalbl (long double VALUE, long double EXPONENT)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'double scalbln (double X, long int N)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'float scalblnf (float X, long int N)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'long double scalblnl (long double X, long int N)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'double scalbn (double X, int N)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'float scalbnf (float X, int N)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'long double scalbnl (long double X, int N)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'int scandir (const char *DIR, struct dirent ***NAMELIST, int (*SELECTOR) (const struct dirent *), int (*CMP) (const struct dirent **, const struct dirent **))' |
| |
| 'dirent.h' (BSD/SVID): *note Scanning Directory Content::. |
| |
| 'int scandir64 (const char *DIR, struct dirent64 ***NAMELIST, int (*SELECTOR) (const struct dirent64 *), int (*CMP) (const struct dirent64 **, const struct dirent64 **))' |
| |
| 'dirent.h' (GNU): *note Scanning Directory Content::. |
| |
| 'int scanf (const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (ISO): *note Formatted Input Functions::. |
| |
| '_SC_ARG_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_ASYNCHRONOUS_IO' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_ATEXIT_MAX' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_AVPHYS_PAGES' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_BC_BASE_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_BC_DIM_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_BC_SCALE_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_BC_STRING_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_CHAR_BIT' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_CHARCLASS_NAME_MAX' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_CHAR_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_CHAR_MIN' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_CHILD_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_CLK_TCK' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_COLL_WEIGHTS_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_DELAYTIMER_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_EQUIV_CLASS_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_EXPR_NEST_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_FSYNC' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_GETGR_R_SIZE_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_GETPW_R_SIZE_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| 'SCHAR_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'SCHAR_MIN' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'int sched_getaffinity (pid_t PID, size_t CPUSETSIZE, cpu_set_t *CPUSET)' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'int sched_getparam (pid_t PID, struct sched_param *PARAM)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_get_priority_max (int POLICY)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_get_priority_min (int POLICY)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_getscheduler (pid_t PID)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_rr_get_interval (pid_t PID, struct timespec *INTERVAL)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_setaffinity (pid_t PID, size_t CPUSETSIZE, const cpu_set_t *CPUSET)' |
| |
| 'sched.h' (GNU): *note CPU Affinity::. |
| |
| 'int sched_setparam (pid_t PID, const struct sched_param *PARAM)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_setscheduler (pid_t PID, int POLICY, const struct sched_param *PARAM)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'int sched_yield (void)' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| '_SC_INT_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_INT_MIN' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_JOB_CONTROL' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_LINE_MAX' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_LOGIN_NAME_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_LONG_BIT' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_MAPPED_FILES' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_MB_LEN_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_MEMLOCK' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_MEMLOCK_RANGE' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_MEMORY_PROTECTION' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_MESSAGE_PASSING' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_MQ_OPEN_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_MQ_PRIO_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_NGROUPS_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_NL_ARGMAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_NL_LANGMAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_NL_MSGMAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_NL_NMAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_NL_SETMAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_NL_TEXTMAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_NPROCESSORS_CONF' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_NPROCESSORS_ONLN' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_NZERO' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_OPEN_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_PAGESIZE' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_PHYS_PAGES' |
| |
| 'unistd.h' (GNU): *note Constants for Sysconf::. |
| |
| '_SC_PII' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_INTERNET' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_INTERNET_DGRAM' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_INTERNET_STREAM' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_OSI' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_OSI_CLTS' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_OSI_COTS' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_OSI_M' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_SOCKET' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PII_XTI' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_PRIORITIZED_IO' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_PRIORITY_SCHEDULING' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_REALTIME_SIGNALS' |
| |
| 'unistdh.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_RTSIG_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SAVED_IDS' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SCHAR_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_SCHAR_MIN' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_SELECT' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_SEMAPHORES' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SEM_NSEMS_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SEM_VALUE_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SHARED_MEMORY_OBJECTS' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SHRT_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_SHRT_MIN' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_SIGQUEUE_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| 'SC_SSIZE_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_STREAM_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_SYNCHRONIZED_IO' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_ATTR_STACKADDR' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_ATTR_STACKSIZE' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_DESTRUCTOR_ITERATIONS' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_KEYS_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_PRIO_INHERIT' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_PRIO_PROTECT' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_PRIORITY_SCHEDULING' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_PROCESS_SHARED' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREADS' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_SAFE_FUNCTIONS' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_STACK_MIN' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_THREAD_THREADS_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_TIMER_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_TIMERS' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_T_IOV_MAX' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_TTY_NAME_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_TZNAME_MAX' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_UCHAR_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_UINT_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_UIO_MAXIOV' |
| |
| 'unistd.h' (POSIX.1g): *note Constants for Sysconf::. |
| |
| '_SC_ULONG_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_USHRT_MAX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_VERSION' |
| |
| 'unistd.h' (POSIX.1): *note Constants for Sysconf::. |
| |
| '_SC_VERSION' |
| |
| 'unistd.h' (POSIX.2): *note Constants for Sysconf::. |
| |
| '_SC_WORD_BIT' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_CRYPT' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_ENH_I18N' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_LEGACY' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_REALTIME' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_REALTIME_THREADS' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_SHM' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_UNIX' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_VERSION' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_XCU_VERSION' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_XPG2' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_XPG3' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| '_SC_XOPEN_XPG4' |
| |
| 'unistd.h' (X/Open): *note Constants for Sysconf::. |
| |
| 'char * secure_getenv (const char *NAME)' |
| |
| 'stdlib.h' (GNU): *note Environment Access::. |
| |
| 'unsigned short int * seed48 (unsigned short int SEED16V[3])' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int seed48_r (unsigned short int SEED16V[3], struct drand48_data *BUFFER)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'int SEEK_CUR' |
| |
| 'stdio.h' (ISO): *note File Positioning::. |
| |
| 'void seekdir (DIR *DIRSTREAM, long int POS)' |
| |
| 'dirent.h' (BSD): *note Random Access Directory::. |
| |
| 'int SEEK_END' |
| |
| 'stdio.h' (ISO): *note File Positioning::. |
| |
| 'int SEEK_SET' |
| |
| 'stdio.h' (ISO): *note File Positioning::. |
| |
| 'int select (int NFDS, fd_set *READ-FDS, fd_set *WRITE-FDS, fd_set *EXCEPT-FDS, struct timeval *TIMEOUT)' |
| |
| 'sys/types.h' (BSD): *note Waiting for I/O::. |
| |
| 'ssize_t send (int SOCKET, const void *BUFFER, size_t SIZE, int FLAGS)' |
| |
| 'sys/socket.h' (BSD): *note Sending Data::. |
| |
| 'ssize_t sendmsg (int SOCKET, const struct msghdr *MESSAGE, int FLAGS)' |
| |
| 'sys/socket.h' (BSD): *note Receiving Datagrams::. |
| |
| 'ssize_t sendto (int SOCKET, const void *BUFFER, size_t SIZE, int FLAGS, struct sockaddr *ADDR, socklen_t LENGTH)' |
| |
| 'sys/socket.h' (BSD): *note Sending Datagrams::. |
| |
| 'void setbuf (FILE *STREAM, char *BUF)' |
| |
| 'stdio.h' (ISO): *note Controlling Buffering::. |
| |
| 'void setbuffer (FILE *STREAM, char *BUF, size_t SIZE)' |
| |
| 'stdio.h' (BSD): *note Controlling Buffering::. |
| |
| 'int setcontext (const ucontext_t *UCP)' |
| |
| 'ucontext.h' (SVID): *note System V contexts::. |
| |
| 'int setdomainname (const char *NAME, size_t LENGTH)' |
| |
| 'unistd.h' (???): *note Host Identification::. |
| |
| 'int setegid (gid_t NEWGID)' |
| |
| 'unistd.h' (POSIX.1): *note Setting Groups::. |
| |
| 'int setenv (const char *NAME, const char *VALUE, int REPLACE)' |
| |
| 'stdlib.h' (BSD): *note Environment Access::. |
| |
| 'int seteuid (uid_t NEWEUID)' |
| |
| 'unistd.h' (POSIX.1): *note Setting User ID::. |
| |
| 'int setfsent (void)' |
| |
| 'fstab.h' (BSD): *note fstab::. |
| |
| 'int setgid (gid_t NEWGID)' |
| |
| 'unistd.h' (POSIX.1): *note Setting Groups::. |
| |
| 'void setgrent (void)' |
| |
| 'grp.h' (SVID, BSD): *note Scanning All Groups::. |
| |
| 'int setgroups (size_t COUNT, const gid_t *GROUPS)' |
| |
| 'grp.h' (BSD): *note Setting Groups::. |
| |
| 'void sethostent (int STAYOPEN)' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'int sethostid (long int ID)' |
| |
| 'unistd.h' (BSD): *note Host Identification::. |
| |
| 'int sethostname (const char *NAME, size_t LENGTH)' |
| |
| 'unistd.h' (BSD): *note Host Identification::. |
| |
| 'int setitimer (int WHICH, const struct itimerval *NEW, struct itimerval *OLD)' |
| |
| 'sys/time.h' (BSD): *note Setting an Alarm::. |
| |
| 'int setjmp (jmp_buf STATE)' |
| |
| 'setjmp.h' (ISO): *note Non-Local Details::. |
| |
| 'void setkey (const char *KEY)' |
| |
| 'crypt.h' (BSD, SVID): *note DES Encryption::. |
| |
| 'void setkey_r (const char *KEY, struct crypt_data * DATA)' |
| |
| 'crypt.h' (GNU): *note DES Encryption::. |
| |
| 'void setlinebuf (FILE *STREAM)' |
| |
| 'stdio.h' (BSD): *note Controlling Buffering::. |
| |
| 'char * setlocale (int CATEGORY, const char *LOCALE)' |
| |
| 'locale.h' (ISO): *note Setting the Locale::. |
| |
| 'int setlogmask (int MASK)' |
| |
| 'syslog.h' (BSD): *note setlogmask::. |
| |
| 'FILE * setmntent (const char *FILE, const char *MODE)' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'void setnetent (int STAYOPEN)' |
| |
| 'netdb.h' (BSD): *note Networks Database::. |
| |
| 'int setnetgrent (const char *NETGROUP)' |
| |
| 'netdb.h' (BSD): *note Lookup Netgroup::. |
| |
| 'int setpgid (pid_t PID, pid_t PGID)' |
| |
| 'unistd.h' (POSIX.1): *note Process Group Functions::. |
| |
| 'int setpgrp (pid_t PID, pid_t PGID)' |
| |
| 'unistd.h' (BSD): *note Process Group Functions::. |
| |
| 'int setpriority (int CLASS, int ID, int NICEVAL)' |
| |
| 'sys/resource.h' (BSD,POSIX): *note Traditional Scheduling |
| Functions::. |
| |
| 'void setprotoent (int STAYOPEN)' |
| |
| 'netdb.h' (BSD): *note Protocols Database::. |
| |
| 'void setpwent (void)' |
| |
| 'pwd.h' (SVID, BSD): *note Scanning All Users::. |
| |
| 'int setregid (gid_t RGID, gid_t EGID)' |
| |
| 'unistd.h' (BSD): *note Setting Groups::. |
| |
| 'int setreuid (uid_t RUID, uid_t EUID)' |
| |
| 'unistd.h' (BSD): *note Setting User ID::. |
| |
| 'int setrlimit (int RESOURCE, const struct rlimit *RLP)' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'int setrlimit64 (int RESOURCE, const struct rlimit64 *RLP)' |
| |
| 'sys/resource.h' (Unix98): *note Limits on Resources::. |
| |
| 'void setservent (int STAYOPEN)' |
| |
| 'netdb.h' (BSD): *note Services Database::. |
| |
| 'pid_t setsid (void)' |
| |
| 'unistd.h' (POSIX.1): *note Process Group Functions::. |
| |
| 'int setsockopt (int SOCKET, int LEVEL, int OPTNAME, const void *OPTVAL, socklen_t OPTLEN)' |
| |
| 'sys/socket.h' (BSD): *note Socket Option Functions::. |
| |
| 'char * setstate (char *STATE)' |
| |
| 'stdlib.h' (BSD): *note BSD Random::. |
| |
| 'int setstate_r (char *restrict STATEBUF, struct random_data *restrict BUF)' |
| |
| 'stdlib.h' (GNU): *note BSD Random::. |
| |
| 'int settimeofday (const struct timeval *TP, const struct timezone *TZP)' |
| |
| 'sys/time.h' (BSD): *note High-Resolution Calendar::. |
| |
| 'int setuid (uid_t NEWUID)' |
| |
| 'unistd.h' (POSIX.1): *note Setting User ID::. |
| |
| 'void setutent (void)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'void setutxent (void)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'int setvbuf (FILE *STREAM, char *BUF, int MODE, size_t SIZE)' |
| |
| 'stdio.h' (ISO): *note Controlling Buffering::. |
| |
| 'int shm_open (const char *NAME, int OFLAG, mode_t MODE)' |
| |
| 'sys/mman.h' (POSIX): *note Memory-mapped I/O::. |
| |
| 'SHRT_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'SHRT_MIN' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'int shutdown (int SOCKET, int HOW)' |
| |
| 'sys/socket.h' (BSD): *note Closing a Socket::. |
| |
| 'S_IEXEC' |
| |
| 'sys/stat.h' (BSD): *note Permission Bits::. |
| |
| 'S_IFBLK' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'S_IFCHR' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'S_IFDIR' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'S_IFIFO' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'S_IFLNK' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'int S_IFMT' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'S_IFREG' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'S_IFSOCK' |
| |
| 'sys/stat.h' (BSD): *note Testing File Type::. |
| |
| 'int SIGABRT' |
| |
| 'signal.h' (ISO): *note Program Error Signals::. |
| |
| 'int sigaction (int SIGNUM, const struct sigaction *restrict ACTION, struct sigaction *restrict OLD-ACTION)' |
| |
| 'signal.h' (POSIX.1): *note Advanced Signal Handling::. |
| |
| 'int sigaddset (sigset_t *SET, int SIGNUM)' |
| |
| 'signal.h' (POSIX.1): *note Signal Sets::. |
| |
| 'int SIGALRM' |
| |
| 'signal.h' (POSIX.1): *note Alarm Signals::. |
| |
| 'int sigaltstack (const stack_t *restrict STACK, stack_t *restrict OLDSTACK)' |
| |
| 'signal.h' (XPG): *note Signal Stack::. |
| |
| 'sig_atomic_t' |
| |
| 'signal.h' (ISO): *note Atomic Types::. |
| |
| 'int sigblock (int MASK)' |
| |
| 'signal.h' (BSD): *note BSD Signal Handling::. |
| |
| 'SIG_BLOCK' |
| |
| 'signal.h' (POSIX.1): *note Process Signal Mask::. |
| |
| 'int SIGBUS' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'int SIGCHLD' |
| |
| 'signal.h' (POSIX.1): *note Job Control Signals::. |
| |
| 'int SIGCLD' |
| |
| 'signal.h' (SVID): *note Job Control Signals::. |
| |
| 'int SIGCONT' |
| |
| 'signal.h' (POSIX.1): *note Job Control Signals::. |
| |
| 'int sigdelset (sigset_t *SET, int SIGNUM)' |
| |
| 'signal.h' (POSIX.1): *note Signal Sets::. |
| |
| 'int sigemptyset (sigset_t *SET)' |
| |
| 'signal.h' (POSIX.1): *note Signal Sets::. |
| |
| 'int SIGEMT' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'sighandler_t SIG_ERR' |
| |
| 'signal.h' (ISO): *note Basic Signal Handling::. |
| |
| 'int sigfillset (sigset_t *SET)' |
| |
| 'signal.h' (POSIX.1): *note Signal Sets::. |
| |
| 'int SIGFPE' |
| |
| 'signal.h' (ISO): *note Program Error Signals::. |
| |
| 'sighandler_t' |
| |
| 'signal.h' (GNU): *note Basic Signal Handling::. |
| |
| 'int SIGHUP' |
| |
| 'signal.h' (POSIX.1): *note Termination Signals::. |
| |
| 'int SIGILL' |
| |
| 'signal.h' (ISO): *note Program Error Signals::. |
| |
| 'int SIGINFO' |
| |
| 'signal.h' (BSD): *note Miscellaneous Signals::. |
| |
| 'int SIGINT' |
| |
| 'signal.h' (ISO): *note Termination Signals::. |
| |
| 'int siginterrupt (int SIGNUM, int FAILFLAG)' |
| |
| 'signal.h' (XPG): *note BSD Signal Handling::. |
| |
| 'int SIGIO' |
| |
| 'signal.h' (BSD): *note Asynchronous I/O Signals::. |
| |
| 'int SIGIOT' |
| |
| 'signal.h' (Unix): *note Program Error Signals::. |
| |
| 'int sigismember (const sigset_t *SET, int SIGNUM)' |
| |
| 'signal.h' (POSIX.1): *note Signal Sets::. |
| |
| 'sigjmp_buf' |
| |
| 'setjmp.h' (POSIX.1): *note Non-Local Exits and Signals::. |
| |
| 'int SIGKILL' |
| |
| 'signal.h' (POSIX.1): *note Termination Signals::. |
| |
| 'void siglongjmp (sigjmp_buf STATE, int VALUE)' |
| |
| 'setjmp.h' (POSIX.1): *note Non-Local Exits and Signals::. |
| |
| 'int SIGLOST' |
| |
| 'signal.h' (GNU): *note Operation Error Signals::. |
| |
| 'int sigmask (int SIGNUM)' |
| |
| 'signal.h' (BSD): *note BSD Signal Handling::. |
| |
| 'sighandler_t signal (int SIGNUM, sighandler_t ACTION)' |
| |
| 'signal.h' (ISO): *note Basic Signal Handling::. |
| |
| 'int signbit (_float-type_ X)' |
| |
| 'math.h' (ISO): *note FP Bit Twiddling::. |
| |
| 'double significand (double X)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'float significandf (float X)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'long double significandl (long double X)' |
| |
| 'math.h' (BSD): *note Normalization Functions::. |
| |
| 'int sigpause (int MASK)' |
| |
| 'signal.h' (BSD): *note BSD Signal Handling::. |
| |
| 'int sigpending (sigset_t *SET)' |
| |
| 'signal.h' (POSIX.1): *note Checking for Pending Signals::. |
| |
| 'int SIGPIPE' |
| |
| 'signal.h' (POSIX.1): *note Operation Error Signals::. |
| |
| 'int SIGPOLL' |
| |
| 'signal.h' (SVID): *note Asynchronous I/O Signals::. |
| |
| 'int sigprocmask (int HOW, const sigset_t *restrict SET, sigset_t *restrict OLDSET)' |
| |
| 'signal.h' (POSIX.1): *note Process Signal Mask::. |
| |
| 'int SIGPROF' |
| |
| 'signal.h' (BSD): *note Alarm Signals::. |
| |
| 'int SIGQUIT' |
| |
| 'signal.h' (POSIX.1): *note Termination Signals::. |
| |
| 'int SIGSEGV' |
| |
| 'signal.h' (ISO): *note Program Error Signals::. |
| |
| 'int sigsetjmp (sigjmp_buf STATE, int SAVESIGS)' |
| |
| 'setjmp.h' (POSIX.1): *note Non-Local Exits and Signals::. |
| |
| 'int sigsetmask (int MASK)' |
| |
| 'signal.h' (BSD): *note BSD Signal Handling::. |
| |
| 'SIG_SETMASK' |
| |
| 'signal.h' (POSIX.1): *note Process Signal Mask::. |
| |
| 'sigset_t' |
| |
| 'signal.h' (POSIX.1): *note Signal Sets::. |
| |
| 'int sigstack (struct sigstack *STACK, struct sigstack *OLDSTACK)' |
| |
| 'signal.h' (BSD): *note Signal Stack::. |
| |
| 'int SIGSTOP' |
| |
| 'signal.h' (POSIX.1): *note Job Control Signals::. |
| |
| 'int sigsuspend (const sigset_t *SET)' |
| |
| 'signal.h' (POSIX.1): *note Sigsuspend::. |
| |
| 'int SIGSYS' |
| |
| 'signal.h' (Unix): *note Program Error Signals::. |
| |
| 'int SIGTERM' |
| |
| 'signal.h' (ISO): *note Termination Signals::. |
| |
| 'int SIGTRAP' |
| |
| 'signal.h' (BSD): *note Program Error Signals::. |
| |
| 'int SIGTSTP' |
| |
| 'signal.h' (POSIX.1): *note Job Control Signals::. |
| |
| 'int SIGTTIN' |
| |
| 'signal.h' (POSIX.1): *note Job Control Signals::. |
| |
| 'int SIGTTOU' |
| |
| 'signal.h' (POSIX.1): *note Job Control Signals::. |
| |
| 'SIG_UNBLOCK' |
| |
| 'signal.h' (POSIX.1): *note Process Signal Mask::. |
| |
| 'int SIGURG' |
| |
| 'signal.h' (BSD): *note Asynchronous I/O Signals::. |
| |
| 'int SIGUSR1' |
| |
| 'signal.h' (POSIX.1): *note Miscellaneous Signals::. |
| |
| 'int SIGUSR2' |
| |
| 'signal.h' (POSIX.1): *note Miscellaneous Signals::. |
| |
| 'int SIGVTALRM' |
| |
| 'signal.h' (BSD): *note Alarm Signals::. |
| |
| 'int SIGWINCH' |
| |
| 'signal.h' (BSD): *note Miscellaneous Signals::. |
| |
| 'int SIGXCPU' |
| |
| 'signal.h' (BSD): *note Operation Error Signals::. |
| |
| 'int SIGXFSZ' |
| |
| 'signal.h' (BSD): *note Operation Error Signals::. |
| |
| 'double sin (double X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'void sincos (double X, double *SINX, double *COSX)' |
| |
| 'math.h' (GNU): *note Trig Functions::. |
| |
| 'void sincosf (float X, float *SINX, float *COSX)' |
| |
| 'math.h' (GNU): *note Trig Functions::. |
| |
| 'void sincosl (long double X, long double *SINX, long double *COSX)' |
| |
| 'math.h' (GNU): *note Trig Functions::. |
| |
| 'float sinf (float X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'double sinh (double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'float sinhf (float X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double sinhl (long double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double sinl (long double X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'S_IREAD' |
| |
| 'sys/stat.h' (BSD): *note Permission Bits::. |
| |
| 'S_IRGRP' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IROTH' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IRUSR' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IRWXG' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IRWXO' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IRWXU' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'int S_ISBLK (mode_t M)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int S_ISCHR (mode_t M)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int S_ISDIR (mode_t M)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int S_ISFIFO (mode_t M)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'S_ISGID' |
| |
| 'sys/stat.h' (POSIX): *note Permission Bits::. |
| |
| 'int S_ISLNK (mode_t M)' |
| |
| 'sys/stat.h' (GNU): *note Testing File Type::. |
| |
| 'int S_ISREG (mode_t M)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int S_ISSOCK (mode_t M)' |
| |
| 'sys/stat.h' (GNU): *note Testing File Type::. |
| |
| 'S_ISUID' |
| |
| 'sys/stat.h' (POSIX): *note Permission Bits::. |
| |
| 'S_ISVTX' |
| |
| 'sys/stat.h' (BSD): *note Permission Bits::. |
| |
| 'S_IWGRP' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IWOTH' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IWRITE' |
| |
| 'sys/stat.h' (BSD): *note Permission Bits::. |
| |
| 'S_IWUSR' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IXGRP' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IXOTH' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'S_IXUSR' |
| |
| 'sys/stat.h' (POSIX.1): *note Permission Bits::. |
| |
| 'size_t' |
| |
| 'stddef.h' (ISO): *note Important Data Types::. |
| |
| 'unsigned int sleep (unsigned int SECONDS)' |
| |
| 'unistd.h' (POSIX.1): *note Sleeping::. |
| |
| 'int snprintf (char *S, size_t SIZE, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (GNU): *note Formatted Output Functions::. |
| |
| 'SO_BROADCAST' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'int SOCK_DGRAM' |
| |
| 'sys/socket.h' (BSD): *note Communication Styles::. |
| |
| 'int socket (int NAMESPACE, int STYLE, int PROTOCOL)' |
| |
| 'sys/socket.h' (BSD): *note Creating a Socket::. |
| |
| 'int socketpair (int NAMESPACE, int STYLE, int PROTOCOL, int FILEDES[2])' |
| |
| 'sys/socket.h' (BSD): *note Socket Pairs::. |
| |
| 'int SOCK_RAW' |
| |
| 'sys/socket.h' (BSD): *note Communication Styles::. |
| |
| 'int SOCK_RDM' |
| |
| 'sys/socket.h' (BSD): *note Communication Styles::. |
| |
| 'int SOCK_SEQPACKET' |
| |
| 'sys/socket.h' (BSD): *note Communication Styles::. |
| |
| 'int SOCK_STREAM' |
| |
| 'sys/socket.h' (BSD): *note Communication Styles::. |
| |
| 'SO_DEBUG' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_DONTROUTE' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_ERROR' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_KEEPALIVE' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_LINGER' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'int SOL_SOCKET' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_OOBINLINE' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_RCVBUF' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_REUSEADDR' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_SNDBUF' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'SO_STYLE' |
| |
| 'sys/socket.h' (GNU): *note Socket-Level Options::. |
| |
| 'SO_TYPE' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'speed_t' |
| |
| 'termios.h' (POSIX.1): *note Line Speed::. |
| |
| 'int sprintf (char *S, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (ISO): *note Formatted Output Functions::. |
| |
| 'double sqrt (double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'float sqrtf (float X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'long double sqrtl (long double X)' |
| |
| 'math.h' (ISO): *note Exponents and Logarithms::. |
| |
| 'void srand (unsigned int SEED)' |
| |
| 'stdlib.h' (ISO): *note ISO Random::. |
| |
| 'void srand48 (long int SEEDVAL)' |
| |
| 'stdlib.h' (SVID): *note SVID Random::. |
| |
| 'int srand48_r (long int SEEDVAL, struct drand48_data *BUFFER)' |
| |
| 'stdlib.h' (GNU): *note SVID Random::. |
| |
| 'void srandom (unsigned int SEED)' |
| |
| 'stdlib.h' (BSD): *note BSD Random::. |
| |
| 'int srandom_r (unsigned int SEED, struct random_data *BUF)' |
| |
| 'stdlib.h' (GNU): *note BSD Random::. |
| |
| 'int sscanf (const char *S, const char *TEMPLATE, ...)' |
| |
| 'stdio.h' (ISO): *note Formatted Input Functions::. |
| |
| 'sighandler_t ssignal (int SIGNUM, sighandler_t ACTION)' |
| |
| 'signal.h' (SVID): *note Basic Signal Handling::. |
| |
| 'ssize_t SSIZE_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'ssize_t' |
| |
| 'unistd.h' (POSIX.1): *note I/O Primitives::. |
| |
| 'stack_t' |
| |
| 'signal.h' (XPG): *note Signal Stack::. |
| |
| 'int stat (const char *FILENAME, struct stat *BUF)' |
| |
| 'sys/stat.h' (POSIX.1): *note Reading Attributes::. |
| |
| 'int stat64 (const char *FILENAME, struct stat64 *BUF)' |
| |
| 'sys/stat.h' (Unix98): *note Reading Attributes::. |
| |
| 'FILE * stderr' |
| |
| 'stdio.h' (ISO): *note Standard Streams::. |
| |
| 'STDERR_FILENO' |
| |
| 'unistd.h' (POSIX.1): *note Descriptors and Streams::. |
| |
| 'FILE * stdin' |
| |
| 'stdio.h' (ISO): *note Standard Streams::. |
| |
| 'STDIN_FILENO' |
| |
| 'unistd.h' (POSIX.1): *note Descriptors and Streams::. |
| |
| 'FILE * stdout' |
| |
| 'stdio.h' (ISO): *note Standard Streams::. |
| |
| 'STDOUT_FILENO' |
| |
| 'unistd.h' (POSIX.1): *note Descriptors and Streams::. |
| |
| 'int stime (const time_t *NEWTIME)' |
| |
| 'time.h' (SVID, XPG): *note Simple Calendar Time::. |
| |
| 'char * stpcpy (char *restrict TO, const char *restrict FROM)' |
| |
| 'string.h' (Unknown origin): *note Copying and Concatenation::. |
| |
| 'char * stpncpy (char *restrict TO, const char *restrict FROM, size_t SIZE)' |
| |
| 'string.h' (GNU): *note Copying and Concatenation::. |
| |
| 'int strcasecmp (const char *S1, const char *S2)' |
| |
| 'string.h' (BSD): *note String/Array Comparison::. |
| |
| 'char * strcasestr (const char *HAYSTACK, const char *NEEDLE)' |
| |
| 'string.h' (GNU): *note Search Functions::. |
| |
| 'char * strcat (char *restrict TO, const char *restrict FROM)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'char * strchr (const char *STRING, int C)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'char * strchrnul (const char *STRING, int C)' |
| |
| 'string.h' (GNU): *note Search Functions::. |
| |
| 'int strcmp (const char *S1, const char *S2)' |
| |
| 'string.h' (ISO): *note String/Array Comparison::. |
| |
| 'int strcoll (const char *S1, const char *S2)' |
| |
| 'string.h' (ISO): *note Collation Functions::. |
| |
| 'char * strcpy (char *restrict TO, const char *restrict FROM)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'size_t strcspn (const char *STRING, const char *STOPSET)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'char * strdup (const char *S)' |
| |
| 'string.h' (SVID): *note Copying and Concatenation::. |
| |
| 'char * strdupa (const char *S)' |
| |
| 'string.h' (GNU): *note Copying and Concatenation::. |
| |
| 'int STREAM_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'char * strerror (int ERRNUM)' |
| |
| 'string.h' (ISO): *note Error Messages::. |
| |
| 'char * strerror_r (int ERRNUM, char *BUF, size_t N)' |
| |
| 'string.h' (GNU): *note Error Messages::. |
| |
| 'char * strfry (char *STRING)' |
| |
| 'string.h' (GNU): *note strfry::. |
| |
| 'size_t strftime (char *S, size_t SIZE, const char *TEMPLATE, const struct tm *BROKENTIME)' |
| |
| 'time.h' (ISO): *note Formatting Calendar Time::. |
| |
| 'size_t strlen (const char *S)' |
| |
| 'string.h' (ISO): *note String Length::. |
| |
| 'int strncasecmp (const char *S1, const char *S2, size_t N)' |
| |
| 'string.h' (BSD): *note String/Array Comparison::. |
| |
| 'char * strncat (char *restrict TO, const char *restrict FROM, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'int strncmp (const char *S1, const char *S2, size_t SIZE)' |
| |
| 'string.h' (ISO): *note String/Array Comparison::. |
| |
| 'char * strncpy (char *restrict TO, const char *restrict FROM, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Copying and Concatenation::. |
| |
| 'char * strndup (const char *S, size_t SIZE)' |
| |
| 'string.h' (GNU): *note Copying and Concatenation::. |
| |
| 'char * strndupa (const char *S, size_t SIZE)' |
| |
| 'string.h' (GNU): *note Copying and Concatenation::. |
| |
| 'size_t strnlen (const char *S, size_t MAXLEN)' |
| |
| 'string.h' (GNU): *note String Length::. |
| |
| 'char * strpbrk (const char *STRING, const char *STOPSET)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'char * strptime (const char *S, const char *FMT, struct tm *TP)' |
| |
| 'time.h' (XPG4): *note Low-Level Time String Parsing::. |
| |
| 'char * strrchr (const char *STRING, int C)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'char * strsep (char **STRING_PTR, const char *DELIMITER)' |
| |
| 'string.h' (BSD): *note Finding Tokens in a String::. |
| |
| 'char * strsignal (int SIGNUM)' |
| |
| 'string.h' (GNU): *note Signal Messages::. |
| |
| 'size_t strspn (const char *STRING, const char *SKIPSET)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'char * strstr (const char *HAYSTACK, const char *NEEDLE)' |
| |
| 'string.h' (ISO): *note Search Functions::. |
| |
| 'double strtod (const char *restrict STRING, char **restrict TAILPTR)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Floats::. |
| |
| 'float strtof (const char *STRING, char **TAILPTR)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Floats::. |
| |
| 'intmax_t strtoimax (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'inttypes.h' (ISO): *note Parsing of Integers::. |
| |
| 'char * strtok (char *restrict NEWSTRING, const char *restrict DELIMITERS)' |
| |
| 'string.h' (ISO): *note Finding Tokens in a String::. |
| |
| 'char * strtok_r (char *NEWSTRING, const char *DELIMITERS, char **SAVE_PTR)' |
| |
| 'string.h' (POSIX): *note Finding Tokens in a String::. |
| |
| 'long int strtol (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'long double strtold (const char *STRING, char **TAILPTR)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Floats::. |
| |
| 'long long int strtoll (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'long long int strtoq (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'stdlib.h' (BSD): *note Parsing of Integers::. |
| |
| 'unsigned long int strtoul (const char *retrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'unsigned long long int strtoull (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Integers::. |
| |
| 'uintmax_t strtoumax (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'inttypes.h' (ISO): *note Parsing of Integers::. |
| |
| 'unsigned long long int strtouq (const char *restrict STRING, char **restrict TAILPTR, int BASE)' |
| |
| 'stdlib.h' (BSD): *note Parsing of Integers::. |
| |
| 'struct aiocb' |
| |
| 'aio.h' (POSIX.1b): *note Asynchronous I/O::. |
| |
| 'struct aiocb64' |
| |
| 'aio.h' (POSIX.1b): *note Asynchronous I/O::. |
| |
| 'struct aioinit' |
| |
| 'aio.h' (GNU): *note Configuration of AIO::. |
| |
| 'struct argp' |
| |
| 'argp.h' (GNU): *note Argp Parsers::. |
| |
| 'struct argp_child' |
| |
| 'argp.h' (GNU): *note Argp Children::. |
| |
| 'struct argp_option' |
| |
| 'argp.h' (GNU): *note Argp Option Vectors::. |
| |
| 'struct argp_state' |
| |
| 'argp.h' (GNU): *note Argp Parsing State::. |
| |
| 'struct dirent' |
| |
| 'dirent.h' (POSIX.1): *note Directory Entries::. |
| |
| 'struct exit_status' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'struct flock' |
| |
| 'fcntl.h' (POSIX.1): *note File Locks::. |
| |
| 'struct fstab' |
| |
| 'fstab.h' (BSD): *note fstab::. |
| |
| 'struct FTW' |
| |
| 'ftw.h' (XPG4.2): *note Working with Directory Trees::. |
| |
| 'struct __gconv_step' |
| |
| 'gconv.h' (GNU): *note glibc iconv Implementation::. |
| |
| 'struct __gconv_step_data' |
| |
| 'gconv.h' (GNU): *note glibc iconv Implementation::. |
| |
| 'struct group' |
| |
| 'grp.h' (POSIX.1): *note Group Data Structure::. |
| |
| 'struct hostent' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'struct if_nameindex' |
| |
| 'net/if.h' (IPv6 basic API): *note Interface Naming::. |
| |
| 'struct in6_addr' |
| |
| 'netinet/in.h' (IPv6 basic API): *note Host Address Data Type::. |
| |
| 'struct in_addr' |
| |
| 'netinet/in.h' (BSD): *note Host Address Data Type::. |
| |
| 'struct iovec' |
| |
| 'sys/uio.h' (BSD): *note Scatter-Gather::. |
| |
| 'struct itimerval' |
| |
| 'sys/time.h' (BSD): *note Setting an Alarm::. |
| |
| 'struct lconv' |
| |
| 'locale.h' (ISO): *note The Lame Way to Locale Data::. |
| |
| 'struct linger' |
| |
| 'sys/socket.h' (BSD): *note Socket-Level Options::. |
| |
| 'struct mallinfo' |
| |
| 'malloc.h' (GNU): *note Statistics of Malloc::. |
| |
| 'struct mntent' |
| |
| 'mntent.h' (BSD): *note mtab::. |
| |
| 'struct msghdr' |
| |
| 'sys/socket.h' (BSD): *note Receiving Datagrams::. |
| |
| 'struct netent' |
| |
| 'netdb.h' (BSD): *note Networks Database::. |
| |
| 'struct obstack' |
| |
| 'obstack.h' (GNU): *note Creating Obstacks::. |
| |
| 'struct option' |
| |
| 'getopt.h' (GNU): *note Getopt Long Options::. |
| |
| 'struct passwd' |
| |
| 'pwd.h' (POSIX.1): *note User Data Structure::. |
| |
| 'struct printf_info' |
| |
| 'printf.h' (GNU): *note Conversion Specifier Options::. |
| |
| 'struct protoent' |
| |
| 'netdb.h' (BSD): *note Protocols Database::. |
| |
| 'struct random_data' |
| |
| 'stdlib.h' (GNU): *note BSD Random::. |
| |
| 'struct rlimit' |
| |
| 'sys/resource.h' (BSD): *note Limits on Resources::. |
| |
| 'struct rlimit64' |
| |
| 'sys/resource.h' (Unix98): *note Limits on Resources::. |
| |
| 'struct rusage' |
| |
| 'sys/resource.h' (BSD): *note Resource Usage::. |
| |
| 'struct sched_param' |
| |
| 'sched.h' (POSIX): *note Basic Scheduling Functions::. |
| |
| 'struct servent' |
| |
| 'netdb.h' (BSD): *note Services Database::. |
| |
| 'struct sgttyb' |
| |
| 'termios.h' (BSD): *note BSD Terminal Modes::. |
| |
| 'struct sigaction' |
| |
| 'signal.h' (POSIX.1): *note Advanced Signal Handling::. |
| |
| 'struct sigstack' |
| |
| 'signal.h' (BSD): *note Signal Stack::. |
| |
| 'struct sockaddr' |
| |
| 'sys/socket.h' (BSD): *note Address Formats::. |
| |
| 'struct sockaddr_in' |
| |
| 'netinet/in.h' (BSD): *note Internet Address Formats::. |
| |
| 'struct sockaddr_un' |
| |
| 'sys/un.h' (BSD): *note Local Namespace Details::. |
| |
| 'struct stat' |
| |
| 'sys/stat.h' (POSIX.1): *note Attribute Meanings::. |
| |
| 'struct stat64' |
| |
| 'sys/stat.h' (LFS): *note Attribute Meanings::. |
| |
| 'struct termios' |
| |
| 'termios.h' (POSIX.1): *note Mode Data Types::. |
| |
| 'struct timespec' |
| |
| 'sys/time.h' (POSIX.1): *note Elapsed Time::. |
| |
| 'struct timeval' |
| |
| 'sys/time.h' (BSD): *note Elapsed Time::. |
| |
| 'struct timezone' |
| |
| 'sys/time.h' (BSD): *note High-Resolution Calendar::. |
| |
| 'struct tm' |
| |
| 'time.h' (ISO): *note Broken-down Time::. |
| |
| 'struct tms' |
| |
| 'sys/times.h' (POSIX.1): *note Processor Time::. |
| |
| 'struct utimbuf' |
| |
| 'utime.h' (POSIX.1): *note File Times::. |
| |
| 'struct utsname' |
| |
| 'sys/utsname.h' (POSIX.1): *note Platform Type::. |
| |
| 'int strverscmp (const char *S1, const char *S2)' |
| |
| 'string.h' (GNU): *note String/Array Comparison::. |
| |
| 'size_t strxfrm (char *restrict TO, const char *restrict FROM, size_t SIZE)' |
| |
| 'string.h' (ISO): *note Collation Functions::. |
| |
| 'int stty (int FILEDES, const struct sgttyb *ATTRIBUTES)' |
| |
| 'sgtty.h' (BSD): *note BSD Terminal Modes::. |
| |
| 'int S_TYPEISMQ (struct stat *S)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int S_TYPEISSEM (struct stat *S)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int S_TYPEISSHM (struct stat *S)' |
| |
| 'sys/stat.h' (POSIX): *note Testing File Type::. |
| |
| 'int SUN_LEN (_struct sockaddr_un *_ PTR)' |
| |
| 'sys/un.h' (BSD): *note Local Namespace Details::. |
| |
| 'int swapcontext (ucontext_t *restrict OUCP, const ucontext_t *restrict UCP)' |
| |
| 'ucontext.h' (SVID): *note System V contexts::. |
| |
| 'int swprintf (wchar_t *S, size_t SIZE, const wchar_t *TEMPLATE, ...)' |
| |
| 'wchar.h' (GNU): *note Formatted Output Functions::. |
| |
| 'int swscanf (const wchar_t *WS, const wchar_t *TEMPLATE, ...)' |
| |
| 'wchar.h' (ISO): *note Formatted Input Functions::. |
| |
| 'int symlink (const char *OLDNAME, const char *NEWNAME)' |
| |
| 'unistd.h' (BSD): *note Symbolic Links::. |
| |
| 'SYMLINK_MAX' |
| |
| 'limits.h' (POSIX.1): *note File Minimums::. |
| |
| 'void sync (void)' |
| |
| 'unistd.h' (X/Open): *note Synchronizing I/O::. |
| |
| 'long int syscall (long int SYSNO, ...)' |
| |
| 'unistd.h' (???): *note System Calls::. |
| |
| 'long int sysconf (int PARAMETER)' |
| |
| 'unistd.h' (POSIX.1): *note Sysconf Definition::. |
| |
| 'int sysctl (int *NAMES, int NLEN, void *OLDVAL, size_t *OLDLENP, void *NEWVAL, size_t NEWLEN)' |
| |
| 'sys/sysctl.h' (BSD): *note System Parameters::. |
| |
| 'void syslog (int FACILITY_PRIORITY, const char *FORMAT, ...)' |
| |
| 'syslog.h' (BSD): *note syslog; vsyslog::. |
| |
| 'int system (const char *COMMAND)' |
| |
| 'stdlib.h' (ISO): *note Running a Command::. |
| |
| 'sighandler_t sysv_signal (int SIGNUM, sighandler_t ACTION)' |
| |
| 'signal.h' (GNU): *note Basic Signal Handling::. |
| |
| 'double tan (double X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'float tanf (float X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'double tanh (double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'float tanhf (float X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double tanhl (long double X)' |
| |
| 'math.h' (ISO): *note Hyperbolic Functions::. |
| |
| 'long double tanl (long double X)' |
| |
| 'math.h' (ISO): *note Trig Functions::. |
| |
| 'int tcdrain (int FILEDES)' |
| |
| 'termios.h' (POSIX.1): *note Line Control::. |
| |
| 'tcflag_t' |
| |
| 'termios.h' (POSIX.1): *note Mode Data Types::. |
| |
| 'int tcflow (int FILEDES, int ACTION)' |
| |
| 'termios.h' (POSIX.1): *note Line Control::. |
| |
| 'int tcflush (int FILEDES, int QUEUE)' |
| |
| 'termios.h' (POSIX.1): *note Line Control::. |
| |
| 'int tcgetattr (int FILEDES, struct termios *TERMIOS-P)' |
| |
| 'termios.h' (POSIX.1): *note Mode Functions::. |
| |
| 'pid_t tcgetpgrp (int FILEDES)' |
| |
| 'unistd.h' (POSIX.1): *note Terminal Access Functions::. |
| |
| 'pid_t tcgetsid (int FILDES)' |
| |
| 'termios.h' (Unix98): *note Terminal Access Functions::. |
| |
| 'TCSADRAIN' |
| |
| 'termios.h' (POSIX.1): *note Mode Functions::. |
| |
| 'TCSAFLUSH' |
| |
| 'termios.h' (POSIX.1): *note Mode Functions::. |
| |
| 'TCSANOW' |
| |
| 'termios.h' (POSIX.1): *note Mode Functions::. |
| |
| 'TCSASOFT' |
| |
| 'termios.h' (BSD): *note Mode Functions::. |
| |
| 'int tcsendbreak (int FILEDES, int DURATION)' |
| |
| 'termios.h' (POSIX.1): *note Line Control::. |
| |
| 'int tcsetattr (int FILEDES, int WHEN, const struct termios *TERMIOS-P)' |
| |
| 'termios.h' (POSIX.1): *note Mode Functions::. |
| |
| 'int tcsetpgrp (int FILEDES, pid_t PGID)' |
| |
| 'unistd.h' (POSIX.1): *note Terminal Access Functions::. |
| |
| 'void * tdelete (const void *KEY, void **ROOTP, comparison_fn_t COMPAR)' |
| |
| 'search.h' (SVID): *note Tree Search Function::. |
| |
| 'void tdestroy (void *VROOT, __free_fn_t FREEFCT)' |
| |
| 'search.h' (GNU): *note Tree Search Function::. |
| |
| 'long int telldir (DIR *DIRSTREAM)' |
| |
| 'dirent.h' (BSD): *note Random Access Directory::. |
| |
| 'TEMP_FAILURE_RETRY (EXPRESSION)' |
| |
| 'unistd.h' (GNU): *note Interrupted Primitives::. |
| |
| 'char * tempnam (const char *DIR, const char *PREFIX)' |
| |
| 'stdio.h' (SVID): *note Temporary Files::. |
| |
| 'char * textdomain (const char *DOMAINNAME)' |
| |
| 'libintl.h' (GNU): *note Locating gettext catalog::. |
| |
| 'void * tfind (const void *KEY, void *const *ROOTP, comparison_fn_t COMPAR)' |
| |
| 'search.h' (SVID): *note Tree Search Function::. |
| |
| 'double tgamma (double X)' |
| |
| 'math.h' (XPG, ISO): *note Special Functions::. |
| |
| 'float tgammaf (float X)' |
| |
| 'math.h' (XPG, ISO): *note Special Functions::. |
| |
| 'long double tgammal (long double X)' |
| |
| 'math.h' (XPG, ISO): *note Special Functions::. |
| |
| 'time_t time (time_t *RESULT)' |
| |
| 'time.h' (ISO): *note Simple Calendar Time::. |
| |
| 'time_t timegm (struct tm *BROKENTIME)' |
| |
| 'time.h' (???): *note Broken-down Time::. |
| |
| 'time_t timelocal (struct tm *BROKENTIME)' |
| |
| 'time.h' (???): *note Broken-down Time::. |
| |
| 'clock_t times (struct tms *BUFFER)' |
| |
| 'sys/times.h' (POSIX.1): *note Processor Time::. |
| |
| 'time_t' |
| |
| 'time.h' (ISO): *note Simple Calendar Time::. |
| |
| 'long int timezone' |
| |
| 'time.h' (SVID): *note Time Zone Functions::. |
| |
| 'FILE * tmpfile (void)' |
| |
| 'stdio.h' (ISO): *note Temporary Files::. |
| |
| 'FILE * tmpfile64 (void)' |
| |
| 'stdio.h' (Unix98): *note Temporary Files::. |
| |
| 'int TMP_MAX' |
| |
| 'stdio.h' (ISO): *note Temporary Files::. |
| |
| 'char * tmpnam (char *RESULT)' |
| |
| 'stdio.h' (ISO): *note Temporary Files::. |
| |
| 'char * tmpnam_r (char *RESULT)' |
| |
| 'stdio.h' (GNU): *note Temporary Files::. |
| |
| 'int toascii (int C)' |
| |
| 'ctype.h' (SVID, BSD): *note Case Conversion::. |
| |
| 'int tolower (int C)' |
| |
| 'ctype.h' (ISO): *note Case Conversion::. |
| |
| 'int _tolower (int C)' |
| |
| 'ctype.h' (SVID): *note Case Conversion::. |
| |
| 'tcflag_t TOSTOP' |
| |
| 'termios.h' (POSIX.1): *note Local Modes::. |
| |
| 'int toupper (int C)' |
| |
| 'ctype.h' (ISO): *note Case Conversion::. |
| |
| 'int _toupper (int C)' |
| |
| 'ctype.h' (SVID): *note Case Conversion::. |
| |
| 'wint_t towctrans (wint_t WC, wctrans_t DESC)' |
| |
| 'wctype.h' (ISO): *note Wide Character Case Conversion::. |
| |
| 'wint_t towlower (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Wide Character Case Conversion::. |
| |
| 'wint_t towupper (wint_t WC)' |
| |
| 'wctype.h' (ISO): *note Wide Character Case Conversion::. |
| |
| 'double trunc (double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'int truncate (const char *FILENAME, off_t LENGTH)' |
| |
| 'unistd.h' (X/Open): *note File Size::. |
| |
| 'int truncate64 (const char *NAME, off64_t LENGTH)' |
| |
| 'unistd.h' (Unix98): *note File Size::. |
| |
| 'float truncf (float X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'long double truncl (long double X)' |
| |
| 'math.h' (ISO): *note Rounding Functions::. |
| |
| 'TRY_AGAIN' |
| |
| 'netdb.h' (BSD): *note Host Names::. |
| |
| 'void * tsearch (const void *KEY, void **ROOTP, comparison_fn_t COMPAR)' |
| |
| 'search.h' (SVID): *note Tree Search Function::. |
| |
| 'char * ttyname (int FILEDES)' |
| |
| 'unistd.h' (POSIX.1): *note Is It a Terminal::. |
| |
| 'int ttyname_r (int FILEDES, char *BUF, size_t LEN)' |
| |
| 'unistd.h' (POSIX.1): *note Is It a Terminal::. |
| |
| 'void twalk (const void *ROOT, __action_fn_t ACTION)' |
| |
| 'search.h' (SVID): *note Tree Search Function::. |
| |
| 'char * tzname [2]' |
| |
| 'time.h' (POSIX.1): *note Time Zone Functions::. |
| |
| 'int TZNAME_MAX' |
| |
| 'limits.h' (POSIX.1): *note General Limits::. |
| |
| 'void tzset (void)' |
| |
| 'time.h' (POSIX.1): *note Time Zone Functions::. |
| |
| 'UCHAR_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'ucontext_t' |
| |
| 'ucontext.h' (SVID): *note System V contexts::. |
| |
| 'uid_t' |
| |
| 'sys/types.h' (POSIX.1): *note Reading Persona::. |
| |
| 'UINT_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'long int ulimit (int CMD, ...)' |
| |
| 'ulimit.h' (BSD): *note Limits on Resources::. |
| |
| 'ULLONG_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'ULONG_LONG_MAX' |
| |
| 'limits.h' (GNU): *note Range of Type::. |
| |
| 'ULONG_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'mode_t umask (mode_t MASK)' |
| |
| 'sys/stat.h' (POSIX.1): *note Setting Permissions::. |
| |
| 'int umount (const char *FILE)' |
| |
| 'sys/mount.h' (SVID, GNU): *note Mount-Unmount-Remount::. |
| |
| 'int umount2 (const char *FILE, int FLAGS)' |
| |
| 'sys/mount.h' (GNU): *note Mount-Unmount-Remount::. |
| |
| 'int uname (struct utsname *INFO)' |
| |
| 'sys/utsname.h' (POSIX.1): *note Platform Type::. |
| |
| 'int ungetc (int C, FILE *STREAM)' |
| |
| 'stdio.h' (ISO): *note How Unread::. |
| |
| 'wint_t ungetwc (wint_t WC, FILE *STREAM)' |
| |
| 'wchar.h' (ISO): *note How Unread::. |
| |
| 'union wait' |
| |
| 'sys/wait.h' (BSD): *note BSD Wait Functions::. |
| |
| 'int unlink (const char *FILENAME)' |
| |
| 'unistd.h' (POSIX.1): *note Deleting Files::. |
| |
| 'int unlockpt (int FILEDES)' |
| |
| 'stdlib.h' (SVID, XPG4.2): *note Allocation::. |
| |
| 'int unsetenv (const char *NAME)' |
| |
| 'stdlib.h' (BSD): *note Environment Access::. |
| |
| 'void updwtmp (const char *WTMP_FILE, const struct utmp *UTMP)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'USER_PROCESS' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'USER_PROCESS' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'USHRT_MAX' |
| |
| 'limits.h' (ISO): *note Range of Type::. |
| |
| 'int utime (const char *FILENAME, const struct utimbuf *TIMES)' |
| |
| 'utime.h' (POSIX.1): *note File Times::. |
| |
| 'int utimes (const char *FILENAME, const struct timeval TVP[2])' |
| |
| 'sys/time.h' (BSD): *note File Times::. |
| |
| 'int utmpname (const char *FILE)' |
| |
| 'utmp.h' (SVID): *note Manipulating the Database::. |
| |
| 'int utmpxname (const char *FILE)' |
| |
| 'utmpx.h' (XPG4.2): *note XPG Functions::. |
| |
| 'TYPE va_arg (va_list AP, TYPE)' |
| |
| 'stdarg.h' (ISO): *note Argument Macros::. |
| |
| 'void va_copy (va_list DEST, va_list SRC)' |
| |
| 'stdarg.h' (ISO): *note Argument Macros::. |
| |
| 'void va_end (va_list AP)' |
| |
| 'stdarg.h' (ISO): *note Argument Macros::. |
| |
| 'va_list' |
| |
| 'stdarg.h' (ISO): *note Argument Macros::. |
| |
| 'void * valloc (size_t SIZE)' |
| |
| 'malloc.h', 'stdlib.h' (BSD): *note Aligned Memory Blocks::. |
| |
| 'int vasprintf (char **PTR, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (GNU): *note Variable Arguments Output::. |
| |
| 'void va_start (va_list AP, LAST-REQUIRED)' |
| |
| 'stdarg.h' (ISO): *note Argument Macros::. |
| |
| 'int VDISCARD' |
| |
| 'termios.h' (BSD): *note Other Special::. |
| |
| 'int VDSUSP' |
| |
| 'termios.h' (BSD): *note Signal Characters::. |
| |
| 'int VEOF' |
| |
| 'termios.h' (POSIX.1): *note Editing Characters::. |
| |
| 'int VEOL' |
| |
| 'termios.h' (POSIX.1): *note Editing Characters::. |
| |
| 'int VEOL2' |
| |
| 'termios.h' (BSD): *note Editing Characters::. |
| |
| 'int VERASE' |
| |
| 'termios.h' (POSIX.1): *note Editing Characters::. |
| |
| 'void verr (int STATUS, const char *FORMAT, va_list AP)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'void verrx (int STATUS, const char *FORMAT, va_list AP)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'int versionsort (const struct dirent **A, const struct dirent **B)' |
| |
| 'dirent.h' (GNU): *note Scanning Directory Content::. |
| |
| 'int versionsort64 (const struct dirent64 **A, const struct dirent64 **B)' |
| |
| 'dirent.h' (GNU): *note Scanning Directory Content::. |
| |
| 'pid_t vfork (void)' |
| |
| 'unistd.h' (BSD): *note Creating a Process::. |
| |
| 'int vfprintf (FILE *STREAM, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (ISO): *note Variable Arguments Output::. |
| |
| 'int vfscanf (FILE *STREAM, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (ISO): *note Variable Arguments Input::. |
| |
| 'int vfwprintf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP)' |
| |
| 'wchar.h' (ISO): *note Variable Arguments Output::. |
| |
| 'int vfwscanf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP)' |
| |
| 'wchar.h' (ISO): *note Variable Arguments Input::. |
| |
| 'int VINTR' |
| |
| 'termios.h' (POSIX.1): *note Signal Characters::. |
| |
| 'int VKILL' |
| |
| 'termios.h' (POSIX.1): *note Editing Characters::. |
| |
| 'int vlimit (int RESOURCE, int LIMIT)' |
| |
| 'sys/vlimit.h' (BSD): *note Limits on Resources::. |
| |
| 'int VLNEXT' |
| |
| 'termios.h' (BSD): *note Other Special::. |
| |
| 'int VMIN' |
| |
| 'termios.h' (POSIX.1): *note Noncanonical Input::. |
| |
| 'void (*error_print_progname) (void)' |
| |
| 'error.h' (GNU): *note Error Messages::. |
| |
| 'int vprintf (const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (ISO): *note Variable Arguments Output::. |
| |
| 'int VQUIT' |
| |
| 'termios.h' (POSIX.1): *note Signal Characters::. |
| |
| 'int VREPRINT' |
| |
| 'termios.h' (BSD): *note Editing Characters::. |
| |
| 'int vscanf (const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (ISO): *note Variable Arguments Input::. |
| |
| 'int vsnprintf (char *S, size_t SIZE, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (GNU): *note Variable Arguments Output::. |
| |
| 'int vsprintf (char *S, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (ISO): *note Variable Arguments Output::. |
| |
| 'int vsscanf (const char *S, const char *TEMPLATE, va_list AP)' |
| |
| 'stdio.h' (ISO): *note Variable Arguments Input::. |
| |
| 'int VSTART' |
| |
| 'termios.h' (POSIX.1): *note Start/Stop Characters::. |
| |
| 'int VSTATUS' |
| |
| 'termios.h' (BSD): *note Other Special::. |
| |
| 'int VSTOP' |
| |
| 'termios.h' (POSIX.1): *note Start/Stop Characters::. |
| |
| 'int VSUSP' |
| |
| 'termios.h' (POSIX.1): *note Signal Characters::. |
| |
| 'int vswprintf (wchar_t *S, size_t SIZE, const wchar_t *TEMPLATE, va_list AP)' |
| |
| 'wchar.h' (GNU): *note Variable Arguments Output::. |
| |
| 'int vswscanf (const wchar_t *S, const wchar_t *TEMPLATE, va_list AP)' |
| |
| 'wchar.h' (ISO): *note Variable Arguments Input::. |
| |
| 'void vsyslog (int FACILITY_PRIORITY, const char *FORMAT, va_list ARGLIST)' |
| |
| 'syslog.h' (BSD): *note syslog; vsyslog::. |
| |
| 'int VTIME' |
| |
| 'termios.h' (POSIX.1): *note Noncanonical Input::. |
| |
| 'int vtimes (struct vtimes *CURRENT, struct vtimes *CHILD)' |
| |
| 'sys/vtimes.h' (sys/vtimes.h): *note Resource Usage::. |
| |
| 'void vwarn (const char *FORMAT, va_list AP)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'void vwarnx (const char *FORMAT, va_list AP)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'int VWERASE' |
| |
| 'termios.h' (BSD): *note Editing Characters::. |
| |
| 'int vwprintf (const wchar_t *TEMPLATE, va_list AP)' |
| |
| 'wchar.h' (ISO): *note Variable Arguments Output::. |
| |
| 'int vwscanf (const wchar_t *TEMPLATE, va_list AP)' |
| |
| 'wchar.h' (ISO): *note Variable Arguments Input::. |
| |
| 'pid_t wait (int *STATUS-PTR)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion::. |
| |
| 'pid_t wait3 (union wait *STATUS-PTR, int OPTIONS, struct rusage *USAGE)' |
| |
| 'sys/wait.h' (BSD): *note BSD Wait Functions::. |
| |
| 'pid_t wait4 (pid_t PID, int *STATUS-PTR, int OPTIONS, struct rusage *USAGE)' |
| |
| 'sys/wait.h' (BSD): *note Process Completion::. |
| |
| 'pid_t waitpid (pid_t PID, int *STATUS-PTR, int OPTIONS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion::. |
| |
| 'void warn (const char *FORMAT, ...)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'void warnx (const char *FORMAT, ...)' |
| |
| 'err.h' (BSD): *note Error Messages::. |
| |
| 'WCHAR_MAX' |
| |
| 'limits.h' (GNU): *note Range of Type::. |
| |
| 'wint_t WCHAR_MAX' |
| |
| 'wchar.h' (ISO): *note Extended Char Intro::. |
| |
| 'wint_t WCHAR_MIN' |
| |
| 'wchar.h' (ISO): *note Extended Char Intro::. |
| |
| 'wchar_t' |
| |
| 'stddef.h' (ISO): *note Extended Char Intro::. |
| |
| 'int WCOREDUMP (int STATUS)' |
| |
| 'sys/wait.h' (BSD): *note Process Completion Status::. |
| |
| 'wchar_t * wcpcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM)' |
| |
| 'wchar.h' (GNU): *note Copying and Concatenation::. |
| |
| 'wchar_t * wcpncpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE)' |
| |
| 'wchar.h' (GNU): *note Copying and Concatenation::. |
| |
| 'size_t wcrtomb (char *restrict S, wchar_t WC, mbstate_t *restrict PS)' |
| |
| 'wchar.h' (ISO): *note Converting a Character::. |
| |
| 'int wcscasecmp (const wchar_t *WS1, const wchar_t *WS2)' |
| |
| 'wchar.h' (GNU): *note String/Array Comparison::. |
| |
| 'wchar_t * wcscat (wchar_t *restrict WTO, const wchar_t *restrict WFROM)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'wchar_t * wcschr (const wchar_t *WSTRING, int WC)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'wchar_t * wcschrnul (const wchar_t *WSTRING, wchar_t WC)' |
| |
| 'wchar.h' (GNU): *note Search Functions::. |
| |
| 'int wcscmp (const wchar_t *WS1, const wchar_t *WS2)' |
| |
| 'wchar.h' (ISO): *note String/Array Comparison::. |
| |
| 'int wcscoll (const wchar_t *WS1, const wchar_t *WS2)' |
| |
| 'wchar.h' (ISO): *note Collation Functions::. |
| |
| 'wchar_t * wcscpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'size_t wcscspn (const wchar_t *WSTRING, const wchar_t *STOPSET)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'wchar_t * wcsdup (const wchar_t *WS)' |
| |
| 'wchar.h' (GNU): *note Copying and Concatenation::. |
| |
| 'size_t wcsftime (wchar_t *S, size_t SIZE, const wchar_t *TEMPLATE, const struct tm *BROKENTIME)' |
| |
| 'time.h' (ISO/Amend1): *note Formatting Calendar Time::. |
| |
| 'size_t wcslen (const wchar_t *WS)' |
| |
| 'wchar.h' (ISO): *note String Length::. |
| |
| 'int wcsncasecmp (const wchar_t *WS1, const wchar_t *S2, size_t N)' |
| |
| 'wchar.h' (GNU): *note String/Array Comparison::. |
| |
| 'wchar_t * wcsncat (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'int wcsncmp (const wchar_t *WS1, const wchar_t *WS2, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note String/Array Comparison::. |
| |
| 'wchar_t * wcsncpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'size_t wcsnlen (const wchar_t *WS, size_t MAXLEN)' |
| |
| 'wchar.h' (GNU): *note String Length::. |
| |
| 'size_t wcsnrtombs (char *restrict DST, const wchar_t **restrict SRC, size_t NWC, size_t LEN, mbstate_t *restrict PS)' |
| |
| 'wchar.h' (GNU): *note Converting Strings::. |
| |
| 'wchar_t * wcspbrk (const wchar_t *WSTRING, const wchar_t *STOPSET)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'wchar_t * wcsrchr (const wchar_t *WSTRING, wchar_t C)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'size_t wcsrtombs (char *restrict DST, const wchar_t **restrict SRC, size_t LEN, mbstate_t *restrict PS)' |
| |
| 'wchar.h' (ISO): *note Converting Strings::. |
| |
| 'size_t wcsspn (const wchar_t *WSTRING, const wchar_t *SKIPSET)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'wchar_t * wcsstr (const wchar_t *HAYSTACK, const wchar_t *NEEDLE)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'double wcstod (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR)' |
| |
| 'wchar.h' (ISO): *note Parsing of Floats::. |
| |
| 'float wcstof (const wchar_t *STRING, wchar_t **TAILPTR)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Floats::. |
| |
| 'intmax_t wcstoimax (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (ISO): *note Parsing of Integers::. |
| |
| 'wchar_t * wcstok (wchar_t *NEWSTRING, const wchar_t *DELIMITERS, wchar_t **SAVE_PTR)' |
| |
| 'wchar.h' (ISO): *note Finding Tokens in a String::. |
| |
| 'long int wcstol (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (ISO): *note Parsing of Integers::. |
| |
| 'long double wcstold (const wchar_t *STRING, wchar_t **TAILPTR)' |
| |
| 'stdlib.h' (ISO): *note Parsing of Floats::. |
| |
| 'long long int wcstoll (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (ISO): *note Parsing of Integers::. |
| |
| 'size_t wcstombs (char *STRING, const wchar_t *WSTRING, size_t SIZE)' |
| |
| 'stdlib.h' (ISO): *note Non-reentrant String Conversion::. |
| |
| 'long long int wcstoq (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (GNU): *note Parsing of Integers::. |
| |
| 'unsigned long int wcstoul (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (ISO): *note Parsing of Integers::. |
| |
| 'unsigned long long int wcstoull (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (ISO): *note Parsing of Integers::. |
| |
| 'uintmax_t wcstoumax (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (ISO): *note Parsing of Integers::. |
| |
| 'unsigned long long int wcstouq (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE)' |
| |
| 'wchar.h' (GNU): *note Parsing of Integers::. |
| |
| 'wchar_t * wcswcs (const wchar_t *HAYSTACK, const wchar_t *NEEDLE)' |
| |
| 'wchar.h' (XPG): *note Search Functions::. |
| |
| 'size_t wcsxfrm (wchar_t *restrict WTO, const wchar_t *WFROM, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Collation Functions::. |
| |
| 'int wctob (wint_t C)' |
| |
| 'wchar.h' (ISO): *note Converting a Character::. |
| |
| 'int wctomb (char *STRING, wchar_t WCHAR)' |
| |
| 'stdlib.h' (ISO): *note Non-reentrant Character Conversion::. |
| |
| 'wctrans_t wctrans (const char *PROPERTY)' |
| |
| 'wctype.h' (ISO): *note Wide Character Case Conversion::. |
| |
| 'wctrans_t' |
| |
| 'wctype.h' (ISO): *note Wide Character Case Conversion::. |
| |
| 'wctype_t wctype (const char *PROPERTY)' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'wctype_t' |
| |
| 'wctype.h' (ISO): *note Classification of Wide Characters::. |
| |
| 'int WEOF' |
| |
| 'wchar.h' (ISO): *note EOF and Errors::. |
| |
| 'wint_t WEOF' |
| |
| 'wchar.h' (ISO): *note Extended Char Intro::. |
| |
| 'int WEXITSTATUS (int STATUS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion Status::. |
| |
| 'int WIFEXITED (int STATUS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion Status::. |
| |
| 'int WIFSIGNALED (int STATUS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion Status::. |
| |
| 'int WIFSTOPPED (int STATUS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion Status::. |
| |
| 'wint_t' |
| |
| 'wchar.h' (ISO): *note Extended Char Intro::. |
| |
| 'wchar_t * wmemchr (const wchar_t *BLOCK, wchar_t WC, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Search Functions::. |
| |
| 'int wmemcmp (const wchar_t *A1, const wchar_t *A2, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note String/Array Comparison::. |
| |
| 'wchar_t * wmemcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'wchar_t * wmemmove (wchar_t *WTO, const wchar_t *WFROM, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'wchar_t * wmempcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE)' |
| |
| 'wchar.h' (GNU): *note Copying and Concatenation::. |
| |
| 'wchar_t * wmemset (wchar_t *BLOCK, wchar_t WC, size_t SIZE)' |
| |
| 'wchar.h' (ISO): *note Copying and Concatenation::. |
| |
| 'int W_OK' |
| |
| 'unistd.h' (POSIX.1): *note Testing File Access::. |
| |
| 'int wordexp (const char *WORDS, wordexp_t *WORD-VECTOR-PTR, int FLAGS)' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'wordexp_t' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'void wordfree (wordexp_t *WORD-VECTOR-PTR)' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'int wprintf (const wchar_t *TEMPLATE, ...)' |
| |
| 'wchar.h' (ISO): *note Formatted Output Functions::. |
| |
| 'WRDE_APPEND' |
| |
| 'wordexp.h' (POSIX.2): *note Flags for Wordexp::. |
| |
| 'WRDE_BADCHAR' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'WRDE_BADVAL' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'WRDE_CMDSUB' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'WRDE_DOOFFS' |
| |
| 'wordexp.h' (POSIX.2): *note Flags for Wordexp::. |
| |
| 'WRDE_NOCMD' |
| |
| 'wordexp.h' (POSIX.2): *note Flags for Wordexp::. |
| |
| 'WRDE_NOSPACE' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'WRDE_REUSE' |
| |
| 'wordexp.h' (POSIX.2): *note Flags for Wordexp::. |
| |
| 'WRDE_SHOWERR' |
| |
| 'wordexp.h' (POSIX.2): *note Flags for Wordexp::. |
| |
| 'WRDE_SYNTAX' |
| |
| 'wordexp.h' (POSIX.2): *note Calling Wordexp::. |
| |
| 'WRDE_UNDEF' |
| |
| 'wordexp.h' (POSIX.2): *note Flags for Wordexp::. |
| |
| 'ssize_t write (int FILEDES, const void *BUFFER, size_t SIZE)' |
| |
| 'unistd.h' (POSIX.1): *note I/O Primitives::. |
| |
| 'ssize_t writev (int FILEDES, const struct iovec *VECTOR, int COUNT)' |
| |
| 'sys/uio.h' (BSD): *note Scatter-Gather::. |
| |
| 'int wscanf (const wchar_t *TEMPLATE, ...)' |
| |
| 'wchar.h' (ISO): *note Formatted Input Functions::. |
| |
| 'int WSTOPSIG (int STATUS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion Status::. |
| |
| 'int WTERMSIG (int STATUS)' |
| |
| 'sys/wait.h' (POSIX.1): *note Process Completion Status::. |
| |
| 'int X_OK' |
| |
| 'unistd.h' (POSIX.1): *note Testing File Access::. |
| |
| '_XOPEN_SOURCE' |
| |
| (X/Open): *note Feature Test Macros::. |
| |
| '_XOPEN_SOURCE_EXTENDED' |
| |
| (X/Open): *note Feature Test Macros::. |
| |
| 'double y0 (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float y0f (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double y0l (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'double y1 (double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float y1f (float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double y1l (long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'double yn (int N, double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'float ynf (int N, float X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
| 'long double ynl (int N, long double X)' |
| |
| 'math.h' (SVID): *note Special Functions::. |
| |
