Neil Matthew, Richard Stones

Beginning Linux Programming (eBook, PDF)

• Format: PDF

Produktbeschreibung

Beginning Linux Programming, Fourth Edition continues its unique approach to teaching UNIX programming in a simple and structured way on the Linux platform. Through the use of detailed and realistic examples, students learn by doing, and are able to move from being a Linux beginner to creating custom applications in Linux. The book introduces fundamental concepts beginning with the basics of writing Unix programs in C, and including material on basic system calls, file I/O, interprocess communication (for getting programs to work together), and shell programming. Parallel to this, the book introduces the toolkits and libraries for working with user interfaces, from simpler terminal mode applications to X and GTK+ for graphical user interfaces. Advanced topics are covered in detail such as processes, pipes, semaphores, socket programming, using MySQL, writing applications for the GNOME or the KDE desktop, writing device drivers, POSIX Threads, and kernel programming for the latest Linux Kernel.

---

Dieser Download kann aus rechtlichen Gründen nur mit Rechnungsadresse in A, B, BG, CY, CZ, D, DK, EW, E, FIN, F, GR, HR, H, IRL, I, LT, L, LR, M, NL, PL, P, R, S, SLO, SK ausgeliefert werden.

Produktdetails

• Verlag: Wiley-Scrivener
• Seitenzahl: 816
• Erscheinungstermin: 16. Juni 2008
• Englisch
• ISBN-13: 9780470249130
• Artikelnr.: 37291337

Autorenporträt

Neil Matthew has been interested in and has programmed computers since 1974. A mathematics graduate from the University of Nottingham, Neil is just plain keen on programming languages and likes to explore new ways of solving computing problems. He's written systems to program in BCPL, FP (Functional Programming), Lisp, Prolog, and a structured BASIC. He even wrote a 6502 microprocessor emulator to run BBC microcomputer programs on UNIX systems. In terms of UNIX experience, Neil has used almost every flavor since the late 1970s, including BSD UNIX, AT&T System V, Sun Solaris, IBM AIX, many others, and of course Linux. He can claim to have been using Linux since August 1993 when he acquired a floppy disk distribution of Soft Landing (SLS) from Canada, with kernel version 0.99.11. He's used Linux-based computers for hacking C, C++, Icon, Prolog, Tcl, and Java at home and at work. All of Neil's "home" projects are developed using Linux. He says Linux is much easier because it supports quite a lot of features from other systems, so that both BSD- and System V-targeted programs will generally compile with little or no change. Neil is currently working as an Enterprise Architect specializing in IT strategy at Celesio AG. He has a background in technical consultancy, software development techniques, and quality assurance. Neil has also programmed in C and C++ for real-time embedded systems. 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.)

Inhaltsangabe

