The GNU C Library Reference Manual

This is Edition 0.10, last updated 2001-07-06, of The GNU C Library Reference Manual, for Version 2.3.x.

Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being "Free Software Needs Free Documentation" and "GNU Lesser General Public License", the Front-Cover texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the section entitled "GNU Free Documentation License".

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development.

Main Menu

This is Edition 0.10, last updated 2001-07-06, of The GNU C Library Reference Manual, for Version 2.3.x of the GNU C Library.

• Introduction: Purpose of the GNU C Library.
• Error Reporting: How library functions report errors.
• Memory: Allocating virtual memory and controlling paging.
• Character Handling: Character testing and conversion functions.
• String and Array Utilities: Utilities for copying and comparing strings and arrays.
• Character Set Handling: Support for extended character sets.
• Locales: The country and language can affect the behavior of library functions.
• Message Translation: How to make the program speak the user's language.
• Searching and Sorting: General searching and sorting functions.
• Pattern Matching: Matching shell ``globs'' and regular expressions.
• I/O Overview: Introduction to the I/O facilities.
• I/O on Streams: High-level, portable I/O facilities.
• Low-Level I/O: Low-level, less portable I/O.
• File System Interface: Functions for manipulating files.
• Pipes and FIFOs: A simple interprocess communication mechanism.
• Sockets: A more complicated IPC mechanism, with networking support.
• Low-Level Terminal Interface: How to change the characteristics of a terminal device.
• Syslog: System logging and messaging.
• Mathematics: Math functions, useful constants, random numbers.
• Arithmetic: Low level arithmetic functions.
• Date and Time: Functions for getting the date and time and formatting them nicely.
• Resource Usage And Limitation: Functions for examining resource usage and getting and setting limits.
• Non-Local Exits: Jumping out of nested function calls.
• Signal Handling: How to send, block, and handle signals.
• Program Basics: Writing the beginning and end of your program.
• Processes: How to create processes and run other programs.
• Job Control: All about process groups and sessions.
• Name Service Switch: Accessing system databases.
• Users and Groups: How users are identified and classified.
• System Management: Controlling the system and getting information about it.
• System Configuration: Parameters describing operating system limits.
• Cryptographic Functions: DES encryption and password handling.
• Debugging Support: Functions to help debugging applications.

  Add-ons

• POSIX Threads: The standard threads library.

  Appendices

• Language Features: C language features provided by the library.
• Library Summary: A summary showing the syntax, header file, and derivation of each library feature.
• Installation: How to install the GNU C library.
• Maintenance: How to enhance and port the GNU C Library.
• Contributors: Who wrote what parts of the GNU C library.
• Free Manuals: Free Software Needs Free Documentation.
• Copying: The GNU Lesser General Public License says how you can copy and share the GNU C Library.
• Documentation License: This manual is under the GNU Free Documentation License.

  Indices

• Concept Index: Index of concepts and names.
• Type Index: Index of types and type qualifiers.
• Function Index: Index of functions and function-like macros.
• Variable Index: Index of variables and variable-like macros.
• File Index: Index of programs and files.

  --- The Detailed Node Listing ---

  Introduction

• Getting Started: What this manual is for and how to use it.
• Standards and Portability: Standards and sources upon which the GNU C library is based.
• Using the Library: Some practical uses for the library.
• Roadmap to the Manual: Overview of the remaining chapters in this manual.

  Standards and Portability

• ISO C: The international standard for the C programming language.
• POSIX: The ISO/IEC 9945 (aka IEEE 1003) standards for operating systems.
• Berkeley Unix: BSD and SunOS.
• SVID: The System V Interface Description.
• XPG: The X/Open Portability Guide.

  Using the Library

• Header Files: How to include the header files in your programs.
• Macro Definitions: Some functions in the library may really be implemented as macros.
• Reserved Names: The C standard reserves some names for the library, and some for users.
• Feature Test Macros: How to control what names are defined.

  Error Reporting

• Checking for Errors: How errors are reported by library functions.
• Error Codes: Error code macros; all of these expand into integer constant values.
• Error Messages: Mapping error codes onto error messages.

  Memory

• Memory Concepts: An introduction to concepts and terminology.
• Memory Allocation: Allocating storage for your program data
• Locking Pages: Preventing page faults
• Resizing the Data Segment: brk, sbrk

  Memory Allocation

• Memory Allocation and C: How to get different kinds of allocation in C.
• Unconstrained Allocation: The malloc facility allows fully general dynamic allocation.
• Allocation Debugging: Finding memory leaks and not freed memory.
• Obstacks: Obstacks are less general than malloc but more efficient and convenient.
• Variable Size Automatic: Allocation of variable-sized blocks of automatic storage that are freed when the calling function returns.

  Unconstrained Allocation

• Basic Allocation: Simple use of malloc.
• Malloc Examples: Examples of malloc. xmalloc.
• Freeing after Malloc: Use free to free a block you got with malloc.
• Changing Block Size: Use realloc to make a block bigger or smaller.
• Allocating Cleared Space: Use calloc to allocate a block and clear it.
• Efficiency and Malloc: Efficiency considerations in use of these functions.
• Aligned Memory Blocks: Allocating specially aligned memory.
• Malloc Tunable Parameters: Use mallopt to adjust allocation parameters.
• Heap Consistency Checking: Automatic checking for errors.
• Hooks for Malloc: You can use these hooks for debugging programs that use malloc.
• Statistics of Malloc: Getting information about how much memory your program is using.
• Summary of Malloc: Summary of malloc and related functions.

  Allocation Debugging

