Free Shipping in Australia
Proud to be B-Corp

Linux Application Development Michael K. Johnson

Linux Application Development By Michael K. Johnson

Linux Application Development by Michael K. Johnson

Condition - Very Good
Only 1 left


A detailed guide for experienced Linux programmers. The book should also be a valuable reference for programmers who don't yet know Linux.

Linux Application Development Summary

Linux Application Development by Michael K. Johnson

A new edition of this title is available, ISBN-10: 0321563220 ISBN-13: 9780321563224

About Michael K. Johnson

Michael K. Johnson is an operating system engineer at Specifix. He was formerly an operating system developer for Red Hat, where he managed the kernel team for three and a half years, and was founding technical leader of the Fedora Project. He occasionally teaches full-day tutorials on Linux application development.

Erik W. Troan, cofounder and Executive VP of Operating Systems at Specifix, was formerly Vice President of Product Engineering at Red Hat, where he was responsible for specifying and building technologies such as RPM, Linux operating systems, the Red Hat Network, high-performance Web servers, and the infrastructure for Red Hat's Web site.

Table of Contents



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.


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.

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


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.

Index. 0201308215T04062001

Additional information

Linux Application Development by Michael K. Johnson
Used - Very Good
Pearson Education (US)
Book picture is for illustrative purposes only, actual binding, cover or edition may vary.
This is a used book - there is no escaping the fact it has been read by someone else and it will show signs of wear and previous use. Overall we expect it to be in very good condition, but if you are not entirely satisfied please get in touch with us

Customer Reviews - Linux Application Development