Acknowledgements x
Foreword xxiii
Introduction xxv
Chapter 1: Getting Started 1
An Introduction to UNIX, Linux, and GNU 1
What Is UNIX? 1
What Is Linux? 3
The GNU Project and the Free Software Foundation 3
Linux Distributions 4
Programming Linux 4
Linux Programs 5
Text Editors 6
The C Compiler 7
Development System Roadmap 8
Getting Help 14
Summary 16
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
Pipes 22
The Shell as a Programming Language 23
Interactive Programs 23
Creating a Script 24
Making a Script Executable 25
Shell Syntax 27
Variables 27
Conditions 31
Control Structures 34
Functions 46
Commands 49
Command Execution 68
Here Documents 73
Debugging Scripts 74
Going Graphical - The dialog Utility 75
Putting It All Together 81
Requirements 82
Design 82
Summary 91
Chapter 3: Working with Files 93
Linux File Structure 94
Directories 94
Files and Devices 95
System Calls and Device Drivers 96
Library Functions 97
Low-Level File Access 98
write 98
read 99
open 100
Initial Permissions 101
Other System Calls for Managing Files 106
The Standard I/O Library 109
fopen 110
fread 110
fwrite 111
fclose 111
fflush 111
fseek 112
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
chmod 120
chown 120
unlink, link, and symlink 121
mkdir and rmdir 121
chdir and getcwd 122
Scanning Directories 122
opendir 123
readdir 123
telldir 123
seekdir 124
closedir 124
Errors 127
strerror 127
perror 127
The /proc File System 128
Advanced Topics: fcntl and mmap 132
fcntl 132
mmap 133
Summary 135
Chapter 4: The Linux Environment 137
Program Arguments 137
getopt 140
getopt_long 142
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
Logging 163
Resources and Limits 167
Summary 173
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
Overview 183
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
Pseudo-Terminals 208
Summary 209
Chapter 6: Managing Text-Based Screens with curses 211
Compiling with curses 212
Curses Terminology and Concepts 213
The Screen 216
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
Windows 224
The WINDOW Structure 224
Generalized Functions 225
Moving and Updating a Window 225
Optimizing Screen Refreshes 229
Subwindows 230
The Keypad 232
Using Color 235
Redefining Colors 238
Pads 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
Summary 254
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
Deadlocks 280
Databases 281
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
Summary 309
Chapter 8: MySQL 311
Installation 312
MySQL Packages 312
Post-Install Configuration 314
Post-Installation Troubleshooting 319
MySQL Administration 320
Commands 320
Creating Users and Giving Them Permissions 325
Passwords 327
Creating a Database 328
Data Types 329
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
Summary 375
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
RCS 393
SCCS 399
Comparing RCS and SCCS 399
CVS 400
CVS Front Ends 404
Subversion 405
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
KDevelop 425
Other Environments 425
Summary 427
Chapter 10: Debugging 429
Types of Errors 429
General Debugging Techniques 430
A Program with Bugs 430
Code Inspection 433
Instrumentation 434
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
Assertions 452
Memory Debugging 453
ElectricFence 454
valgrind 455
Summary 459
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
Threads 480
Signals 481
Sending Signals 484
Signal Sets 489
Summary 493
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 503
Synchronization with Semaphores 503
Synchronization with Mutexes 508
Thread Attributes 512
Canceling a Thread 517
Threads in Abundance 520
Summary 524
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
Aims 554
Implementation 555
Client Interface Functions 558
The Server Interface, server.c 565
The Pipe 569
Application Summary 574
Summary 575
Chapter 14: Semaphores, Shared Memory, and Message Queues 577
Semaphores 577
Semaphore Definition 579
A Theoretical Example 579
Linux Semaphore Facilities 580
Using Semaphores 582
Shared Memory 586
shmget 588
shmat 588
shmdt 589
shmctl 589
Message Queues 594
msgget 594
msgsnd 595
msgrcv 595
msgctl 596
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
Summary 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
select 635
Multiple Clients 638
Datagrams 642
Summary 644
Chapter 16: Programming GNOME Using GTK+ 645
Introducing X 645
X Server 646
X Client 646
X Protocol 646
Xlib 647
Toolkits 647
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
GtkWindow 662
GtkEntry 663
GtkSpinButton 666
GtkButton 668
GtkTreeView 672
GNOME Widgets 676
GNOME Menus 677
Dialogs 682
GtkDialog 682
Modal Dialog Box 684
Nonmodal Dialogs 685
GtkMessageDialog 686
CD Database Application 687
Summary 699
Chapter 17: Programming KDE Using Qt 701
Introducing KDE and Qt 701
Installing Qt 702
Signals and Slots 705
Qt Widgets 712
QLineEdit 712
Qt Buttons 716
QComboBox 721
QListView 724
Dialogs 727
QDialog 728
QMessageBox 730
QInputDialog 731
Using qmake to Simplify Writing Makefiles 733
Menus and Toolbars with KDE 733
CD Database Application Using KDE/Qt 738
MainWindow 738
AddCdDialog 742
LogonDialog 743
main.cpp 745
Summary 746
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
Summary 759
Index 761