Michael K. Johnson
Erik W. Troan


ISBN: 0-201-30821-5

Part 1: Getting Started
History of Linux Development
    A Short History of Free Unix Software
    Development of Linux
    Basic Lineage of Unix Systems
    Linux Lineage
Licenses and Copyright
    Free Software Licenses
        Combinations of Free and Commercial Software
        The GNU General Public License
        The GNU Library General Public License
        MIT/X-Style Licenses
        BSD-Style Licenses
        Artistic License
        License Incompatibilities
More Information on Linux
    Overview of Linux Documentation
        The HOWTOs and mini-HOWTOs
        The LDP Books
        The Linux Software Map
        The man Pages
    Other Books
    Source Code
    Linux (and Other) Newsgroups
    Mailing Lists
        Other Lists
    Other Documentation
    Your Distribution Vendor
Part 2: Development Tools and Environment
Development Tools
        Complex Command Lines
        Suffix Rules
    The GNU Debugger
gcc Options and Extensions
    gcc Options
    Header Files
        long long
        Inline Functions
        Alternative Extended Keywords
Memory Debugging Tools
    Buggy Code
    Electric Fence
        Using Electric Fence
        Memory Alignment
        Other Features
        Resource Consumption
        Finding Overruns
        Finding Memory Leaks
    mpr and mcheck()
        Finding Memory Corruption with mcheck
        Finding Memory Leaks with mpr
Creating and Using Libraries
    Static Libraries
    Shared Libraries
    Designing Shared Libraries
        Managing Compatibility
        Incompatible Libraries
        Designing Compatible Libraries
    Building Shared Libraries
    Installing Shared Libraries
    Using Shared Libraries
        Using Noninstalled Libraries
        Preloading Libraries
Linux Development Environment
    Understanding System Calls
        System Call Limitations
        System Call Return Codes
        Using System Calls
        Common Error Return Codes
    Finding Header and Library Files
Part 3: System Programming
The Process Model
    Defining a Process
        Complicating Things with Threads
        The Linux Approach
    Process Attributes
        The pid and Parentage
        The fsuid
        User and Group ID Summary
    Process Information
        Program Arguments
        Resource Usage
        Establishing Usage Limits
    Process Primitives
        Having Children
        Watching Your Children Die
        Running New Programs
        A Bit of History: vfork()
        Killing Yourself
        Killing Others
        Dumping Core
    Simple Children
        Running and Waiting with system()
        Reading or Writing from a Process
    Sessions and Process Groups
        Controlling Terminal
        Process Groups
    Introduction to ladsh
        Running External Programs with ladsh
    Creating Clones
Simple File Handling
    The File Mode
        File Access Permissions
        File Permission Modifiers
        File Types
        The Process's umask
    Basic File Operations
        File Descriptors
        Closing Files
        Opening Files in the File System
        Reading, Writing, and Moving Around
        Partial Reads and Writes
        Shortening Files
        Other Operations
    Querying and Changing Inode Information
        Finding Inode Information
        A Simple Example of stat()
        Easily Determining Access Rights
        Changing a File's Access Permissions
        Changing a File's Owner and Group
        Changing a File's Timestamps
        Ext2 Extended Attributes
    Manipulating Directory Entries
        Creating Device and Named Pipe Entries
        Creating Hard Links
        Using Symbolic Links
        Removing Files
        Renaming Files
    Manipulating File Descriptors
        Changing the Access Mode for an Open File
        Modifiying the close-on-exec Flag
        Duplicating File Descriptors
    Creating Unnamed Pipes
    Adding Redirection to ladsh
        The Data Structures
        Changing the Code
Directory Operations
    The Current Working Directory
        Finding the Current Working Directory
        The . and .. Special Files
        Changing the Current Directory
    Changing the Root Directory
    Creating and Removing Directories
        Creating New Directories
        Removing Directories
    Reading a Directory's Contents
        Starting Over
    File Name Globbing
        Use a Subprocess
        Internal Globbing
    Adding Directories and Globbing to ladsh
        Adding cd and pwd
        Adding File Name Globbing
