Customised Linux Training

Two Options for Customised Linux Training

In addition to our off-the-shelf Linux Training, we also provide two options for Linux course customisation to client specification.

Fully Bespoke Linux Training

The first option is fully bespoke Linux Training in which original Linux course content is designed and written in conjunction with the client. Everything about such Linux courses is a matter for negotiation between ourselves and the prospective client. In addition to our considerable in-house Linux resourses, a range of external Linux consultants enable us to cover even the most esoteric of Linux specialisms.

Low Cost Customised Linux Training

We can deliver a high degree of customisation at the same cost as off-the-peg Linux training; by the simple device of mixing and matching pre-prepared Linux course modules.

The following lists provide outline details of Linux modules we have delivered or are about to deliver for our clients.

With a few notable exceptions, each Linux module is designed to be delivered in a quarter-day session.

As with all of our Linux courses, the bulk of that time is given over to practical and graduated exercises.

Introduction

Unix and Linux
Unix system architecture
Unix philosophy
What is Linux?
Using a Linux system
Linux command line
Logging out
Command syntax
Files
Creating files with cat
Displaying files' contents with cat
Deleting files with rm
Unix command feedback
Copying and renaming files with cp and mv
Filename completion
Command history

Getting started

Files and directories
Examples of absolute paths
Current directory
Making and deleting directories
Relative paths
Special dot directories
Hidden files
Paths to home directories
Looking for files in the system
Running programs
Specifying multiple files
Finding documentation for programs
Specifying files with wildcards
Chaining programs together
Graphical and text interfaces
Text editors

Work effectively on the Unix command line

Shells
The Bash shell
Navigating the filesystem
Command-line arguments
Syntax of command-line options
Examples of command-line options
Where programs are found
Setting shell variables
Bash configuration variables
Using history
Reusing history items
Retrieving arguments from the history
Summary of Bash editing keys
Combining commands on one line
Repeating commands with for
Command substitution
Finding files with locate
Finding files more flexibly: find
find criteria
find actions: executing programs

Process text streams using text processing filters

Working with text files
Lines of text
Filtering text and piping
Displaying files with less
Concatenating files with cat
Counting words and lines with wc
Sorting lines of text with sort
Removing duplicate lines with uniq
Selecting parts of lines with cut
Expanding tabs to spaces with expand
Using fmt to format text files
Reading the start of a file with head
Reading the end of a file with tail
Numbering lines of a file with nl
Dumping bytes of binary data with od
Paginating text files with pr
Dividing files into chunks with split
Using split to span disks
tac: backwards cat
Translating sets of characters with tr
tr examples
sed – the stream editor
Substituting with sed
Put files side-by-side with paste
Performing database joins with join

Perform basic file management

Filesystem objects
Directory and file names
File extensions
Visiting directories with cd
Going back to previous directories
Filename completion
Wildcard patterns
Copying files with cp
Examples of cp
Moving files with mv
Deleting files with rm
Deleting files with peculiar names
Making directories with mkdir
Removing directories with rmdir
Identifying types of files
Changing timestamps with touch

Use unix streams, pipes and redirects

Standard files
Standard input
Standard output
Standard error
Pipes
Connecting programs to files
Appending to files
Redirecting multiple files
Redirection with file descriptors
Running programs with xargs
tee

Search text files using regular expressions

Searching files with grep
Pattern matching
Matching repeated patterns
Matching alternative patterns
Extended regular expression syntax
sed
Further reading

Job control

Job control
jobs
fg
bg

Advanced shell usage

More about quoting
Quoting: single quotes
Quoting: backslashes
Quoting: double quotes
Quoting: combining quoting mechanisms
Recap: specifying files with wildcards
Globbing files within directories
Globbing to match a single character
Globbing to match certain characters
Generating filenames: {}
Shell programming

Filesystem concepts

Filesystems
The unified filesystem
File types
Inodes and directories

Manage file ownership

Users and groups
The superuser: root
Changing file ownership with chown
Changing file group ownership with chgrp
Changing the ownership of a directory and its contents
Changing ownership and group ownership simultaneously

Use file permissions to control access to files

Basic concepts: permissions on files
Basic concepts: permissions on directories
Basic concepts: permissions for different groups of people
Examining permissions: ls -l
Preserving permissions when copying files
How permissions are applied
Changing file and directory permissions: chmod
Specifying permissions for chmod
Changing the permissions of a directory and its contents
Special directory permissions: ‘sticky’
Special directory permissions: setgid
Special file permissions: setgid
Special file permissions: setuid
Permissions as numbers
Default permissions: umask

Create, monitor, and kill processes

What is a process?
Process properties
Process monitoring: ps
ps options
Process monitoring: pstree
pstree options
Process monitoring: top
top command-line options
top interactive commands
Signalling processes
Common signals for interactive use
Sending signals: kill
Sending signals to dæmons: pidof

Modify process execution priorities

Concepts
nice
renice

Create partitions and filesystems

Concepts: disks and partitions
Disk naming
Using fdisk
Making new partitions
Changing partition types
Making filesystems with mkfs
Useful websites

Control filesystem mounting and unmounting

