Cours Programmation Système en C sous Linux (Avancé)

Programmation Système en C sous Linux : Ce qu'il faut savoir. La programmation système en C couvre les appels système POSIX, la gestion des processus, des signaux, la concurrence (threads, sémaphores) et les communications inter‑processus sur un noyau Linux. Ce savoir‑faire permet d'écrire des utilitaires, des services et des démons fiables et performants dans des environnements Debian/Ubuntu. La version PDF est disponible gratuitement et permet de télécharger des exemples de code et des exercices pratiques.

🎯 Ce que vous allez apprendre

• Arguments et variables d'environnement — traiter argc/argv, convertir des chaînes en nombres avec atoi / sscanf et manipuler les variables d'environnement via getenv et putenv. Techniques pour écrire des utilitaires ligne de commande robustes qui héritent et transmettent l'environnement aux processus fils.
• Processus, fork et gestion des PID — création de processus avec fork, gestion des PID/PPID et états de terminaison (zombies). Orchestrer père/fils, récupérer le statut via wait et comprendre les implications de privilèges et de setuid sur la sécurité.
• Lancement d'un programme : exec et sécurité — familles exec pour remplacer l'image du processus, comparaison avec system et risques associés (injections shell, problèmes avec setuid). Schémas sûrs fork+exec et bonnes pratiques pour programmes privilégiés.
• Communication entre processus (IPC) — pipes anonymes, tubes nommés (FIFO), redirections d'E/S et transmission de données binaires. Exemples pour relier des processus via descripteurs et effectuer du multiplexage d'E/S.
• Concurrence POSIX : threads, mutex et sémaphores — création de threads POSIX, protection des données partagées avec pthread_mutex_t et synchronisation via sémaphores. Exercices visant la prévention des conditions de course et l'utilisation correcte des primitives POSIX.
• Gestion de fichiers et programmation réseau — interrogation d'attributs (stat), parcours de répertoires (opendir), descripteurs et sockets TCP (IP, ports, bind, listen, accept). Implémentation d'un serveur‑client basique en C sous Linux.

📑 Sommaire détaillé du cours

• Gestion des processus
• Threads POSIX
• Communication IPC
• Programmation Réseau
• Système de fichiers

La progression suit un enchaînement pédagogique : démarrer par la gestion des processus et des états de terminaison, aborder la programmation multithread et la synchronisation, étudier les mécanismes d'IPC (pipes, FIFO, sockets), appliquer les notions à la programmation réseau et terminer par le système de fichiers. Chaque chapitre inclut rappels conceptuels, exemples en C et exercices corrigés pour mise en pratique et vérification des acquis.

Installation de l'environnement

Préparer une machine Debian/Ubuntu pour compiler et exécuter les exemples requiert quelques paquets de base. Installer build-essential (contient gcc, make), ajouter gdb pour le débogage et valgrind pour l'analyse mémoire. Pour les exemples multithread, assurer la présence des en‑têtes POSIX et de la bibliothèque pthreads. Commandes typiques : sudo apt update, sudo apt install build-essential gdb valgrind. Prévoir des permissions adaptées pour tester des scénarios setuid en environnement contrôlé.

Pourquoi choisir ce cours ?

Rédigé par Rémy Malgouyres (LIMOS UMR 6158, IUT, Université Clermont 1), le document cible l'API POSIX sous Linux (Debian/Ubuntu) et combine rappels théoriques, extraits de code en C et exercices corrigés. La progression va des manipulations d'arguments et d'environnement aux sockets TCP et à la synchronisation multithread, favorisant la mise en pratique. Le format contient de nombreux extraits de code et cas d'usage concrets, utiles pour préparer projets système et entretiens techniques.

👤 À qui s'adresse ce cours ?

• Public cible : étudiants en informatique, développeurs systèmes ou ingénieurs souhaitant maîtriser la programmation bas niveau sous Linux pour écrire utilitaires, services réseau et modules multithread.

Prérequis techniques

• Bonne maîtrise du langage C (pointeurs, gestion mémoire, structures).
• Familiarité avec la ligne de commande Unix/Linux et outils de compilation (gcc, make).
• Notions de base sur les processus et les sockets. Ces prérequis permettent d'aborder les exercices pratiques et le TD corrigé inclus dans le PDF.

Programmation modulaire en C

Structure de projet

