+++ /dev/null
-@menu
-* Introduction:: Purpose of the GNU C Library.
-* Error Reporting:: How library functions report errors.
-* Memory Allocation:: Allocating memory dynamically and
- manipulating it via pointers.
-* Character Handling:: Character testing and conversion functions.
-* String and Array Utilities:: Utilities for copying and comparing strings
- and arrays.
-* Character Set Handling:: Support for extended character sets.
-* Locales:: The country and language can affect the
- behavior of library functions.
-* Message Translation:: How to make the program speak the user's
- language.
-* Searching and Sorting:: General searching and sorting functions.
-* Pattern Matching:: Matching shell ``globs'' and regular
- expressions.
-* I/O Overview:: Introduction to the I/O facilities.
-* I/O on Streams:: High-level, portable I/O facilities.
-* Low-Level I/O:: Low-level, less portable I/O.
-* File System Interface:: Functions for manipulating files.
-* Pipes and FIFOs:: A simple interprocess communication
- mechanism.
-* Sockets:: A more complicated IPC mechanism, with
- networking support.
-* Low-Level Terminal Interface:: How to change the characteristics of a
- terminal device.
-* Mathematics:: Math functions, useful constants, random
- numbers.
-* Arithmetic:: Low level arithmetic functions.
-* Date and Time:: Functions for getting the date and time and
- formatting them nicely.
-* Non-Local Exits:: Jumping out of nested function calls.
-* Signal Handling:: How to send, block, and handle signals.
-* Process Startup:: Writing the beginning and end of your
- program.
-* Processes:: How to create processes and run other
- programs.
-* Job Control:: All about process groups and sessions.
-* Name Service Switch:: Accessing system databases.
-* Users and Groups:: How users are identified and classified.
-* System Information:: Getting information about the hardware and
- operating system.
-* System Configuration:: Parameters describing operating system
- limits.
-
-Add-ons
-
-* Cryptographic Functions:: DES encryption and password handling.
-* 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,
- and derivation of each library feature.
-* Installation:: How to install the GNU C library.
-* Maintenance:: How to enhance and port the GNU C Library.
-* Contributors:: Who wrote what parts of the GNU C library.
-* Copying:: The GNU Library General Public License says
- how you can copy and share the GNU C Library.
-
-Indices
-
-* Concept Index:: Index of concepts and names.
-* Type Index:: Index of types and type qualifiers.
-* Function Index:: Index of functions and function-like macros.
-* Variable Index:: Index of variables and variable-like macros.
-* File Index:: Index of programs and files.
-
- --- The Detailed Node Listing ---
-
-Introduction
-
-* Getting Started:: What this manual is for and how to use it.
-* Standards and Portability:: Standards and sources upon which the GNU
- C library is based.
-* Using the Library:: Some practical uses for the library.
-* Roadmap to the Manual:: Overview of the remaining chapters in
- this manual.
-
-Standards and Portability
-
-* ISO C:: The international standard for the C
- programming language.
-* POSIX:: The ISO/IEC 9945 (aka IEEE 1003) standards
- for operating systems.
-* Berkeley Unix:: BSD and SunOS.
-* SVID:: The System V Interface Description.
-* XPG:: The X/Open Portability Guide.
-
-Using the Library
-
-* Header Files:: How to include the header files in your
- programs.
-* Macro Definitions:: Some functions in the library may really
- be implemented as macros.
-* Reserved Names:: The C standard reserves some names for
- the library, and some for users.
-* Feature Test Macros:: How to control what names are defined.
-
-Error Reporting
-
-* Checking for Errors:: How errors are reported by library functions.
-* Error Codes:: Error code macros; all of these expand
- into integer constant values.
-* Error Messages:: Mapping error codes onto error messages.
-
-Memory Allocation
-
-* Memory Concepts:: An introduction to concepts and terminology.
-* Dynamic Allocation and C:: How to get different kinds of allocation in C.
-* Unconstrained Allocation:: The @code{malloc} facility allows fully general
- dynamic allocation.
-* Allocation Debugging:: Finding memory leaks and not freed memory.
-* Obstacks:: Obstacks are less general than malloc
- but more efficient and convenient.
-* Variable Size Automatic:: Allocation of variable-sized blocks
- of automatic storage that are freed when the
- calling function returns.
-
-Unconstrained Allocation
-
-* Basic Allocation:: Simple use of @code{malloc}.
-* Malloc Examples:: Examples of @code{malloc}. @code{xmalloc}.
-* Freeing after Malloc:: Use @code{free} to free a block you
- got with @code{malloc}.
-* Changing Block Size:: Use @code{realloc} to make a block
- bigger or smaller.
-* Allocating Cleared Space:: Use @code{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:
- @code{memalign} and @code{valloc}.
-* Malloc Tunable Parameters:: Use @code{mallopt} to adjust allocation
- parameters.
-* Heap Consistency Checking:: Automatic checking for errors.
-* Hooks for Malloc:: You can use these hooks for debugging
- programs that use @code{malloc}.
-* Statistics of Malloc:: Getting information about how much
- memory your program is using.
-* Summary of Malloc:: Summary of @code{malloc} and related functions.
-
-Allocation Debugging
-
-* Tracing malloc:: How to install the tracing functionality.
-* Using the Memory Debugger:: Example programs excerpts.
-* Tips for the Memory Debugger:: Some more or less clever ideas.
-* Interpreting the traces:: What do all these lines mean?
-
-Obstacks
-
-* Creating Obstacks:: How to declare an obstack in your program.
-* Preparing for Obstacks:: Preparations needed before you can
- use obstacks.
-* Allocation in an Obstack:: Allocating objects in an obstack.
-* Freeing Obstack Objects:: Freeing objects in an obstack.
-* Obstack Functions:: The obstack functions are both
- functions and macros.
-* Growing Objects:: Making an object bigger by stages.
-* Extra Fast Growing:: Extra-high-efficiency (though more
- complicated) growing objects.
-* Status of an Obstack:: Inquiries about the status of an obstack.
-* Obstacks Data Alignment:: Controlling alignment of objects in obstacks.
-* Obstack Chunks:: How obstacks obtain and release chunks;
- efficiency considerations.
-* Summary of Obstacks::
-
-Variable Size Automatic
-
-* Alloca Example:: Example of using @code{alloca}.
-* Advantages of Alloca:: Reasons to use @code{alloca}.
-* Disadvantages of Alloca:: Reasons to avoid @code{alloca}.
-* GNU C Variable-Size Arrays:: Only in GNU C, here is an alternative
- method of allocating dynamically and
- freeing automatically.
-
-Character Handling
-
-* Classification of Characters:: Testing whether characters are
- letters, digits, punctuation, etc.
-
-* Case Conversion:: Case mapping, and the like.
-* Classification of Wide Characters:: Character class determination for
- wide characters.
-* Using Wide Char Classes:: Notes on using the wide character
- classes.
-* Wide Character Case Conversion:: Mapping of wide characters.
-
-String and Array Utilities
-
-* Representation of Strings:: Introduction to basic concepts.
-* String/Array Conventions:: Whether to use a string function or an
- arbitrary array function.
-* String Length:: Determining the length of a string.
-* Copying and Concatenation:: Functions to copy the contents of strings
- and arrays.
-* String/Array Comparison:: Functions for byte-wise and character-wise
- comparison.
-* Collation Functions:: Functions for collating strings.
-* Search Functions:: Searching for a specific element or substring.
-* Finding Tokens in a String:: Splitting a string into tokens by looking
- for delimiters.
-* Encode Binary Data:: Encoding and Decoding of Binary Data.
-* Argz and Envz Vectors:: Null-separated string vectors.
-
-Argz and Envz Vectors
-
-* Argz Functions:: Operations on argz vectors.
-* Envz Functions:: Additional operations on environment vectors.
-
-Character Set Handling
-
-* Extended Char Intro:: Introduction to Extended Characters.
-* Charset Function Overview:: Overview about Character Handling
- Functions.
-* Restartable multibyte conversion:: Restartable multibyte conversion
- Functions.
-* Non-reentrant Conversion:: Non-reentrant Conversion Function.
-* Generic Charset Conversion:: Generic Charset Conversion.
-
-Restartable multibyte conversion
-
-* Selecting the Conversion:: Selecting the conversion and its properties.
-* Keeping the state:: Representing the state of the conversion.
-* Converting a Character:: Converting Single Characters.
-* Converting Strings:: Converting Multibyte and Wide Character
- Strings.
-* Multibyte Conversion Example:: A Complete Multibyte Conversion Example.
-
-Non-reentrant Conversion
-
-* Non-reentrant Character Conversion:: Non-reentrant Conversion of Single
- Characters.
-* Non-reentrant String Conversion:: Non-reentrant Conversion of Strings.
-* Shift State:: States in Non-reentrant Functions.
-
-Generic Charset Conversion
-
-* Generic Conversion Interface:: Generic Character Set Conversion Interface.
-* iconv Examples:: A complete @code{iconv} example.
-* Other iconv Implementations:: Some Details about other @code{iconv}
- Implementations.
-* glibc iconv Implementation:: The @code{iconv} Implementation in the GNU C
- library.
-
-Locales
-
-* Effects of Locale:: Actions affected by the choice of
- locale.
-* Choosing Locale:: How the user specifies a locale.
-* Locale Categories:: Different purposes for which you can
- select a locale.
-* Setting the Locale:: How a program specifies the locale
- with library functions.
-* Standard Locales:: Locale names available on all systems.
-* Locale Information:: How to access the information for the locale.
-* Formatting Numbers:: A dedicated function to format numbers.
-
-Locale Information
-
-* The Lame Way to Locale Data:: ISO C's @code{localeconv}.
-* The Elegant and Fast Way:: X/Open's @code{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. @samp{$}).
-* 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 @code{catgets} family of functions.
-* The Uniforum approach:: The @code{gettext} family of functions.
-
-Message catalogs a la X/Open
-
-* The catgets Functions:: The @code{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 @code{catgets} interface.
-
-The Uniforum approach
-
-* Message catalogs with gettext:: The @code{gettext} family of functions.
-* Helper programs for gettext:: Programs to handle message catalogs
- for @code{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.
-* Using gettextized software:: The possibilities of the user to influence
- the way @code{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 @code{bsearch} function.
-* Array Sort Function:: The @code{qsort} function.
-* Search/Sort Example:: An example program.
-* Hash Search Function:: The @code{hsearch} function.
-* Tree Search Function:: The @code{tsearch} function.
-
-Pattern Matching
-
-* Wildcard Matching:: Matching a wildcard pattern against a single string.
-* Globbing:: Finding the files that match a wildcard pattern.
-* Regular Expressions:: Matching regular expressions against strings.
-* Word Expansion:: Expanding shell variables, nested commands,
- arithmetic, and wildcards.
- This is what the shell does with shell commands.
-
-Globbing
-
-* Calling Glob:: Basic use of @code{glob}.
-* Flags for Globbing:: Flags that enable various options in @code{glob}.
-* More Flags for Globbing:: GNU specific extensions to @code{glob}.
-
-Regular Expressions
-
-* POSIX Regexp Compilation:: Using @code{regcomp} to prepare to match.
-* Flags for POSIX Regexps:: Syntax variations for @code{regcomp}.
-* Matching POSIX Regexps:: Using @code{regexec} to match the compiled
- pattern that you get from @code{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 @code{wordexp}.
-* Flags for Wordexp:: Options you can enable in @code{wordexp}.
-* Wordexp Example:: A sample program that does word expansion.
-* Tilde Expansion:: Details of how tilde expansion works.
-* Variable Substitution:: Different types of variable substitution.
-
-I/O Overview
-
-* I/O Concepts:: Some basic information and terminology.
-* File Names:: How to refer to a file.
-
-I/O Concepts
-
-* Streams and File Descriptors:: The GNU Library provides two ways
- to access the contents of files.
-* File Position:: The number of bytes from the
- beginning of the file.
-
-File Names
-
-* Directories:: Directories contain entries for files.
-* File Name Resolution:: A file name specifies how to look up a file.
-* File Name Errors:: Error conditions relating to file names.
-* File Name Portability:: File name portability and syntax issues.
-
-I/O on Streams
-
-* Streams:: About the data type representing a stream.
-* Standard Streams:: Streams to the standard input and output
- devices are created for you.
-* Opening Streams:: How to create a stream to talk to a file.
-* Closing Streams:: Close a stream when you are finished with it.
-* 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:: @code{printf} and related functions.
-* Customizing Printf:: You can define new conversion specifiers for
- @code{printf} and friends.
-* Formatted Input:: @code{scanf} and related functions.
-* EOF and Errors:: How you can tell if an I/O error happens.
-* Binary Streams:: Some systems distinguish between text files
- and binary files.
-* File Positioning:: About random-access streams.
-* Portable Positioning:: Random access on peculiar ISO C systems.
-* Stream Buffering:: How to control buffering of streams.
-* Other Kinds of Streams:: Streams that do not necessarily correspond
- to an open file.
-* Formatted Messages:: Print strictly formatted messages.
-
-Unreading
-
-* Unreading Idea:: An explanation of unreading with pictures.
-* How Unread:: How to call @code{ungetc} to do unreading.
-
-Formatted Output
-
-* Formatted Output Basics:: Some examples to get you started.
-* Output Conversion Syntax:: General syntax of conversion
- specifications.
-* Table of Output Conversions:: Summary of output conversions and
- what they do.
-* Integer Conversions:: Details about formatting of integers.
-* Floating-Point Conversions:: Details about formatting of
- floating-point numbers.
-* Other Output Conversions:: Details about formatting of strings,
- characters, pointers, and the like.
-* Formatted Output Functions:: Descriptions of the actual functions.
-* Dynamic Output:: Functions that allocate memory for the output.
-* Variable Arguments Output:: @code{vprintf} and friends.
-* Parsing a Template String:: What kinds of args does a given template
- call for?
-* Example of Parsing:: Sample program using @code{parse_printf_format}.
-
-Customizing Printf
-
-* Registering New Conversions:: Using @code{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 @code{register_printf_function}.
-* Printf Extension Example:: How to define a @code{printf}
- handler function.
-* Predefined Printf Handlers:: Predefined @code{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 @code{malloc} the buffer.
-* Other Input Conversions:: Details of miscellaneous other conversions.
-* Formatted Input Functions:: Descriptions of the actual functions.
-* Variable Arguments Input:: @code{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 @dfn{cookie} records where to fetch or
- store data that is read or written.
-* Hook Functions:: How you should define the four @dfn{hook
- functions} that a custom stream needs.
-
-Formatted Messages
-
-* Printing Formatted Messages:: The @code{fmtmsg} function.
-* Adding Severity Classes:: Add more severity classes.
-* Example:: How to use @code{fmtmsg} and @code{addseverity}.
-
-Low-Level I/O
-
-* Opening and Closing Files:: How to open and close file
- descriptors.
-* Truncating Files:: Change the size of a file.
-* I/O Primitives:: Reading and writing data.
-* File Position Primitive:: Setting a descriptor's file
- position.
-* Descriptors and Streams:: Converting descriptor to stream
- or vice-versa.
-* Stream/Descriptor Precautions:: Precautions needed if you use both
- descriptors and streams.
-* Scatter-Gather:: Fast I/O to discontinous buffers.
-* Memory-mapped I/O:: Using files like memory.
-* Waiting for I/O:: How to check for input or output
- on multiple file descriptors.
-* Synchronizing I/O:: Making sure all I/O actions completed.
-* Asynchronous I/O:: Perform I/O in parallel.
-* Control Operations:: Various other operations on file
- descriptors.
-* Duplicating Descriptors:: Fcntl commands for duplicating
- file descriptors.
-* Descriptor Flags:: Fcntl commands for manipulating
- flags associated with file
- descriptors.
-* File Status Flags:: Fcntl commands for manipulating
- flags associated with open files.
-* File Locks:: Fcntl commands for implementing
- file locking.
-* Interrupt Input:: Getting an asynchronous signal when
- input arrives.
-* IOCTLs:: Generic I/O Control operations.
-
-Stream/Descriptor Precautions
-
-* Linked Channels:: Dealing with channels sharing a file position.
-* Independent Channels:: Dealing with separately opened, unlinked channels.
-* Cleaning Streams:: Cleaning a stream makes it safe to use
- another channel.
-
-Asynchronous I/O
-
-* Asynchronous Reads/Writes:: Asynchronous Read and Write Operations.
-* Status of AIO Operations:: Getting the Status of AIO Operations.
-* Synchronizing AIO Operations:: Getting into a consistent state.
-* Cancel AIO Operations:: Cancelation 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 @code{open}.
-* Operating Modes:: Special modes to control I/O operations.
-* Getting File Status Flags:: Fetching and changing these flags.
-
-File System Interface
-
-* Working Directory:: This is used to resolve relative
- file names.
-* Accessing Directories:: Finding out what files a directory
- contains.
-* Working on 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 @code{pipe} function.
-* Pipe to a Subprocess:: Using a pipe to communicate with a
- child process.
-* FIFO Special Files:: Making a FIFO special file.
-* Pipe Atomicity:: When pipe (or FIFO) I/O is atomic.
-
-Sockets
-
-* Socket Concepts:: Basic concepts you need to know about.
-* Communication Styles::Stream communication, datagrams, and other styles.
-* Socket Addresses:: How socket names (``addresses'') work.
-* Interface Naming:: Identifying specific network interfaces.
-* Local Namespace:: Details about the local namespace.
-* Internet Namespace:: Details about the Internet namespace.
-* Misc Namespaces:: Other namespaces not documented fully here.
-* Open/Close Sockets:: Creating sockets and destroying them.
-* Connections:: Operations on sockets with connection state.
-* Datagrams:: Operations on datagram sockets.
-* Inetd:: Inetd is a daemon that starts servers on request.
- The most convenient way to write a server
- is to make it work with Inetd.
-* Socket Options:: Miscellaneous low-level socket options.
-* Networks Database:: Accessing the database of network names.
-
-Socket Addresses
-
-* Address Formats:: About @code{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
- Internet namespace.
-* Host Addresses:: All about host addresses of internet host.
-* Protocols Database:: Referring to protocols by name.
-* Ports:: Internet port numbers.
-* Services Database:: Ports may have symbolic names.
-* Byte Order:: Different hosts may use different byte
- ordering conventions; you need to
- canonicalize host address and port number.
-* Inet Example:: Putting it all together.
-
-Host Addresses
-
-* Abstract Host Addresses:: What a host number consists of.
-* Data type: 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
- 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 @code{send}.
-* Receiving Data:: Reading data with @code{recv}.
-* Socket Data Options:: Using @code{send} and @code{recv}.
-
-Datagrams
-
-* Sending Datagrams:: Sending packets on a datagram socket.
-* Receiving Datagrams:: Receiving packets on a datagram socket.
-* Datagram Example:: An example program: packets sent over a
- datagram socket in the local namespace.
-* Example Receiver:: Another program, that receives those packets.
-
-Inetd
-
-* Inetd Servers::
-* Configuring Inetd::
-
-Socket Options
-
-* Socket Option Functions:: The basic functions for setting and getting
- socket options.
-* Socket-Level Options:: Details of the options at the socket level.
-
-Low-Level Terminal Interface
-
-* Is It a Terminal:: How to determine if a file is a terminal
- device, and what its name is.
-* I/O Queues:: About flow control and typeahead.
-* Canonical or Not:: Two basic styles of input processing.
-* Terminal Modes:: How to examine and modify flags controlling
- details of terminal I/O: echoing,
- signals, editing.
-* Line Control:: Sending break sequences, clearing
- terminal buffers @dots{}
-* 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 @code{struct termios} and
- related types.
-* Mode Functions:: Functions to read and set the terminal
- attributes.
-* Setting Modes:: The right way to set terminal attributes
- reliably.
-* Input Modes:: Flags controlling low-level input handling.
-* Output Modes:: Flags controlling low-level output handling.
-* Control Modes:: Flags controlling serial port behavior.
-* Local Modes:: Flags controlling high-level input handling.
-* Line Speed:: How to read and set the terminal line speed.
-* Special Characters:: Characters that have special effects,
- and how to change them.
-* Noncanonical Input:: Controlling how long to wait for input.
-
-Special Characters
-
-* Editing Characters:: Special characters that terminate lines and
- delete text, and other editing functions.
-* Signal Characters:: Special characters that send or raise signals
- to or for certain classes of processes.
-* Start/Stop Characters:: Special characters that suspend or resume
- suspended output.
-* Other Special:: Other special characters for BSD systems:
- they can discard output, and print status.
-
-Pseudo-Terminals
-
-* Allocation:: Allocating a pseudo terminal.
-* Pseudo-Terminal Pairs:: How to open both sides of a
- pseudo-terminal in a single operation.
-
-Mathematics
-
-* Mathematical Constants:: Precise numeric values for often-used
- constants.
-* Trig Functions:: Sine, cosine, tangent, and friends.
-* Inverse Trig Functions:: Arcsine, arccosine, etc.
-* Exponents and Logarithms:: Also pow and sqrt.
-* Hyperbolic Functions:: sinh, cosh, tanh, etc.
-* Special Functions:: Bessel, gamma, erf.
-* Pseudo-Random Numbers:: Functions for generating pseudo-random
- numbers.
-* FP Function Optimizations:: Fast code or small code.
-
-Pseudo-Random Numbers
-
-* ISO Random:: @code{rand} and friends.
-* BSD Random:: @code{random} and friends.
-* SVID Random:: @code{drand48} and friends.
-
-Arithmetic
-
-* 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.
-* Integer Division:: Integer division with guaranteed rounding.
-* Parsing of Numbers:: Converting strings to numbers.
-* System V Number Conversion:: An archaic way to convert numbers to strings.
-
-Floating Point Errors
-
-* FP Exceptions:: IEEE 754 math exceptions and how to detect them.
-* Infinity and NaN:: Special values returned by calculations.
-* Status bit operations:: Checking for exceptions after the fact.
-* Math Error Reporting:: How the math functions report errors.
-
-Arithmetic Functions
-
-* Absolute Value:: Absolute values of integers and floats.
-* Normalization Functions:: Extracting exponents and putting them back.
-* Rounding Functions:: Rounding floats to integers.
-* Remainder Functions:: Remainders on division, precisely defined.
-* FP Bit Twiddling:: Sign bit adjustment. Adding epsilon.
-* FP Comparison Functions:: Comparisons without risk of exceptions.
-* Misc FP Arithmetic:: Max, min, positive difference, multiply-add.
-
-Parsing of Numbers
-
-* Parsing of Integers:: Functions for conversion of integer values.
-* Parsing of Floats:: Functions for conversion of floating-point
- values.
-
-Date and Time
-
-* Processor Time:: Measures processor time used by a program.
-* Calendar Time:: Manipulation of ``real'' dates and times.
-* Precision Time:: Manipulation and monitoring of high accuracy
- time.
-* Setting an Alarm:: Sending a signal after a specified time.
-* Sleeping:: Waiting for a period of time.
-* Resource Usage:: Measuring various resources used.
-* Limits on Resources:: Specifying limits on resource usage.
-* Priority:: Reading or setting process run priority.
-
-Processor Time
-
-* Basic CPU Time:: The @code{clock} function.
-* Detailed CPU Time:: The @code{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.
-* Formatting Date and 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.
-
-Non-Local Exits
-
-* Intro: Non-Local Intro. When and how to use these facilities.
-* Details: Non-Local Details. Functions for nonlocal exits.
-* Non-Local Exits and Signals:: Portability issues.
-
-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 @code{open},
- @code{read}, @code{write} and other functions.
-* Generating Signals:: How to send a signal to a process.
-* Blocking Signals:: Making the system hold signals temporarily.
-* Waiting for a Signal:: Suspending your program until a signal
- arrives.
-* Signal Stack:: Using a Separate Signal Stack.
-* BSD Signal Handling:: Additional functions for backward
- compatibility with BSD.
-
-Concepts of Signals
-
-* Kinds of Signals:: Some examples of what can cause a signal.
-* Signal Generation:: Concepts of why and how signals occur.
-* Delivery of Signal:: Concepts of what a signal does to the
- process.
-
-Standard Signals
-
-* Program Error Signals:: Used to report serious program errors.
-* Termination Signals:: Used to interrupt and/or terminate the
- program.
-* Alarm Signals:: Used to indicate expiration of timers.
-* Asynchronous I/O Signals:: Used to indicate input is available.
-* Job Control Signals:: Signals used to support job control.
-* Operation Error Signals:: Used to report operational system errors.
-* Miscellaneous Signals:: Miscellaneous Signals.
-* Signal Messages:: Printing a message describing a signal.
-
-Signal Actions
-
-* Basic Signal Handling:: The simple @code{signal} function.
-* Advanced Signal Handling:: The more powerful @code{sigaction} function.
-* Signal and Sigaction:: How those two functions interact.
-* Sigaction Function Example:: An example of using the sigaction function.
-* Flags for Sigaction:: Specifying options for signal handling.
-* Initial Signal Actions:: How programs inherit signal actions.
-
-Defining Handlers
-
-* Handler Returns:: Handlers that return normally, and what
- this means.
-* Termination in Handler:: How handler functions terminate a program.
-* Longjmp in Handler:: Nonlocal transfer of control out of a
- signal handler.
-* Signals in Handler:: What happens when signals arrive while
- the handler is already occupied.
-* Merged Signals:: When a second signal arrives before the
- first is handled.
-* Nonreentrancy:: Do not call any functions unless you know they
- are reentrant with respect to signals.
-* Atomic Data Access:: A single handler can run in the middle of
- reading or writing a single object.
-
-Atomic Data Access
-
-* Non-atomic Example:: A program illustrating interrupted access.
-* Types: 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 @code{kill}.
-* Kill Example:: Using @code{kill} for Communication.
-
-Blocking Signals
-
-* Why Block:: The purpose of blocking signals.
-* Signal Sets:: How to specify which signals to
- block.
-* Process Signal Mask:: Blocking delivery of signals to your
- process during normal execution.
-* Testing for Delivery:: Blocking to Test for Delivery of
- a Signal.
-* Blocking for Handler:: Blocking additional signals while a
- handler is being run.
-* Checking for Pending Signals:: Checking for Pending Signals
-* Remembering a Signal:: How you can get almost the same
- effect as blocking a signal, by
- handling it and setting a flag
- to be tested later.
-
-Waiting for a Signal
-
-* Using Pause:: The simple way, using @code{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.
-
-Process Startup
-
-* Program Arguments:: Parsing your program's command-line arguments.
-* Environment Variables:: How to access parameters inherited from
- a parent process.
-* Program Termination:: How to cause a process to terminate and
- return status information to its parent.
-
-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 @code{getopt}.
-* Argp:: Parsing program options using @code{argp_parse}.
-* Suboptions:: Some programs need more detailed options.
-* Suboptions Example:: This shows how it could be done for @code{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 @code{exit}, a
- process terminates normally.
-* Exit Status:: The @code{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 @code{abort} function causes
- abnormal program termination.
-* Termination Internals:: What happens when a process terminates.
-
-Processes
-
-* Running a Command:: The easy way to run another program.
-* Process Creation Concepts:: An overview of the hard way to do it.
-* Process Identification:: How to get the process ID of a process.
-* Creating a Process:: How to fork a child process.
-* Executing a File:: How to make a process execute another program.
-* Process Completion:: How to tell when a child process has completed.
-* Process Completion Status:: How to interpret the status value
- returned from a child process.
-* BSD Wait Functions:: More functions, for backward compatibility.
-* Process Creation Example:: A complete example program.
-
-Job Control
-
-* Concepts of Job Control:: Jobs can be controlled by a shell.
-* Job Control is Optional:: Not all POSIX systems support job control.
-* Controlling Terminal:: How a process gets its controlling terminal.
-* Access to the Terminal:: How processes share the controlling terminal.
-* Orphaned Process Groups:: Jobs left after the user logs out.
-* Implementing a Shell:: What a shell must do to implement job control.
-* Functions for Job Control:: Functions to control process groups.
-
-Implementing a Shell
-
-* Data Structures:: Introduction to the sample shell.
-* Initializing the Shell:: What the shell must do to take
- responsibility for job control.
-* Launching Jobs:: Creating jobs to execute commands.
-* Foreground and Background:: Putting a job in foreground of background.
-* Stopped and Terminated Jobs:: Reporting job status.
-* Continuing Stopped Jobs:: How to continue a stopped job in
- the foreground or background.
-* Missing Pieces:: Other parts of the shell.
-
-Functions for Job Control
-
-* Identifying the Terminal:: Determining the controlling terminal's name.
-* Process Group Functions:: Functions for manipulating process groups.
-* Terminal Access Functions:: Functions for controlling terminal access.
-
-Name Service Switch
-
-* NSS Basics:: What is this NSS good for.
-* NSS Configuration File:: Configuring NSS.
-* NSS Module Internals:: How does it work internally.
-* Extending NSS:: What to do to add services or databases.
-
-NSS Configuration File
-
-* Services in the NSS configuration:: Service names in the NSS configuration.
-* Actions in the NSS configuration:: React appropriately to the lookup result.
-* Notes on NSS Configuration File:: Things to take care about while
- configuring NSS.
-
-NSS Module Internals
-
-* NSS Module Names:: Construction of the interface function of
- the NSS modules.
-* NSS Modules Interface:: Programming interface in the NSS module
- functions.
-
-Extending NSS
-
-* Adding another Service to NSS:: What is to do to add a new service.
-* NSS Module Function Internals:: Guidelines for writing new NSS
- service functions.
-
-Users and Groups
-
-* User and Group IDs:: Each user has a unique numeric ID;
- likewise for groups.
-* Process Persona:: The user IDs and group IDs of a process.
-* Why Change Persona:: Why a program might need to change
- its user and/or group IDs.
-* How Change Persona:: Changing the user and group IDs.
-* Reading Persona:: How to examine the user and group IDs.
-
-* Setting User ID:: Functions for setting the user ID.
-* Setting Groups:: Functions for setting the group IDs.
-
-* Enable/Disable Setuid:: Turning setuid access on and off.
-* Setuid Program Example:: The pertinent parts of one sample program.
-* Tips for Setuid:: How to avoid granting unlimited access.
-
-* Who Logged In:: Getting the name of the user who logged in,
- or of the real user ID of the current process.
-
-* User Accounting Database:: Keeping information about users and various
- actions in databases.
-
-* User Database:: Functions and data structures for
- accessing the user database.
-* Group Database:: Functions and data structures for
- accessing the group database.
-* Database Example:: Example program showing the use of database
- inquiry functions.
-* Netgroup Database:: Functions for accessing the netgroup database.
-
-User Accounting Database
-
-* Manipulating the Database:: Scanning and modifying the user
- accounting database.
-* XPG Functions:: A standardized way for doing the same thing.
-* Logging In and Out:: Functions from BSD that modify the user
- accounting database.
-
-User Database
-
-* User Data Structure:: What each user record contains.
-* Lookup User:: How to look for a particular user.
-* Scanning All Users:: Scanning the list of all users, one by one.
-* Writing a User Entry:: How a program can rewrite a user's record.
-
-Group Database
-
-* Group Data Structure:: What each group record contains.
-* Lookup Group:: How to look for a particular group.
-* Scanning All Groups:: Scanning the list of all groups.
-
-Netgroup Database
-
-* Netgroup Data:: Data in the Netgroup database and where
- it comes from.
-* Lookup Netgroup:: How to look for a particular netgroup.
-* Netgroup Membership:: How to test for netgroup membership.
-
-System Information
-
-* Host Identification:: Determining the name of the machine.
-* Hardware/Software Type ID:: Determining the hardware type of the
- machine and what operating system it is
- running.
-* Filesystem handling:: Which is mounted and/or available?
-
-System Configuration
-
-* General Limits:: Constants and functions that describe
- various process-related limits that have
- one uniform value for any given machine.
-* System Options:: Optional POSIX features.
-* Version Supported:: Version numbers of POSIX.1 and POSIX.2.
-* Sysconf:: Getting specific configuration values
- of general limits and system options.
-* Minimums:: Minimum values for general limits.
-
-* Limits for Files:: Size limitations that pertain to individual files.
- These can vary between file systems
- or even from file to file.
-* Options for Files:: Optional features that some files may support.
-* File Minimums:: Minimum values for file limits.
-* Pathconf:: Getting the limit values for a particular file.
-
-* Utility Limits:: Capacity limits of some POSIX.2 utility programs.
-* Utility Minimums:: Minimum allowable values of those limits.
-
-* String Parameters:: Getting the default search path.
-
-Sysconf
-
-* Sysconf Definition:: Detailed specifications of @code{sysconf}.
-* Constants for Sysconf:: The list of parameters @code{sysconf} can read.
-* Examples of Sysconf:: How to use @code{sysconf} and the parameter
- macros properly together.
-
-Cryptographic Functions
-
-* Legal Problems:: This software can get you locked up, or worse.
-* getpass:: Prompting the user for a password.
-* crypt:: A one-way function for UNIX passwords.
-* DES Encryption:: Routines for DES encryption.
-
-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
- cancelled.
-* Mutexes:: One way to synchronize threads.
-* Condition Variables:: Another way.
-* POSIX Semaphores:: And a third way.
-* Thread-Specific Data:: Variables with different values in
- different threads.
-* Threads and Signal Handling:: Why you should avoid mixing the two, and
- how to do it if you must.
-* Miscellaneous Thread Functions:: A grab bag of utility routines.
-
-Language Features
-
-* Consistency Checking:: Using @code{assert} to abort if
- something ``impossible'' happens.
-* Variadic Functions:: Defining functions with varying numbers
- of args.
-* Null Pointer Constant:: The macro @code{NULL}.
-* Important Data Types:: Data types for object sizes.
-* Data Type Measurements:: Parameters of data type representations.
-
-Variadic Functions
-
-* Why Variadic:: Reasons for making functions take
- variable arguments.
-* How Variadic:: How to define and call variadic functions.
-* Variadic Example:: A complete example.
-
-How Variadic
-
-* Variadic Prototypes:: How to make a prototype for a function
- with variable arguments.
-* Receiving Arguments:: Steps you must follow to access the
- optional argument values.
-* How Many Arguments:: How to decide whether there are more arguments.
-* Calling Variadics:: Things you need to know about calling
- variable arguments functions.
-* Argument Macros:: Detailed specification of the macros
- for accessing variable arguments.
-* Old Varargs:: The pre-ISO way of defining variadic functions.
-
-Data Type Measurements
-
-* Width of Type:: How many bits does an integer type hold?
-* Range of Type:: What are the largest and smallest values
- that an integer type can hold?
-* Floating Type Macros:: Parameters that measure the floating point types.
-* Structure Measurement:: Getting measurements on structure types.
-
-Floating Type Macros
-
-* Floating Point Concepts:: Definitions of terminology.
-* Floating Point Parameters:: Details of specific macros.
-* IEEE Floating Point:: The measurements for one common
- representation.
-
-Installation
-
-* Configuring and compiling:: How to compile and test GNU libc.
-* Running make install:: How to install it once you've got it compiled.
-* Tools for Compilation:: You'll need these first.
-* Supported Configurations:: What it runs on, what it doesn't.
-* Linux:: Specific advice for Linux systems.
-* Reporting Bugs:: So they'll get fixed.
-
-Maintenance
-
-* Source Layout:: How to add new functions or header files
- to the GNU C library.
-* Porting:: How to port the GNU C library to
- a new machine or operating system.
-
-Porting
-
-* Hierarchy Conventions:: The layout of the @file{sysdeps} hierarchy.
-* Porting to Unix:: Porting the library to an average
- Unix-like system.
-@end menu
git.samba.org / jlayton / glibc.git / commitdiff