Advanced File Handling
    Input and Output Multiplexing
        Nonblocking I/O
        Multiplexing with select()
    Memory Mapping
        Page Alignment
        Establishing Memory Mappings
        Unmapping Regions
        Syncing Memory Regions to Disk
        Locking Memory Regions
    File Locking
        Lock Files
        Record Locking
        Mandatory Locks
    Scatter/Gather Reads and Writes
Signal Processing
    Signal Concepts
        Simple Signals
        POSIX Signals
        Signals and System Calls
    The Linux (and POSIX) Signal API
        Sending Signals
        Using sigset_t
        Catching Signals
        Manipulating a Process's Signal Mask
        Finding the Set of Pending Signals
        Waiting for Signals
    Available Signals
    Writing Signal Handlers
    Reopening Log Files
Job Control
    Job Control Basics
        Restarting Processes
        Stopping Processes
        Handling Job Control Signals
    Job Control in ladsh
Terminals and Pseudo Terminals
    tty Operations
        Controlling Terminals
    termios Overview
    termios Examples
        Serial Communications
    termios Debugging
    termios Reference
        Window Sizes
        Input Flags
        Output Flags
        Control Flags
        Control Characters
        Local Flags
        Controlling read()
    Pseudo ttys
        Opening Pseudo ttys
        Pseudo tty Example
Networking with Sockets
    Protocol Support
        Nice Networking
        Real Networking
        Making Reality Play Nice
    Utility Functions
    Basic Socket Operations
        Creating a Socket
        Establishing Connections
        Binding an Address to a Socket
        Waiting for Connections
        Connecting to a Server
    Unix Domain Sockets
        Unix Domain Addresses
        Waiting for a Connection
        Connecting to a Server
        Running the Unix Domain Examples
        Unnamed Unix Domain Sockets
        Passing File Descriptors
    Networking Machines with TCP/IP
        Byte Ordering
        IPv4 Addressing
        IP Socket Addresses
        Manipulating IP Addresses
        Using Hostnames
        Host Information Lookup Example
        Looking Up Port Numbers
        Listening for TCP Connections
        TCP Client Applications
    Socket Errors
    Telling Time and Dates
        Representing Time
        Converting, Formatting, and Parsing Times
        The Limits of Time
    Using Timers
        Interval Timers
Random Numbers
    Pseudo-Random Numbers
    Cryptography and Random Numbers
Programming Virtual Consoles
    Getting Started
    Determining Whether the Terminal Is a VC
    Finding the Current VC
    Managing VC Switching
    Example: The open Command
The Linux Console
    Capability Databases
    Glyphs, Characters, and Maps
    Linux Console Capabilities
        Control Characters
        Escape Sequences
        Testing Sequences
        Complex Escape Sequences
    Direct Screen Writing
Part 4: Development Libraries
String Matching
    Globbing Arbitrary Strings
    Regular Expressions
Terminal Handling with S-Lang
    Input Handling
        Initializing S-Lang Input Handling
        Restoring the Terminal State
        Reading Characters from the Terminal
        Checking for Input with SLang_input_pending()
    Output Handling
        Initializing Screen Management
        Updating the Display
        Moving the Cursor
        Finishing Screen Management
        Skeleton Screen Management
        Switching Character Sets
        Writing to the Screen
        Drawing Lines and Boxes
        Using Color
The Database Library
    Basic Operations
        Opening a db File
        Closing a Database
        Obtaining the File Descriptor
        Syncing the Database
    Reading Records
        Reading Records Sequentially
        Reading a Particular Record
    Modifying the Database
        Adding Records
        Removing Records
Parsing Command-Line Options
    Basic popt Usage
        The Option Table
        Creating a Context
        Parsing the Command Line
        Leftover Arguments
    Error Handling
    Option Aliasing
        Specifying Aliases
        Enabling Aliases
    Parsing Argument Strings
    Handling Extra Arguments
    Sample Application
Dynamic Loading at Run Time
    The dl Interface
Names and the User Databases
    ID-to-Name Translation
        Example: The id Command
    Modifying the System Databases
        Pluggable Authentication Modules
        Password Database Library
Direct Access to I/O Ports
    Almost Portable I/O Port Access
    Direct I/O Port Access
        The Safe Way
        The Dangerous Way
ladsh Source Code
The GNU Licenses
    The GNU General Public License
    The GNU Library General Public License

Copyright © 1998 by Addison Wesley Longman, Inc.