• Tracing malloc: How to install the tracing functionality.
• Using the Memory Debugger: Example programs excerpts.
• Tips for the Memory Debugger: Some more or less clever ideas.
• Interpreting the traces: What do all these lines mean?

  Obstacks

• Creating Obstacks: How to declare an obstack in your program.
• Preparing for Obstacks: Preparations needed before you can use obstacks.
• Allocation in an Obstack: Allocating objects in an obstack.
• Freeing Obstack Objects: Freeing objects in an obstack.
• Obstack Functions: The obstack functions are both functions and macros.
• Growing Objects: Making an object bigger by stages.
• Extra Fast Growing: Extra-high-efficiency (though more complicated) growing objects.
• Status of an Obstack: Inquiries about the status of an obstack.
• Obstacks Data Alignment: Controlling alignment of objects in obstacks.
• Obstack Chunks: How obstacks obtain and release chunks; efficiency considerations.
• Summary of Obstacks:

  Variable Size Automatic

• Alloca Example: Example of using alloca.
• Advantages of Alloca: Reasons to use alloca.
• Disadvantages of Alloca: Reasons to avoid alloca.
• GNU C Variable-Size Arrays: Only in GNU C, here is an alternative method of allocating dynamically and freeing automatically.

  Locking Pages

• Why Lock Pages: Reasons to read this section.
• Locked Memory Details: Everything you need to know locked memory
• Page Lock Functions: Here's how to do it.

  Character Handling

• Classification of Characters: Testing whether characters are letters, digits, punctuation, etc.

• Case Conversion: Case mapping, and the like.
• Classification of Wide Characters: Character class determination for wide characters.
• Using Wide Char Classes: Notes on using the wide character classes.
• Wide Character Case Conversion: Mapping of wide characters.

  String and Array Utilities

• Representation of Strings: Introduction to basic concepts.
• String/Array Conventions: Whether to use a string function or an arbitrary array function.
• String Length: Determining the length of a string.
• Copying and Concatenation: Functions to copy the contents of strings and arrays.
• String/Array Comparison: Functions for byte-wise and character-wise comparison.
• Collation Functions: Functions for collating strings.
• Search Functions: Searching for a specific element or substring.
• Finding Tokens in a String: Splitting a string into tokens by looking for delimiters.
• strfry: Function for flash-cooking a string.
• Trivial Encryption: Obscuring data.
• Encode Binary Data: Encoding and Decoding of Binary Data.
• Argz and Envz Vectors: Null-separated string vectors.

  Argz and Envz Vectors

• Argz Functions: Operations on argz vectors.
• Envz Functions: Additional operations on environment vectors.

  Character Set Handling

• Extended Char Intro: Introduction to Extended Characters.
• Charset Function Overview: Overview about Character Handling Functions.
• Restartable multibyte conversion: Restartable multibyte conversion Functions.
• Non-reentrant Conversion: Non-reentrant Conversion Function.
• Generic Charset Conversion: Generic Charset Conversion.

  Restartable multibyte conversion

• Selecting the Conversion: Selecting the conversion and its properties.
• Keeping the state: Representing the state of the conversion.
• Converting a Character: Converting Single Characters.
• Converting Strings: Converting Multibyte and Wide Character Strings.
• Multibyte Conversion Example: A Complete Multibyte Conversion Example.

  Non-reentrant Conversion

• Non-reentrant Character Conversion: Non-reentrant Conversion of Single Characters.
• Non-reentrant String Conversion: Non-reentrant Conversion of Strings.
• Shift State: States in Non-reentrant Functions.

  Generic Charset Conversion

• Generic Conversion Interface: Generic Character Set Conversion Interface.
• iconv Examples: A complete iconv example.
• Other iconv Implementations: Some Details about other iconv Implementations.
• glibc iconv Implementation: The iconv Implementation in the GNU C library.

  Locales

• Effects of Locale: Actions affected by the choice of locale.
• Choosing Locale: How the user specifies a locale.
• Locale Categories: Different purposes for which you can select a locale.
• Setting the Locale: How a program specifies the locale with library functions.
• Standard Locales: Locale names available on all systems.
• Locale Information: How to access the information for the locale.
• Formatting Numbers: A dedicated function to format numbers.
• Yes-or-No Questions: Check a Response against the locale.

  Locale Information

• The Lame Way to Locale Data: ISO C's localeconv.
• The Elegant and Fast Way: X/Open's nl_langinfo.

  The Lame Way to Locale Data

• General Numeric: Parameters for formatting numbers and currency amounts.
• Currency Symbol: How to print the symbol that identifies an amount of money (e.g. $).
• Sign of Money Amount: How to print the (positive or negative) sign for a monetary amount, if one exists.

  Message Translation

• Message catalogs a la X/Open: The catgets family of functions.
• The Uniforum approach: The gettext family of functions.

  Message catalogs a la X/Open

• The catgets Functions: The catgets function family.
• The message catalog files: Format of the message catalog files.
• The gencat program: How to generate message catalogs files which can be used by the functions.
• Common Usage: How to use the catgets interface.

  The Uniforum approach

• Message catalogs with gettext: The gettext family of functions.
• Helper programs for gettext: Programs to handle message catalogs for gettext.

  Message catalogs with gettext

