www.fifi.org
    Documentation
        Manpages
        GNU Info
        Debian document tree
        Whole document tree
    Trigance web page
    Public services
    User info
    Mailing lists
    Secure server
    Multilingual usage

GNU Info

Info Node: (libc.info)Top

(libc.info)Top


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.

Introduction: Purpose of the GNU C Library.
Error Reporting: How library functions report errors.
Memory: 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.
Locales: The country and language can affect the
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
Sockets: A more complicated IPC mechanism, with
Low-Level Terminal Interface: How to change the characteristics of a
Syslog: System logging and messaging.
Mathematics: Math functions, useful constants, random
Arithmetic: Low level arithmetic functions.
Date and Time: Functions for getting the date and time and
Resource Usage And Limitation: Functions for examining resource usage and
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
Processes: 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
System Configuration: Parameters describing operating system
Cryptographic Functions: DES encryption and password handling.
Debugging Support: Functions to help debugging applications..

Add-ons

POSIX Threads: The standard threads library.

Appendices

Language Features: C language features provided by the library.
Library Summary: A summary showing the syntax, header file,
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
Documentation License: This manual is under the GNU Free

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
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
POSIX: The ISO/IEC 9945 (aka IEEE 1003) standards
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
Macro Definitions: Some functions in the library may really
Reserved Names: The C standard reserves some names for
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
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
Allocation Debugging: Finding memory leaks and not freed memory.
Obstacks: Obstacks are less general than malloc
Variable Size Automatic: Allocation of variable-sized blocks

Unconstrained Allocation

Basic Allocation: Simple use of `malloc'.
Malloc Examples: Examples of `malloc'. `xmalloc'.
Freeing after Malloc: Use `free' to free a block you
Changing Block Size: Use `realloc' to make a block
Allocating Cleared Space: Use `calloc' to allocate a
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
Statistics of Malloc: Getting information about how much
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
Allocation in an Obstack: Allocating objects in an obstack.
Freeing Obstack Objects: Freeing objects in an obstack.
Obstack Functions: The obstack functions are both
Growing Objects: Making an object bigger by stages.
Extra Fast Growing: Extra-high-efficiency (though more
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

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

Locales

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
Setting the Locale: How a program specifies the locale
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 Symbol: How to print the symbol that identifies an
Sign of Money Amount: How to print the (positive or negative) sign

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

Searching and Sorting

Comparison Functions: Defining how to compare two objects.
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,

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
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
File Position: The number of bytes from the

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
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
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
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
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
Table of Output Conversions: Summary of output conversions and
Integer Conversions: Details about formatting of integers.
Floating-Point Conversions: Details about formatting of
Other Output Conversions: Details about formatting of strings,
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'.

Customizing Printf

Registering New Conversions: Using `register_printf_function'
Conversion Specifier Options: The handler must be able to get
Defining the Output Handler: Defining the handler and arginfo
Printf Extension Example: How to define a `printf'
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
Obstack Streams: Streams that store data in an obstack.
Custom Streams: Defining your own streams with an arbitrary

Custom Streams

Streams and Cookies: The "cookie" records where to fetch or
Hook Functions: How you should define the four "hook

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
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
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
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
File Status Flags: Fcntl commands for manipulating
File Locks: Fcntl commands for implementing
Interrupt Input: Getting an asynchronous signal when
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

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
Accessing Directories: Finding out what files a directory
Working with Directory Trees: Apply actions to all files or a selectable
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
Scanning Directory Content: Get entries for user selected subset of
Simple Directory Lister Mark II: Revised version of the program.

File Attributes

Attribute Meanings: The names of the file attributes,
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,
Permission Bits: How information about a file's access
Access Permission: How the system decides who can access a file.
Setting Permissions: How permissions for new files are assigned,
Testing File Access: How to find out if your process can
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.

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.
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: Local Namespace Concepts. What you need to understand.
Details: Local Namespace Details. Address format, symbolic names, etc.
Example: Local Socket Example. Example of creating a socket.

Internet Namespace

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.
Ports: Internet port numbers.
Services Database: Ports may have symbolic names.
Byte Order: Different hosts may use different byte
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.
Functions: Host Address Functions. Functions to operate on them.
Names: 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.

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
Transferring Data: How to send and receive data.
Byte Stream Example: An example program: a client for communicating
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
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-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
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
BSD Terminal Modes: BSD compatible terminal mode setting
Line Control: Sending break sequences, clearing
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
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,
Noncanonical Input: Controlling how long to wait for input.

Special Characters

Editing Characters: Special characters that terminate lines and
Signal Characters: Special characters that send or raise signals
Start/Stop Characters: Special characters that suspend or resume
Other Special: Other special characters for BSD systems:

Pseudo-Terminals

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

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

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

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

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

Non-Local Exits

Intro: Non-Local Intro. When and how to use these facilities.
Details: 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
Signal Actions: Specifying what happens when a
Defining Handlers: How to write a signal handler function.
Interrupted Primitives: Signal handlers affect use of `open',
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

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
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
Merged Signals: When a second signal arrives before the
Nonreentrancy: Do not call any functions unless you know they
Atomic Data Access: A single handler can run in the middle of

Atomic Data Access

Non-atomic Example: A program illustrating interrupted access.
Types: Atomic Types. Data types that guarantee no interruption.
Usage: 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
Testing for Delivery: Blocking to Test for Delivery of
Blocking for Handler: Blocking additional signals while a
Checking for Pending Signals: Checking for Pending Signals
Remembering a Signal: How you can get almost the same

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
Standard Environment: These environment variables have

Program Termination

Normal Termination: If a program calls `exit', a
Exit Status: The `exit status' provides information
Cleanups on Exit: A process can run its own cleanup
Aborting a Program: The `abort' function causes
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
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
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
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
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

Users and Groups

User and Group IDs: Each user has a unique numeric ID;
Process Persona: The user IDs and group IDs of a process.
Why Change Persona: Why a program might need to change
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,
User Accounting Database: Keeping information about users and various
User Database: Functions and data structures for
Group Database: Functions and data structures for
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 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
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
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
System Options: Optional POSIX features.
Version Supported: Version numbers of POSIX.1 and POSIX.2.
Sysconf: Getting specific configuration values
Minimums: Minimum values for general limits.
Limits for Files: Size limitations that pertain to individual files.
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

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 UNIX passwords.
DES Encryption: Routines for DES encryption.

Debugging Support

Backtraces: Obtaining and printing a back trace of the

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
Mutexes: 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
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.

Language Features

Consistency Checking: Using `assert' to abort if
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.

Variadic Functions

Why Variadic: Reasons for making functions take
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
Receiving Arguments: Steps you must follow to access the
How Many Arguments: How to decide whether there are more arguments.
Calling Variadics: Things you need to know about calling
Argument Macros: Detailed specification of the macros
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
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

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

Maintenance

Source Layout: How to add new functions or header files
Porting: How to port the GNU C library to

Porting

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

automatically generated by info2www version 1.2.2.9