GNU Info

Info Node: (


Next: Introduction Prev: (dir) Up: (dir)
Enter node , (file) or (file)node

Main Menu

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

Purpose of the GNU C Library.
Error Reporting
How library functions report errors.
Allocating virtual memory and controlling
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.
The country and language can affect the
behavior of library functions.
Message Translation
How to make the program speak the user's
Searching and Sorting
General searching and sorting functions.
Pattern Matching
Matching shell ``globs'' and regular
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
A more complicated IPC mechanism, with
networking support.
Low-Level Terminal Interface
How to change the characteristics of a
terminal device.
System logging and messaging.
Math functions, useful constants, random
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
How to create processes and run other
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
Cryptographic Functions
DES encryption and password handling.
Debugging Support
Functions to help debugging applications..

POSIX Threads
The standard threads 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.
How to install the GNU C library.
How to enhance and port the GNU C Library.
Who wrote what parts of the GNU C library.
Free Manuals
Free Software Needs Free Documentation.
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.

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


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

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

Header Files
How to include the header files in your
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 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 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
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?

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
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
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
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.
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
Restartable multibyte conversion
Restartable multibyte conversion
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
Multibyte Conversion Example
A Complete Multibyte Conversion Example.
Non-reentrant Conversion

Non-reentrant Character Conversion
Non-reentrant Conversion of Single
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'
glibc iconv Implementation
The `iconv' Implementation in the GNU C

Effects of Locale
Actions affected by the choice of
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
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.
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.

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

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.
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 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
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.
How to use `fmtmsg' and `addseverity'.
Low-Level I/O

Opening and Closing Files
How to open and close file
I/O Primitives
Reading and writing data.
File Position Primitive
Setting a descriptor's file
Descriptors and Streams
Converting descriptor to stream
or vice-versa.
Stream/Descriptor Precautions
Precautions needed if you use both
descriptors and streams.
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
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.
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
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.

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.
Operations on sockets with connection state.
Operations on datagram sockets.
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

Local Namespace Concepts. What you need to understand.
Local Namespace Details. Address format, symbolic names, etc.
Local Socket 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.
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
Host Address Data Type. Data type for a host number.
Host Address Functions. Functions to operate on them.
Host 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.

What the client program must do.
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'.

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 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.
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
Setting Modes
The right way to set terminal attributes
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.

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

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

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

Mathematical Constants
Precise numeric values for often-used
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
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.

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.
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
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.
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.
Reading or setting process run priority.
Memory Resources
Querying memory available resources.
Processor Resources
Learn about the processors available.

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
Non-Local Exits

Non-Local Intro. When and how to use these facilities.
Non-Local 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
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
Standard Signals

Program Error Signals
Used to report serious program errors.
Termination Signals
Used to interrupt and/or terminate the
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.
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.
Atomic Types. Data types that guarantee no interruption.
Atomic 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
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.
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

Parsing program options using `getopt'.
Parsing program options using `argp_parse'.
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.

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
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?
Controlling what is mounted and how
Mount Information

The `fstab' file
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.
Getting specific configuration values
of general limits and system options.
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.
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 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.
Prompting the user for a password.
A one-way function for UNIX passwords.
DES Encryption
Routines for DES encryption.
Debugging Support

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.
Stopping a thread before it's done.
Cleanup Handlers
Deallocating resources when a thread is
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
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

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.
Specific advice for Linux systems.
Reporting Bugs
So they'll get fixed.

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

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

automatically generated by info2www version