• Translation with gettext: What has to be done to translate a message.
• Locating gettext catalog: How to determine which catalog to be used.
• Advanced gettext functions: Additional functions for more complicated situations.
• Charset conversion in gettext: How to specify the output character set gettext uses.
• GUI program problems: How to use gettext in GUI programs.
• Using gettextized software: The possibilities of the user to influence the way gettext works.

  Searching and Sorting

• Comparison Functions: Defining how to compare two objects. Since the sort and search facilities are general, you have to specify the ordering.
• Array Search Function: The bsearch function.
• Array Sort Function: The qsort function.
• Search/Sort Example: An example program.
• Hash Search Function: The hsearch function.
• Tree Search Function: The tsearch function.

  Pattern Matching

• Wildcard Matching: Matching a wildcard pattern against a single string.
• Globbing: Finding the files that match a wildcard pattern.
• Regular Expressions: Matching regular expressions against strings.
• Word Expansion: Expanding shell variables, nested commands, arithmetic, and wildcards. This is what the shell does with shell commands.

  Globbing

• Calling Glob: Basic use of glob.
• Flags for Globbing: Flags that enable various options in glob.
• More Flags for Globbing: GNU specific extensions to glob.

  Regular Expressions

• POSIX Regexp Compilation: Using regcomp to prepare to match.
• Flags for POSIX Regexps: Syntax variations for regcomp.
• Matching POSIX Regexps: Using regexec to match the compiled pattern that you get from regcomp.
• Regexp Subexpressions: Finding which parts of the string were matched.
• Subexpression Complications: Find points of which parts were matched.
• Regexp Cleanup: Freeing storage; reporting errors.

  Word Expansion

• Expansion Stages: What word expansion does to a string.
• Calling Wordexp: How to call wordexp.
• Flags for Wordexp: Options you can enable in wordexp.
• Wordexp Example: A sample program that does word expansion.
• Tilde Expansion: Details of how tilde expansion works.
• Variable Substitution: Different types of variable substitution.

  I/O Overview

• I/O Concepts: Some basic information and terminology.
• File Names: How to refer to a file.

  I/O Concepts

• Streams and File Descriptors: The GNU Library provides two ways to access the contents of files.
• File Position: The number of bytes from the beginning of the file.

  File Names

• Directories: Directories contain entries for files.
• File Name Resolution: A file name specifies how to look up a file.
• File Name Errors: Error conditions relating to file names.
• File Name Portability: File name portability and syntax issues.

  I/O on Streams

• Streams: About the data type representing a stream.
• Standard Streams: Streams to the standard input and output devices are created for you.
• Opening Streams: How to create a stream to talk to a file.
• Closing Streams: Close a stream when you are finished with it.
• Streams and Threads: Issues with streams in threaded programs.
• Streams and I18N: Streams in internationalized applications.
• Simple Output: Unformatted output by characters and lines.
• Character Input: Unformatted input by characters and words.
• Line Input: Reading a line or a record from a stream.
• Unreading: Peeking ahead/pushing back input just read.
• Block Input/Output: Input and output operations on blocks of data.
• Formatted Output: printf and related functions.
• Customizing Printf: You can define new conversion specifiers for printf and friends.
• Formatted Input: scanf and related functions.
• EOF and Errors: How you can tell if an I/O error happens.
• Error Recovery: What you can do about errors.
• Binary Streams: Some systems distinguish between text files and binary files.
• File Positioning: About random-access streams.
• Portable Positioning: Random access on peculiar ISO C systems.
• Stream Buffering: How to control buffering of streams.
• Other Kinds of Streams: Streams that do not necessarily correspond to an open file.
• Formatted Messages: Print strictly formatted messages.

  Unreading

• Unreading Idea: An explanation of unreading with pictures.
• How Unread: How to call ungetc to do unreading.

  Formatted Output

• Formatted Output Basics: Some examples to get you started.
• Output Conversion Syntax: General syntax of conversion specifications.
• Table of Output Conversions: Summary of output conversions and what they do.
• Integer Conversions: Details about formatting of integers.
• Floating-Point Conversions: Details about formatting of floating-point numbers.
• Other Output Conversions: Details about formatting of strings, characters, pointers, and the like.
• Formatted Output Functions: Descriptions of the actual functions.
• Dynamic Output: Functions that allocate memory for the output.
• Variable Arguments Output: vprintf and friends.
• Parsing a Template String: What kinds of args does a given template call for?
• Example of Parsing: Sample program using parse_printf_format.

  Customizing Printf

• Registering New Conversions: Using register_printf_function to register a new output conversion.
• Conversion Specifier Options: The handler must be able to get the options specified in the template when it is called.
• Defining the Output Handler: Defining the handler and arginfo functions that are passed as arguments to register_printf_function.
• Printf Extension Example: How to define a printf handler function.
• Predefined Printf Handlers: Predefined printf handlers.

  Formatted Input

• Formatted Input Basics: Some basics to get you started.
• Input Conversion Syntax: Syntax of conversion specifications.
• Table of Input Conversions: Summary of input conversions and what they do.
• Numeric Input Conversions: Details of conversions for reading numbers.
• String Input Conversions: Details of conversions for reading strings.
• Dynamic String Input: String conversions that malloc the buffer.
• Other Input Conversions: Details of miscellaneous other conversions.
• Formatted Input Functions: Descriptions of the actual functions.
• Variable Arguments Input: vscanf and friends.

  Stream Buffering

