The GNU C Library

Main Menu

This is Edition 0.12, last updated 2007-10-27, of The GNU C Library Reference Manual, for Version 2.8 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.

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.

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.
• 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.