The GNU C Library

[ Up: (DIR) ]
[ Previous: (DIR) ][ Next: Introduction ]

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.

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

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.