• Buffering Concepts: Terminology is defined here.
• Flushing Buffers: How to ensure that output buffers are flushed.
• Controlling Buffering: How to specify what kind of buffering to use.

  Other Kinds of Streams

• String Streams: Streams that get data from or put data in a string or memory buffer.
• Obstack Streams: Streams that store data in an obstack.
• Custom Streams: Defining your own streams with an arbitrary input data source and/or output data sink.

  Custom Streams

• Streams and Cookies: The cookie records where to fetch or store data that is read or written.
• Hook Functions: How you should define the four hook functions that a custom stream needs.

  Formatted Messages

• Printing Formatted Messages: The fmtmsg function.
• Adding Severity Classes: Add more severity classes.
• Example: How to use fmtmsg and addseverity.

  Low-Level I/O

• Opening and Closing Files: How to open and close file descriptors.
• I/O Primitives: Reading and writing data.
• File Position Primitive: Setting a descriptor's file position.
• Descriptors and Streams: Converting descriptor to stream or vice-versa.
• Stream/Descriptor Precautions: Precautions needed if you use both descriptors and streams.
• Scatter-Gather: Fast I/O to discontinuous buffers.
• Memory-mapped I/O: Using files like memory.
• Waiting for I/O: How to check for input or output on multiple file descriptors.
• Synchronizing I/O: Making sure all I/O actions completed.
• Asynchronous I/O: Perform I/O in parallel.
• Control Operations: Various other operations on file descriptors.
• Duplicating Descriptors: Fcntl commands for duplicating file descriptors.
• Descriptor Flags: Fcntl commands for manipulating flags associated with file descriptors.
• File Status Flags: Fcntl commands for manipulating flags associated with open files.
• File Locks: Fcntl commands for implementing file locking.
• Interrupt Input: Getting an asynchronous signal when input arrives.
• IOCTLs: Generic I/O Control operations.

  Stream/Descriptor Precautions

• Linked Channels: Dealing with channels sharing a file position.
• Independent Channels: Dealing with separately opened, unlinked channels.
• Cleaning Streams: Cleaning a stream makes it safe to use another channel.

  Asynchronous I/O

• Asynchronous Reads/Writes: Asynchronous Read and Write Operations.
• Status of AIO Operations: Getting the Status of AIO Operations.
• Synchronizing AIO Operations: Getting into a consistent state.
• Cancel AIO Operations: Cancellation of AIO Operations.
• Configuration of AIO: How to optimize the AIO implementation.

  File Status Flags

• Access Modes: Whether the descriptor can read or write.
• Open-time Flags: Details of open.
• Operating Modes: Special modes to control I/O operations.
• Getting File Status Flags: Fetching and changing these flags.

  File System Interface

• Working Directory: This is used to resolve relative file names.
• Accessing Directories: Finding out what files a directory contains.
• Working with Directory Trees: Apply actions to all files or a selectable subset of a directory hierarchy.
• Hard Links: Adding alternate names to a file.
• Symbolic Links: A file that ``points to'' a file name.
• Deleting Files: How to delete a file, and what that means.
• Renaming Files: Changing a file's name.
• Creating Directories: A system call just for creating a directory.
• File Attributes: Attributes of individual files.
• Making Special Files: How to create special files.
• Temporary Files: Naming and creating temporary files.

  Accessing Directories

• Directory Entries: Format of one directory entry.
• Opening a Directory: How to open a directory stream.
• Reading/Closing Directory: How to read directory entries from the stream.
• Simple Directory Lister: A very simple directory listing program.
• Random Access Directory: Rereading part of the directory already read with the same stream.
• Scanning Directory Content: Get entries for user selected subset of contents in given directory.
• Simple Directory Lister Mark II: Revised version of the program.

  File Attributes

• Attribute Meanings: The names of the file attributes, and what their values mean.
• Reading Attributes: How to read the attributes of a file.
• Testing File Type: Distinguishing ordinary files, directories, links...
• File Owner: How ownership for new files is determined, and how to change it.
• Permission Bits: How information about a file's access mode is stored.
• Access Permission: How the system decides who can access a file.
• Setting Permissions: How permissions for new files are assigned, and how to change them.
• Testing File Access: How to find out if your process can access a file.
• File Times: About the time attributes of a file.
• File Size: Manually changing the size of a file.

  Pipes and FIFOs

• Creating a Pipe: Making a pipe with the pipe function.
• Pipe to a Subprocess: Using a pipe to communicate with a child process.
• FIFO Special Files: Making a FIFO special file.
• Pipe Atomicity: When pipe (or FIFO) I/O is atomic.

  Sockets

• Socket Concepts: Basic concepts you need to know about.
• Communication Styles: Stream communication, datagrams and other styles.
• Socket Addresses: How socket names (``addresses'') work.
• Interface Naming: Identifying specific network interfaces.
• Local Namespace: Details about the local namespace.
• Internet Namespace: Details about the Internet namespace.
• Misc Namespaces: Other namespaces not documented fully here.
• Open/Close Sockets: Creating sockets and destroying them.
• Connections: Operations on sockets with connection state.
• Datagrams: Operations on datagram sockets.
• Inetd: Inetd is a daemon that starts servers on request. The most convenient way to write a server is to make it work with Inetd.
• Socket Options: Miscellaneous low-level socket options.
• Networks Database: Accessing the database of network names.

  Socket Addresses

