| Index Entry | | Section |
|---|
|
| ! | | |
|---|
| !posix: | | Other Safety Remarks |
|
| . | | |
|---|
| .lib section in a.out corrupted: | | Error Codes |
|
| / | | |
|---|
| /condition: | | Other Safety Remarks |
| /etc/hostname: | | Host Identification |
| /etc/nsswitch.conf: | | NSS Configuration File |
|
| 4 | | |
|---|
| 4.n BSD Unix: | | Berkeley Unix |
|
| : | | |
|---|
| :identifier: | | Other Safety Remarks |
|
| ? | | |
|---|
| ?: | | Error Codes |
|
| _ | | |
|---|
| _POSIX_OPTION_ORDER environment variable.: | | Standard Environment |
| _POSIX_SAVED_IDS: | | How Change Persona |
|
| A | | |
|---|
| abort signal: | | Program Error Signals |
| aborting a program: | | Aborting a Program |
| absolute file name: | | File Name Resolution |
| absolute priority: | | Absolute Priority |
| absolute value functions: | | Absolute Value |
| AC-Safe: | | POSIX Safety Concepts |
| AC-Unsafe: | | POSIX Safety Concepts |
| accepting connections: | | Accepting Connections |
| access permission for a file: | | Access Permission |
| access, testing for: | | Testing File Access |
| Accessing a corrupted shared library: | | Error Codes |
| accessing directories: | | Accessing Directories |
| Address already in use: | | Error Codes |
| Address family not supported by protocol: | | Error Codes |
| address of socket: | | Socket Addresses |
| address space: | | Memory Subsystem |
| address space: | | Program Basics |
| Advertise error: | | Error Codes |
| alarm signal: | | Alarm Signals |
| alarms, setting: | | Setting an Alarm |
| alignment (in obstacks): | | Obstacks Data Alignment |
| alignment (with malloc): | | Aligned Memory Blocks |
| alloca disadvantages: | | Disadvantages of Alloca |
| alloca function: | | Variable Size Automatic |
| allocating file storage: | | Storage Allocation |
| allocating pseudo-terminals: | | Allocation |
| allocation (obstacks): | | Allocation in an Obstack |
| allocation debugging: | | Allocation Debugging |
| allocation hooks, for malloc: | | Hooks for Malloc |
| allocation of memory with malloc: | | Basic Allocation |
| allocation size of string: | | Representation of Strings |
| allocation statistics: | | Statistics of Malloc |
| alphabetic character: | | Classification of Characters |
| alphabetic character: | | Classification of Wide Characters |
| alphanumeric character: | | Classification of Characters |
| alphanumeric character: | | Classification of Wide Characters |
| alternative malloc implementations: | | Replacing malloc |
| append-access files: | | File Position |
| argc (program argument count): | | Program Arguments |
| argp (program argument parser): | | Argp |
| argp parser functions: | | Argp Parser Functions |
| ARGP_HELP_FMT environment variable: | | Argp User Customization |
| Argument list too long: | | Error Codes |
| argument parsing with argp: | | Argp |
| argument promotion: | | Calling Variadics |
| argument vectors, null-byte separated: | | Argz and Envz Vectors |
| arguments (variadic functions): | | Receiving Arguments |
| arguments, how many: | | How Many Arguments |
| arguments, to program: | | Program Arguments |
| argv (program argument vector): | | Program Arguments |
| argz vectors (string vectors): | | Argz and Envz Vectors |
| arithmetic expansion: | | Expansion Stages |
| array comparison functions: | | String/Array Comparison |
| array copy functions: | | Copying Strings and Arrays |
| array search function: | | Array Search Function |
| array sort function: | | Array Sort Function |
| AS-Safe: | | POSIX Safety Concepts |
| AS-Unsafe: | | POSIX Safety Concepts |
| ASCII character: | | Classification of Characters |
| assertions: | | Consistency Checking |
| Async-Cancel-Safe: | | POSIX Safety Concepts |
| Async-Cancel-Unsafe: | | POSIX Safety Concepts |
| Async-Signal-Safe: | | POSIX Safety Concepts |
| Async-Signal-Unsafe: | | POSIX Safety Concepts |
| Attempting to link in too many shared libraries: | | Error Codes |
| attributes of a file: | | Attribute Meanings |
| Authentication error: | | Error Codes |
| automatic freeing: | | Variable Size Automatic |
| automatic memory allocation: | | Memory Allocation and C |
| automatic storage class: | | Memory Allocation and C |
| automatic storage with variable size: | | Variable Size Automatic |
| auxiliary vector: | | Auxiliary Vector |
|
| B | | |
|---|
| background job: | | Concepts of Job Control |
| background job, launching: | | Foreground and Background |
| backtrace: | | Backtraces |
| backtrace_fd: | | Backtraces |
| backtrace_symbols: | | Backtraces |
| Bad address: | | Error Codes |
| Bad file descriptor: | | Error Codes |
| Bad font file format: | | Error Codes |
| Bad message: | | Error Codes |
| base (of floating point number): | | Floating Point Concepts |
| baud rate: | | Line Speed |
| Berkeley Unix: | | Berkeley Unix |
| Bessel functions: | | Special Functions |
| bias (of floating point number exponent): | | Floating Point Concepts |
| big-endian: | | Byte Order |
| binary I/O to a stream: | | Block Input/Output |
| binary search function (for arrays): | | Array Search Function |
| binary stream: | | Binary Streams |
| binding a socket address: | | Socket Addresses |
| blank character: | | Classification of Characters |
| blank character: | | Classification of Wide Characters |
| Block device required: | | Error Codes |
| block I/O to a stream: | | Block Input/Output |
| blocked signals: | | Delivery of Signal |
| blocked signals, checking for: | | Checking for Pending Signals |
| blocking signals: | | Blocking Signals |
| blocking signals, in a handler: | | Blocking for Handler |
| bootstrapping, and services: | | Actions in the NSS configuration |
| break condition, detecting: | | Input Modes |
| break condition, generating: | | Line Control |
| breaking a string into tokens: | | Finding Tokens in a String |
| Broken pipe: | | Error Codes |
| broken pipe signal: | | Operation Error Signals |
| broken-down time: | | Calendar Time |
| broken-down time: | | Broken-down Time |
| BSD Unix: | | Berkeley Unix |
| buffering of streams: | | Stream Buffering |
| buffering, controlling: | | Controlling Buffering |
| bugs, reporting: | | Reporting Bugs |
| bus error: | | Program Error Signals |
| butterfly: | | Misc FP Arithmetic |
| byte order conversion, for socket: | | Byte Order |
| byte stream: | | Socket Concepts |
|
| C | | |
|---|
| C threads: | | ISO C Threads |
| C++ streams: | | Streams and I18N |
| calendar time: | | Time Basics |
| calendar time and broken-down time: | | Broken-down Time |
| calendar, Gregorian: | | Calendar Time |
| call once: | | Call Once |
| calling variadic functions: | | Calling Variadics |
| Can not access a needed shared library: | | Error Codes |
| Cannot allocate memory: | | Error Codes |
| Cannot assign requested address: | | Error Codes |
| Cannot exec a shared library directly: | | Error Codes |
| Cannot send after transport endpoint shutdown: | | Error Codes |
| canonical input processing: | | Canonical or Not |
| capacity limits, POSIX: | | General Limits |
| carrier detect: | | Control Modes |
| case conversion of characters: | | Case Conversion |
| catching signals: | | Delivery of Signal |
| categories for locales: | | Locale Categories |
| change working directory: | | Working Directory |
| changing the locale: | | Setting the Locale |
| changing the size of a block (malloc): | | Changing Block Size |
| changing the size of a block (obstacks): | | Growing Objects |
| Channel number out of range: | | Error Codes |
| channels: | | Stream/Descriptor Precautions |
| character case conversion: | | Case Conversion |
| character predicates: | | Classification of Characters |
| character testing: | | Classification of Characters |
| checking for pending signals: | | Checking for Pending Signals |
| child process: | | Processor Time |
| child process: | | Processes |
| child process: | | Process Creation Concepts |
| child process signal: | | Job Control Signals |
| chunks: | | Obstack Chunks |
| classes, floating-point: | | Floating Point Classes |
| classification of characters: | | Classification of Characters |
| cleaning up a stream: | | Linked Channels |
| clearing terminal input queue: | | Line Control |
| client: | | Connections |
| clock ticks: | | Processor And CPU Time |
| clock, high accuracy: | | High Accuracy Clock |
| close-on-exec (file descriptor flag): | | Descriptor Flags |
| closing a file descriptor: | | Opening and Closing Files |
| closing a socket: | | Closing a Socket |
| closing a stream: | | Closing Streams |
| collating strings: | | Collation Functions |
| combining locales: | | Choosing Locale |
| command argument syntax: | | Argument Syntax |
| command arguments, parsing: | | Parsing Program Arguments |
| command line arguments: | | Program Arguments |
| command substitution: | | Expansion Stages |
| Communication error on send: | | Error Codes |
| communication style (of a socket): | | Socket Concepts |
| comparing strings and arrays: | | String/Array Comparison |
| Comparison Function: | | Comparison Functions |
| compiling: | | Configuring and compiling |
| complex exponentiation functions: | | Exponents and Logarithms |
| complex logarithm functions: | | Exponents and Logarithms |
| complex numbers: | | Complex Numbers |
| complex trigonometric functions: | | Trig Functions |
| Computer bought the farm: | | Error Codes |
| concatenating strings: | | Copying Strings and Arrays |
| concatenating strings: | | Concatenating Strings |
| condition variables: | | ISO C Condition Variables |
| Conditionally Safe Features: | | Conditionally Safe Features |
| condvar: | | ISO C Condition Variables |
| configuring: | | Configuring and compiling |
| conjugate complex numbers: | | Operations on Complex |
| connecting a socket: | | Connecting |
| connection: | | Connections |
| Connection refused: | | Error Codes |
| Connection reset by peer: | | Error Codes |
| Connection timed out: | | Error Codes |
| consistency checking: | | Consistency Checking |
| consistency checking, of heap: | | Heap Consistency Checking |
| const: | | Conditionally Safe Features |
| constants: | | Memory Concepts |
| constants: | | Mathematical Constants |
| continue signal: | | Job Control Signals |
| control character: | | Classification of Characters |
| control character: | | Classification of Wide Characters |
| control operations on files: | | Control Operations |
| controlling process: | | Controlling Terminal |
| controlling terminal: | | Concepts of Job Control |
| controlling terminal, access to: | | Access to the Terminal |
| controlling terminal, determining: | | Identifying the Terminal |
| controlling terminal, setting: | | Open-time Flags |
| conversion specifications (printf): | | Formatted Output Basics |
| conversion specifications (scanf): | | Formatted Input Basics |
| converting byte order: | | Byte Order |
| converting case of characters: | | Case Conversion |
| converting file descriptor to stream: | | Descriptors and Streams |
| converting floats to integers: | | Rounding Functions |
| converting group ID to group name: | | Lookup Group |
| converting group name to group ID: | | Lookup Group |
| converting host address to name: | | Host Names |
| converting host name to address: | | Host Names |
| converting network name to network number: | | Networks Database |
| converting network number to network name: | | Networks Database |
| converting port number to service name: | | Services Database |
| converting service name to port number: | | Services Database |
| converting string to collation order: | | Collation Functions |
| converting strings to numbers: | | Parsing of Numbers |
| converting user ID to user name: | | Lookup User |
| converting user name to user ID: | | Lookup User |
| cookie, for custom stream: | | Streams and Cookies |
| copy-on-write page fault: | | Locked Memory Details |
| copying files: | | Copying File Data |
| copying strings and arrays: | | Copying Strings and Arrays |
| corrupt: | | Unsafe Features |
| cpu priority: | | Priority |
| CPU time: | | Time Basics |
| CPU time: | | Processor And CPU Time |
| CPU time: | | Processor Time |
| create on open (file status flag): | | Open-time Flags |
| creating a directory: | | Creating Directories |
| creating a FIFO special file: | | FIFO Special Files |
| creating a pipe: | | Creating a Pipe |
| creating a pipe to a subprocess: | | Pipe to a Subprocess |
| creating a process: | | Process Creation Concepts |
| creating a socket: | | Creating a Socket |
| creating a socket pair: | | Socket Pairs |
| creating special files: | | Making Special Files |
| CRNG: | | Unpredictable Bytes |
| cryptographic random number generator: | | Unpredictable Bytes |
| CSPRNG: | | Unpredictable Bytes |
| cube root function: | | Exponents and Logarithms |
| currency symbols: | | Currency Symbol |
| current limit: | | Limits on Resources |
| current working directory: | | Working Directory |
| custom streams: | | Custom Streams |
| customizing malloc: | | Replacing malloc |
| customizing printf: | | Customizing Printf |
| cwd: | | Other Safety Remarks |
|
| D | | |
|---|
| data loss on sockets: | | Socket Concepts |
| databases: | | Name Service Switch |
| datagram socket: | | Datagrams |
| datagrams, transmitting: | | Sending Datagrams |
| data_cache_size tunables: | | Hardware Capability Tunables |
| date: | | Time Basics |
| Daylight Saving Time: | | Broken-down Time |
| decimal digit character: | | Classification of Characters |
| decimal-point separator: | | General Numeric |
| declaration (compared to definition): | | Header Files |
| declaring variadic functions: | | Calling Variadics |
| decompose complex numbers: | | Operations on Complex |
| default action (for a signal): | | Delivery of Signal |
| default action for a signal: | | Basic Signal Handling |
| default argument promotions: | | Calling Variadics |
| default value, and NSS: | | Notes on NSS Configuration File |
| defining new printf conversions: | | Customizing Printf |
| definition (compared to declaration): | | Header Files |
| delayed suspend character: | | Signal Characters |
| deleting a directory: | | Deleting Files |
| deleting a file: | | Deleting Files |
| delivery of signals: | | Delivery of Signal |
| descriptors and streams: | | Stream/Descriptor Precautions |
| Destination address required: | | Error Codes |
| deterministic random bit generator: | | Unpredictable Bytes |
| Device not a stream: | | Error Codes |
| Device or resource busy: | | Error Codes |
| digit character: | | Classification of Characters |
| digit character: | | Classification of Wide Characters |
| directories, accessing: | | Accessing Directories |
| directories, creating: | | Creating Directories |
| directories, deleting: | | Deleting Files |
| directory: | | Directories |
| directory entry: | | Directories |
| directory hierarchy: | | Working with Directory Trees |
| Directory not empty: | | Error Codes |
| directory stream: | | Accessing Directories |
| disadvantages of alloca: | | Disadvantages of Alloca |
| DISCARD character: | | Other Special |
| Disk quota exceeded: | | Error Codes |
| division by zero: | | FP Exceptions |
| dlopen: | | Unsafe Features |
| DNS: | | Host Identification |
| DNS server unavailable: | | Actions in the NSS configuration |
| domain (of socket): | | Socket Concepts |
| domain error: | | Math Error Reporting |
| domain name: | | Host Identification |
| Domain Name System: | | Host Identification |
| dot notation, for Internet addresses: | | Abstract Host Addresses |
| DRBG: | | Unpredictable Bytes |
| DSUSP character: | | Signal Characters |
| duplicating file descriptors: | | Duplicating Descriptors |
| dynamic memory allocation: | | Memory Allocation and C |
| dynamic memory allocation: | | Memory Allocation and C |
|
| E | | |
|---|
| EBCDIC: | | Extended Char Intro |
| echo of terminal input: | | Local Modes |
| effective group ID: | | Process Persona |
| effective user ID: | | Process Persona |
| efficiency and obstacks: | | Extra Fast Growing |
| efficiency of chunks: | | Obstack Chunks |
| EINTR, and restarting interrupted primitives: | | Interrupted Primitives |
| elapsed time: | | Time Basics |
| elapsed time: | | Elapsed Time |
| elision tunables: | | Elision Tunables |
| end of file, on a stream: | | EOF and Errors |
| end-of-file, on a file descriptor: | | I/O Primitives |
| env: | | Other Safety Remarks |
| environment: | | Environment Variables |
| environment access: | | Environment Access |
| environment representation: | | Environment Access |
| environment variable: | | Environment Variables |
| environment vectors, null-byte separated: | | Argz and Envz Vectors |
| envz vectors (environment vectors): | | Argz and Envz Vectors |
| EOF character: | | Editing Characters |
| EOL character: | | Editing Characters |
| EOL2 character: | | Editing Characters |
| epoch: | | Simple Calendar Time |
| ERASE character: | | Editing Characters |
| errno: | | System Calls |
| error codes: | | Error Reporting |
| error messages, in argp: | | Argp Helper Functions |
| error reporting: | | Error Reporting |
| errors, mathematical: | | Math Error Reporting |
| establishing a handler: | | Signal Actions |
| ethers: | | NSS Basics |
| EUC: | | Extended Char Intro |
| EUC-JP: | | glibc iconv Implementation |
| exception: | | FP Exceptions |
| exception: | | Program Error Signals |
| Exchange full: | | Error Codes |
| exclusive lock: | | File Locks |
| Exec format error: | | Error Codes |
| exec functions: | | Executing a File |
| execing a program: | | Memory Concepts |
| executable: | | Memory Concepts |
| executing a file: | | Executing a File |
| exit status: | | Exit Status |
| exit status value: | | Program Termination |
| exiting a program: | | Memory Concepts |
| expansion of shell words: | | Word Expansion |
| exponent (of floating point number): | | Floating Point Concepts |
| exponentiation functions: | | Exponents and Logarithms |
| extending printf: | | Customizing Printf |
| extracting file descriptor from stream: | | Descriptors and Streams |
|
| F | | |
|---|
| fcntl function: | | Control Operations |
| fd: | | Other Safety Remarks |
| FDL, GNU Free Documentation License: | | Documentation License |
| feature test macros: | | Feature Test Macros |
| field splitting: | | Expansion Stages |
| FIFO special file: | | Pipes and FIFOs |
| file access permission: | | Access Permission |
| file access time: | | File Times |
| file allocation: | | Storage Allocation |
| file attribute modification time: | | File Times |
| file attributes: | | Attribute Meanings |
| file copy: | | Copying File Data |
| file creation mask: | | Setting Permissions |
| file descriptor flags: | | Descriptor Flags |
| File descriptor in bad state: | | Error Codes |
| file descriptor sets, for select: | | Waiting for I/O |
| file descriptors, standard: | | Descriptors and Streams |
| File exists: | | Error Codes |
| file fragmentation: | | Storage Allocation |
| File locking deadlock error: | | Error Codes |
| file locks: | | File Locks |
| file modification time: | | File Times |
| file name: | | File Names |
| file name component: | | Directories |
| file name errors: | | File Name Errors |
| file name resolution: | | File Name Resolution |
| File name too long: | | Error Codes |
| file name translation flags: | | Open-time Flags |
| file names, multiple: | | Hard Links |
| file owner: | | File Owner |
| file permission bits: | | Permission Bits |
| file pointer: | | Streams |
| file position: | | File Position |
| file positioning on a file descriptor: | | File Position Primitive |
| file positioning on a stream: | | File Positioning |
| file status flags: | | File Status Flags |
| File too large: | | Error Codes |
| files, accessing: | | Memory Concepts |
| files, sparse: | | Storage Allocation |
| filtering i/o through subprocess: | | Pipe to a Subprocess |
| flag character (printf): | | Output Conversion Syntax |
| flag character (scanf): | | Input Conversion Syntax |
| flags for sigaction: | | Flags for Sigaction |
| flags, file name translation: | | Open-time Flags |
| flags, open-time action: | | Open-time Flags |
| floating point: | | Floating Point Numbers |
| floating point, IEEE: | | IEEE Floating Point |
| floating type measurements: | | Floating Type Macros |
| floating-point classes: | | Floating Point Classes |
| floating-point exception: | | Program Error Signals |
| flow control, terminal: | | Line Control |
| flow label: | | Internet Address Formats |
| flushing a stream: | | Flushing Buffers |
| flushing terminal output queue: | | Line Control |
| foreground job: | | Concepts of Job Control |
| foreground job, launching: | | Foreground and Background |
| forking a process: | | Process Creation Concepts |
| format string, for printf: | | Formatted Output |
| format string, for scanf: | | Formatted Input |
| formatted input from a stream: | | Formatted Input |
| formatted messages: | | Formatted Messages |
| formatted output to a stream: | | Formatted Output |
| FP arithmetic: | | FP Bit Twiddling |
| FQDN: | | Host Identification |
| fragmentation of files: | | Storage Allocation |
| frame, real memory: | | Memory Concepts |
| free documentation: | | Free Manuals |
| freeing (obstacks): | | Freeing Obstack Objects |
| freeing memory: | | Memory Concepts |
| freeing memory allocated with malloc: | | Freeing after Malloc |
| fully buffered stream: | | Buffering Concepts |
| Function not implemented: | | Error Codes |
| function prototypes (variadic): | | Variadic Prototypes |
|
| G | | |
|---|
| gamma function: | | Special Functions |
| gcvt_r: | | System V Number Conversion |
| gencat: | | The gencat program |
| generation of signals: | | Signal Generation |
| generic i/o control operations: | | IOCTLs |
| globbing: | | Globbing |
| gnu allocator: | | The GNU Allocator |
| graphic character: | | Classification of Characters |
| graphic character: | | Classification of Wide Characters |
| Gratuitous error: | | Error Codes |
| Gregorian calendar: | | Calendar Time |
| group: | | NSS Basics |
| group database: | | Group Database |
| group ID: | | User and Group IDs |
| group name: | | User and Group IDs |
| group owner of a file: | | File Owner |
| grouping of digits: | | General Numeric |
| growing objects (in obstacks): | | Growing Objects |
|
| H | | |
|---|
| handling multiple signals: | | Merged Signals |
| hangup signal: | | Termination Signals |
| hard limit: | | Limits on Resources |
| hard link: | | Hard Links |
| hardware capability tunables: | | Hardware Capability Tunables |
| hashing, passphrase: | | Passphrase Storage |
| header files: | | Header Files |
| heap: | | Unsafe Features |
| heap consistency checking: | | Heap Consistency Checking |
| heap, dynamic allocation from: | | Unconstrained Allocation |
| heap, freeing memory from: | | Freeing after Malloc |
| hexadecimal digit character: | | Classification of Characters |
| hexadecimal digit character: | | Classification of Wide Characters |
| hidden bit (of floating point number mantissa): | | Floating Point Concepts |
| hierarchy, directory: | | Working with Directory Trees |
| high-priority data: | | Out-of-Band Data |
| high-resolution time: | | Calendar Time |
| holes in files: | | File Position Primitive |
| home directory: | | Standard Environment |
| HOME environment variable: | | Standard Environment |
| hook functions (of custom streams): | | Hook Functions |
| host address, Internet: | | Abstract Host Addresses |
| Host is down: | | Error Codes |
| host name: | | Host Identification |
| hostid: | | Other Safety Remarks |
| hostname: | | Host Identification |
| hosts: | | NSS Basics |
| hosts database: | | Host Names |
| how many arguments: | | How Many Arguments |
| hwcap tunables: | | Hardware Capability Tunables |
| hwcaps tunables: | | Hardware Capability Tunables |
| hyperbolic functions: | | Hyperbolic Functions |
| hyperbolic functions: | | Hyperbolic Functions |
|
| I | | |
|---|
| i18n: | | Unsafe Features |
| iconv: | | Unsafe Features |
| Identifier removed: | | Error Codes |
| identifying terminals: | | Is It a Terminal |
| IEEE 754: | | Floating Point Numbers |
| IEEE floating point: | | Floating Point Numbers |
| IEEE floating point representation: | | IEEE Floating Point |
| IEEE Std 1003.1: | | POSIX |
| IEEE Std 1003.2: | | POSIX |
| ignore action for a signal: | | Basic Signal Handling |
| illegal instruction: | | Program Error Signals |
| Illegal seek: | | Error Codes |
| impossible events: | | Consistency Checking |
| Inappropriate file type or format: | | Error Codes |
| Inappropriate ioctl for device: | | Error Codes |
| Inappropriate operation for background process: | | Error Codes |
| independent channels: | | Independent Channels |
| inexact exception: | | FP Exceptions |
| infinity: | | Infinity and NaN |
| init: | | Conditionally Safe Features |
| initial signal actions: | | Initial Signal Actions |
| inode number: | | Attribute Meanings |
| input available signal: | | Asynchronous I/O Signals |
| input conversions, for scanf: | | Table of Input Conversions |
| input from multiple files: | | Waiting for I/O |
| Input/output error: | | Error Codes |
| installation tools: | | Tools for Compilation |
| installing: | | Running make install |
| integer: | | Integers |
| integer division functions: | | Integer Division |
| integer type range: | | Range of Type |
| integer type width: | | Width of Type |
| interactive signals, from terminal: | | Local Modes |
| interactive stop signal: | | Job Control Signals |
| internal representation: | | Extended Char Intro |
| internationalization: | | Locales |
| Internet host address: | | Abstract Host Addresses |
| Internet namespace, for sockets: | | Internet Namespace |
| interposing malloc: | | Replacing malloc |
| interprocess communication, with FIFO: | | FIFO Special Files |
| interprocess communication, with pipes: | | Creating a Pipe |
| interprocess communication, with signals: | | Kill Example |
| interprocess communication, with sockets: | | Sockets |
| interrupt character: | | Signal Characters |
| interrupt signal: | | Termination Signals |
| interrupt-driven input: | | Interrupt Input |
| Interrupted system call: | | Error Codes |
| Interrupted system call should be restarted: | | Error Codes |
| interrupting primitives: | | Interrupted Primitives |
| interval: | | Time Basics |
| interval timer, setting: | | Setting an Alarm |
| INTR character: | | Signal Characters |
| Invalid argument: | | Error Codes |
| Invalid cross-device link: | | Error Codes |
| invalid exception: | | FP Exceptions |
| Invalid exchange: | | Error Codes |
| Invalid or incomplete multibyte or wide character: | | Error Codes |
| Invalid request code: | | Error Codes |
| Invalid request descriptor: | | Error Codes |
| Invalid slot: | | Error Codes |
| inverse complex hyperbolic functions: | | Hyperbolic Functions |
| inverse complex trigonometric functions: | | Inverse Trig Functions |
| inverse hyperbolic functions: | | Hyperbolic Functions |
| inverse trigonometric functions: | | Inverse Trig Functions |
| invocation of program: | | Program Arguments |
| IOCTLs: | | IOCTLs |
| ipc: | | Inter-Process Communication |
| IPv6 flow label: | | Internet Address Formats |
| IPv6 scope ID: | | Internet Address Formats |
| IPv6 traffic class: | | Internet Address Formats |
| Is a directory: | | Error Codes |
| Is a named type file: | | Error Codes |
| ISO 10646: | | Extended Char Intro |
| ISO 2022: | | Extended Char Intro |
| ISO 6937: | | Extended Char Intro |
| ISO C: | | ISO C |
| ISO C threads: | | ISO C Threads |
| ISO-2022-JP: | | glibc iconv Implementation |
| ISO/IEC 9945-1: | | POSIX |
| ISO/IEC 9945-2: | | POSIX |
|
| J | | |
|---|
| job: | | Job Control |
| job control: | | Job Control |
| job control functions: | | Functions for Job Control |
| job control signals: | | Job Control Signals |
| job control, enabling: | | Initializing the Shell |
| job control, enabling: | | Initializing the Shell |
|
| K | | |
|---|
| Kermit the frog: | | Search/Sort Example |
| kernel call: | | System Calls |
| kernel header files: | | Linux |
| Key has been revoked: | | Error Codes |
| Key has expired: | | Error Codes |
| Key was rejected by service: | | Error Codes |
| KILL character: | | Editing Characters |
| kill signal: | | Termination Signals |
| killing a process: | | Signaling Another Process |
| Korn Shell: | | Wildcard Matching |
|
| L | | |
|---|
| LANG environment variable: | | The catgets Functions |
| LANG environment variable: | | Standard Environment |
| launching jobs: | | Launching Jobs |
| LC_ALL environment variable: | | The catgets Functions |
| LC_ALL environment variable: | | Standard Environment |
| LC_COLLATE environment variable: | | Standard Environment |
| LC_CTYPE environment variable: | | Standard Environment |
| LC_MESSAGES environment variable: | | The catgets Functions |
| LC_MESSAGES environment variable: | | Standard Environment |
| LC_MONETARY environment variable: | | Standard Environment |
| LC_NUMERIC environment variable: | | Standard Environment |
| LC_TIME environment variable: | | Standard Environment |
| LD_PRELOAD and malloc: | | Replacing malloc |
| leap second: | | Broken-down Time |
| length of string: | | Representation of Strings |
| Level 2 halted: | | Error Codes |
| Level 2 not synchronized: | | Error Codes |
| Level 3 halted: | | Error Codes |
| Level 3 reset: | | Error Codes |
| level, for socket options: | | Socket Options |
| library: | | Introduction |
| limit: | | Limits on Resources |
| limits on resource usage: | | Limits on Resources |
| limits, file name length: | | Limits for Files |
| limits, floating types: | | Floating Type Macros |
| limits, integer types: | | Range of Type |
| limits, link count of files: | | Limits for Files |
| limits, number of open files: | | General Limits |
| limits, number of processes: | | General Limits |
| limits, number of supplementary group IDs: | | General Limits |
| limits, pipe buffer size: | | Limits for Files |
| limits, POSIX: | | General Limits |
| limits, program argument size: | | General Limits |
| limits, terminal input queue: | | Limits for Files |
| limits, time zone name length: | | General Limits |
| line buffered stream: | | Buffering Concepts |
| line speed: | | Line Speed |
| lines (in a text file): | | Binary Streams |
| link: | | Directories |
| Link has been severed: | | Error Codes |
| Link number out of range: | | Error Codes |
| link, hard: | | Hard Links |
| link, soft: | | Symbolic Links |
| link, symbolic: | | Symbolic Links |
| linked channels: | | Linked Channels |
| listening (sockets): | | Listening |
| literals: | | Memory Concepts |
| little-endian: | | Byte Order |
| LNEXT character: | | Other Special |
| load average: | | Processor Resources |
| local namespace, for sockets: | | Local Namespace |
| local network address number: | | Abstract Host Addresses |
| local time: | | Calendar Time |
| locale: | | Other Safety Remarks |
| locale categories: | | Locale Categories |
| locale, changing: | | Setting the Locale |
| locales: | | Locales |
| lock: | | Unsafe Features |
| locking pages: | | Locking Pages |
| logarithm functions: | | Exponents and Logarithms |
| login name: | | User and Group IDs |
| login name, determining: | | Who Logged In |
| LOGNAME environment variable: | | Standard Environment |
| long jumps: | | Non-Local Exits |
| long-named options: | | Argument Syntax |
| longjmp: | | Advantages of Alloca |
| loss of data on sockets: | | Socket Concepts |
| lost resource signal: | | Operation Error Signals |
| lower-case character: | | Classification of Characters |
| lower-case character: | | Classification of Wide Characters |
|
| M | | |
|---|
| Machine is not on the network: | | Error Codes |
| macros: | | Obstack Functions |
| main function: | | Program Arguments |
| malloc debugger: | | Allocation Debugging |
| malloc function: | | Unconstrained Allocation |
| malloc replacement: | | Replacing malloc |
| malloc tunables: | | Memory Allocation Tunables |
| mantissa (of floating point number): | | Floating Point Concepts |
| matching failure, in scanf: | | Formatted Input Basics |
| math errors: | | Errors in Math Functions |
| mathematical constants: | | Mathematical Constants |
| maximum: | | Misc FP Arithmetic |
| maximum field width (scanf): | | Input Conversion Syntax |
| maximum limit: | | Limits on Resources |
| maximum possible integer: | | Integers |
| measurements of floating types: | | Floating Type Macros |
| mem: | | Other Safety Remarks |
| memory allocation: | | Memory |
| memory allocation tunables: | | Memory Allocation Tunables |
| memory lock: | | Locking Pages |
| memory mapped file: | | Memory Concepts |
| memory mapped I/O: | | Memory Concepts |
| memory page: | | Memory Subsystem |
| Memory page has hardware error: | | Error Codes |
| memory protection: | | Memory Protection |
| memory protection key: | | Memory Protection |
| merging of signals: | | Merged Signals |
| Message too long: | | Error Codes |
| MIN termios slot: | | Noncanonical Input |
| minimum: | | Misc FP Arithmetic |
| minimum field width (printf): | | Output Conversion Syntax |
| minimum possible integer: | | Integers |
| mixing descriptors and streams: | | Stream/Descriptor Precautions |
| modem disconnect: | | Control Modes |
| modem status lines: | | Control Modes |
| monetary value formatting: | | The Lame Way to Locale Data |
| MPK: | | Memory Protection |
| MT-Safe: | | POSIX Safety Concepts |
| MT-Unsafe: | | POSIX Safety Concepts |
| multi-threaded application: | | Streams and Threads |
| multibyte character: | | Representation of Strings |
| multibyte character: | | Extended Char Intro |
| multibyte string: | | Representation of Strings |
| multibyte string: | | Representation of Strings |
| Multihop attempted: | | Error Codes |
| multiple names for one file: | | Hard Links |
| multiplexing input: | | Waiting for I/O |
| multiply-add: | | Misc FP Arithmetic |
| mutex: | | ISO C Mutexes |
| mutex tunables: | | POSIX Thread Tunables |
| mutual exclusion: | | ISO C Mutexes |
|
| N | | |
|---|
| Name not unique on network: | | Error Codes |
| name of running program: | | Error Messages |
| name of socket: | | Socket Addresses |
| Name Service Switch: | | Name Service Switch |
| name space: | | Reserved Names |
| names of signals: | | Standard Signals |
| namespace (of socket): | | Socket Concepts |
| NaN: | | Infinity and NaN |
| NaN: | | FP Bit Twiddling |
| Need authenticator: | | Error Codes |
| netgroup: | | NSS Basics |
| Netgroup: | | Netgroup Data |
| network byte order: | | Byte Order |
| Network dropped connection on reset: | | Error Codes |
| Network is down: | | Error Codes |
| Network is unreachable: | | Error Codes |
| network number: | | Abstract Host Addresses |
| network protocol: | | Socket Concepts |
| networks: | | NSS Basics |
| networks database: | | Networks Database |
| NIS: | | Host Identification |
| NIS domain name: | | Host Identification |
| NIS domain name: | | Host Identification |
| NIS domain name: | | Host Identification |
| nisplus, and booting: | | Actions in the NSS configuration |
| nisplus, and completeness: | | Actions in the NSS configuration |
| NLSPATH environment variable: | | The catgets Functions |
| NLSPATH environment variable: | | Standard Environment |
| No anode: | | Error Codes |
| No buffer space available: | | Error Codes |
| No child processes: | | Error Codes |
| No CSI structure available: | | Error Codes |
| No data available: | | Error Codes |
| No locks available: | | Error Codes |
| No medium found: | | Error Codes |
| No message of desired type: | | Error Codes |
| No route to host: | | Error Codes |
| No space left on device: | | Error Codes |
| No such device: | | Error Codes |
| No such device or address: | | Error Codes |
| No such file or directory: | | Error Codes |
| No such process: | | Error Codes |
| No XENIX semaphores available: | | Error Codes |
| non-blocking open: | | Open-time Flags |
| non-local exit, from signal handler: | | Longjmp in Handler |
| non-local exits: | | Non-Local Exits |
| noncanonical input processing: | | Canonical or Not |
| non_temporal_threshold tunables: | | Hardware Capability Tunables |
| normalization functions (floating-point): | | Normalization Functions |
| normalized floating point number: | | Floating Point Concepts |
| Not a directory: | | Error Codes |
| not a number: | | Infinity and NaN |
| Not a XENIX named type file: | | Error Codes |
| Not supported: | | Error Codes |
| NSS: | | Unsafe Features |
| NSS: | | Name Service Switch |
| nsswitch.conf: | | NSS Configuration File |
| null byte: | | Representation of Strings |
| null pointer constant: | | Null Pointer Constant |
| null wide character: | | Representation of Strings |
| number of arguments passed: | | How Many Arguments |
| number syntax, parsing: | | Parsing of Numbers |
| numeric value formatting: | | The Lame Way to Locale Data |
| Numerical argument out of domain: | | Error Codes |
| Numerical result out of range: | | Error Codes |
|
| O | | |
|---|
| Object is remote: | | Error Codes |
| obstack status: | | Status of an Obstack |
| obstacks: | | Obstacks |
| one-way hashing: | | Passphrase Storage |
| open-time action flags: | | Open-time Flags |
| opening a file: | | I/O Concepts |
| opening a file descriptor: | | Opening and Closing Files |
| opening a pipe: | | Creating a Pipe |
| opening a pseudo-terminal pair: | | Pseudo-Terminal Pairs |
| opening a socket: | | Creating a Socket |
| opening a socket pair: | | Socket Pairs |
| opening a stream: | | Opening Streams |
| Operation already in progress: | | Error Codes |
| Operation canceled: | | Error Codes |
| Operation not permitted: | | Error Codes |
| Operation not possible due to RF-kill: | | Error Codes |
| Operation not supported: | | Error Codes |
| Operation now in progress: | | Error Codes |
| Operation would block: | | Error Codes |
| Optimization: | | FP Function Optimizations |
| optimizing NSS: | | Notes on NSS Configuration File |
| option parsing with argp: | | Argp |
| optional arguments: | | Variadic Functions |
| optional POSIX features: | | System Options |
| orientation, stream: | | Opening Streams |
| orientation, stream: | | Streams and I18N |
| orphaned process group: | | Orphaned Process Groups |
| Other Safety Remarks: | | Other Safety Remarks |
| Out of streams resources: | | Error Codes |
| out-of-band data: | | Out-of-Band Data |
| output conversions, for printf: | | Table of Output Conversions |
| output possible signal: | | Asynchronous I/O Signals |
| overflow exception: | | FP Exceptions |
| Owner died: | | Error Codes |
| owner of a file: | | File Owner |
|
| P | | |
|---|
| Package not installed: | | Error Codes |
| packet: | | Socket Concepts |
| page boundary: | | Aligned Memory Blocks |
| page fault: | | Memory Concepts |
| page fault, copy-on-write: | | Locked Memory Details |
| page frame: | | Memory Concepts |
| page protection: | | Memory Protection |
| page, memory: | | Memory Subsystem |
| page, virtual memory: | | Memory Concepts |
| paging: | | Memory Concepts |
| paging: | | Locking Pages |
| parameter promotion: | | String/Array Conventions |
| parent directory: | | File Name Resolution |
| parent process: | | Processes |
| parent process: | | Process Creation Concepts |
| parity checking: | | Input Modes |
| parsing a template string: | | Parsing a Template String |
| parsing numbers (in formatted input): | | Parsing of Numbers |
| parsing program arguments: | | Parsing Program Arguments |
| parsing tokens from a string: | | Finding Tokens in a String |
| passphrase hashing: | | Passphrase Storage |
| passwd: | | NSS Basics |
| password database: | | User Database |
| PATH environment variable: | | Standard Environment |
| pause function: | | Waiting for a Signal |
| peeking at input: | | Unreading |
| pending signals: | | Delivery of Signal |
| pending signals, checking for: | | Checking for Pending Signals |
| period of time: | | Time Basics |
| Permission denied: | | Error Codes |
| permission to access a file: | | Access Permission |
| persona: | | Process Persona |
| physical address: | | Memory Subsystem |
| physical memory: | | Memory Subsystem |
| pi (trigonometric constant): | | Trig Functions |
| pipe: | | Pipes and FIFOs |
| pipe signal: | | Operation Error Signals |
| pipe to a subprocess: | | Pipe to a Subprocess |
| plugin: | | Unsafe Features |
| port number: | | Ports |
| positioning a file descriptor: | | File Position Primitive |
| positioning a stream: | | File Positioning |
| positive difference: | | Misc FP Arithmetic |
| POSIX: | | POSIX |
| POSIX capacity limits: | | General Limits |
| POSIX optional features: | | System Options |
| POSIX Safety Concepts: | | POSIX Safety Concepts |
| POSIX.1: | | POSIX |
| POSIX.2: | | POSIX |
| power functions: | | Exponents and Logarithms |
| precision (of floating point number): | | Floating Point Concepts |
| precision (printf): | | Output Conversion Syntax |
| predicates on arrays: | | String/Array Comparison |
| predicates on characters: | | Classification of Characters |
| predicates on strings: | | String/Array Comparison |
| preempting malloc: | | Replacing malloc |
| preemptive scheduling: | | Absolute Priority |
| Preliminary: | | POSIX Safety Concepts |
| primitives, interrupting: | | Interrupted Primitives |
| printing character: | | Classification of Characters |
| printing character: | | Classification of Wide Characters |
| priority of a process: | | Priority |
| priority, absolute: | | Absolute Priority |
| process: | | Program Basics |
| process: | | Processes |
| process completion: | | Process Completion |
| process group functions: | | Functions for Job Control |
| process group ID: | | Launching Jobs |
| process group leader: | | Launching Jobs |
| process groups: | | Job Control |
| process ID: | | Process Identification |
| process image: | | Process Creation Concepts |
| process priority: | | Priority |
| process signal mask: | | Process Signal Mask |
| process termination: | | Program Termination |
| processor time: | | Time Basics |
| processor time: | | Processor Time |
| profiling alarm signal: | | Alarm Signals |
| profiling timer: | | Setting an Alarm |
| program: | | Program Basics |
| program argument syntax: | | Argument Syntax |
| program arguments: | | Program Arguments |
| program arguments, parsing: | | Parsing Program Arguments |
| program error signals: | | Program Error Signals |
| program name: | | Error Messages |
| program startup: | | Program Arguments |
| program termination: | | Program Termination |
| program termination signals: | | Termination Signals |
| programming your own streams: | | Custom Streams |
| project complex numbers: | | Operations on Complex |
| protection flags: | | Memory Protection |
| protection key: | | Memory Protection |
| protocol (of socket): | | Socket Concepts |
| Protocol driver not attached: | | Error Codes |
| Protocol error: | | Error Codes |
| protocol family: | | Socket Concepts |
| Protocol family not supported: | | Error Codes |
| Protocol not available: | | Error Codes |
| Protocol not supported: | | Error Codes |
| Protocol wrong type for socket: | | Error Codes |
| protocols: | | NSS Basics |
| protocols database: | | Protocols Database |
| prototypes for variadic functions: | | Variadic Prototypes |
| pseudo-random numbers: | | Pseudo-Random Numbers |
| pseudo-random numbers, cryptographic: | | Unpredictable Bytes |
| pseudo-terminals: | | Pseudo-Terminals |
| pthread mutex tunables: | | POSIX Thread Tunables |
| pthreads: | | POSIX Threads |
| punctuation character: | | Classification of Characters |
| punctuation character: | | Classification of Wide Characters |
| pushing input back: | | Unreading |
|
| Q | | |
|---|
| quick sort function (for arrays): | | Array Sort Function |
| QUIT character: | | Signal Characters |
| quit signal: | | Termination Signals |
| quit signal: | | Termination Signals |
| quote removal: | | Expansion Stages |
|
| R | | |
|---|
| race: | | Conditionally Safe Features |
| race conditions, relating to job control: | | Launching Jobs |
| race conditions, relating to signals: | | Signals in Handler |
| radix (of floating point number): | | Floating Point Concepts |
| raising signals: | | Generating Signals |
| random numbers: | | Pseudo-Random Numbers |
| random numbers, cryptographic: | | Unpredictable Bytes |
| random-access files: | | File Position |
| randomness source: | | Unpredictable Bytes |
| range error: | | Math Error Reporting |
| range of integer type: | | Range of Type |
| read lock: | | File Locks |
| Read-only file system: | | Error Codes |
| reading from a directory: | | Accessing Directories |
| reading from a file descriptor: | | I/O Primitives |
| reading from a socket: | | Transferring Data |
| reading from a stream, by blocks: | | Block Input/Output |
| reading from a stream, by characters: | | Character Input |
| reading from a stream, formatted: | | Formatted Input |
| ready to run: | | Absolute Priority |
| real group ID: | | Process Persona |
| real user ID: | | Process Persona |
| real-time timer: | | Setting an Alarm |
| realtime CPU scheduling: | | Absolute Priority |
| realtime processing: | | Why Lock Pages |
| realtime scheduling: | | Realtime Scheduling |
| receiving datagrams: | | Receiving Datagrams |
| record locking: | | File Locks |
| redirecting input and output: | | Duplicating Descriptors |
| reentrant functions: | | Nonreentrancy |
| reentrant NSS functions: | | NSS Module Names |
| relative file name: | | File Name Resolution |
| Remote address changed: | | Error Codes |
| Remote I/O error: | | Error Codes |
| removal of quotes: | | Expansion Stages |
| removing a file: | | Deleting Files |
| removing macros that shadow functions: | | Macro Definitions |
| renaming a file: | | Renaming Files |
| replacing malloc: | | Replacing malloc |
| reporting bugs: | | Reporting Bugs |
| reporting errors: | | Error Reporting |
| REPRINT character: | | Editing Characters |
| Required key not available: | | Error Codes |
| reserved names: | | Reserved Names |
| Resource deadlock avoided: | | Error Codes |
| resource limits: | | Limits on Resources |
| Resource temporarily unavailable: | | Error Codes |
| restarting interrupted primitives: | | Interrupted Primitives |
| restrictions on signal handler functions: | | Nonreentrancy |
| RFS specific error: | | Error Codes |
| root directory: | | File Name Resolution |
| Rot13: | | Obfuscating Data |
| rpc: | | NSS Basics |
| RPC bad procedure for program: | | Error Codes |
| RPC program not available: | | Error Codes |
| RPC program version wrong: | | Error Codes |
| RPC struct is bad: | | Error Codes |
| RPC version wrong: | | Error Codes |
| runnable process: | | Absolute Priority |
| running a command: | | Running a Command |
|
| S | | |
|---|
| saved set-group-ID: | | How Change Persona |
| saved set-user-ID: | | How Change Persona |
| scanning the group list: | | Scanning All Groups |
| scanning the user list: | | Scanning All Users |
| scatter-gather: | | Scatter-Gather |
| scheduling, traditional: | | Traditional Scheduling |
| scope ID: | | Internet Address Formats |
| search function (for arrays): | | Array Search Function |
| search functions (for strings): | | Search Functions |
| seed (for random numbers): | | Pseudo-Random Numbers |
| seeking on a file descriptor: | | File Position Primitive |
| seeking on a stream: | | File Positioning |
| segmentation violation: | | Program Error Signals |
| sending a datagram: | | Sending Datagrams |
| sending signals: | | Generating Signals |
| sequential-access files: | | File Position |
| server: | | Connections |
| services: | | NSS Basics |
| services database: | | Services Database |
| session: | | Job Control |
| session: | | Concepts of Job Control |
| session leader: | | Concepts of Job Control |
| setting an alarm: | | Setting an Alarm |
| setuid programs: | | How Change Persona |
| setuid programs and file access: | | Testing File Access |
| severity class: | | Printing Formatted Messages |
| severity class: | | Adding Severity Classes |
| sgettext: | | GUI program problems |
| sgettext: | | GUI program problems |
| shadow: | | NSS Basics |
| shadowing functions with macros: | | Macro Definitions |
| shared lock: | | File Locks |
| shared memory: | | Memory Subsystem |
| shared_cache_size tunables: | | Hardware Capability Tunables |
| shell: | | Concepts of Job Control |
| shift state: | | Keeping the state |
| Shift_JIS: | | Extended Char Intro |
| shrinking objects: | | Growing Objects |
| shutting down a socket: | | Closing a Socket |
| sig: | | Conditionally Safe Features |
| sigaction flags: | | Flags for Sigaction |
| sigaction function: | | Advanced Signal Handling |
| SIGCHLD, handling of: | | Stopped and Terminated Jobs |
| sigintr: | | Other Safety Remarks |
| sign (of floating point number): | | Floating Point Concepts |
| signal: | | FP Exceptions |
| signal: | | Signal Handling |
| signal action: | | Delivery of Signal |
| signal actions: | | Signal Actions |
| signal flags: | | Flags for Sigaction |
| signal function: | | Basic Signal Handling |
| signal handler function: | | Defining Handlers |
| signal mask: | | Process Signal Mask |
| signal messages: | | Signal Messages |
| signal names: | | Standard Signals |
| signal number: | | Standard Signals |
| signal set: | | Signal Sets |
| signals, generating: | | Generating Signals |
| signedness: | | Integers |
| significand (of floating point number): | | Floating Point Concepts |
| SIGTTIN, from background job: | | Access to the Terminal |
| SIGTTOU, from background job: | | Access to the Terminal |
| simple time: | | Calendar Time |
| single-byte string: | | Representation of Strings |
| single-call functions: | | Call Once |
| size of string: | | Representation of Strings |
| SJIS: | | Extended Char Intro |
| socket: | | Sockets |
| socket address (name) binding: | | Socket Addresses |
| socket domain: | | Socket Concepts |
| socket namespace: | | Socket Concepts |
| Socket operation on non-socket: | | Error Codes |
| socket option level: | | Socket Options |
| socket options: | | Socket Options |
| socket pair: | | Socket Pairs |
| socket protocol: | | Socket Concepts |
| socket shutdown: | | Closing a Socket |
| Socket type not supported: | | Error Codes |
| socket, client actions: | | Connecting |
| socket, closing: | | Closing a Socket |
| socket, connecting: | | Connecting |
| socket, creating: | | Creating a Socket |
| socket, initiating a connection: | | Connecting |
| sockets, accepting connections: | | Accepting Connections |
| sockets, listening: | | Listening |
| sockets, server actions: | | Listening |
| soft limit: | | Limits on Resources |
| soft link: | | Symbolic Links |
| Software caused connection abort: | | Error Codes |
| sort function (for arrays): | | Array Sort Function |
| sparse files: | | File Position Primitive |
| sparse files: | | Storage Allocation |
| special files: | | Making Special Files |
| special functions: | | Special Functions |
| specified action (for a signal): | | Delivery of Signal |
| speed of execution: | | Why Lock Pages |
| square root function: | | Exponents and Logarithms |
| Srmount error: | | Error Codes |
| stable sorting: | | Array Sort Function |
| Stale file handle: | | Error Codes |
| standard dot notation, for Internet addresses: | | Abstract Host Addresses |
| standard environment variables: | | Standard Environment |
| standard error file descriptor: | | Descriptors and Streams |
| standard error stream: | | Standard Streams |
| standard file descriptors: | | Descriptors and Streams |
| standard input file descriptor: | | Descriptors and Streams |
| standard input stream: | | Standard Streams |
| standard output file descriptor: | | Descriptors and Streams |
| standard output stream: | | Standard Streams |
| standard streams: | | Standard Streams |
| standards: | | Standards and Portability |
| START character: | | Start/Stop Characters |
| startup of program: | | Program Arguments |
| State not recoverable: | | Error Codes |
| stateful: | | Keeping the state |
| stateful: | | Converting a Character |
| stateful: | | Converting Strings |
| stateful: | | Generic Conversion Interface |
| stateful: | | iconv Examples |
| stateful: | | glibc iconv Implementation |
| static memory allocation: | | Memory Allocation and C |
| static storage class: | | Memory Allocation and C |
| STATUS character: | | Other Special |
| status codes: | | Error Reporting |
| status of a file: | | Attribute Meanings |
| status of obstack: | | Status of an Obstack |
| sticky bit: | | Permission Bits |
| STOP character: | | Start/Stop Characters |
| stop signal: | | Job Control Signals |
| stopped job: | | Concepts of Job Control |
| stopped jobs, continuing: | | Continuing Stopped Jobs |
| stopped jobs, detecting: | | Stopped and Terminated Jobs |
| storage allocating: | | Storage Allocation |
| storage allocation: | | Memory |
| stream (sockets): | | Socket Concepts |
| stream orientation: | | Opening Streams |
| stream orientation: | | Streams and I18N |
| stream, for I/O to a string: | | String Streams |
| streams and descriptors: | | Stream/Descriptor Precautions |
| Streams pipe error: | | Error Codes |
| streams, and file descriptors: | | Descriptors and Streams |
| streams, C++: | | Streams and I18N |
| streams, standard: | | Standard Streams |
| string: | | Representation of Strings |
| string allocation: | | Representation of Strings |
| string collation functions: | | Collation Functions |
| string comparison functions: | | String/Array Comparison |
| string concatenation functions: | | Copying Strings and Arrays |
| string concatenation functions: | | Concatenating Strings |
| string copy functions: | | Copying Strings and Arrays |
| string length: | | Representation of Strings |
| string literal: | | Representation of Strings |
| string search functions: | | Search Functions |
| string stream: | | String Streams |
| string truncation: | | Truncating Strings |
| string vectors, null-byte separated: | | Argz and Envz Vectors |
| string, representation of: | | Representation of Strings |
| Structure needs cleaning: | | Error Codes |
| style of communication (of a socket): | | Socket Concepts |
| subprocess: | | Process Creation Concepts |
| subshell: | | Initializing the Shell |
| substitution of variables and commands: | | Expansion Stages |
| successive signals: | | Merged Signals |
| summer time: | | Broken-down Time |
| SunOS: | | Berkeley Unix |
| supplementary group IDs: | | Process Persona |
| SUSP character: | | Signal Characters |
| suspend character: | | Signal Characters |
| SVID: | | SVID |
| swap space: | | Memory Concepts |
| symbolic link: | | Symbolic Links |
| symbolic link, opening: | | Open-time Flags |
| synchronizing: | | Synchronizing I/O |
| synchronizing: | | Synchronizing AIO Operations |
| syntax error messages, in argp: | | Argp Helper Functions |
| syntax, for program arguments: | | Argument Syntax |
| syntax, for reading numbers: | | Parsing of Numbers |
| sysconf: | | Query Memory Parameters |
| sysconf: | | Query Memory Parameters |
| sysconf: | | Processor Resources |
| sysconf: | | Processor Resources |
| system call: | | System Calls |
| system call number: | | System Calls |
| System V Unix: | | SVID |
|
| T | | |
|---|
| task ID: | | Process Identification |
| TCP (Internet protocol): | | Protocols Database |
| template, for printf: | | Formatted Output |
| template, for scanf: | | Formatted Input |
| term: | | Conditionally Safe Features |
| TERM environment variable: | | Standard Environment |
| terminal flow control: | | Line Control |
| terminal identification: | | Is It a Terminal |
| terminal input queue: | | I/O Queues |
| terminal input queue, clearing: | | Line Control |
| terminal input signal: | | Job Control Signals |
| terminal line control functions: | | Line Control |
| terminal line speed: | | Line Speed |
| terminal line speed: | | Line Speed |
| terminal mode data types: | | Mode Data Types |
| terminal mode functions: | | Mode Functions |
| terminal modes, BSD: | | BSD Terminal Modes |
| terminal output queue: | | I/O Queues |
| terminal output queue, flushing: | | Line Control |
| terminal output signal: | | Job Control Signals |
| terminated jobs, detecting: | | Stopped and Terminated Jobs |
| termination signal: | | Termination Signals |
| testing access permission: | | Testing File Access |
| testing exit status of child process: | | Process Completion |
| Text file busy: | | Error Codes |
| text stream: | | Binary Streams |
| thrashing: | | Memory Subsystem |
| thread control: | | ISO C Thread Management |
| thread creation: | | ISO C Thread Management |
| thread group: | | Process Identification |
| thread ID: | | Process Identification |
| thread management: | | ISO C Thread Management |
| thread mutex tunables: | | POSIX Thread Tunables |
| thread of control: | | Program Basics |
| thread-local storage: | | ISO C Thread-local Storage |
| Thread-Safe: | | POSIX Safety Concepts |
| Thread-Unsafe: | | POSIX Safety Concepts |
| threads: | | Streams and Threads |
| threads: | | Threads |
| ticks, clock: | | Processor And CPU Time |
| tilde expansion: | | Expansion Stages |
| time: | | Time Basics |
| TIME termios slot: | | Noncanonical Input |
| time zone: | | TZ Variable |
| time zone database: | | TZ Variable |
| time, elapsed: | | Time Basics |
| time, high precision: | | High Accuracy Clock |
| timer: | | Unsafe Features |
| Timer expired: | | Error Codes |
| timer, profiling: | | Setting an Alarm |
| timer, real-time: | | Setting an Alarm |
| timer, virtual: | | Setting an Alarm |
| timers, setting: | | Setting an Alarm |
| timespec: | | Elapsed Time |
| timeval: | | Elapsed Time |
| timing error in signal handling: | | Remembering a Signal |
| TMPDIR environment variable: | | Temporary Files |
| tokenizing strings: | | Finding Tokens in a String |
| Too many levels of symbolic links: | | Error Codes |
| Too many links: | | Error Codes |
| Too many open files: | | Error Codes |
| Too many open files in system: | | Error Codes |
| Too many processes: | | Error Codes |
| Too many references: cannot splice: | | Error Codes |
| Too many users: | | Error Codes |
| tools, for installing library: | | Tools for Compilation |
| traffic class: | | Internet Address Formats |
| Translator died: | | Error Codes |
| transmitting datagrams: | | Sending Datagrams |
| Transport endpoint is already connected: | | Error Codes |
| Transport endpoint is not connected: | | Error Codes |
| tree, directory: | | Working with Directory Trees |
| triangulation: | | glibc iconv Implementation |
| trigonometric functions: | | Trig Functions |
| truncating strings: | | Truncating Strings |
| Tunable names: | | Tunable names |
| Tunable namespaces: | | Tunable names |
| tunables: | | Tunables |
| tunables thread mutex: | | POSIX Thread Tunables |
| tunables, data_cache_size: | | Hardware Capability Tunables |
| tunables, elision: | | Elision Tunables |
| tunables, hwcap: | | Hardware Capability Tunables |
| tunables, hwcaps: | | Hardware Capability Tunables |
| tunables, malloc: | | Memory Allocation Tunables |
| tunables, non_temporal_threshold: | | Hardware Capability Tunables |
| tunables, shared_cache_size: | | Hardware Capability Tunables |
| type measurements, floating: | | Floating Type Macros |
| type measurements, integer: | | Width of Type |
| type modifier character (printf): | | Output Conversion Syntax |
| type modifier character (scanf): | | Input Conversion Syntax |
| typeahead buffer: | | I/O Queues |
| TZ environment variable: | | Standard Environment |
|
| U | | |
|---|
| UCS-2: | | Extended Char Intro |
| UCS-4: | | Extended Char Intro |
| ulps: | | Errors in Math Functions |
| umask: | | Setting Permissions |
| unbuffered stream: | | Buffering Concepts |
| unconstrained memory allocation: | | Unconstrained Allocation |
| undefining macros that shadow functions: | | Macro Definitions |
| underflow exception: | | FP Exceptions |
| Unicode: | | Extended Char Intro |
| Unix, Berkeley: | | Berkeley Unix |
| Unix, System V: | | SVID |
| unlinking a file: | | Deleting Files |
| unordered comparison: | | FP Comparison Functions |
| unreading characters: | | Unreading |
| Unsafe Features: | | Unsafe Features |
| upper-case character: | | Classification of Characters |
| upper-case character: | | Classification of Wide Characters |
| urgent data signal: | | Asynchronous I/O Signals |
| urgent socket condition: | | Out-of-Band Data |
| usage limits: | | Limits on Resources |
| usage messages, in argp: | | Argp Helper Functions |
| user accounting database: | | User Accounting Database |
| user database: | | User Database |
| user ID: | | User and Group IDs |
| user ID, determining: | | Who Logged In |
| user name: | | User and Group IDs |
| user signals: | | Miscellaneous Signals |
| usual file name errors: | | File Name Errors |
| UTF-16: | | Extended Char Intro |
| UTF-7: | | Extended Char Intro |
| UTF-8: | | Extended Char Intro |
| UTF-8: | | Extended Char Intro |
|
| V | | |
|---|
| Value too large for defined data type: | | Error Codes |
| variable number of arguments: | | Variadic Functions |
| variable substitution: | | Expansion Stages |
| variable-sized arrays: | | GNU C Variable-Size Arrays |
| variadic function argument access: | | Receiving Arguments |
| variadic function prototypes: | | Variadic Prototypes |
| variadic functions: | | Variadic Functions |
| variadic functions, calling: | | Calling Variadics |
| va_copy: | | Concatenating Strings |
| virtual time alarm signal: | | Alarm Signals |
| virtual timer: | | Setting an Alarm |
| volatile declarations: | | Nonreentrancy |
|
| W | | |
|---|
| waiting for a signal: | | Waiting for a Signal |
| waiting for completion of child process: | | Process Completion |
| waiting for input or output: | | Waiting for I/O |
| WERASE character: | | Editing Characters |
| whitespace character: | | Classification of Characters |
| whitespace character: | | Classification of Wide Characters |
| wide character: | | Extended Char Intro |
| wide string: | | Representation of Strings |
| wide string: | | Representation of Strings |
| width of integer type: | | Width of Type |
| wildcard expansion: | | Expansion Stages |
| wint_t: | | String/Array Conventions |
| word expansion: | | Word Expansion |
| working directory: | | Working Directory |
| write lock: | | File Locks |
| writing to a file descriptor: | | I/O Primitives |
| writing to a socket: | | Transferring Data |
| writing to a stream, by blocks: | | Block Input/Output |
| writing to a stream, by characters: | | Simple Output |
| writing to a stream, formatted: | | Formatted Output |
| Wrong medium type: | | Error Codes |
|
| Y | | |
|---|
| You really blew it this time: | | Error Codes |
| YP: | | Host Identification |
| YP domain name: | | Host Identification |
| YP domain name: | | Host Identification |
| YP domain name: | | Host Identification |
|
| Z | | |
|---|
| zero divide: | | FP Exceptions |
|