This intensive course rapidly trains programmers to develop applications and programs on Red Hat Enterprise Linux. Through realistic labs, programming exercises, and demonstrations, you'll get hands-on training and learn concepts and skills essential to programming and software development for Linux-based applications and products.

What You'll Learn

• GNU Compiler Collection
• Building Software with Make
• The GNU C Library and System Calls
• Program Arguments and Environment
• Building Libraries
• Time Functions
• Process Management
• Memory Operations
• Debugging
• Basic File Operations
• Communicating with Pipes
• Managing Signals
• Programming with Threads
• Advanced File Operations
• Interprocess Communication (IPC)

Who Needs to Attend

• Experienced C programmers who want to learn key skills for creating applications and programs on Red Hat Enterprise Linux
• Windows and UNIX programmers who are migrating their programs to Linux

Prerequisites

• Experience in C programming
• RH133 or equivalent UNIX or Linux workstation user skills for developers
• Shell scripting in a UNIX or Linux environment
• Experience with editors such as vi, emacs

Follow-On Courses

• Red HatŪ Linux Kernel Internals 1 (RHD361)
• Red HatŪ Linux Kernel Internals 2: Device Drivers (RHD362)

Course Outline

1. GNU Compiler Collection (GCC)

• History of GCC
• Four Stages of GCC
• Interrupting the Compiler
• Compiling a C Program
• Preprocessor Features
• Predefined Preprocessor Symbols
• Warnings and Extensions
• Optimization
• Linking

2. Building Software with Make

• Introducing make(1)
• How make Works
• Makefile Rule Syntax
• Example: Makefile First Steps
• Makefile Improved
• Implicit Rules
• Example: Simpler Is Better Makefile
• Variables
• Defining Variables
• Example: Makefile with Variables
• Automatic Variables
• Special Targets
• Defining Useful Phony Targets

3. The GNU C Library and System Calls

• Library Goals
• Library Standards
• GNU C Library - glibc
• Library Functions vs. System Calls
• Using System Calls
• Handling Errors with errno
• Making Sense of errno
• Using strace

4. Program Arguments and Environment

• Program Startup
• Using argc/argv
• Handling Options with getopt()
• Handling Options with getopt_long()
• Environment
• Manipulating the Environment
• Program Exit
• Registering Exit Handlers

5. Building Libraries

• Why Use Libraries?
• Static vs. Shared
• Static Library Benefits
• Shared Library Benefits
• Creating a Static Library
• Using Static Libraries
• Creating a Shared Library
• Using Shared Libraries
• Shared Library Management
• Library Locations
• ldconfig

6. Time Functions

• When Does Time Begin?
• Time Data Types
• Determining Real Time
• Converting time_t
• Converting tm Structure
• Process Time
• Time Arithmetic
• Second Resolution Timers
• Fine-Grained Timers<
• Real Time Clock (RTC)

7. Process Management

• What a Process Is
• Process Relationships
• Create a Child Process
• Doing Something Else
• Related execve() Functions
• Wait For a Child
• More Precise Waiting
• Changing Priority/Nice
• Real Time Priority

8. Memory Operations

• Allocating/Freeing Memory
• Memory Alignment
• Locked Memory
• Memory Copy/Initialization
• Memory Comparison/Search

9. Debugging

• What Is My Program Doing?
• Source Level Debugging
• Invoking gdb
• Getting Started with gdb
• Examining and Changing Memory
• Debuginfo Libraries
• Using gdb with a Running Process
• Using gdb to Autopsy a Crash
• Debugging Libraries - ElectricFence
• Debugging with valgrind
• Profiling for Performance

10. Basic File Operations

• Stream vs. System Calls
• Opening/Closing Streams
• Stream Input/Output Functions
• Stream Status/Errors
• Stream File Positioning
• Stream Buffering
• Temporary/Scratch Files
• Opening/Closing File Descriptors
• File Descriptor I/O
• Repositioning File Descriptors
• Stream/File Descriptor Conversions
• cat using ANSI I/O
• cat using POSIX I/O

11. Communicating with Pipes

• Introduction to Pipes
• Standard I/O: popen()/pclose()
• Using popen()/pclose()
• System Call: pipe()
• Using pipe()
• Named Pipes
• Using Named Pipes
• For Further Reading

12. Managing Signals

• What Signals Are
• Blocking/Checking Signals
• Working with Signal Sets
• Example of Blocking Signals
• Handling Signals with sigaction()
• sigaction() Example
• Handling Signals with signal()
• Sending Signals
• Real-Time Signals

13. Programming with Threads

• Introducing Threaded Programming
• Applications Suited to Threads
• Building Threaded Programs
• Creating Threads
• Thread Identity
• Synchronizing by Joining
• Detaching Threads
• Stopping Threads
• Synchronizing with Mutexes
• Using Mutexes
• Read/Write Locks
• Conditional Variables
• Using Conditional Variables
• A Conditional Variable Gotcha
• For Further Reading

14. Advanced File Operations

• Directory Operations
• File System Operations
• Multiplexed I/O with select()
• Miscellaneous I/O Functions
• Memory Mapped I/O
• Using Memory Mapped I/O
• File Locking

15. Interprocess Communication (IPC)

• Interprocess Communication (IPC)
• POSIX IPC Overview
• POSIX Shared Memory
• POSIX Semaphores
• POSIX Message Queues
• System V IPC Overview
• System V IPC Shared Memory
• System V IPC Semaphore Arrays
• System V IPC Message Queues

16. Basic Network Programming

• Linux Networking Overview
• Getting Started with socket()
• Client Functions
• Specifying IPv4 Addresses
• Host Versus Network Byte Order
• Example TCP/IP Client
• Address Conversion Functions
• Using getaddrinfo()
• Server Functions
• Example TCP/IP Server
• Datagram Communication with UDP

17. Working with the Linux Community

• Getting in Touch with the Community
• General Considerations
• Building a Community
• Licenses
• GPL
• LGPL
• BSD
• Creative Commons