• Address Formats: About struct sockaddr.
• Setting Address: Binding an address to a socket.
• Reading Address: Reading the address of a socket.

  Local Namespace

• Concepts: What you need to understand.
• Details: Address format, symbolic names, etc.
• Example: Example of creating a socket.

  Internet Namespace

• Internet Address Formats: How socket addresses are specified in the Internet namespace.
• Host Addresses: All about host addresses of Internet host.
• Protocols Database: Referring to protocols by name.
• Ports: Internet port numbers.
• Services Database: Ports may have symbolic names.
• Byte Order: Different hosts may use different byte ordering conventions; you need to canonicalize host address and port number.
• Inet Example: Putting it all together.

  Host Addresses

• Abstract Host Addresses: What a host number consists of.
• Data type: Data type for a host number.
• Functions: Functions to operate on them.
• Names: Translating host names to host numbers.

  Open/Close Sockets

• Creating a Socket: How to open a socket.
• Closing a Socket: How to close a socket.
• Socket Pairs: These are created like pipes.

  Connections

• Connecting: What the client program must do.
• Listening: How a server program waits for requests.
• Accepting Connections: What the server does when it gets a request.
• Who is Connected: Getting the address of the other side of a connection.
• Transferring Data: How to send and receive data.
• Byte Stream Example: An example program: a client for communicating over a byte stream socket in the Internet namespace.
• Server Example: A corresponding server program.
• Out-of-Band Data: This is an advanced feature.

  Transferring Data

• Sending Data: Sending data with send.
• Receiving Data: Reading data with recv.
• Socket Data Options: Using send and recv.

  Datagrams

• Sending Datagrams: Sending packets on a datagram socket.
• Receiving Datagrams: Receiving packets on a datagram socket.
• Datagram Example: An example program: packets sent over a datagram socket in the local namespace.
• Example Receiver: Another program, that receives those packets.

  Inetd

• Inetd Servers:
• Configuring Inetd:

  Socket Options

• Socket Option Functions: The basic functions for setting and getting socket options.
• Socket-Level Options: Details of the options at the socket level.

  Low-Level Terminal Interface

• Is It a Terminal: How to determine if a file is a terminal device, and what its name is.
• I/O Queues: About flow control and typeahead.
• Canonical or Not: Two basic styles of input processing.
• Terminal Modes: How to examine and modify flags controlling details of terminal I/O: echoing, signals, editing. Posix.
• BSD Terminal Modes: BSD compatible terminal mode setting
• Line Control: Sending break sequences, clearing terminal buffers ...
• Noncanon Example: How to read single characters without echo.
• Pseudo-Terminals: How to open a pseudo-terminal.

  Terminal Modes

• Mode Data Types: The data type struct termios and related types.
• Mode Functions: Functions to read and set the terminal attributes.
• Setting Modes: The right way to set terminal attributes reliably.
• Input Modes: Flags controlling low-level input handling.
• Output Modes: Flags controlling low-level output handling.
• Control Modes: Flags controlling serial port behavior.
• Local Modes: Flags controlling high-level input handling.
• Line Speed: How to read and set the terminal line speed.
• Special Characters: Characters that have special effects, and how to change them.
• Noncanonical Input: Controlling how long to wait for input.

  Special Characters

• Editing Characters: Special characters that terminate lines and delete text, and other editing functions.
• Signal Characters: Special characters that send or raise signals to or for certain classes of processes.
• Start/Stop Characters: Special characters that suspend or resume suspended output.
• Other Special: Other special characters for BSD systems: they can discard output, and print status.

  Pseudo-Terminals

• Allocation: Allocating a pseudo terminal.
• Pseudo-Terminal Pairs: How to open both sides of a pseudo-terminal in a single operation.

  Syslog

• Overview of Syslog: Overview of a system's Syslog facility
• Submitting Syslog Messages: Functions to submit messages to Syslog

  Submitting Syslog Messages

• openlog: Open connection to Syslog
• syslog; vsyslog: Submit message to Syslog
• closelog: Close connection to Syslog
• setlogmask: Cause certain messages to be ignored
• Syslog Example: Example of all of the above

  Mathematics

• Mathematical Constants: Precise numeric values for often-used constants.
• Trig Functions: Sine, cosine, tangent, and friends.
• Inverse Trig Functions: Arcsine, arccosine, etc.
• Exponents and Logarithms: Also pow and sqrt.
• Hyperbolic Functions: sinh, cosh, tanh, etc.
• Special Functions: Bessel, gamma, erf.
• Errors in Math Functions: Known Maximum Errors in Math Functions.
• Pseudo-Random Numbers: Functions for generating pseudo-random numbers.
• FP Function Optimizations: Fast code or small code.

  Pseudo-Random Numbers

• ISO Random: rand and friends.
• BSD Random: random and friends.
• SVID Random: drand48 and friends.

  Arithmetic

• Integers: Basic integer types and concepts
• Integer Division: Integer division with guaranteed rounding.
• Floating Point Numbers: Basic concepts. IEEE 754.
• Floating Point Classes: The five kinds of floating-point number.
• Floating Point Errors: When something goes wrong in a calculation.
• Rounding: Controlling how results are rounded.
• Control Functions: Saving and restoring the FPU's state.
• Arithmetic Functions: Fundamental operations provided by the library.
• Complex Numbers: The types. Writing complex constants.
• Operations on Complex: Projection, conjugation, decomposition.
• Parsing of Numbers: Converting strings to numbers.
• System V Number Conversion: An archaic way to convert numbers to strings.

  Floating Point Errors

