| 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 |
| aliases: | NSS Basics |
| 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 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: | Time Basics |
| 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 time, simple: | Time Basics |
| calendar, Gregorian: | Time Basics |
| 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: | Time Types |
| clock ticks: | Processor And CPU Time |
| clock, disciplining: | Setting and Adjusting the Time |
| clock, high accuracy: | Setting and Adjusting the Time |
| 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 linker: | Dynamic Linker |
| dynamic linking tunables: | Dynamic Linking Tunables |
| dynamic loader: | Dynamic Linker |
| 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 |
| 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: | Time Basics |
| epoch: | Time Types |
| 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 |
| gmon tunables: | gmon Tunables |
| gnu allocator: | The GNU Allocator |
| graphic character: | Classification of Characters |
| graphic character: | Classification of Wide Characters |
| Gratuitous error: | Error Codes |
| Gregorian calendar: | Time Basics |
| 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 |
| gshadow: | NSS Basics |
|
| 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 |
| 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 |
| initgroups: | NSS Basics |
| 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 |
| leap seconds: | Time Basics |
| 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 abbreviation 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: | Time Basics |
| 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 |
| memory related tunables: | Memory Related Tunables |
| 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 |
| monotonic time: | Getting the Time |
| 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 |
| publickey: | NSS Basics |
| 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 |
| rtld tunables: | Dynamic Linking Tunables |
| 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 |
| seconds, leap: | Time Basics |
| 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 calendar time: | Time Basics |
| simple time: | Time Basics |
| 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: | Time Types |
| 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: | Setting and Adjusting the Time |
| 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: | Time Types |
| timeval: | Time Types |
| 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 |
|
| X |
|---|
xmalloc function: | Malloc Examples |
xrealloc and xreallocarray functions: | Changing Block Size |
|
| 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 |
|