Mounting filesystems
Mounting a filesystem: mount
Mounting other filesystems
Unmounting a filesystem: umount
Configuring mount: /etc/fstab
Sample /etc/fstab
Filesystem types
Mount options
Other columns in /etc/fstab
Mounting a file

Maintain the integrity of filesystems

Filesystem concepts
Potential problems
Monitoring space: df
Monitoring inodes: df
Monitoring disk usage: du
du options
Finding and repairing filesystem corruption: fsck
Running fsck

Find system files and place files in the correct location

Unix filesystem layout
The filesystem hierarchy standard
Shareable and non-shareable data
Static and dynamic data
Overview of the FHS
FHS: installed software
FHS: other directories under /usr
FHS: directories under /var
FHS: other directories
FHS: other directories
Finding programs with which
The type built-in command
Checking for shell builtins with type
Updating the locate database
updatedb.conf
whatis
Finding manpages with apropos
Web resources

Set and view disk quotas

What are quotas?
Hard and soft limits
Per-user and per-group quotas
Block and inode limits
Displaying quota limits: quota
Options in /etc/fstab
Enabling quota: quotaon
Changing quota limits: setquota
edquota
repquota

Boot the system

Boot loaders
Lilo
Sample lilo.conf file
Selecting what to boot
Other ways of starting Linux
Specifying kernel parameters
Specifying kernel parameters in lilo.conf
Useful kernel parameters
Boot messages
Kernel modules

Change runlevels and shutdown or reboot system

Understanding runlevels
Typical runlevels
Single-user mode and sulogin
Shutting down and restarting the system
Setting the default runlevel
Selecting a different runlevel at bootup
Determining the current runlevel
Switching runlevel
Services in each runlevel: the init.d directory
Symbolic links in rcN.d
Starting or stopping individual services

Use and manage local system documentation

Manual pages
Navigating within manual pages
Sections of a manual page
Sections of the manual
Manual section numbering
Determining available manpages with whatis
Printing manual pages
Searching for manpages with apropos
Displaying all manpages of a particular name with man -a
Searching the content of all manpages with man -K
Finding the right manual page
Help on shell builtins
Location of manual pages
Info pages
Navigating within info pages
Documentation in /usr/share/doc/
Contents of /usr/share/doc
Interrogating commands for help
Finding documentation

Find linux documentation on the internet

The Linux Documentation Project
HOWTOs
Obtaining HOWTOs
Vendor- and application-specific web sites
Usenet newsgroups
FAQs
Local Help

Write system documentation

Documentation
A system log
Making documentation available
Plain text documentation
HTML documentation
Microsoft Word documentation
LaTeX documentation
Manual page documentation
Paper documentation

Provide user support

Providing user support
Attitude to providing user support
User support skills

Manage users and group accounts and related system files

/etc/passwd
/etc/group
Shadow passwords and groups
passwd
useradd
userdel
usermod
Locking accounts
groupadd
groupmod
newgrp and gpasswd
chage
pwconv and pwunconv

Tune the user environment and system environment variables

Configuration files
Shell configuration files
Changing environment variables
Changing the prompt
Shell aliases
Setting up home directories for new accounts

Configure and use system log files

syslog
/etc/syslog.conf
Sample /etc/syslog.conf
Reconfiguring syslog
Examining logs: less and grep
Examining logs in real time: tail
Log rotation
Sample /etc/logrotate.conf

Automate and schedule system administration tasks

Running commands in the future
At commands
Commands run by the At dæmon
At command specification
Opening windows from At commands
At command date & time specification
Managing At commands
Simple cron job specification
More complex cron job specification
Crontab format
Crontab date & time specification
More complex crontab dates & times
/etc/crontab
User crontabs
Cron job output
At command and cron job permissions

Maintain an effective data backup strategy

Reasons for backup
Backup media
Types of backup
Backup strategy
Archiving files with tar
Creating archives with tar
Listing the files in tar archives
Extracting files from tar archives
Device files for accessing tapes
Using tar for backups
Controlling tape drives with mt
Deciding what to backup
What not to backup
Scripting backup
Other backup software

Configure fundamental system hardware

Bios: datetime, disks, boot, devices
Bios: interrupts and dma addresses
Bios: device settings
1024 cylinder limit

Setup scsi and nic devices

Nic: understand 3 era methodologies: jumper, non-volatile memory, self-configuring
Nic: verify configs with /proc/interrupts /proc/dma /proc/ioports
Scsi: types
Scsi: ids, scsi logical unit numbers, linux device files
Scsi: termination
Scsi: controllers on pcs (scsi bios)

Configure modems and sound cards

Modems: what they are
Modems: types, ie. winmodems
Modems: avoiding i/o and interrupt conflicts (sharing not necessary)
Sound: correctly specify kernel module sound driver
Sound: settings in /etc/modules.conf

Design hard-disk lay-out

Issues and considerations
Disk space
Type of system / role
Backup schemes and resources
Swap space
Filesystem functions

Install a boot manager

Functions of lilo: find and load kernel into memory, start the kernel in memory
How lilo works: bootloader in mbr started by bios, prompt-based kernel selection, map installer
Lilo command
/etc/lilo.conf
Lilo locations