• FP Exceptions: IEEE 754 math exceptions and how to detect them.
• Infinity and NaN: Special values returned by calculations.
• Status bit operations: Checking for exceptions after the fact.
• Math Error Reporting: How the math functions report errors.

  Arithmetic Functions

• Absolute Value: Absolute values of integers and floats.
• Normalization Functions: Extracting exponents and putting them back.
• Rounding Functions: Rounding floats to integers.
• Remainder Functions: Remainders on division, precisely defined.
• FP Bit Twiddling: Sign bit adjustment. Adding epsilon.
• FP Comparison Functions: Comparisons without risk of exceptions.
• Misc FP Arithmetic: Max, min, positive difference, multiply-add.

  Parsing of Numbers

• Parsing of Integers: Functions for conversion of integer values.
• Parsing of Floats: Functions for conversion of floating-point values.

  Date and Time

• Time Basics: Concepts and definitions.
• Elapsed Time: Data types to represent elapsed times
• Processor And CPU Time: Time a program has spent executing.
• Calendar Time: Manipulation of ``real'' dates and times.
• Setting an Alarm: Sending a signal after a specified time.
• Sleeping: Waiting for a period of time.

  Processor And CPU Time

• CPU Time: The clock function.
• Processor Time: The times function.

  Calendar Time

• Simple Calendar Time: Facilities for manipulating calendar time.
• High-Resolution Calendar: A time representation with greater precision.
• Broken-down Time: Facilities for manipulating local time.
• High Accuracy Clock: Maintaining a high accuracy system clock.
• Formatting Calendar Time: Converting times to strings.
• Parsing Date and Time: Convert textual time and date information back into broken-down time values.
• TZ Variable: How users specify the time zone.
• Time Zone Functions: Functions to examine or specify the time zone.
• Time Functions Example: An example program showing use of some of the time functions.

  Parsing Date and Time

• Low-Level Time String Parsing: Interpret string according to given format.
• General Time String Parsing: User-friendly function to parse data and time strings.

  Resource Usage And Limitation

• Resource Usage: Measuring various resources used.
• Limits on Resources: Specifying limits on resource usage.
• Priority: Reading or setting process run priority.
• Memory Resources: Querying memory available resources.
• Processor Resources: Learn about the processors available.

  Priority

• Absolute Priority: The first tier of priority. Posix
• Realtime Scheduling: Scheduling among the process nobility
• Basic Scheduling Functions: Get/set scheduling policy, priority
• Traditional Scheduling: Scheduling among the vulgar masses
• CPU Affinity: Limiting execution to certain CPUs

  Traditional Scheduling

• Traditional Scheduling Intro:
• Traditional Scheduling Functions:

  Memory Resources

• Memory Subsystem: Overview about traditional Unix memory handling.
• Query Memory Parameters: How to get information about the memory subsystem?

  Non-Local Exits

• Intro: When and how to use these facilities.
• Details: Functions for non-local exits.
• Non-Local Exits and Signals: Portability issues.
• System V contexts: Complete context control a la System V.

  Signal Handling

• Concepts of Signals: Introduction to the signal facilities.
• Standard Signals: Particular kinds of signals with standard names and meanings.
• Signal Actions: Specifying what happens when a particular signal is delivered.
• Defining Handlers: How to write a signal handler function.
• Interrupted Primitives: Signal handlers affect use of open, read, write and other functions.
• Generating Signals: How to send a signal to a process.
• Blocking Signals: Making the system hold signals temporarily.
• Waiting for a Signal: Suspending your program until a signal arrives.
• Signal Stack: Using a Separate Signal Stack.
• BSD Signal Handling: Additional functions for backward compatibility with BSD.

  Concepts of Signals

• Kinds of Signals: Some examples of what can cause a signal.
• Signal Generation: Concepts of why and how signals occur.
• Delivery of Signal: Concepts of what a signal does to the process.

  Standard Signals

• Program Error Signals: Used to report serious program errors.
• Termination Signals: Used to interrupt and/or terminate the program.
• Alarm Signals: Used to indicate expiration of timers.
• Asynchronous I/O Signals: Used to indicate input is available.
• Job Control Signals: Signals used to support job control.
• Operation Error Signals: Used to report operational system errors.
• Miscellaneous Signals: Miscellaneous Signals.
• Signal Messages: Printing a message describing a signal.

  Signal Actions

• Basic Signal Handling: The simple signal function.
• Advanced Signal Handling: The more powerful sigaction function.
• Signal and Sigaction: How those two functions interact.
• Sigaction Function Example: An example of using the sigaction function.
• Flags for Sigaction: Specifying options for signal handling.
• Initial Signal Actions: How programs inherit signal actions.

  Defining Handlers

• Handler Returns: Handlers that return normally, and what this means.
• Termination in Handler: How handler functions terminate a program.
• Longjmp in Handler: Nonlocal transfer of control out of a signal handler.
• Signals in Handler: What happens when signals arrive while the handler is already occupied.
• Merged Signals: When a second signal arrives before the first is handled.
• Nonreentrancy: Do not call any functions unless you know they are reentrant with respect to signals.
• Atomic Data Access: A single handler can run in the middle of reading or writing a single object.

  Atomic Data Access

