Back to Search Results

Training Course Summary:

This hands on UNIX/POSIX system-programming course covers system programming for the UNIX/POSIX environment utilizing ANSI C. Emphasis is on the UNIX/POSIX system calls for I/O, process control, interprocess communication, and network programming. Different I/O techniques are contrasted and standard C library I/O functions and UNIX system calls are presented in detail. Students acquire the knowledge needed to effectively exploit the features of the UNIX/POSIX environment. Solid knowledge of C or C++ required.

Pre-Requisites:

UNIX/Linux and C programming experience equivalent to the material presented in the UNIX/Linux Fundamentals and ANSI C Programming courses.

Training Course Overview/Content:

Introduction to UNIX/POSIX
Introduction to the POSIX/UNIX Standards
UNIX Origins and Evolution
C Language and UNIX Portability
Portable Operating System Interface for Computer Environments (POSIX)
POSIX and Application Portability
System Calls vs. Library Calls
References
Online Documentation
System Headers
Open Source
Operating Environment Review
Kernel
Processes
Memory
File System
Standard Descriptors
Security Model
Program Development Review
Editing
Compiling and Linking
Debugging
UNIX/POSIX Processes

A Look Inside a Process
Process Attributes
Environment Variables
System Memory vs. Process Memory
Variable Argument Lists
Threading
Memory
Dynamically Allocating Additional Storage
Determining Resource Utilization Limits
Memory Alignment (RISC)
Swap Space
Shared Libraries
Process Creation
Inheritance from Parent
Standard File Descriptors
Signal Handlers
Overlaying the Current Image
Foreground and Background Processes
Signal Handling
ANSI/BSD Signal Handling
POSIX/SVr4 Signal Handling
Process Destruction
Process Deactivation Sequence
Zombie Processes

Threading
Decision Criteria
Thread Creation
Thread Synchronization
Thread Destruction
Error Handling
Overview of Error Handling Facilities
Error Return Conventions
System Call Errors
Error Handling Functions
Minimal Error Handling
Stream Error Handling
The System Log Facility

UNIX/POSIX Files and File System
File System
Mount Points vs. Drive Letters
File System Attributes
Obtaining File System Attributes
/proc File System
/var File System
Network File Systems (NFS, SMB and CIFS)
Files
File Attributes
Obtaining File Attributes
Regular Files
Special Files
Sparse Files
File I/O
Stream I/O (Application Buffered)
Opening and Closing Files
Unformatted Stream I/O
Formatted Stream I/O
Managing Stream I/O Buffering
Positioning within a Stream
Non-Stream I/O (Non-Application Buffered)
File Descriptors vs. File Handles
Opening and Closing Files
Reading and Writing Files
Positioning Within a File
Managing I/O Buffering
Connecting Standard Input or Output to Files
Shared Files
File Locking
Ancillary Function

Terminal and Raw I/O
Terminal I/O
Setting Terminal Characteristics
Reading Single and Multiple Keystrokes
Generating Signals for Each Keystroke or Line
Raw Device I/O
Local Interprocess Communication

Using Signals for Interprocess Communication
Criteria for Choice
Catching Signals
Sending Signals
Kernel IPC Facilities
Shared Memory
Semaphores
Message Queues
Managing Kernel IPC Resources
Pipes
Pipe Lines
Named Pipes

Network Interprocess Communication
Berkley Sockets
Stateless Connections
Stateful Connections
Network Interface
Network Addressing
Byte Ordering
Socket Data Structures
Socket Connection Protocol
Listening on Multiple Sockets
Network Considerations
Network Reliability Impact
Packet Filtering Firewalls
Proxy Firewalls
Quality of Service
Open Network Computing Remote Procedure Calls
CORBA
XML-RPC
Web Services
Advanced Programming Topics

Program Development
Source Control
Make
Compiler
Linker
Executables vs. Libraries
Shared Libraries vs. Standard Libraries
Debugging
Tracing
Core Dumps
Using the /proc Filesystem
Using /dev/kmem
Attaching Background Processes
Security
Secure Sand Box
Bounds Checking
Clearing Memory
Sticky Bit
Set UID/GID
ACLs
Privileged Ports
Shared Libraries
PAM