Advanced Unix Programming Training

Answers to Popular Questions:

Yes, this class can be tailored to meet your specific training needs.
Yes, we provide Linux Unix consulting services.
Yes, group discounts are provided.

Course Description

In-depth training for software developers on Linux and UNIX system programming facilities. Learn how to develop sophisticated multiprocess applications using system calls and library routines.
Course Length: 4 Days
Course Tuition: $1390 (US)


Fundamentals of UNIX or Fundamentals of Linux, C Programming, and Advanced C Programming. Strong C programming skills are required for this course.

Course Outline


UNIX Standards
Brief History of UNIX
AT&T and Berkeley UNIX Systems
Major Vendors
What is a Standard?
What is POSIX?
Other Industry Specs and Standards
Library vs. System-Level Functions

Files and Directories
Basic File Types
File Descriptors
The open() and creat() Functions
Keeping Track of Open Files
File Table Entries
The v-node Structure
The fcntl Function
The fcntl() Function ? with F_DUPFD Command
File Attributes
The access() Function
link(), unlink(), remove(), and rename() Functions
Functions to Create, Remove, and Read Directories

System I/O
Standard I/O vs System I/O
System I/O Calls
File and Record Locking

What is a Process?
Process Creation and Termination
Process Memory Layout
Dynamic Memory Allocation
Accessing Environment Variables
Real and Effective User IDs

Process Management
The Difference Between Programs and Processes
The fork() System Function
Parent and Child
The exec System Function
Current Image and New Image
The wait() and waitpid() Function
Interpreter files and exec

Basic Interprocess Communication: Pipes
Interprocess Communication

What is a Signal?
Types of Signals
Signal Action
Blocking Signals from Delivery
The sigaction() Function
Signal Sets and Operations
Sending a Signal to Another Process
Blocking Signals with sigprocmask()
Scheduling and Waiting for Signals
Restarting System Calls (SVR4)
Signals and Reentrancy

Introduction to Pthreads
Processes and Threads
Creating Threads
Overview of Thread Architectures
Processes Versus Threads
The Pthreads API
Thread Termination
Joining Threads
Detaching Threads
Passing Arguments to Threads

Pthreads Synchronization
The Sharing Problem
Creating and Initializing Mutexes
Using Mutexes
Additional Synchronization Requirement
Using Condition Variables

Overview of Client/Server Programming
Designing Applications for a Distributed Environment
Clients and Servers
Ports and Services
Connectionless vs. Connection-Oriented Servers
Stateless vs. Stateful Servers
Concurrency Issues

The Berkeley Sockets API
Berkeley Sockets
Data Structures of the Sockets API
Socket System Calls
Socket Utility Functions

TCP Client Design
Algorithms Instead of Details
Client Architecture
Generic Client/Server Model ? TCP
The TCP Client Algorithm

TCP Server Design
General Concepts
Iterative Servers
Concurrent Servers
Performance Consideration
An Iterative Server Design
A Concurrent Server Design

System V Interprocess Communication
System V IPC
Elements Common to msg, shm, and sem Facilities
The Three System V IPC Facilities
IPC via Message Queues
IPC via Shared Memory
Coordinating the Use of Shared Memory Segments
Semaphore Sets - emget()
Semaphore Sets - semctl()
Semaphore Sets - the semop() calls
Shared Memory Coordination Using Semaphores
Commands for IPC Facility Handling - ipcs and ipcrm

Appendix A: Date and Time Functions
Time Representations
Decoding Calendar Time
Shorthand Functions - asctime(), ctime()
Formatting Date and Time Strings
Process Times
The Difference Between clock() and times()
Berkeley High Resolution Timers

Appendix B: Standard I/O
Standard I/O Calls to manipulate streams
Standard I/O Calls which perform character I/O
Standard I/O Calls which perform string I/O
Standard I/O Calls Which Perform Formatted I/O
Standard I/O Calls Which Perform Binary I/O

Course Directory [training on all levels]

Upcoming Classes