• Non-atomic Example: A program illustrating interrupted access.
• Types: Data types that guarantee no interruption.
• Usage: Proving that interruption is harmless.

  Generating Signals

• Signaling Yourself: A process can send a signal to itself.
• Signaling Another Process: Send a signal to another process.
• Permission for kill: Permission for using kill.
• Kill Example: Using kill for Communication.

  Blocking Signals

• Why Block: The purpose of blocking signals.
• Signal Sets: How to specify which signals to block.
• Process Signal Mask: Blocking delivery of signals to your process during normal execution.
• Testing for Delivery: Blocking to Test for Delivery of a Signal.
• Blocking for Handler: Blocking additional signals while a handler is being run.
• Checking for Pending Signals: Checking for Pending Signals
• Remembering a Signal: How you can get almost the same effect as blocking a signal, by handling it and setting a flag to be tested later.

  Waiting for a Signal

• Using Pause: The simple way, using pause.
• Pause Problems: Why the simple way is often not very good.
• Sigsuspend: Reliably waiting for a specific signal.

  BSD Signal Handling

• BSD Handler: BSD Function to Establish a Handler.
• Blocking in BSD: BSD Functions for Blocking Signals.

  Program Basics

• Program Arguments: Parsing your program's command-line arguments.
• Environment Variables: Less direct parameters affecting your program
• System Calls: Requesting service from the system
• Program Termination: Telling the system you're done; return status

  Program Arguments

• Argument Syntax: By convention, options start with a hyphen.
• Parsing Program Arguments: Ways to parse program options and arguments.

  Parsing Program Arguments

• Getopt: Parsing program options using getopt.
• Argp: Parsing program options using argp_parse.
• Suboptions: Some programs need more detailed options.
• Suboptions Example: This shows how it could be done for mount.

  Environment Variables

• Environment Access: How to get and set the values of environment variables.
• Standard Environment: These environment variables have standard interpretations.

  Program Termination

• Normal Termination: If a program calls exit, a process terminates normally.
• Exit Status: The exit status provides information about why the process terminated.
• Cleanups on Exit: A process can run its own cleanup functions upon normal termination.
• Aborting a Program: The abort function causes abnormal program termination.
• Termination Internals: What happens when a process terminates.

  Processes

• Running a Command: The easy way to run another program.
• Process Creation Concepts: An overview of the hard way to do it.
• Process Identification: How to get the process ID of a process.
• Creating a Process: How to fork a child process.
• Executing a File: How to make a process execute another program.
• Process Completion: How to tell when a child process has completed.
• Process Completion Status: How to interpret the status value returned from a child process.
• BSD Wait Functions: More functions, for backward compatibility.
• Process Creation Example: A complete example program.

  Job Control

• Concepts of Job Control: Jobs can be controlled by a shell.
• Job Control is Optional: Not all POSIX systems support job control.
• Controlling Terminal: How a process gets its controlling terminal.
• Access to the Terminal: How processes share the controlling terminal.
• Orphaned Process Groups: Jobs left after the user logs out.
• Implementing a Shell: What a shell must do to implement job control.
• Functions for Job Control: Functions to control process groups.

  Implementing a Shell

• Data Structures: Introduction to the sample shell.
• Initializing the Shell: What the shell must do to take responsibility for job control.
• Launching Jobs: Creating jobs to execute commands.
• Foreground and Background: Putting a job in foreground of background.
• Stopped and Terminated Jobs: Reporting job status.
• Continuing Stopped Jobs: How to continue a stopped job in the foreground or background.
• Missing Pieces: Other parts of the shell.

  Functions for Job Control

• Identifying the Terminal: Determining the controlling terminal's name.
• Process Group Functions: Functions for manipulating process groups.
• Terminal Access Functions: Functions for controlling terminal access.

  Name Service Switch

• NSS Basics: What is this NSS good for.
• NSS Configuration File: Configuring NSS.
• NSS Module Internals: How does it work internally.
• Extending NSS: What to do to add services or databases.

  NSS Configuration File

• Services in the NSS configuration: Service names in the NSS configuration.
• Actions in the NSS configuration: React appropriately to the lookup result.
• Notes on NSS Configuration File: Things to take care about while configuring NSS.

  NSS Module Internals

• NSS Module Names: Construction of the interface function of the NSS modules.
• NSS Modules Interface: Programming interface in the NSS module functions.

  Extending NSS

• Adding another Service to NSS: What is to do to add a new service.
• NSS Module Function Internals: Guidelines for writing new NSS service functions.

  Users and Groups

• User and Group IDs: Each user has a unique numeric ID; likewise for groups.
• Process Persona: The user IDs and group IDs of a process.
• Why Change Persona: Why a program might need to change its user and/or group IDs.
• How Change Persona: Changing the user and group IDs.
• Reading Persona: How to examine the user and group IDs.

• Setting User ID: Functions for setting the user ID.
• Setting Groups: Functions for setting the group IDs.

• Enable/Disable Setuid: Turning setuid access on and off.
• Setuid Program Example: The pertinent parts of one sample program.
• Tips for Setuid: How to avoid granting unlimited access.

• Who Logged In: Getting the name of the user who logged in, or of the real user ID of the current process.

• User Accounting Database: Keeping information about users and various actions in databases.