Make and install programs from source

Find and get sources
Understand tarballs
Configure command: functions and use
Make command: unerstand and use
Make install

Manage shared libraries

Understand function of linking: static vs dynamic, shared libs
Understand and use ldd
Linking and finding libs via ld_library_path
Understand and use ldconfig for linking and finding
System libs ind /etc/ld.so.cache /etc/ld.so.conf

Use debian package management

Overview
Debian naming and numbering
Dpkg
Apt-get
Alien
Dselect

Use red hat package manager (rpm)

Overview
Red hat naming and numbering
Running rpm
Major operating modes of rpm
Main options in each rpm mode
Rpm man page

Manage kernel modules at runtime

Concepts: monolithic vs. modular
Module files: /lib/modules/KERNEL-VERSION
lsmod
insmod
rmmod
modinfo
modprobe
Configure and control modules (esp. interrupts and dma) via /etc/modules.conf
modules.dep
depmod

Reconfigure, build and install a custom kernel and modules

Kernel versions: naming and numbering
Required tools and files
Kernel source tree, esp. .config and makefile
Creating a configuration
Compiling a kernel
Installing a new kernel
Configuring a new kernel with lilo

Perform basic file editing operations using vi

Start vi
Edit
Inserts
Change and replace
Delete
Copy and paste
Find

Manage printers and print queues

lpd
lpr
lpq
lprm
lpc

Print files

Using lpr

Install and configure local and remote printers

Detailed knoeledge of /etc/printcap
Filters
Managing remote printers (inc samba) via /etc/printcap

Customize and use the shell environment

Overview: what shells are and some history
Bash
Environment variables
Shell variables (vs. environment)
Aliases
Functions
Config files

Customize or write simple scripts