Fractionner le code source facilite la maintenance : séparer interfaces (.h) et implémentations (.c) réduit les temps de compilation et clarifie les responsabilités. La compilation séparée permet de recompiler uniquement les unités modifiées et de lier bibliothèques statiques ou partagées. Cette approche est particulièrement utile dans un système Unix où les appels système POSIX sont répartis entre modules spécialisés.

Exemple de structure

project/
├─ include/
│  └─ utils.h
├─ src/
│  ├─ main.c
│  └─ utils.c
├─ Makefile
└─ tests/
   └─ test_utils.c

Garde d'en-tête et includes

Utiliser des garde‑fichier d'en‑tête (#ifndef / #define / #endif) et limiter les symboles publics. Ajouter explicitement les includes nécessaires pour clarifier les dépendances, par exemple : #include <stdlib.h> ou #include <stdio.h>.

#ifndef UTILS_H
#define UTILS_H

#include <stdlib.h> /* allocation, conversion */
#include <stdio.h>  /* I/O */

int safe_parse_int(const char *s, int *out);

#endif /* UTILS_H */

Contrats et testabilité

Documenter les contrats de fonctions (effets de bord, propriété de la mémoire) et écrire des tests unitaires pour chaque module améliore la robustesse. Préférer des fonctions réentrantes lorsque possible et séparer clairement la gestion des erreurs et des ressources (descripteurs, locks).

Architecture d'un projet C sous Linux

Une architecture claire répartit modules, tests et outils d'automatisation. Fractionner le code source en composants cohérents réduit les risques lors des évolutions et facilite l'analyse des appels système POSIX. Inclure un répertoire examples/ et un tests/ avec TD corrigé permet de valider les scénarios courants. Pour les projets système, séparer les parties qui manipulent les privilèges, les E/S et la logique applicative limite la surface de bugs et simplifie les audits de sécurité.

Compilation et automatisation avec Makefiles

Automatiser la compilation réduit les erreurs humaines. Un Makefile standard définit variables (CC, CFLAGS, LDFLAGS), cibles (all, clean, install) et s'appuie sur règles implicites pour la compilation séparée. Utiliser .PHONY et génération automatique des dépendances (-MMD -MP) évite les rebuilds inutiles.

CC = gcc
CFLAGS = -Wall -Wextra -O2 -g
SRCS = main.c utils.c ipc.c
OBJS = $(SRCS:.c=.o)

all: app

app: $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^

clean:
	rm -f $(OBJS) app

Outils de développement et débogage

Les outils principaux sont gcc, make et gdb. Compiler avec -g et -O0 facilite le pas à pas dans gdb, tandis que -Wall -Wextra révèle des avertissements utiles. Pour l'analyse mémoire, valgrind reste pertinent. Des outils complémentaires comme strace et ltrace aident à tracer les appels système et liaisons de bibliothèque lors du diagnostic.

Programmation réseau

Conception et implémentation de sockets TCP/UDP, gestion des adresses (IPv4/IPv6), écoute et acceptation de connexions, et gestion non bloquante via select/poll/epoll. Exemples montrent comment écrire un serveur simple, gérer correctement les erreurs d'E/S et concevoir des protocoles applicatifs robustes. Les tests d'intégration serveur-client présents dans le PDF aident à valider les scénarios réseau courants.

• socket
• bind
• listen
• accept

Gestion de fichiers et système de fichiers

Au‑delà des appels usuels (open, read, write, stat, opendir), comprendre le modèle VFS et les inodes aide à appréhender métadonnées, liens et permissions. Certains appels bas niveau (mount(2), ioctl) et fichiers de périphérique (/dev/sda1) permettent des opérations systèmes avancées. Un programme C peut invoquer des utilitaires via fork+exec ou utiliser les interfaces systèmes quand disponibles ; ceci exige une attention particulière aux descripteurs, aux permissions et aux signaux pendant les opérations longues.

TD et Exercices corrigés de programmation système

Le document fournit un ensemble de TD corrigé et d'exercices couvrant la création et la synchronisation de processus, l'utilisation de threads POSIX, les mécanismes IPC et la programmation réseau. Chaque exercice inclut un énoncé précis, des indices méthodologiques et une solution commentée mettant l'accent sur la sécurité des ressources, la gestion des erreurs et les bonnes pratiques. Ces corrections facilitent l'auto‑évaluation et la préparation aux projets pratiques.