Beginning Linux Programming, 4th Edition
Print on Demand
Beginning Linux Programming, 4th Edition
ISBN: 978-0-470-14762-7 November 2007 816 Pages
Download Product Flyer
Description
About the Author
Rick Stones started programming at school (more years ago than he cares to remember) on a 6502-powered BBC micro, which, with the help of a few spare parts, continued to function for the next 15 years. He graduated from Nottingham University with a degree in Electronic Engineering, but decided software was more fun.
Over the years he has worked for a variety of companies, from the very small with just a dozen employees, to the very large, including the IT services giant EDS. Along the way he has worked on a range of projects, from real-time communications to accounting systems, to very large help desk systems. He is currently working as an IT architect, acting as a technical authority on various major projects for a large pan-European company.
A bit of a programming linguist, he has programmed in various assemblers, a rather neat proprietary telecommunications language called SL-1, some FORTRAN, Pascal, Perl, SQL, and smidgeons of Python and C++, as well as C. (Under duress he even admits that he was once reasonably proficient in Visual Basic, but tries not to advertise this aberration.)
Permissions
Request permission to reuse content from this site
Table of contents
Chapter 1: Getting Started 1
An Introduction to UNIX, Linux, and GNU 1
What Is Linux? 3
The GNU Project and the Free Software Foundation 3
Linux Distributions 4
Programming Linux 4
Linux Programs 5
The C Compiler 7
Development System Roadmap 8
Getting Help 14
Chapter 2: Shell Programming 17
Why Program with a Shell? 18
A Bit of Philosophy 18
What Is a Shell? 19
Pipes and Redirection 21
Redirecting Output 21
Redirecting Input 22
The Shell as a Programming Language 23
Interactive Programs 23
Creating a Script 24
Making a Script Executable 25
Shell Syntax 27
Control Structures 34
Command Execution 68
Here Documents 73
Debugging Scripts 74
Going Graphical — The dialog Utility 75
Putting It All Together 81
Chapter 3: Working with Files 93
Linux File Structure 94
Files and Devices 95
System Calls and Device Drivers 96
Library Functions 97
Low-Level File Access 98
Initial Permissions 101
Other System Calls for Managing Files 106
The Standard I/O Library 109
fgetc, getc, and getchar 112
fputc, putc, and putchar 112
fgets and gets 113
Formatted Input and Output 113
printf, fprintf, and sprintf 113
scanf, fscanf, and sscanf 115
Other Stream Functions 117
Stream Errors 119
Streams and File Descriptors 119
File and Directory Maintenance 120
unlink, link, and symlink 121
mkdir and rmdir 121
chdir and getcwd 122
Scanning Directories 122
The /proc File System 128
Advanced Topics: fcntl and mmap 132
Chapter 4: The Linux Environment 137
Program Arguments 137
Environment Variables 144
Use of Environment Variables 146
The environ Variable 147
Time and Date 148
Temporary Files 156
User Information 158
Host Information 161
Resources and Limits 167
Chapter 5: Terminals 175
Reading from and Writing to the Terminal 175
Talking to the Terminal 180
The Terminal Driver and the General Terminal Interface 182
Hardware Model 183
The termios Structure 184
Input Modes 186
Output Modes 186
Control Modes 187
Local Modes 188
Special Control Characters 188
Terminal Speed 192
Additional Functions 192
Terminal Output 196
Terminal Type 197
Identify Your Terminal Type 197
Using terminfo Capabilities 200
Detecting Keystrokes 205
Virtual Consoles 207
Chapter 6: Managing Text-Based Screens with curses 211
Compiling with curses 212
Curses Terminology and Concepts 213
Output to the Screen 216
Reading from the Screen 217
Clearing the Screen 218
Moving the Cursor 218
Character Attributes 218
The Keyboard 221
Keyboard Modes 221
Keyboard Input 222
The WINDOW Structure 224
Generalized Functions 225
Moving and Updating a Window 225
Optimizing Screen Refreshes 229
Using Color 235
Redefining Colors 238
The CD Collection Application 240
Starting a New CD Collection Application 240
Looking at main 243
Building the Menu 243
Database File Manipulation 245
Querying the CD Database 250
Chapter 7: Data Management 255
Managing Memory 255
Simple Memory Allocation 256
Allocating Lots of Memory 257
Abusing Memory 260
The Null Pointer 261
Freeing Memory 262
Other Memory Allocation Functions 264
File Locking 264
Creating Lock Files 265
Locking Regions 268
Use of read and write with Locking 271
Competing Locks 276
Other Lock Commands 280
The dbm Database 281
The dbm Routines 283
dbm Access Functions 283
Additional dbm Functions 287
The CD Application 289
Updating the Design 289
The CD Database Application Using dbm 290
Chapter 8: MySQL 311
MySQL Packages 312
Post-Install Configuration 314
Post-Installation Troubleshooting 319
MySQL Administration 320
Creating Users and Giving Them Permissions 325
Creating a Database 328
Creating a Table 330
Graphical Tools 333
Accessing MySQL Data from C 335
Connection Routines 337
Error Handling 341
Executing SQL Statements 342
Miscellaneous Functions 357
The CD Database Application 358
Creating the Tables 359
Adding Some Data 362
Accessing the Application Data from C 364
Chapter 9: Development Tools 377
Problems of Multiple Source Files 377
The make Command and Makefiles 378
The Syntax of Makefiles 378
Options and Parameters to make 379
Comments in a Makefile 382
Macros in a Makefile 382
Multiple Targets 384
Built-in Rules 387
Suffix and Pattern Rules 388
Managing Libraries with make 389
Advanced Topic: Makefiles and Subdirectories 391
GNU make and gcc 391
Source Code Control 392
Comparing RCS and SCCS 399
CVS Front Ends 404
Writing a Manual Page 406
Distributing Software 409
The patch Program 410
Other Distribution Utilities 411
RPM Packages 413
Working with RPM Package Files 414
Installing RPM Packages 415
Building RPM Packages 415
Other Package Formats 424
Development Environments 424
Other Environments 425
Chapter 10: Debugging 429
Types of Errors 429
General Debugging Techniques 430
A Program with Bugs 430
Code Inspection 433
Controlled Execution 436
Debugging with gdb 437
Starting gdb 437
Running a Program 438
Stack Trace 438
Examining Variables 439
Listing the Program 440
Setting Breakpoints 441
Patching with the Debugger 444
Learning More about gdb 445
More Debugging Tools 445
Lint: Removing the Fluff from Your Programs 446
Function Call Tools 449
Execution Profiling with prof/gprof 451
Memory Debugging 453
Chapter 11: Processes and Signals 461
What Is a Process? 461
Process Structure 462
The Process Table 463
Viewing Processes 463
System Processes 464
Process Scheduling 467
Starting New Processes 468
Waiting for a Process 475
Zombie Processes 477
Input and Output Redirection 479
Sending Signals 484
Signal Sets 489
Chapter 12: POSIX Threads 495
What Is a Thread? 495
Advantages and Drawbacks of Threads 496
A First Threads Program 497
Simultaneous Execution 501
Synchronization with Semaphores 503
Synchronization with Mutexes 508
Thread Attributes 512
Canceling a Thread 517
Threads in Abundance 520
Chapter 13: Inter-Process Communication: Pipes 525
What Is a Pipe? 525
Process Pipes 526
Sending Output to popen 528
Passing More Data 529
How popen Is Implemented 530
The Pipe Call 531
Parent and Child Processes 535
Reading Closed Pipes 536
Pipes Used as Standard Input and Output 537
Named Pipes: FIFOs 540
Accessing a FIFO 542
Advanced Topic: Client/Server Using FIFOs 549
The CD Database Application 553
Client Interface Functions 558
The Server Interface, server.c 565
Application Summary 574
Chapter 14: Semaphores, Shared Memory, and Message Queues 577
Semaphore Definition 579
A Theoretical Example 579
Linux Semaphore Facilities 580
Using Semaphores 582
Shared Memory 586
Message Queues 594
The CD Database Application 599
Revising the Server Functions 600
Revising the Client Functions 602
IPC Status Commands 604
Displaying Semaphore Status 604
Displaying Shared Memory Status 604
Displaying Message Queue Status 605
Chapter 15: Sockets 607
What Is a Socket? 608
Socket Connections 608
Socket Attributes 612
Creating a Socket 614
Socket Addresses 615
Naming a Socket 616
Creating a Socket Queue 617
Accepting Connections 617
Requesting Connections 618
Closing a Socket 619
Socket Communications 619
Host and Network Byte Ordering 622
Network Information 624
The Internet Daemon (xinetd/inetd) 629
Socket Options 631
Multiple Clients 632
Multiple Clients 638
Chapter 16: Programming GNOME Using GTK+ 645
Introducing X 645
Window Managers 647
Other Ways to Create a GUI — Platform-Independent Windowing APIs 648
Introducing GTK+ 648
GLib Type System 649
GTK+ Object System 650
Introducing GNOME 651
Installing the GNOME/GTK+ Development Libraries 652
Events, Signals, and Callbacks 655
Packing Box Widgets 658
GTK+ Widgets 661
GNOME Widgets 676
GNOME Menus 677
Modal Dialog Box 684
Nonmodal Dialogs 685
CD Database Application 687
Chapter 17: Programming KDE Using Qt 701
Introducing KDE and Qt 701
Installing Qt 702
Signals and Slots 705
Using qmake to Simplify Writing Makefiles 733
Menus and Toolbars with KDE 733
CD Database Application Using KDE/Qt 738
Chapter 18: Standards for Linux 747
The C Programming Language 748
A Brief History Lesson 748
The GNU Compiler Collection 749
gcc Options 749
Interfaces and the Linux Standards Base 751
LSB Standard Libraries 752
LSB Users and Groups 754
LSB System Initialization 754
The Filesystem Hierarchy Standard 755
Further Reading about Standards 758
Downloads
| Beginning Linux Programming, 4th Edition Zip file containing all the code for the book. | Download |
| Download File Correction pg 362 Code downloads for all chapters of this title are available here. | Download |
Errata
| Chapter | Page | Details | Date | Print Run |
|---|---|---|---|---|
| 2 | 52 | Error in Code Try it Out: The Dot Command. The first «echo $version», «ion» should be bold | 14-Oct-2015 | |
| 55 | Error in Text Try It Out, section 2 |
Currently reads: ?export2?
Should read: ?./export2?
In the «How it works» section, second sentence:
HOW IT READS NOW:
. so when it subsequently invokes export1, the .
HOW IT SHOULD READ:
. so when it subsequently invokes export2, the .
trap INT
trap — INT
The executed script print out
-«press interrupt (CTRL-C) to interrupt . «
Should be:
-«press interrupt (control-C) to interrupt . «
The third entry in the table of Options near the bottom of the page, -maxdepths N
Should read -maxdepth N
Section 4:
The line reading «Proceeding from the heat-oppressed brain» should be deleted
Insert text:
CURRENTLY READS:
bar
fud
usr/bin/X11/startx
startx
/usr/local/etc
/usr
SHOULD READ:
bar
fud
usr/bin/X11/startx
startx
/usr/local/etc/
/usr/
(a line of code in the first grey box on the page)
Currently reads:
num_tracks=$(wc -l $temp_file)
Should Read
num_tracks=$(wc -l
(a line of code in the first grey box on the page)
Currently reads:
num_tracks=$(wc -l $temp_file)
Should Read:
num_tracks=$(wc -l
Second paragraph in «Directories» section:
You can see the inode number for a file using ln -i.
. using ls -i.
code snippet at the top:
46 should be 47
Try It Out:
Text reading:
./longopt: invalid option — q
should be deleted
Try It Out:
The output from the SELECT LAST_INSERT_ID(); command is given as:
14
15
To be consistent with the previous sequence of steps and results in the text, should be:
12
13
At the bottom of the page:
We inserted childno 6
We inserted childno 7
To be consistent with the sequence of steps and results in the text, this should be:
We inserted childno 14
We inserted childno 15
The line:
If the MySQL Query Browser is used, the semi-colon is not needed. It is required for the command-line client.
In the 3rd paragraph, the sentence:
Here you don’t care too much about whether ensuring previous commands succeeded, so you can stick to the simpler form.
should be deleted.
The code download for Makefile6 in chapter 9 contains some additional lines for managing rpm files and manual pages which are not mentioned in the book text or used by the examples in the book. These additional lines can be ignored.
The sentences:
You can modify your earlier makefile, Makefile6, to add a new target to bundle the files into a tarball.
and
The final version of the makefile, simply called Makefile, follows:
should be replaced with:
You can modify your earlier makefile, Makefile5, to add a new target to bundle the files into a tarball.
and
The final version of the makefile, simply called Makefile, follows:
About 2/3 down the page:
CURRENTLY READS:
void (*) (int) sa_handler
SHOULD READ:
void (*sa_handler)(int)
In line 18 of the «chapter06/multiw1.c» source code file:
Currently reads:
refreshing the actual screen once the logical screen has been filled:
Should read:
refreshing the actual screen once the logical screen has been filled: */
Corrected file posted
Line 42 of the chapter07/app/cd_data.h source code file:
Currently reads:
/* two for simple data retrival */
Should read:
/* two for simple data retrieval */
CURRENTLY READS:
SHOULD READ:
First paragraph
Currently reads:
«However, the local address (the server socket) is given as 1574 (or you may see mvel-lm as a service name), but the port chosen in the example is 9734. Why are they different? The answer is that port numbers and addresses are communicated over socket interfaces as binary numbers. Different computers use different byte ordering for integers. For example, an Intel processor stores the 32-bit integer as four consecutive bytes in memory in the order 1-2-3-4, where 1 is the most significant byte. IBM PowerPC processors would store the integer in the byte order 4-3-2-1. If the memory used for integers were simply copied byte-by-byte, the two different computers would not be able to agree on integer values.»
Should read:
«However, the local address (the server socket) is given as 1574 (or you may see mvel-lm as a service name), but the port chosen in the example is 9734. Why are they different? The answer is that port numbers and addresses are communicated over socket interfaces as binary numbers. Different computers use different byte ordering for integers. For example, an IBM PowerPC processor stores the 32-bit integer as four consecutive bytes in memory in the order 1-2-3-4, where 1 is the most significant byte. Intel processors would store the integer in the byte order 4-3-2-1. If the memory used for integers were simply copied byte-by-byte, the two different computers would not be able to agree on integer values.»
Grey tip box at top of page currently reads:
In general, if a loop should should always execute at least once, use a while loop; if it may not need to execute at all, use an until loop.
Источник
