Table of contents

Jump directly to the chapter of interest:

The Debian Project

  • What Is Debian?
    • A Multi-Platform Operating System
      • The Quality of Free Software
        • The Legal Framework: A Non-Profit Organization
        • The Foundation Documents
          • The Commitment towards Users
            • The Debian Free Software Guidelines
            • The Inner Workings of the Debian Project
              • The Debian Developers
                • The Active Role of Users
                  • Teams and Sub-Projects
                    • Existing Debian Sub-Projects
                      • Administrative Teams
                        • Development Teams, Transversal Teams
                      • The Role of Distributions
                        • The Installer: debian-installer
                          • The Software Library
                          • Lifecycle of a Release
                            • The Experimental Status
                              • The Unstable Status
                                • Migration to Testing
                                  • The Release: Testing Becomes Stable

                                  Presenting the Case Study

                                  • Fast Growing IT Needs
                                    • Long-Term Plans
                                      • Why a GNU/Linux Distribution?
                                        • Why the Debian Distribution?
                                          • Community- and Commercially-Driven Distributions
                                          • Why Debian Squeeze?

                                            Analysing the Existing Setup and Migrating

                                            • Coexistence in Heterogeneous Environments
                                              • Integration with Windows Machines
                                                • Integration with Mac OS Machines
                                                  • Integration with Other Linux/Unix Machines
                                                  • How To Migrate
                                                    • Identifying Services
                                                      • Network and Processes
                                                      • Backing up the Configuration
                                                        • Taking Over an Existing Debian Server
                                                          • Installing Debian
                                                            • Installing and Configuring the Selected Services

                                                            Installation

                                                            • Installation Methods
                                                              • Installing from a CD-ROM/DVD-ROM
                                                                • Booting from a USB Key
                                                                  • Installing through Network Booting
                                                                    • Other Installation Methods
                                                                    • Installing, Step by Step
                                                                      • Booting and Starting the Installer
                                                                        • Selecting the Language
                                                                          • Selecting the Country
                                                                            • Selecting the Keyboard Layout
                                                                              • Detecting Hardware
                                                                                • Loading Components
                                                                                  • Detecting Network Hardware
                                                                                    • Configuring the Network
                                                                                      • Configuring the Clock
                                                                                        • Administrator Password
                                                                                          • Creating the First User
                                                                                            • Detecting Disks and Other Devices
                                                                                              • Starting the Partitioning Tool
                                                                                                • Guided Partitioning
                                                                                                  • Manual Partitioning
                                                                                                    • Configuring Multidisk Devices (Software RAID)
                                                                                                      • Configuring the Logical Volume Manager (LVM)
                                                                                                        • Setting Up Encrypted Partitions
                                                                                                        • Installing the Base System
                                                                                                          • Configuring the Package Manager (apt)
                                                                                                            • Debian Package Popularity Contest
                                                                                                              • Selecting Packages for Installation
                                                                                                                • Installing the GRUB Bootloader
                                                                                                                  • Finishing the Installation and Rebooting
                                                                                                                  • After the First Boot
                                                                                                                    • Installing Additional Software
                                                                                                                      • Upgrading the System

                                                                                                                      Packaging System: Tools and Fundamental Principles

                                                                                                                      • Structure of a Binary Package
                                                                                                                        • Package Meta-Information
                                                                                                                          • Description: the control File
                                                                                                                            • Dependencies: the Depends Field
                                                                                                                              • Conflicts: the Conflicts field
                                                                                                                                • Incompatibilities: the Breaks Field
                                                                                                                                  • Provided Items: the Provides Field
                                                                                                                                    • Providing a “Service”
                                                                                                                                      • Interchangeability with Another Package
                                                                                                                                        • Current Limitations
                                                                                                                                        • Replacing Files: the Replaces Field
                                                                                                                                        • Configuration Scripts
                                                                                                                                          • Installation and upgrade
                                                                                                                                            • Package Removal
                                                                                                                                            • Checksums, List of Configuration Files
                                                                                                                                            • Structure of a Source Package
                                                                                                                                              • Format
                                                                                                                                                • Usage within Debian
                                                                                                                                                • Manipulating Packages with dpkg
                                                                                                                                                  • Installing Packages
                                                                                                                                                    • Package Removal
                                                                                                                                                      • Other dpkg Features
                                                                                                                                                        • dpkg's Log File
                                                                                                                                                        • Coexistence with Other Packaging Systems

                                                                                                                                                          Maintenance and Updates: The APT Tools

                                                                                                                                                          • Filling in the sources.list File
                                                                                                                                                            • The Other Official Repositories
                                                                                                                                                              • The Stable Updates
                                                                                                                                                                • The Backports Repository backports.debian.org
                                                                                                                                                                  • The Experimental Repository
                                                                                                                                                                  • Non-Official Resources: apt-get.org and mentors.debian.net
                                                                                                                                                                  • aptitude and apt-get Commands
                                                                                                                                                                    • Initialization
                                                                                                                                                                      • Installing and Removing
                                                                                                                                                                        • System Upgrade
                                                                                                                                                                          • Configuration Options
                                                                                                                                                                            • Managing Package Priorities
                                                                                                                                                                              • Working with Several Distributions
                                                                                                                                                                              • The apt-cache Command
                                                                                                                                                                                • Frontends: aptitude, synaptic
                                                                                                                                                                                  • aptitude
                                                                                                                                                                                    • Tracking Automatically Installed Packages
                                                                                                                                                                                      • Managing Recommendations, Suggestions and Tasks
                                                                                                                                                                                        • Better Solver Algorithms
                                                                                                                                                                                        • synaptic
                                                                                                                                                                                        • Checking Package Authenticity
                                                                                                                                                                                          • Upgrading from One Stable Distribution to the Next
                                                                                                                                                                                            • Recommended Procedure
                                                                                                                                                                                              • Handling Problems after an Upgrade
                                                                                                                                                                                              • Keeping a System Up to Date
                                                                                                                                                                                                • Automatic Upgrades
                                                                                                                                                                                                  • Configuring dpkg
                                                                                                                                                                                                    • Configuring APT
                                                                                                                                                                                                      • Configuring debconf
                                                                                                                                                                                                        • Handling Command Line Interactions
                                                                                                                                                                                                          • The Miracle Combination
                                                                                                                                                                                                          • Searching for Packages

                                                                                                                                                                                                            Solving Problems and Finding Relevant Information

                                                                                                                                                                                                            • Documentation Sources
                                                                                                                                                                                                              • Manual Pages
                                                                                                                                                                                                                • info Documents
                                                                                                                                                                                                                  • Specific Documentation
                                                                                                                                                                                                                    • Websites
                                                                                                                                                                                                                      • Tutorials (HOWTO)
                                                                                                                                                                                                                      • Common Procedures
                                                                                                                                                                                                                        • Configuring a Program
                                                                                                                                                                                                                          • Monitoring What Daemons Are Doing
                                                                                                                                                                                                                            • Asking for Help on a Mailing List
                                                                                                                                                                                                                              • Reporting a Bug When the Problem Is Too Difficult

                                                                                                                                                                                                                              Basic Configuration: Network, Accounts, Printing...

                                                                                                                                                                                                                              • Configuring the System for Another Language
                                                                                                                                                                                                                                • Setting the Default Language
                                                                                                                                                                                                                                  • Configuring the Keyboard
                                                                                                                                                                                                                                    • Migrating to UTF-8
                                                                                                                                                                                                                                    • Configuring the Network
                                                                                                                                                                                                                                      • Ethernet Interface
                                                                                                                                                                                                                                        • Connecting with PPP through a PSTN Modem
                                                                                                                                                                                                                                          • Connecting through an ADSL Modem
                                                                                                                                                                                                                                            • Modems Supporting PPPOE
                                                                                                                                                                                                                                              • Modems Supporting PPTP
                                                                                                                                                                                                                                                • Modems Supporting DHCP
                                                                                                                                                                                                                                                • Automatic Network Configuration for Roaming Users
                                                                                                                                                                                                                                                • Setting the Hostname and Configuring the Name Service
                                                                                                                                                                                                                                                  • Name Resolution
                                                                                                                                                                                                                                                    • Configuring DNS Servers
                                                                                                                                                                                                                                                      • /etc/hosts File
                                                                                                                                                                                                                                                    • User and Group Databases
                                                                                                                                                                                                                                                      • User List: /etc/passwd
                                                                                                                                                                                                                                                        • The Hidden and Encrypted Password File: /etc/shadow
                                                                                                                                                                                                                                                          • Modifying an Existing Account or Password
                                                                                                                                                                                                                                                            • Disabling an Account
                                                                                                                                                                                                                                                              • Group List: /etc/group
                                                                                                                                                                                                                                                              • Creating Accounts
                                                                                                                                                                                                                                                                • Environment of Shells
                                                                                                                                                                                                                                                                  • Configuring Printing
                                                                                                                                                                                                                                                                    • Configuring the Bootloader
                                                                                                                                                                                                                                                                      • Identifying the Disks
                                                                                                                                                                                                                                                                        • Configuring LILO
                                                                                                                                                                                                                                                                          • Configuration de GRUB 2
                                                                                                                                                                                                                                                                            • Configuration de GRUB Legacy
                                                                                                                                                                                                                                                                              • For Macintosh Computers (PowerPC): Configuring Yaboot
                                                                                                                                                                                                                                                                              • More to configure: time synchronization, logs, shares...
                                                                                                                                                                                                                                                                                • Timezone
                                                                                                                                                                                                                                                                                  • Time Synchronization
                                                                                                                                                                                                                                                                                    • For Workstations
                                                                                                                                                                                                                                                                                      • For Servers
                                                                                                                                                                                                                                                                                      • Rotating Log Files
                                                                                                                                                                                                                                                                                        • Sharing Administrator Rights
                                                                                                                                                                                                                                                                                          • Liste of Mount Points
                                                                                                                                                                                                                                                                                            • locate and updatedb
                                                                                                                                                                                                                                                                                            • Compiling a Kernel
                                                                                                                                                                                                                                                                                              • Introduction and prerequisites
                                                                                                                                                                                                                                                                                                • Getting the Sources
                                                                                                                                                                                                                                                                                                  • Configuring the Kernel
                                                                                                                                                                                                                                                                                                    • Compiling and building the package
                                                                                                                                                                                                                                                                                                      • Compiling External Modules
                                                                                                                                                                                                                                                                                                        • Applying a Kernel Patch
                                                                                                                                                                                                                                                                                                        • Installing a Kernel
                                                                                                                                                                                                                                                                                                          • Features of a Debian Kernel Package
                                                                                                                                                                                                                                                                                                            • Installing with dpkg

                                                                                                                                                                                                                                                                                                            Unix Services

                                                                                                                                                                                                                                                                                                            • System Boot
                                                                                                                                                                                                                                                                                                              • Remote Login
                                                                                                                                                                                                                                                                                                                • Remote Login: telnet
                                                                                                                                                                                                                                                                                                                  • Secure Remote Login: SSH
                                                                                                                                                                                                                                                                                                                    • Key-Based Authentication
                                                                                                                                                                                                                                                                                                                      • Using Remote X11 Applications
                                                                                                                                                                                                                                                                                                                        • Creating Encrypted Tunnels with Port Forwarding
                                                                                                                                                                                                                                                                                                                        • Using Remote Graphical Desktops
                                                                                                                                                                                                                                                                                                                        • Managing Rights
                                                                                                                                                                                                                                                                                                                          • Administration Interfaces
                                                                                                                                                                                                                                                                                                                            • Administrating On a Web Interface: webmin
                                                                                                                                                                                                                                                                                                                              • Configuring Packages: debconf
                                                                                                                                                                                                                                                                                                                              • syslog System Events
                                                                                                                                                                                                                                                                                                                                • Principle and Mechanism
                                                                                                                                                                                                                                                                                                                                  • The Configuration File
                                                                                                                                                                                                                                                                                                                                    • Syntax of the Selector
                                                                                                                                                                                                                                                                                                                                      • Syntax of Actions
                                                                                                                                                                                                                                                                                                                                    • The inetd Super-Server
                                                                                                                                                                                                                                                                                                                                      • Task Scheduling: cron and atd
                                                                                                                                                                                                                                                                                                                                        • Format of a crontab File
                                                                                                                                                                                                                                                                                                                                          • Using the at Command
                                                                                                                                                                                                                                                                                                                                          • Asynchronous Scheduling: anacron
                                                                                                                                                                                                                                                                                                                                            • Quotas
                                                                                                                                                                                                                                                                                                                                              • Backing Up
                                                                                                                                                                                                                                                                                                                                                • Backing Up with rsync
                                                                                                                                                                                                                                                                                                                                                  • Restoring Machines without Backups
                                                                                                                                                                                                                                                                                                                                                  • Hot Plugging: hotplug
                                                                                                                                                                                                                                                                                                                                                    • Introduction
                                                                                                                                                                                                                                                                                                                                                      • The Naming Problem
                                                                                                                                                                                                                                                                                                                                                        • How udev works
                                                                                                                                                                                                                                                                                                                                                          • Example
                                                                                                                                                                                                                                                                                                                                                          • Power Management
                                                                                                                                                                                                                                                                                                                                                            • Advanced Power Management (APM)
                                                                                                                                                                                                                                                                                                                                                              • Advanced Configuration and Power Interface (ACPI)
                                                                                                                                                                                                                                                                                                                                                              • Laptop Extension Cards: PCMCIA

                                                                                                                                                                                                                                                                                                                                                                Network Infrastructure

                                                                                                                                                                                                                                                                                                                                                                • Gateway
                                                                                                                                                                                                                                                                                                                                                                  • Virtual Private Network
                                                                                                                                                                                                                                                                                                                                                                    • OpenVPN
                                                                                                                                                                                                                                                                                                                                                                      • Public Key Infrastructure: easy-rsa
                                                                                                                                                                                                                                                                                                                                                                        • Configuring the OpenVPN Server
                                                                                                                                                                                                                                                                                                                                                                          • Configuring the OpenVPN Client
                                                                                                                                                                                                                                                                                                                                                                          • Virtual Private Network with SSH
                                                                                                                                                                                                                                                                                                                                                                            • IPsec
                                                                                                                                                                                                                                                                                                                                                                              • PPTP
                                                                                                                                                                                                                                                                                                                                                                                • Configuring the Client
                                                                                                                                                                                                                                                                                                                                                                                  • Configuring the Server
                                                                                                                                                                                                                                                                                                                                                                                • Quality of Service
                                                                                                                                                                                                                                                                                                                                                                                  • Principle and Mechanism
                                                                                                                                                                                                                                                                                                                                                                                    • Configuring and Implementing
                                                                                                                                                                                                                                                                                                                                                                                      • Reducing Latencies: wondershaper
                                                                                                                                                                                                                                                                                                                                                                                        • Standard Configuration
                                                                                                                                                                                                                                                                                                                                                                                      • Dynamic Routing
                                                                                                                                                                                                                                                                                                                                                                                        • IPv6
                                                                                                                                                                                                                                                                                                                                                                                          • Domain Name Servers (DNS)
                                                                                                                                                                                                                                                                                                                                                                                            • Principle and Mechanism
                                                                                                                                                                                                                                                                                                                                                                                              • Configuring
                                                                                                                                                                                                                                                                                                                                                                                              • DHCP
                                                                                                                                                                                                                                                                                                                                                                                                • Presentation
                                                                                                                                                                                                                                                                                                                                                                                                  • Configuring
                                                                                                                                                                                                                                                                                                                                                                                                    • DHCP and DNS
                                                                                                                                                                                                                                                                                                                                                                                                    • Network Diagnosis Tools
                                                                                                                                                                                                                                                                                                                                                                                                      • Local Diagnosis: netstat
                                                                                                                                                                                                                                                                                                                                                                                                        • Remote Diagnosis: nmap
                                                                                                                                                                                                                                                                                                                                                                                                          • Sniffers: tcpdump and wireshark

                                                                                                                                                                                                                                                                                                                                                                                                          Network Services: Postfix, Apache, NFS, Samba, Squid, LDAP

                                                                                                                                                                                                                                                                                                                                                                                                          • Mail Server
                                                                                                                                                                                                                                                                                                                                                                                                            • Installing Postfix
                                                                                                                                                                                                                                                                                                                                                                                                              • Configuring Virtual Domains
                                                                                                                                                                                                                                                                                                                                                                                                                • Virtual Alias Domains
                                                                                                                                                                                                                                                                                                                                                                                                                  • Virtual Mailbox Domains
                                                                                                                                                                                                                                                                                                                                                                                                                  • Restrictions for receiving and sending
                                                                                                                                                                                                                                                                                                                                                                                                                    • IP-Based Access Restrictions
                                                                                                                                                                                                                                                                                                                                                                                                                      • Checking the Validity of the EHLO or HELO Commands
                                                                                                                                                                                                                                                                                                                                                                                                                        • Accepting or Refusing Based on the Announced Sender
                                                                                                                                                                                                                                                                                                                                                                                                                          • Accepting or Refusing Based on the Recipient
                                                                                                                                                                                                                                                                                                                                                                                                                            • Restrictions Associated with the DATA Command
                                                                                                                                                                                                                                                                                                                                                                                                                              • Applying Restrictions
                                                                                                                                                                                                                                                                                                                                                                                                                                • Filtering Based on the Message Contents
                                                                                                                                                                                                                                                                                                                                                                                                                                • Setting Up greylisting
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Customizing Filters Based On the Recipient
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Integrating an Antivirus
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Authenticated SMTP
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Web Server (HTTP)
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Installing Apache
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Configuring Virtual Hosts
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Common Directives
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Requesting an Authentication
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Restricting Access
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Log Analyzers
                                                                                                                                                                                                                                                                                                                                                                                                                                                • FTP File Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • NFS File Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Securing NFS
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • NFS Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • NFS Client
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Setting Up Windows Shares with Samba
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Samba Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Configuring with debconf
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Configuring Manually
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Changes to smb.conf
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Adding Users
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Switching to Domain Controller
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Samba Client
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The smbclient Program
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Mounting a Windows Share
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Printing on a Shared Printer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • HTTP/FTP Proxy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Installing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Configuring a Cache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Configuring a Filter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • LDAP Directory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Installing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Filling in the Directory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing Accounts with LDAP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuring NSS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Configuring PAM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Securing LDAP Data Exchanges
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Configuring the Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Configuring the Client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Advanced Administration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • RAID and LVM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Software RAID
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Different RAID Levels
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Setting Up RAID
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Backing up the Configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • LVM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • LVM Concepts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Setting Up LVM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • LVM Over Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • RAID or LVM?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Virtualization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Xen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • LXC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Preliminaries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Network Configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Setting Up the System
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Starting the Container
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Virtualization with KVM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Preliminaries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Network Configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Installation with virt-install
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Managing Machines With virsh
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Automated Installation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Fully Automatic Installer (FAI)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Preseeding Debian-Installer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Using a Preseed File
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Creating a Preseed File
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creating a Customized Boot Media
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Booting From the Network
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Preparing a Bootable USB Key
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creating a CD-Rom Image
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Simple-CDD: The All-In-One Solution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creating Profiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Configuring and Using build-simple-cdd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Generating an ISO Image
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Supervision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Setting Up Munin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Configuring Hosts To Monitor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Configuring the Grapher
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Setting Up Nagios
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Installing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuring

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Workstation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Configuring the X11 Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Customizing the Graphical Interface
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Choosing a Display Manager
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Choosing a Window Manager
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Menu Management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Graphical Desktops
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • GNOME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • KDE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Xfce and Others
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Tools
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Email
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Evolution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • KMail
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Thunderbird and Icedove
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Web Browsers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Development
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Tools for GTK+ on GNOME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Tools for Qt on KDE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Collaborative Work
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Working in Groups: groupware
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Instant Messaging Systems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Configuring the Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Jabber Clients
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Collaborative Work With FusionForge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Office Suites
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Emulating Windows: Wine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Security

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Defining a Security Policy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Firewall or Packet Filtering
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Behavior of Netfilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Syntax of iptables and ip6tables
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Commands
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Creating Rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Installing the Rules at Each Boot
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Supervision: prevention, detection, dissuasion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Monitoring Logs with logcheck
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Monitoring Activity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • In Real Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • History
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Detecting Changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Auditing Packages: debsums and its Limits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Monitoring Files: AIDE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Detecting Intrusion (IDS/NIDS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Introduction to SELinux
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Principles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Setting Up SELinux
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Managing an SELinux System
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Managing SELinux Modules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Managing Identities
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Managing File Contexts, Ports and Booleans
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Adapting the Rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Writing a .fc File
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Writing a .if File
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Writing a .te File
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Compiling the Files
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Other Security Related Considerations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Inherent Risks of Web Applications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Knowing What To Expect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Choosing the Software Wisely
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Managing a Machine as a Whole
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Users Are Players
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Physical Security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Legal Liability
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Dealing with a Compromised Machine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Detecting and Seeing the Cracker's Intrusion
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Putting the Server Off-Line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Keeping Everything that Could Be Used as Evidence
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Re-installing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Forensic Analysis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Reconstituting the Attack Scenario

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Creating a Debian Package

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Rebuilding a Package from its Sources
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Getting the Sources
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Making Changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Starting the Rebuild
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Building your First Package
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Meta-Packages or Fake Packages
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Simple File Archive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Creating a Package Repository for APT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Becoming a Package Maintainer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Learning to Make Packages
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Rules
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Procedures
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Tools
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The lintian Program
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • devscripts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • debhelper and dh-make
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • dupload and dput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Acceptance Process
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Prerequisites
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Registration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Accepting the Principles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Checking Skills
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Final Approval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Conclusion: Debian's Future

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Upcoming Developments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Debian's Future
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Future of this Book

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Derivative Distributions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Census and Cooperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ubuntu Linux
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Knoppix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Linux Mint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • SimplyMEPIS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Aptosid (formerly Sidux)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Damn Small Linux
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • And Much More

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Short Remedial Course

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Shell and Basic Commands
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Browsing the Directory Tree and Managing Files
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Displaying and Modifying Text Files
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Searching for Files and within Files
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Managing Processes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • System Information: Memory, Disk Space, Identity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Organization of the Filesystem Hierarchy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The Root Directory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The User's Home Directory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Inner Workings of a Computer: The Different Layers Involved
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Deepest Layer: the Hardware
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The Starter: the BIOS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The Kernel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The User Space
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Some Tasks Handled by the Kernel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Driving the Hardware
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Filesystems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Shared Functions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Managing Processes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Rights Management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The User Space
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Process
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Daemons
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Inter-Process Communications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Libraries