Concept of shell scripts (esp. vs dos batch)
She-bang (#!) shell selector
The script environment
Paths and permissions (inc suid and sgid)
Return values
File tests
Command substitution
Mail from scripts
Key commands:
Break
Case
Continue
Echo
Exit
For
Function
Getopts
If
Kill
Read
Return
Shift
Source
Test
Until
While

Install & configure xfree86

Select xserver
Install from source
Install from binaries
Configure via file xf86config, knowing all sections of the file and via autoconfig tools
Xfonts
Xset
Xfs
Control x apps via .xresources

Setup xdm

Config files /etc/x11/xdm directory
Xaccess
Xresources
Xserver
Xsession
Xsetup_0
Xdm-config
Running xdm automatically
Basic customisation of xdm
Use for managing x-terminals / x-stations

Identify and terminate runaway x applications

Top
Ps
Virtual terminals
Kill

Install & customize a window manager environment

Understand startup procedure: startx -> xinit (via xinitrc) -> xfree86 -> client apps inc wm
Know wm config files (not tested)
Terminal emulators: /etc/lib/x11/app-defaults and .xdefaults
X libraries (gtk, ldd)
Remote clients with local display: setup, host:display.screen syntax

Fundamentals of tcp/ip

Ip addresses and names
Masks
Protocols
Services and port numbers
Utilities

Tcp ip troubleshooting & configuration

Know network interfaces
/etc/hostname
/etc/hosts
/etc/nsswitch.conf
/etc/host.conf
/etc/resolv.conf
/etc/networks
Host command
Hostname, domainname and dnsdomainname commands
Ifconfig
Netstat
Ping
Route
Traceroute
Dhcp
Manually configure dhcp
Dynamic allocation
Relay dhcp
Dhcp leases
Dhcpd

Configure and use ppp

Concepts: client-server, ports, modems
Connection steps: serial connect -> account authenticate -> clientppp -> server binary datastream to initiate link, client uses temp ip address to send binary datastream and establish link
Ppd
Connect manually
Know about pap, chap, mschap authentication (setup not required)

Configure and manage inetd and related services

Concept: superdaemon
/etc/inetd.conf inc sections
Tcp wrappers
Starting and stopping services

Operate and perform basic configuration of sendmail

Basic internet mail concepts (mta, mua, etc)
Recognise /ettc/sendmail.cf
Dsmail directive (to send to smart host)
Redirect using aliases
/etc/aliases
Forwarding to another account
.forward
Queuing
Mailq

Operate and perform basic configuration of apache

Know config files in /etc/httpd/conf or /usr/local/apache/conf
Httpd.conf
Srm.conf
Access.conf
Basic directives
Start and stop

Properly manage the nfs, smb, and nmb daemons

Nfs concepts
/etc/exports
Mount
Smb.conf
Use samba as wins client via nmbd
Run swat
No need to create custom samba configs

Setup and configure basic dns services

Understand concept of resolver libraries, inc how they id a host or domain:
Via /etc/hosts
Via nis
Via dns
Understand dns config files:
/etc/hosts
/etc/resolv.conf
/etc/host.conf (on older linux)
Use of named for local cacheing only (non-authorative answer)
Get info about named from /var/log/messages
Basic use of nslookup and host
Know distinction between bind v4 and bind v8 (/etc/named.boot vs. /etc/named.conf)

Perform security admin tasks

Tasks:
Secure in-bound requests
Verify packages
Authenticate
Manage local security resources
Tcp wrappers
Tcpd
Inetd
Access control
Logging
Finding suid files
Verifying packages with rpm -v etc
Sgid effects on directories
Password management
Chage
Ssh

Setup host security

Shadow passwords
Minimum inetd
Syslog
Forwarding root mail to admins
Cert and bugtraq

Setup user level security

Ulimit (setting max use of resources and hence counteract dos)

Kernel Components

Utilize kernel components that are necessary to specific hardware
Utilize kernel components that are necessary to specific hardware drivers
Utilize kernel components that are necessary to specific system resources
Utilize kernel components that are necessary to specific system requirements
Implementing different types of kernel images
Identifying stable and development kernels and patches
zImage and bzImage

Compiling a kernel

Properly compile a kernel to include specific features
Properly compile a kernel to disable specific features
Implementing updates in a new kernel
Noting changes in a new kernel
make
config
xconfig
menuconfig
oldconfig
mrproper
zImage and bzImage
modules
modules_install
mkinitrd (Debian)
mkinitrd (Red Hat)
/usr/src/linux/
/etc/lilo.conf

Patching a kernel

Properly patch a kernel
Patch a kernel to implement kernel updates
Patch a kernel to implement bug fixes
Patch a kernel to add support for new hardware
Properly remove kernel patches from existing production kernels
patch
Makefile
gzip
bzip

Customizing a kernel

Customize a kernel by compiling
Customize a kernel by patching
Customize a kernel by editing configuration files
Assess requirements for a kernel compile versus a kernel patch
Build and configure kernel modules
patch
make
/usr/src/linux
/proc/sys/kernel
modprobe
/etc/conf.modules and /etc/modules.conf
insmod
lsmod
kmod
kerneld

Customizing system startup and boot processes

System startup scripts
Customize standard system boot processes
Customize standard system run levels
Interacting with run levels
Creating custom initrd images
/etc/init.d
/etc/inittab
/etc/rc.d
mkinitrd (Debian)
mkinitrd (Red Hat)

System recovery

Manipulate a Linux system during the boot process
Manipulate a Linux system in recovery mode
The init utility
The init=kernel option
LILO
init
inittab
mount
fsck

Operating the Linux filesystem

Properly navigate the standard Linux filesystem
Properly configure the standard Linux filesystem
Configuring various filesystem types
Mounting various filesystem types
Manipulating filesystems to adjust for disk space requirements
Manipulating filesystems to adjust for device additions
/etc/fstab
mount
umount
/etc/mtab
sync
swapon and swapoff
/proc/mounts

Maintaining a Linux filesystem

Maintain a Linux filesystem using system utilities
Manipulating a standard ext2 filesystem
fsck (fsck.ext2)
badblocks
Mke2fs
Dumpe2fs
Debuge2fs
Tune2fs

Creating and configuring filesystem options

Configure automount filesystems
Configuring Automount for network filesystems
Configuring Automount for device filesystems
Creating non ext2 filesystems
Creating filesystems for CD-ROMs
/etc/auto.master
/etc/auto
mkisofs
dd
mke2fs

Configure and implement software RAID

RAID concepts
Software RAID vs. Hardware RAID
Configuring RAID 0
Configuring RAID 1
Configuring RAID 5
mkraid
/etc/raidtab

Adding new hardware

Configure internal devices
Configure external devices
Configure internal new hard disks (internel)
Configure internal new hard disks (scsi)
Configure dumb terminal devices
Configure serial UPS devices
Configure multi-port serial cards
Configure LCD panels
XFree86
modprobe
lsmod
lsdev
lspci
setserial
usbview
/proc/bus/usb

Software and kernel configuration

Configure kernel options to support various hardware devices
Configure kernel options to support UDMA66 drives
Configure kernel options to support IDE CD burners
Using LVM (Logical Volume Manager) to manage hard disk drives and partitions
Software tools to interact with hard disk settings
hdparm
tune2fs
/proc/interrupts
sysctl

Configuring PCMCIA devices

Configure a Linux installation to include PCMCIA support
Configuring PCMCIA ethernet adapters to autodetect when inserted
/etc/pcmcia/
*.opts
cardctl
cardmgr

Configuring a samba server

Set up a Samba server for different clients
smbd
Setting up a login script for Samba clients
Setting up an nmbd WINS server
Changing the workgroup in which a server participates
Defining a shared directory in smb.conf
Defining a shared printer in smb.conf
Using nmblookup to test WINS server functionality
Using smbmount to mount an SMB share on a Linux client
smbstatus
smbtestparm
smbpasswd
lmhosts

Configuring an NFS server

Create an exports file and specify filesystems to be exported
/etc/exports
exportfs
Editing exports file entries to restrict access to certain hosts
Specify mount options in the exports file
showmount
Configure user ID mapping
Mount an NFS filesystem on a client
Subnets or netgroups
Using mount options to specify soft or hard and background retries
Signal handling
Locking
Block size
Configure tcpwrappers to further secure NFS
nfsstat

System logging

Configuring syslogd to act as a central network log server
Configuring syslogd to send log output to a central log server
Logging remote connections
Using using grep and other text utils to automate log analysis
syslog.conf
sysklogd
/etc/hosts

Packaging software

Packaging software
Building Debian packages
/debian/rules
Rebuilding a DEB
Building Red Hat packages
Rebuilding RPMs
rpm
SPEC file format

Backup operations

Creating an offsite backup storage plan

Automating tasks using scripts

Write simple perl scripts
Simple perl scripts using perl modules
Install perl modules from CPAN
perl -MCPAN -e shell
Using sed in scripts
Using awk in scripts
Using scripts to check for process execution
Checking processes and generating email alerts on death
Generating pager alerts when processes die
Schedule scripts to parse logs for alerts and email admins
crontab
Schedule scripts to synchronize files across machines using rsync
Schedule scripts to monitor files for changes and generate email alerts
Schedule scripts to notify admins when specified users log in or out

Creating recovery disks

A standard bootdisk for system entrance
A recovery disk for system repair
/usr/sbin/rdev
/bin/cat
/bin/mount and the -o loop option
Any standard editor
/sbin/lilo
/bin/dd
/sbin/mke2fs
/etc/fstab and /etc/inittab
/usr/sbin/chroot
Location and contents of the LDP Bootdisk-HOWTO

Identifying boot stages

The 4 stages of boot-up
Boot loader start and hand off to kernel
Kernel loading
Hardware initializiation and setup
Daemon initialization and setup

Troubleshooting LILO

Determine specific stage failures and corrective techniques
Meaning of L, LI, , LILO, and scrolling 010101 errrors
Different LILO install locations
/boot/boot.b
Significance of /boot/boot

General troubleshooting

Screen output during bootup
Utilize kernel boot messages to diagnose kernel errors
Identify and correct common hardware issues
Determine if the problem is hardware or software
dmesg
Kernel syslog entries in system logs
System and daemon log files in /var/log/
/sbin/lspci
/usr/bin/lsdev
/sbin/lsmod
/sbin/modprobe
/sbin/insmod
/bin/uname
Location of system kernel and attending modules
/boot
/lib/modules
The /proc filesystem
strace
strings
ltrace
lsof

Troubleshooting system resources

Identify, diagnose and repair local system environment
/etc/profile and /etc/profile.d/
Core system variables
/etc/bashrc and other appropriate global shell configuration files
/etc/init.d/
/etc/rc.*
/bin/ln
/bin/rm
Editor of choice
/etc/ld.so.conf
/sbin/ldconfig
/sbin/sysctl and /etc/sysctl.conf

Troubleshooting environment configurations

Common local system and user environment configuration issues
Common repair techniques
/etc/inittab
/sbin/init
/etc/passwd
/etc/shadow
/etc/group
/etc/profile
/etc/rc.local or /etc/rc.boot
/usr/sbin/cron
/usr/bin/crontab
/var/spool/cron/crontabs/
/etc/SHELL_NAME
/etc/login.defs
/etc/syslog.conf

Basic networking configuration

Configure a network device to connect to a local network
Configure a network device to connect to a wide-area network
Communicate between subnets within a single network
Configure dialup access using mgetty
Configure dialup acccess using a modem
Configure dialup acccess using ISDN
Configure authentication protocols (PAP)
Configure authentication protocols (CHAP)
Configure TCP/IP logging
/sbin/route
/sbin/ifconfig
/sbin/arp
/usr/sbin/arpwatch
/etc/

Configuring mailing lists

Majordomo
Majordomo2
Monitor majordomo problems by viewing majordomo logs

Using Sendmail

Managing sendmail
Email aliases
Mail quotas
Virtual mail domains
Configuring internal mail relays
Monitoring SMTP servers
/etc/aliases
sendmail.cw
virtusertable
genericstable

Managing Mail Traffic

Implementing client mail management software to filter mail
Implementing client mail management software to sort mail
Implementing client mail management software to monitor incoming user mail
procmail
.procmailrc
Using server-side procmail
Using server-side procmail

Serving news

Install the inn news server
Configure the inn news server
Customizing newsgroup feeds
Monitoring served newsgroups
The innd news daemon

Basic BIND 8 configuration

Configure BIND to function as a caching-only DNS server
Convert a BIND 4.9 named.boot file to the BIND 8.x named.conf
Format, and reload the DNS by using kill or ndc
Configuring DNS logging
Configuring BIND options
Configuring directory location for zone files
/etc/named.conf
/usr/sbin/ndc
/usr/sbin/named-bootconf
kill

Create and maintain DNS zones

Create a zone file for a forward zone
Create a zone file for a reverse zone
Create a zone file for a root level server
Setting appropriate values for the SOA resource record
Setting appropriate values for the NS records
Setting appropriate values for the MX records
Adding hosts with A resource records
Adding hosts with A resource records and CNAME records
Adding the zone to the /etc/named.conf file using the zone statement
Adding hosts to reverse zones with PTR records
Adding the zone to the /etc/named.conf file using the zone statement
Delegate a zone to another DNS server
The /var/named zone file
Syntax resource record formats
dig
nslookup
host

Securing a DNS server

Configure BIND to run as a non-root user
Configure BIND to run in a chroot jail
Configuring DNSSEC statements
Configure a split DNS configuration using the forwarders statement
Specifying a non-standard version number string in response to queries
SysV init files
/etc/named.conf
/etc/passwd
dnskeygen

Implementing a web server

Install and configure an Apache web server
Monitoring Apache load and performance
Restricting client user access
Configuring mod_perl
Configuring mod_php and PHP support
Setting up client user authentication
Configuring Apache server options
Maximum requests
Minimum and maximim servers
Minimum and maximim clients
access.log
.htaccess
httpd.conf
mod_auth
htpasswd
htgroup

Maintaining a web server

Configure Apache to use virtual hosts
Creating an SSL certification for Apache using OpenSSL
Defining SSL definitions in configuration files using OpenSSL
Customizing file access by implementing redirect statements in Apache's configuration files
httpd.conf

Implementing a proxy server

Install a proxy server using Squid
Configure a proxy server using Squid
Implementing access policies
Setting up authentication
Utilizing memory usage
squid.conf
acl
http_access

DHCP configuration

What is DHCP?
Static hosts
Dynamic hosts
dhcpd.conf
dhcpd.leases

NIS configuration

What is NIS?
Setting up a client
Setting up a server
nsswitch.conf
YP utilities
/etc/nis/

LDAP configuration

Configuring an LDAP server
LDIF files
User configuration
slapd and slapd.conf

PAM authentication

Configuring PAM
NIS and LDAP
pam.conf and /etc/pam.d

Configuring a router

IP chains
Packet filtering rules
Network address translation (NAT)
IP tables
/proc/sys/net/ipv4
routed

Securing FTP servers

Setting up FTP
Configuring FTP access restrictions
Anonymous FTP
Anonymous uploads
chroot

Secure shell (OpenSSH)

How SSH works
sshd
Generating keys
Port forwarding
X forwarding

TCP wrappers

Security need for TCP wrappers
tcpd
/etc/inetd.conf
/etc/hosts.allow and /etc/hosts.deny
xinetd

Security tasks

Install and configure Kerberos
Auditing source code
Getting security alerts
Open mail relays
Installing intrusion detection systems
Port scanning with nmap

Apache Basics

What is apache?
Installation on Linux
How apache listens
Configuration file(s)
Key configuration directives
Serverroot, documentroot
Serveradmin
Bindaddress, and port
Listen
User and group
Apache processes
Logging
Customizable logging
Customlog examples
Example configuration
Two sites and more ...
Virtual hosting options
Name-based hosting
Block directives
Directorymatch, et al.
Access control
Authorisation files
Other useful directives
Exercises
Solutions

Apache CGI Programming

Basic CGI
Enabling CGIs
Addhandler
How do CGIs work
URL-encoding
CGI language
A simple CGI
Using user information
CGIs and redirection
What else?
Useful CGIs
Basic CGIs - round up
Exercises

Apache with mod_perl

What is mod_perl?
How mod_perl works
Installing mod_perl
Make magic
Turning it on
Coding for mod_perl
More gotchas
Easy way out - perlrun
Exercises

Apache with mod_ssl

mod_ssl
Security and mod_ssl
Encryption
Identification
Building openssl
Building mod_ssl
Building apache
Exercises

Apache other modules

mod_speling
Case under mod_speling
Compiling with mod_speling
Notes on usage
mod_rewrite
Using mod_rewrite
What's getting rewritten?
Rewriting proper
More rewriting
Rewriting conditionals
Exercises
Solutions

Apache use & programming

Basic CGI
Get & post
URL-encoding
CGI language
A simple CGI
CGIs and redirection
What else?
Useful CGIs
Basic CGIs - round up
What is mod_perl?
How mod_perl works
Installing mod_perl
Coding for mod_perl
More gotchas
Easy way out - perlrun
mod_ssl
Security and mod_ssl
Encryption
Identification
Building openssl
Building mod_ssl
Building apache
Exercises
Solutions

Key Configuration Files

/etc/passwd
Editing /etc/passwd
Other changes to /etc/passwd
/etc/group
Editing /etc/group
Important note
Shadow passwords
/etc/shadow
Scheduling jobs (cron)
/etc/crontab
run-parts
logrotate
Module configuration
Modules configuration - `options'
Mounting filesystems
Runlevels
Single user mode
Multi user mode
Starting up and shutting down
Changing runlevel
Initscripts
rcn.d
Initscripts - an example
Restarting services
Exercises
Solutions

Concurrent Versions System

Introduction to CVS
Creating a repository
Setting up your repository
Checking out a working directory
Making changes to files
Merging your changes
Merging: an example
Committing changes
Examining logged changes
Adding and deleting files
Example: adding a file to a project
Deleting files
Renaming files
Writing good log entries
Handling conflicts
Identifying conflicts:
Resolving conflicts
Resolving conflicts
Understanding conflicts
Locking

Dial Up and Remote Access

Dial-in/out
The basics
Authentication
Setting-up dial-out
One dial-out setup
Dial-in setup
Other options
Preferred installation architectures
sendmail configuration for non dial-on-demand

Email

How email works
Where does an email go?
Overview
Email protocols
Where the protocols go
Basic installation
Sendmail behaviour
Linuxconf & sendmail
Configuration files (sendmail.cf)
Configuration files (sendmail.cw and /etc/mail/)
Monitoring sendmail
Example of mailq
Talking smtp
Talking pop
Managing users under sendmail
/etc/aliases
Aliases - other uses
Sendmail exercises

Basic Filesystem

Filesystem overview
Files
Directories
Directory hierarchy
Pathnames
Current directory
Dot (.) and dotdot(..)
Moving and copying files
Removing files
Operations on directories
Inodes
Links
Hard links
Soft links
Access control and uid
Categories of access control
Access control - example
Changing access permission: chmod
Chmod symbolically
Chmod numerically
Umask
Special files - /dev
Special files - /proc
Filesystem structure
/etc/fstab - example
Mounting additional volumes
Mounting shared filesystems
Summary
Filesystem exercises
Filesystem solutions

Shared File Systems

NFS (network file system)
Exporting file systems
Viewing exports
Importing file systems
Samba installation
Samba basics
Access to files and printers
Testing samba
Smbclient
Samba configuration file
Testing samba
Exercises
Solutions

Init Scripts

Runlevels
Single user mode
Multi user mode
Starting up and shutting down
Initscripts
/etc/rc.d/rcn.d
Initscripts - an example
Restarting services
Init script exercises

Job Control Tools

Introduction
Background jobs
Kill
The nice command
Hang up (nohup)
Execute programs at specified times (at)
Options and commands related to at
Running commands regularly (crontab)
Summary
Job control exercises
Job control solutions

Linux Kernel and Tracing

Kernel overview
Memory management
Scheduling
Module principles
Module commands
Module loading/unloading
Module dependencies
Module dependencies 2
Autoloading of modules
Module unloading
New/updated modules
Kernel recompiling
Boot disks
Getting and configuring a kernel
Kernel sources
Applying kernel patches
Configuration
Make menuconfig
Network device selection - an example
Configuration issues
Build process
Building a kernel
Module building
Installing a new kernel
Setting up to boot the new kernel
Tracing executables
ltrace
Exercises

Linux Fundamentals: An Overview

Generic features of unix
Linux --- the kernel of a system
Fundamental characteristics of linux
Multiuser multitasking and time-sharing
Protected memory mode
Multiple filesystem types
The many faces of a gnu/linux system
The filesystem
Filenames
Filename extensions and file types
Hidden filenames
The shell (bash)
Key features of the bash shell
Interacting with a linux `terminal'
Software tools: the unix philosophy
Tasks/processes
Process communication
Re-directing I/O to and from files
Pipes & tools
Linux as a programming environment
Networking
TCP/IP
Documentation
Using the man pages (on-line manual)
Overview exercises
Overview solutions

Printing Services

Linux printing
Printing documents
Main printing tools
Using lpr
Using lpq
Using lprm
Samba printing
Printing to a windows printer via samba

The Red Hat Package Management System (rpm)

Package management (rpm)
Distributed rpms
Binary rpms
Source rpms
Building rpms
Rpm naming conventions
Creating a .spec file
Details of a .spec file
Group hierarchy
%build
%install
%files
Building a package (rpm -b)
Pre and post install
Note on testing

Samba

Samba installation
Samba basics
Access to files and printers
Testing samba
Smbclient
Samba configuration file
Testing samba
Swat -- samba web administration tool
Installing swat
Options for swat
Global settings in swat
Share settings in swat
Printer configuration under swat
Viewing samba status with swat
View samba configuration in swat
Samba exercises

Basic Shell

Introduction
Getting around the command line
History
Plumbing
Output redirection
Input redirection
Combining redirection
Pipelines
Background processes
Background processes and nohup
Command grouping and sub-shells
Process management
Signals
Background processes: top
Filename generation
Quoting mechanisms
Shell built-in commands
Basic shell exercises
Basic shell solutions

Shell Programming

Introduction
Writing and running shell scripts
Subshell or subroutine?
Processing commands
Command substitution
Shell variables and variable substitution
Shell environment variables
Set
Quoting
.profile file
Arguments
Shell parameters
Blank interpretation
Comments
Read
Shift
Exit status or return code
Test
File status tests
Relational tests
For loop
If
True and false
While and until
Break and continue
Case
Simple conditionals
Here documents
Use of commands
Find
Evaluate expressions (expr)
Summary
Shell programming exercises
Shell programming solutions

Special Topics: Boot Manager, Installing Apps, System Info from /proc

The linux bootloader (lilo)
Lilo configuration
Understanding lilo.conf
Red hat package management tool (rpm)
Install, upgrade and uninstall with rpm
Query options for rpm
Verify options for rpm
Output from the rpm verification option
Building and installing applications
Autoconf
Using ./configure
Options to configure
Location of install
Installation requirements
Compilation roundup
The /proc filesytem
Process specific subdirectories
Process status
Process memory usage (statm)
Kernel data
Interrupts in use
IDE devices (/proc/ide)
Networking (/proc/net)
Networking 2 (/proc/net)
Scsi info (/proc/scsi)
Parallel port (/proc/parport)
Kernel parameters (/proc/sys)
File system data (/proc/fs)
Example: increase maximum filehandles
General kernel parameters (/proc/sys/kernel)
Virtual memory subsystem (/proc/sys/vm)
Device specific parameters (/proc/sys/dev)
Remote procedure calls (/proc/sys/sunrpc)
Networking (/proc/sys/net)
Ipv4 settings (/proc/sys/net/ipv4)
Special topics exercises
Special topics solutions

Squid Basics

Squid is
Squid also supports
What to cache and for how long?
Getting and installing squid
Squid directory structure
Basic configuration (caching proxy only)
Running squid
Basic client (browser) configuration
Basics access control
More advanced access control
Destination address based acls
Cache hierarchy concepts
Parents and siblings
Integration with other software
Log analysis and stats
Tools
Analysis
Squid exercises

System Daemons

Daemons
Stand alone vs on demand
Stand alone daemons
On-demand daemons
Cron jobs
/etc/crontab
Run-parts
Crond
Details on inetd
Configuration of inetd
Tcp wrappers (/usr/sbin/tcpd)
Tcp wrapper validation
System logging daemon
Syslog.conf
System log rotation
Sshd
Ssh principles
Ssh configuration
Xntpd
Time daemon config (/etc/ntp.conf)
Client/server configuration of xntpd
Example of /etc/ntp.conf
Xntpdc
Name resolution
/etc/hosts
/etc/resolv.conf
Dns
Dns configuration file (/etc/named.conf)
Zone files
Name entries
Dig
Dig (other servers)
Exercises
Solutions

Basic TCP/IP

Introduction to IP concepts - components
History
Packets
Addresses
Transferring data
Hosts & interfaces
Routing
Ports
Well known ports
Name resolution
/etc/hosts
/etc/resolv.conf
Dns
Dns - boot file (/etc/named.boot)
Zone files
Dns summary
Ip-related tools and utilities
Ping
Ifconfig
Traceroute
Netstat
Remote login
Telnet
Telnet command mode
Ssh
File transfer
Ftp
Setting up an interface
Exercises

Fundamentals of TCP/IP

Fundamentals of TCP/IP networking
History
Recap of basic IP concepts - components
IP versions
Packets
Addresses
Netmasks and subnetting
Netmasks with /xx
Transferring data
Hosts & interfaces
Routing
Ports
Exercises
Solutions

Practical TCP/IP

Ping protocols
Network statistics (netstat) in practice
Network traffic (tcpdump) in practice
tcpdump options
tcpdump examples
Firewalling
Basic theory
ipchains details
ipchains options
Options for rules
ipchains - examples
Removing rules
Implementing ipchains
Save and restore
ipchains setup script
Real world ipchains
Interface configuration and management
Point-and-click interface administration
/etc/sysconfig/network-scripts
ifcfg-ethx
Altering an interface
Adding an interface
The `proper' way
Drivers
The secure shell in practice (ssh)
Secure copying in practice (scp)
Summary
Exercises
Solutions

Basic Tools

Introduction
Using tools
The on-line manual (man)
Finding files the long way (find)
Locate files (locate)
View and concatenate files (cat)
View large files & output (less)
Viewing parts of files (head and tail)
Listing file information (ls)
File classification (file)
Count words, lines, characters (wc)
Differences between files (diff)
Compare binary files (cmp)
Regular expression searches (grep)
Grep examples
Sort and merge files (sort)
Sort examples
Display unique lines (uniq)
Split files (split)
Splitting files by context (csplit)
Compression utilities (gzip)
Store and retrieve archives (tar)
Translating characters (tr)
Examples of tr usage
Execute programs at specified times (at)
Options and commands related to at
Running commands regularly (crontab)
Evaluate expressions (expr)
Linux printing
Printing documents
Main printing tools
Using lpr
Using lpq
Using lprm
Basic tools exercises
Basic tools solutions

More Tools

Introduction
Displaying system processes (top)
Options and interactive commands for top
Reporting process status (ps)
Options for reporting process status (ps)
Finding files using specified criteria (find)
Criteria used in find expressions
Examples of using (find)
Reporting virtual memory statistics (vmstat)
Output from vmstat
Free
Ldd
Uptime
Xargs
Options to xargs
Positioning filenames with xargs
Cpio
Gzip
Unzipping
Tar
Raw devices and tar
Exercises
Solutions

Introduction To Editing with vi

Text editors under linux
Vi and your terminal
Vi screen layout
Opening files with vi
Vi modes
Saving, changing file and quitting
Moving around in command mode
Numeric prefixes
Further movement
Movement by lines - examples
Inserting text
Multiple insertion
Deleting text
Changing text
Copy and paste
Finding your place
Miscellaneous commands
Search and replace
Regular expressions
Regular expression conventions
Regular expression examples
Regular expression replacement
Vi exercises
Vi solutions

Basic X-windows

What x-windows is
X needs window managers
Window managers are applications
Desktop environments
Starting x
Stopping x
Running shells (xterms) under x
Running applications from an xterm
Running applications from a window manager
Configuring x
Basic x hardware configuration
Basic x software configuration
Networked x - the client-server relationship
Principles of running remote x apps
How to run remote x apps
Authentication
Better authentication
Basic x exercises