Info Node: (libc.info)Top
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
- 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
- Low-Level Terminal Interface
- How to change the characteristics of a
- 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
- 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
Standards and Portability
- ISO C
- The international standard for the C
- 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.
- 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 and C
- How to get different kinds of allocation in C.
- Unconstrained Allocation
- The `malloc' facility allows fully general
- 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.
- 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
- 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.
- 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
- 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;
- 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
- 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.
- 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
- 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
- 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
- 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 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.
- 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 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 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
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
- 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
- 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.
- 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'.
- 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.
- 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 Concepts
- Some basic information and terminology.
- File Names
- How to refer to a file.
- 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.
- 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 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
- 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
- Example of Parsing
- Sample program using `parse_printf_format'.
- 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
- Printf Extension Example
- How to define a `printf'
- Predefined Printf Handlers
- Predefined `printf' handlers.
- 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.
- 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.
- 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.
- Printing Formatted Messages
- The `fmtmsg' function.
- Adding Severity Classes
- Add more severity classes.
- How to use `fmtmsg' and `addseverity'.
- 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
- 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
- Descriptor Flags
- Fcntl commands for manipulating
flags associated with file
- File Status Flags
- Fcntl commands for manipulating
flags associated with open files.
- File Locks
- Fcntl commands for implementing
- Interrupt Input
- Getting an asynchronous signal when
- Generic I/O Control operations.
- 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
- 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
- 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.
- 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.
- 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,
- 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
- 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.
- 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.
- Local Namespace Details. Address format, symbolic names, etc.
- Local Socket Example. Example of creating a socket.
- Internet Address Formats
- How socket addresses are specified in the
- 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.
- 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.
- 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.
- 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 Option Functions
- The basic functions for setting and getting
- 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.
- Mode Data Types
- The data type `struct termios' and
- 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.
- 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
- 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.
- 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.
- 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.
- 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
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 Intro
- Traditional Scheduling Functions
- Memory Subsystem
- Overview about traditional Unix memory handling.
- Query Memory Parameters
- How to get information about the memory
- 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.
- 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
- 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.
- 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.
- Handler Returns
- Handlers that return normally, and what
- Termination in Handler
- How handler functions terminate a program.
- Longjmp in Handler
- Nonlocal transfer of control out of a
- 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.
- 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.
- 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
- 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 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
- 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 Access
- How to get and set the values of
- Standard Environment
- These environment variables have
- 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.
- 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
NSS Module Internals
- NSS Module Names
- Construction of the interface function of
the NSS modules.
- NSS Modules Interface
- Programming interface in the NSS module
- Adding another Service to NSS
- What is to do to add a new service.
- NSS Module Function Internals
- Guidelines for writing new NSS
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
- Netgroup Database
- Functions for accessing the netgroup database.
User Accounting Database
- Manipulating the Database
- Scanning and modifying the user
- XPG Functions
- A standardized way for doing the same thing.
- Logging In and Out
- Functions from BSD that modify the user
- 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 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 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.
- Host Identification
- Determining the name of the machine.
- Platform Type
- Determining operating system and basic
- Filesystem Handling
- Controlling/querying mounts
- System Parameters
- Getting and setting various system parameters
- Mount Information
- What is or could be mounted?
- Controlling what is mounted and how
- The `fstab' file
- The `mtab' file
- Other Mount Information
- Other (non-libc) sources of mount information
- 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.
- 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.
- Obtaining and printing a back trace of the
- 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
- 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
- Streams and Fork
- Interactions between stdio streams and
- Miscellaneous Thread Functions
- A grab bag of utility routines.
- Consistency Checking
- Using `assert' to abort if
something ``impossible'' happens.
- Variadic Functions
- Defining functions with varying numbers
- Null Pointer Constant
- The macro `NULL'.
- Important Data Types
- Data types for object sizes.
- Data Type Measurements
- Parameters of data type representations.
- Why Variadic
- Reasons for making functions take
- How Variadic
- How to define and call variadic functions.
- Variadic Example
- A complete example.
- 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
automatically generated by info2www version 184.108.40.206