• User Database: Functions and data structures for accessing the user database.
• Group Database: Functions and data structures for accessing the group database.
• Database Example: Example program showing the use of database inquiry functions.
• Netgroup Database: Functions for accessing the netgroup database.

  User Accounting Database

• Manipulating the Database: Scanning and modifying the user accounting database.
• XPG Functions: A standardized way for doing the same thing.
• Logging In and Out: Functions from BSD that modify the user accounting database.

  User Database

• User Data Structure: What each user record contains.
• Lookup User: How to look for a particular user.
• Scanning All Users: Scanning the list of all users, one by one.
• Writing a User Entry: How a program can rewrite a user's record.

  Group Database

• Group Data Structure: What each group record contains.
• Lookup Group: How to look for a particular group.
• Scanning All Groups: Scanning the list of all groups.

  Netgroup Database

• Netgroup Data: Data in the Netgroup database and where it comes from.
• Lookup Netgroup: How to look for a particular netgroup.
• Netgroup Membership: How to test for netgroup membership.

  System Management

• Host Identification: Determining the name of the machine.
• Platform Type: Determining operating system and basic machine type
• Filesystem Handling: Controlling/querying mounts
• System Parameters: Getting and setting various system parameters

  Filesystem Handling

• Mount Information: What is or could be mounted?
• Mount-Unmount-Remount: Controlling what is mounted and how

  Mount Information

• fstab: The fstab file
• mtab: The mtab file
• Other Mount Information: Other (non-libc) sources of mount information

  System Configuration

• General Limits: Constants and functions that describe various process-related limits that have one uniform value for any given machine.
• System Options: Optional POSIX features.
• Version Supported: Version numbers of POSIX.1 and POSIX.2.
• Sysconf: Getting specific configuration values of general limits and system options.
• Minimums: Minimum values for general limits.

• Limits for Files: Size limitations that pertain to individual files. These can vary between file systems or even from file to file.
• Options for Files: Optional features that some files may support.
• File Minimums: Minimum values for file limits.
• Pathconf: Getting the limit values for a particular file.

• Utility Limits: Capacity limits of some POSIX.2 utility programs.
• Utility Minimums: Minimum allowable values of those limits.

• String Parameters: Getting the default search path.

  Sysconf

• Sysconf Definition: Detailed specifications of sysconf.
• Constants for Sysconf: The list of parameters sysconf can read.
• Examples of Sysconf: How to use sysconf and the parameter macros properly together.

  Cryptographic Functions

• Legal Problems: This software can get you locked up, or worse.
• getpass: Prompting the user for a password.
• crypt: A one-way function for passwords.
• DES Encryption: Routines for DES encryption.

  Debugging Support

• Backtraces: Obtaining and printing a back trace of the current stack.

  POSIX Threads

• Basic Thread Operations: Creating, terminating, and waiting for threads.
• Thread Attributes: Tuning thread scheduling.
• Cancellation: Stopping a thread before it's done.
• Cleanup Handlers: Deallocating resources when a thread is canceled.
• Mutexes: One way to synchronize threads.
• Condition Variables: Another way.
• POSIX Semaphores: And a third way.
• Thread-Specific Data: Variables with different values in different threads.
• Threads and Signal Handling: Why you should avoid mixing the two, and how to do it if you must.
• Threads and Fork: Interactions between threads and the fork function.
• Streams and Fork: Interactions between stdio streams and fork.
• Miscellaneous Thread Functions: A grab bag of utility routines.

  Language Features

• Consistency Checking: Using assert to abort if something ``impossible'' happens.
• Variadic Functions: Defining functions with varying numbers of args.
• Null Pointer Constant: The macro NULL.
• Important Data Types: Data types for object sizes.
• Data Type Measurements: Parameters of data type representations.

  Variadic Functions

• Why Variadic: Reasons for making functions take variable arguments.
• How Variadic: How to define and call variadic functions.
• Variadic Example: A complete example.

  How Variadic

• Variadic Prototypes: How to make a prototype for a function with variable arguments.
• Receiving Arguments: Steps you must follow to access the optional argument values.
• How Many Arguments: How to decide whether there are more arguments.
• Calling Variadics: Things you need to know about calling variable arguments functions.
• Argument Macros: Detailed specification of the macros for accessing variable arguments.
• Old Varargs: The pre-ISO way of defining variadic functions.

  Data Type Measurements

• Width of Type: How many bits does an integer type hold?
• Range of Type: What are the largest and smallest values that an integer type can hold?
• Floating Type Macros: Parameters that measure the floating point types.
• Structure Measurement: Getting measurements on structure types.

  Floating Type Macros

• Floating Point Concepts: Definitions of terminology.
• Floating Point Parameters: Details of specific macros.
• IEEE Floating Point: The measurements for one common representation.

  Installation

• Configuring and compiling: How to compile and test GNU libc.
• Running make install: How to install it once you've got it compiled.
• Tools for Compilation: You'll need these first.
• Supported Configurations: What it runs on, what it doesn't.
• Linux: Specific advice for GNU/Linux systems.
• Reporting Bugs: So they'll get fixed.

  Maintenance

• Source Layout: How to add new functions or header files to the GNU C library.
• Porting: How to port the GNU C library to a new machine or operating system.

  Porting

• Hierarchy Conventions: The layout of the sysdeps hierarchy.
• Porting to Unix: Porting the library to an average Unix-like system.