jean-christophe lapayre 1 unix pour l'utilisateur les commandes fondamentales
TRANSCRIPT
![Page 1: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/1.jpg)
1Jean-Christophe Lapayre
Unix pour l'utilisateurUnix pour l'utilisateur
Les commandes fondamentales
![Page 2: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/2.jpg)
2Jean-Christophe Lapayre
![Page 3: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/3.jpg)
3Jean-Christophe Lapayre
Vérifier la connexion PC/UnixVérifier la connexion PC/Unix
ping : commande permettant de vérifier qu'une machine est accessible sur le réseauping adresse_ipping nom_de machine (nécessite un DNS
ou un fichier hosts)Ouverture d'une session interactive
La commande telnetrlogin
![Page 4: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/4.jpg)
4Jean-Christophe Lapayre
arborescencearborescence
/ : Répertoire racine, tous les autres répertoires en dépendent.
/bin : Contient les binaires fondamentaux à la gestion de Linux.
/dev : Contient une multitudes de fichiers dits spéciaux. L'un deux correspond à mon modem. Je dois indiquer ce fichier dans la configuration de mes outils de communication. De même /dev/hda1 correspond à la première partition de mon disque dur IDE, si mon disque dur est un SCSI, son nom sera /dev/sda1. Un dernier exemple : /dev/fd0 correspond à mon lecteur de disquettes.
/etc : Contient tous les fichiers de configuration de linux. On y retrouve par exemple le fichier /etc/passwd, qui définit les mots de passe des utilisateurs.
/sbin : Contient les binaires du système. On y trouve par exemple la commande shutdown qui permet d'arrêter l'ordinateur.
/home : Répertoire qui contient les répertoires des utilisateurs du système. Le répertoire des utilisateurs est automatiquement créé avec la création d'un compte. Tous mes fichiers personnels sont dans /home/(maltesse).
![Page 5: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/5.jpg)
5Jean-Christophe Lapayre
Arborescence suiteArborescence suite /lost+found : Répertoire des fichiers perdus. Ces fameux fichiers qui, du fait d'erreur disque, se
retrouvent sans chemin d'accès. Le binaire fsck, qui est lancé régulièrement au démarrage de linux, se charge de les détecter et de les stocker dans le répertoire /lost+found
/tmp : Répertoire accessible par tous les utilisateurs du système, il permet de ne pas encombrer son répertoire personnel par des fichiers que l'on souhaite de toute manière détruire ou modifier.
/var/spool : Répertoire des fichiers qui servent de file d'attente. Par exemple, les files d'attente de l'imprimante se trouvent sous ce répertoire. Les données à imprimer, envoyer, ... sont stockées dans ces files d'attentes jusqu'à ce qu'elles soient traitées.
/usr : Contient tout ce qui concerne les binaires utiles à tous les utilisateurs et quelques commandes d'administration. On y trouve cependant d'autres choses: /usr/bin contient donc les binaires disponibles pour les utilisateurs et les scripts.
/usr/X11R6 : Contient tout ce qui concerne Xfree86 (les bibliothèques, les binaires, la documentation).
/usr/include : contient tous les "headers" nécessaires à la programmation dans les différents langages.
/usr/lib : Contient toutes les bibliothèques nécessaires au fonctionnement des logiciels. (comme par exemple la bibliothèque C ou C++ ou tcl/tk).
/usr/local : On y met ce que l'on veut, mais surtout les fichiers d'usage local.
![Page 6: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/6.jpg)
6Jean-Christophe Lapayre
Manipulation des fichiersManipulation des fichiers
Lister les fichiers : ls Créer un fichier vide : touch nom_fichier Créer un fichier en saisissant le contenu directement
sur la consolecat >nom_fichier
Voici mon premier fichier<ctrl-d>
![Page 7: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/7.jpg)
7Jean-Christophe Lapayre
Manipulation des fichiersManipulation des fichiers
Copier de fichiers : cpAfficher le contenu d'un fichier : catDétruire un fichier : rmCréer un répertoire : mkdirChanger de répertoire : cdCopier un fichier d'un répertoire à l'autreAfficher page à page : moreDésigner plusieurs fichiers dans la même commande
Les caractères jokerEviter les manipulations hasardeuses* : -iDétruire un répertoire
![Page 8: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/8.jpg)
8Jean-Christophe Lapayre
Créer des alias de commandeCréer des alias de commande
Pour émuler des commandes déjà connuesalias copy=cp
Pour positionner des options par défautalias rm='rm -i'
Supprimer un alias définiunalias rm
Désactivation temporaire\rm nom_fichier
![Page 9: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/9.jpg)
9Jean-Christophe Lapayre
Détails sur les commandesDétails sur les commandes
man : l'indispensable manuel en ligne Unix
Ou commande –hOu commande –helpOu commande --help
![Page 10: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/10.jpg)
10Jean-Christophe Lapayre
[bastide@moe bastide]$ man manNAME man - format and display the on-line manual pages manpath - determine user's search path for man pagesSYNOPSIS man [-adfhkKtwW] [-m system] [-p string] [-C config_file] [-M path] [-P pager] [-S section_list] [section] name ...
Le synopsis montre :
- Des options facultatives sans paramètres complémentaires : [-adfhkKtwW]
- Des options facultatives qui nécessitent un paramètre complémentaire : [-P pager]
- Des paramètres optionnels : [section]
- Un paramètre obligatoire : name
- Le fait que le paramètre obligatoire peut être répété une ou plusieurs fois : name ...
Décryptage d'une page manDécryptage d'une page man
![Page 11: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/11.jpg)
11Jean-Christophe Lapayre
Comparaison commandes : Unix et MS-DosComparaison commandes : Unix et MS-Dos
Dos Unix Copie COPY, CP cp Suppression DEL,
REMOVE rm
Déplacement REN, RENAME
mv
Création de répertoire
MD, MKDIR mkdir
Destruction de Répertoire
RD, RMDIR rmdir
Changement de répertoire
CD, CHDIR cd
Listage DIR ls Affichage du contenu
TYPE cat
![Page 12: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/12.jpg)
12Jean-Christophe Lapayre
Retour sur les commandesRetour sur les commandes
Options avancées de cpcopie récursive (-r)
Options avancées de lslisting long (-l)listing des fichiers cachés (-a)listing récursif (-R)listing avec caractère distinctif (-F)sans inspections des répertoires (-d)
Options avancées de rmDestruction récursive (-r)Destruction forcée (-f)
![Page 13: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/13.jpg)
13Jean-Christophe Lapayre
Redirections des Entrées / SortiesRedirections des Entrées / Sorties
![Page 14: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/14.jpg)
14Jean-Christophe Lapayre
Redirection des Entrées/SortiesRedirection des Entrées/Sorties
Chacune de E/S d'un programme peut être redirigée séparément vers un fichierlire les données d'entrée dans un fichierEnvoyer les résultats ou les erreurs dans un
fichier
![Page 15: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/15.jpg)
15Jean-Christophe Lapayre
Caractères de redirectionCaractères de redirection
Redirection de l'entrée standardwc < .cshrc
Redirection de la sortie standardls > liste
![Page 16: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/16.jpg)
16Jean-Christophe Lapayre
Tubes et filtresTubes et filtres
La sortie standard d'un programme peut être connectée à l'entrée standard d'un autreLes résultats du premier programme
servent de données au deuxième programme
Tube (pipe) : suite de commandes réliées par le caractère '|'ls /etc | moreLs –la | grep lapayre
![Page 17: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/17.jpg)
17Jean-Christophe Lapayre
Gestion des fichiersGestion des fichiers
![Page 18: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/18.jpg)
18Jean-Christophe Lapayre
Différents types de fichiersDifférents types de fichiers
Unix connaît plusieurs types de fichiers. Ces différents types sont visibles par l'option -l de la commande ls Fichier ordinaire (-)
Contient n'importe quel type de données. Dans certains cas, la commande file permet de connaître les données contenues dans ce fichier.
Répertoire (d)Contient d'autres fichiers et sous-répertoires.
Lien symbolique (l)Permet de désigner le même fichier par plusieurs noms différents
Fichier spécial : périphérique en mode caractère (c)Dans le répertoire /dev
Fichier spécial : périphérique en mode bloc (b) Tube nommé (named pipe) (p)
Utilisation avancée, pour la communication entre processus Socket (s)
Idem.
![Page 19: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/19.jpg)
19Jean-Christophe Lapayre
Trois catégories d'utilisateursTrois catégories d'utilisateurs
Pour chaque fichier, il existe trois type d'utilisateurs :Le propriétaire (owner) du fichier. La personne qui
crée un fichier en est propriétaire, jusqu'à ce qu'elle (ou l'administrateur système) utilise la commande chown.
Les membres du groupe du propriétaire du fichier.Les autres utilisateurs du système
![Page 20: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/20.jpg)
20Jean-Christophe Lapayre
Trois types d'autorisationTrois types d'autorisation
Autorisation d'écriture : permet de modifier un fichier, ou de le supprimer. Pour un répertoire, permet de créer des fichiers dans un répertoire ou de les détruire, et de détruire le répertoire lui-même.
Autorisation de lecture : permet d'afficher le contenu d'un fichier et de le copier. Pour un répertoire, permet de lister les fichiers contenus dans ce répertoire.
Autorisation d'exécution : permet d'exécuter un fichier (il doit s'agir d'un programme compilé ou d'un script). Pour un répertoire, permet de se positionner (cd) dans ce répertoire ou de le traverser (par cd ou ls).
![Page 21: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/21.jpg)
21Jean-Christophe Lapayre
[bastide@moe bastide]$ ls - /etc/passwd-rw-r—r-- 1 root bin 2055 Jul 28 18:03 /etc/passwd$
Les permissions peuvent être affichées de manière numérique sous la forme de trois nombres en octal (de 0 à 7),en considérant que r=4, w=2, et x = 1
Par exemple :
Affichage des autorisationsAffichage des autorisations
Affichage en mode symbolique
Désignation en mode octal
1 1 1 1 1 0 1 0 1
![Page 22: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/22.jpg)
22Jean-Christophe Lapayre
La commande chmodLa commande chmod
chmod [-Rcfv] mode file ...Mode symboliques
u,g,o,a : user, group, others, all+,-,= : ajoute, supprime ou fixe le droitr,w,x : read, write, execute
Mode octalChmod – R 777 ~lapayre/tpUnix donne les
droits lecture, écriture exécution pour tous sur le répertoire tpUnix (et ses sous-répertoires)
![Page 23: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/23.jpg)
23Jean-Christophe Lapayre
Gestion des processusGestion des processus
![Page 24: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/24.jpg)
24Jean-Christophe Lapayre
Commandes de gestion des processusCommandes de gestion des processus
Lancement d'un processus en tâche de fondnomProcessus &Si oubli : processus déjà lancé, Ctrl Z puis bg
Affichage des processus en cours : ps -efTuer un processus : kill -9
background
![Page 25: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/25.jpg)
25Jean-Christophe Lapayre
La commande find : testsLa commande find : tests
Par nom: find . -name "*html" -print
Par possesseur: find . -user igsi -print
Par groupe: find . -group igsi -print
Par type: find . -type d -name "*html"
–print Par date d’accès
find . –amin –3 –print Par permissions
find . –perm 777 -print
Affichage du nom des fichiers trouvés: -print
Exécution d'une commande sur les fichiers trouvés: -exec commande {} \; find . -name "*.bak"
-exec rm {} \; find . -name "*.bak"
-ok rm {} \;
Rechercher des fichiers, exécuter des commandes sur les fichiers
![Page 26: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/26.jpg)
26Jean-Christophe Lapayre
Un peu de CUn peu de C
# include <stdio.h>
main ()
{
printf("hello world \n");
}
Compilation avec gcc
gcc –o hello hello.c
gcc rend le fichier hello exécutable
![Page 27: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/27.jpg)
27Jean-Christophe Lapayre
Éditeur KateÉditeur Kate
kate &
cc –o forki.c forki
sourceexécutable
![Page 28: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/28.jpg)
28Jean-Christophe Lapayre
un peu de Cun peu de C
# include <stdio.h> est interpreté par le préprocesseur C.
stdio.h est un fichier définissant certaines macro-instructions et
certaines variables utilisées par la bibliothèque des E/S .
Par convention tous les programmes C possèdent une fonction appelée
main. C'est cette fonction qui sera lancée à l'exécution du programme. Les
parenthèses vides () indiquent que main n'utilise pas de paramètre.
Le texte de main est compris entre 2 accolades { et } ; elles délimitent
la fonction( begin end du Pascal ).
\n correspond au caractère new-line et provoque le passage à la ligne
![Page 29: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/29.jpg)
29Jean-Christophe Lapayre
22. la sortie avec format : printfprintf ( " libellé + format ",arg1,arg2,...)chaque format est introduit par %, les différents formats sont :d: decimalo: octalx: hexadecimalu: decimal non signéc: un seul caractères: une chaîne de caractèrese: de la forme - m.nnnnnn E xx type float ou doublef: de la forme - mmm.nnnnnn type float ou double
g: n'impr. pas les zéros non signifi.type float ou double
un peu de Cun peu de C
1. Les types de donnéeschar caractère int entier float réel simple précision double réel double précision
2. Les entrées-sorties21. l'entrée et la sortie standard : getchar et putchar
getchar() : permet de lire un caractère à la fois depuis le terminal. La fin de fichier ( ^D ou Del sur le terminal )
putchar(x): envoie le caractère x sur le terminal. On peut changer la destination
standard en utilisant la réorientation de UNIX.
![Page 30: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/30.jpg)
30Jean-Christophe Lapayre
un peu de Cun peu de C
23. l'entrée avec format : scanfscanf ( " libellé + format ", arg1, arg2,.....)
format en entrée :
d: entier décimal
o: entier en octal
x: entier en hexa
h: entier de type short
c: un seul caractère
s: une chaine de caractères
f: un nombre en virgule flottante
exemple : float a;
int b;
char baratin [ 10 ] ;
scanf ("%f %d %s",&a,&b,baratin );
![Page 31: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/31.jpg)
31Jean-Christophe Lapayre
Construire la commande WC en langage cConstruire la commande WC en langage c
La commande wc existe (testez la)
Il s'agit de la reprogrammer, vous appellerez cette commande wclin
Vous utiliserez notamment : getchar() : permet de lire un caractère à la fois depuis le terminal If avec expression dans laquelle &&(et), ||(ou) nb++ (permet d’incrémenter un entier nb) '\n' est le caractère de fin de ligne -1 (en fait EOF) correspond à la fin de fichier printf pour afficher les résultats
![Page 32: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/32.jpg)
32Jean-Christophe Lapayre
Construire la commande WC en langage cConstruire la commande WC en langage c
#include <stdio.h>
main()
{
int nbl=0;
int nbm=0;
int nbc=0;
int caract;
int oldcaract;
while ((caract=getchar())!=-1)
{
nbc++;
if (caract=='\n') nbl++;
if (nbc!=1 && ((caract=='\n' && (oldcaract!='\n' && oldcaract!=' '))
|| (caract==' ' && (oldcaract!='\n' && oldcaract!=' '))))
nbm++;
oldcaract=caract;
}
if (oldcaract==-1) --nbm;
printf("nb lignes : %d, nb mots : %d, nb caract : %d\n",nbl,nbm,nbc);
}
![Page 33: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/33.jpg)
33Jean-Christophe Lapayre
Utiliser la commande WC en langage cUtiliser la commande WC en langage c
Créez un fichier de quelques lignes. Appliquez wclin à ce fichier sans modifier le fichier, en utilisant les fonctionnalités de UNIX
Redirections ???
Wclin < fichieressai
![Page 34: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/34.jpg)
34Jean-Christophe Lapayre
Construisez la commande WC en langage c Construisez la commande WC en langage c avec utilisation d’argumentsavec utilisation d’arguments
Un programme c commence toujours par l’appel de la fonction main. Il est possible de passer des paramètres : Main(argc,argv)
int argc;
char *argv[]; argc est le nombre d’éléments du tableau argv argv est un pointeur sur le tableau de chaînes de
caractères des arguments utilisés par main Par exemple :
L’appel « wclin1 fichieressai » de la commande wclin1 donne à argc la valeur 2, argv[0] contient le nom wclin1 et argv[1] contient le nom du fichier fichieressai.
![Page 35: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/35.jpg)
35Jean-Christophe Lapayre
Construisez la commande WC en langage c Construisez la commande WC en langage c avec utilisation d’argumentsavec utilisation d’arguments
Construisez wclin1 (wclin adaptée pour utiliser les arg?? En lisant dans un fichier)
Vous utiliserez :
FILE *fichier; type
fichier=fopen(argv[1],"r"); ouverturefeof(fichier)) fin de fichiercaract = fgetc(fichier) lecture caractère/caractèrefclose(fichier); fermeture
Vous utiliserez cette commande sur un fichier quelconque
« wclin1 fichieressai »
![Page 36: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/36.jpg)
36Jean-Christophe Lapayre
#include <stdio.h>main(argc,argv)char **argv;int argc;{
int nbl=0;int nbm=0;int nbc=0;int caract;int oldcaract;FILE *fichier;
/* ouverture du fichier */printf("%s \n",argv[1]);fichier=fopen(argv[1],"r");while (!feof(fichier)){
caract=fgetc(fichier);
nbc++;if (caract=='\n') nbl++;if (nbc!=1 && ((caract=='\n' && (oldcaract!='\n' && oldcaract!=' '))
|| (caract==' ' && (oldcaract!='\n' && oldcaract!=' '))))nbm++;
oldcaract=caract; }fclose(fichier);if (oldcaract==-1) --nbc;printf("nb lignes : %d, nb mots : %d, nb caract : %d\n",nbl,nbm,nbc);
}
Construisez la commande WC en langage c Construisez la commande WC en langage c avec utilisation d’argumentsavec utilisation d’arguments
![Page 37: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/37.jpg)
37Jean-Christophe Lapayre
Time sharingTime sharing
Lorsque plusieurs processus sont lancés sur un seul processeur, ils se partagent la ressource.
Pour visualiser ce phénomène, réalisez un programme c très simple. Il s’agit de réaliser une boucle de 20 itérations (avec un for) dans laquelle on place une pause de 5 secondes (sleep(5)) et qui affiche un message identifiant le processus avant la pause et un après. Ce programme s’appellera lance, il utilisera la notion d’arguments de commande :
Vous utiliserez « lance proc1 » pour voir les messages de proc1.
Vous lancerez en parallèle un processus proc1 et un proc2 pour voir comment le time-sharing opère.
![Page 38: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/38.jpg)
38Jean-Christophe Lapayre
Time sharingTime sharing
#include <stdio.h>main(argc,argv)char **argv;int argc;{
int i;for (i=0;i<20;i++){
printf("avant sleep %d de %s\n",i+1,argv[1]);
sleep(5);
printf("après sleep %d de %s\n",i+1,argv[1]); }printf("fin de %s\n",argv[1]);
}
![Page 39: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/39.jpg)
39Jean-Christophe Lapayre
Communication entre deux processus liésCommunication entre deux processus liés
Un processus peut créer un fils (une duplication complète de lui-même,avec son segment de pile…) par exemple dans une application multimédia, chacun des fils gère un média différent.
L ’instruction Fork( ) crée un tel fils Les threads sont des processus légers. Ils partagent le
segment de pile et une partie du segment de données avec le père. Mais la mise en place est beaucoup moins aisée, nous ne l ’aborderons pas cette année.
P1
P2
P3
Son
Vidéo
![Page 40: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/40.jpg)
40Jean-Christophe Lapayre
Primitives de gestion des processusPrimitives de gestion des processus
Identification d ’un processus getpid() : n° du processus getppid() : n° du processus père à noter, le père d ’un processus est par défaut le shell
de lancement.
Identification du propriétaire getuid() : n° du propriétaire réel getgid() : n° de groupe réel
Mise en sommeil sleep(n) : n secondes
![Page 41: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/41.jpg)
41Jean-Christophe Lapayre
Primitive fork()Primitive fork()
Cette primitive permet la création dynamique d ’un nouveau processus qui est une copie exacte du processus appelant : il s ’appelle processus fils.
Il hérite de son père : le même code une copie de la zone de données la priorité les propriétaires les descripteurs de fichier …
Dans le programme, on teste la valeur de retour de la fonction fork() pour n ’exécuter que le code correspondant au père ou au fils. valeur 0 on est dans le fils valeur -1 il y a une erreur de création valeur = n 0 on est dans le père, n est le numéro du fils
![Page 42: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/42.jpg)
42Jean-Christophe Lapayre
Exemple de Fork()Exemple de Fork()
#include <stdio.h>#include <stdlib.h>#include <unistd.h>main(){int numfils;int status;
numfils = fork();if (numfils == -1)
{printf("erreur de cration \n");exit(1);
}if (numfils == 0)
{…/* écrire ici le code du programme fils */…exit(numfils); /* permet de renvoyer le num du fils */
}else
{…/* écrire ici le code du programme père */…wait(status); /* le père attend le fils pour fermer */
}}
if (numfils == 0){
…/* écrire ici le code du programme fils */…exit(numfils); /* permet de renvoyer le num du fils */
}
{…/* écrire ici le code du programme père */…wait(&status); /* le père attend le fils pour fermer */
}
![Page 43: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/43.jpg)
43Jean-Christophe Lapayre
Exemple de Fork()Exemple de Fork()#include <stdio.h>#include <stdlib.h>#include <unistd.h>main(){int numfils;int *status;
numfils = fork();Switch (numfils)
{case –1:
printf("erreur de cration \n");exit(1);break;
case 0:…/* écrire ici le code du programme fils */…exit(numfils); /* permet de renvoyer le num du fils */break;
default:…/* écrire ici le code du programme père */…wait(&status); /* le père attend le fils pour fermer */
}}
…/* écrire ici le code du programme fils */…exit(numfils); /* permet de renvoyer le num du fils */break;
…/* écrire ici le code du programme père */…wait(&status); /* le père attend le fils pour fermer */Break;
![Page 44: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/44.jpg)
44Jean-Christophe Lapayre
exit, wait et variable statusexit, wait et variable status
numfils=fork();Switch (numfils)
{case –1:
printf("erreur de création \n");exit(1); break;
case 0:/* écrire ici le code du programme fils */…exit(numfils); /* permet de renvoyer le num du fils */
/* que VOUS donnez */break;
default:…/* écrire ici le code du programme père */…wait(&status); /* le père attend le fils pour fermer *//* affiche le numéro placé dans l'exit*/printf("le fils %d a quitté \n", (int) status/256);
}}
![Page 45: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/45.jpg)
45Jean-Christophe Lapayre
Fork itératifFork itératif
for (i=0 ; i < nbfils ; i++) { val=fork(); if (val==0) { /* un fils */ int n,num; char message[15]; printf("je suis le fils %d de ID %d et de pere %d \n", i,getpid(),getppid());
… blabla … exit(i); } }for (i=0;i<nbfils;i++) { wait(&status); printf("PERE : mon fils %d a fini\n",(int) status/256); }
![Page 46: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/46.jpg)
46Jean-Christophe Lapayre
Communication entre père et filsCommunication entre père et fils
Entre un processus père et un fils, il est possible de communiquer par : Fichier mémoire partage : shared memory par sockets : AF_INET ou AF_UNIX, TCP ou UDP par tubes
les tubes nommés utilisant la primitive open les tubes anonymes utilisant la primitive pipe
Les tubes anonymes ne sont utilisables qu’entre des processus apparentés.
![Page 47: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/47.jpg)
47Jean-Christophe Lapayre
Les tubesLes tubes
Les tubes (pipes) permettent le transfert de données entre des processus selon un schéma premier entré / premier sorti (FIFO)
Leur mise en œuvre permet aux processus de communiquer même s ’ils ne connaissent pas les processus qui sont à l ’autre bout du tube.
Nous ne développerons ici que la mise en place des tubes anonymes.
![Page 48: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/48.jpg)
48Jean-Christophe Lapayre
Communication entre père et fils par tubes anonymesCommunication entre père et fils par tubes anonymes
Un tube est unidirectionnel Pour écrire sur un tube, il faut le fermer en lecture Pour lire dans un tube, il faut le fermer en écriture
Pour un tube donné, un processus sera ou bien écrivain, ou bien lecteur, mais pas les deux en même temps.
C ’est un mode de fonctionnement totalement asynchrone. Les valeurs sont écrites par un processus, la seule garantie est l ’ordre FIFO pour la lecture.
Ecriture lecture
TUBE
![Page 49: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/49.jpg)
49Jean-Christophe Lapayre
Fonctionnement des tubesFonctionnement des tubes
Si les processus doivent échanger des données, il faut deux tubes un père/fils et un fils/père
Processusécrivain
Processuslecture
1
2
3
1
12
123
![Page 50: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/50.jpg)
50Jean-Christophe Lapayre
Exemple de tubesExemple de tubes#include <stdio.h>
#define lire 0#define ecrire 1
main() { int no_fils,n; int *status; char c;
/* declaration des tubes */ int tubepf[2],tubefp[2]; printf("DEBUT : Je suis le processus PERE %d \n",getpid()); printf("DEBUT : No du grand-pere %d \n",getppid());
/* initialisation des pipes */ pipe(tubefp); pipe(tubepf);
if ((no_fils=fork())==-1) { printf("Je suis le PERE impossible de cree le fils \n"); exit (1); }
Tube où le père écrit et le fils lit : du Père vers le Fils
Tube où le fils écrit et le père lit : du Fils vers le Père
![Page 51: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/51.jpg)
51Jean-Christophe Lapayre
if (no_fils !=0) {char message[15]; int n,num; printf(" PERE le no du fils est %d \n",no_fils); printf(" PERE j attends la fin de mon fils\n");
/* le pere envoie au fils son numero */ num = no_fils;
close(tubepf[lire]); /*fermeture en lecture du tube d'ecriture*/ n=write(tubepf[ecrire],&num,sizeof(num));
/* le pere lit "merci" de son fils */ close(tubefp[ecrire]); /*fermeture en ecriture du tube en lecture*/
n=read(tubefp[lire],&message,sizeof(message)); printf(" PERE : j'ai recu %s\n",message);
/* le pere envoie "pas de quoi" au fils */ strcpy(message,"pas de quoi"); n=write(tubepf[ecrire],&message,sizeof(message));
/*fermeture final de PF en ecriture et FP en lecture */ close(tubepf[ecrire]); close(tubefp[lire]);
wait (&status); printf(" PERE : fin du fils avec status %d %d\n",n,(int)status/256); }
Exemple de tubesExemple de tubes
![Page 52: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/52.jpg)
52Jean-Christophe Lapayre
else {int no_proc,pere_proc,num; char message[15]; no_proc=getpid();pere_proc=getppid();
printf("FILS : mon num est %d\n",no_proc); printf("FILS : num de mon pere est %d\n",pere_proc);
/* le fils recoit du pere son numero qui confirme getpid()*/ close(tubepf[ecrire]); n=read(tubepf[lire],&num,sizeof(num)); printf("FILS : j'ai recu %d qui confirme mon numero\n",num);
/* le fils remercie son pere */ close(tubefp[lire]); strcpy(message,"merci"); n=write(tubefp[ecrire],&message,sizeof(message));
/* le fils recoit du pere "pas de quoi" */ n=read(tubepf[lire],&message,sizeof(message)); printf("FILS : j'ai recu %s\n",message);
/*fermeture final de FP en ecriture et PF en lecture */ close(tubepf[lire]); close(tubefp[ecrire]);
printf("FILS : je termine \n"); exit(1); }}
Exemple de tubesExemple de tubes
![Page 53: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/53.jpg)
53Jean-Christophe Lapayre
Les socketsLes sockets
Application cliente
API Socket
UDP TCP
IP
Physique
Application : serveur
API Socket
UDP TCP
IP
Physique
Protocole Applicatif
![Page 54: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/54.jpg)
54Jean-Christophe Lapayre
Sockets : l’abstractionSockets : l’abstraction comme un descripteur de fichier dans le système UNIX, associe un descripteur à un socket; le concepteur d’application utilise ce descripteur pour référencer la
communication client/serveur sous-jacente. une structure de données «socket» est créée à l’ ouverture de
socket;
table de descripteur
de fichiers
Family:
Service:
Local IP:
Remote IP:
Local Port:Remote Port:
Table de descripteursde processus
Structure Socket
La primitive socket permet l’ouverture de cette socket; initialement, après l’appel à cette fonction, la structure de données associée au socket est principalement vide, les appels à d’autres primitives de l’interface socket renseigneront ces champs vides.
![Page 55: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/55.jpg)
55Jean-Christophe Lapayre
Les Sockets : Mode connectéLes Sockets : Mode connecté
SERVEUR
socket
bind
listen
accept
closeclose
CLIENTMODE CONNECTE
En mode connecté il y a établissement (listen,connect, accept) puis libération (close) d’une connexion entre le cleint et le serveur.
socket
connectconnexion
recv
send
send
recv
requête
réponse
![Page 56: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/56.jpg)
56Jean-Christophe Lapayre
Les Sockets : primitivesLes Sockets : primitives
Elles permettent d’établir un lien de communication en mode connecté ou non-connecté sur un réseau,
Structurent une application soit en mode client , soit en mode serveur,
Permettent d’échanger des données entre ces applications. La primitive socket:
point d’encrage qui permet à l’application d’obtenir un lien de communication vers la suite de protocole qui servira d’échange,
définit le mode de communication utilisé (connecté ou non-connecté).
La primitive bind: permet de spécifier le point de terminaison local (essentiellement le port TCP/UDP dans l’environnement TCP/IP).
la primitive connect: permet à un client d’établir une communication active avec un
serveur, le point de terminaison distant (adresse IP + port TCP/UDP dans
l’environnement TCP/IP) est spécifié lors de cet appel.
![Page 57: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/57.jpg)
57Jean-Christophe Lapayre
Les Sockets : primitivesLes Sockets : primitives
la primitive listen : permet à un serveur d’entrer dans un mode d’écoute de communication , dés lors le serveur est « connectable » par un client, le processus est bloqué jusqu’à l’arrivée d’une communication entrante.
la primitive accept : permet à un serveur de recevoir la communication entrante (client), crée un nouveau socket et retourne le descripteur associé à l’application. le serveur utilise ce descripteur pour gérer la communication entrante le serveur utilise le descripteur de socket précédent pour traiter la
prochaine communication à venir. les primitives send et recv:
Lorsque la communication est établie, client et serveur échangent des données afin d’obtenir (client) et transmettre (serveur) le service désiré.
En mode connecté, clients et serveurs utilisent send et recv; en mode non-connecté, ils utilisent les primitives recvfrom et sendto.
la primitive close : termine la connexion et libère le socket associé.
![Page 58: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/58.jpg)
58Jean-Christophe Lapayre
Les Sockets : Mode non connectéLes Sockets : Mode non connecté
SERVEUR
socket
bind
sendtorecvfrom
sendto recvfrom
close
socket
CLIENT
bind
![Page 59: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/59.jpg)
59Jean-Christophe Lapayre
Socket : Mode non connectéSocket : Mode non connecté
En mode non-connecté:
le client n’établit pas de connexion avec le serveur mais émet un datagramme (sendto) vers le serveur.
Le serveur n’accepte pas de connexion, mais attend un datagramme d’un client par recvfrom qui transmet le datagramme à l’application ainsi que l’adresse client.
Les sockets en mode non-connecté peuvent utiliser la primitive connect pour associer un socket à une destination précise ==> send peut alors être utilisée à la place de la sendto,
De même, si l’adresse de l’émetteur d’un datagramme n’intéresse pas un processus la primitive recv peut être utilisée à la place de la primitive recvfrom.
![Page 60: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/60.jpg)
60Jean-Christophe Lapayre
Sockets : gestion de nomsSockets : gestion de noms
Les primitives gethostname et sethostname Dans le monde UNIX, la primitive gethostname permet aux processus
utilisateurs d’accéder au nom de la machine locale. D’autre part, la primitive sethostname permet à des processus
privilégiés de définir le nom de la machine locale. La primitive getpeername
Cette primitive est utilisée afin de connaître le point de terminaison du distant.
Habituellement, un client connaît le point de terminaison (couple port/adresse IP) puisqu’il se connecte à ce serveur distant; cependant, un serveur qui utilise la primitive accept pour obtenir une connexion, a la possibilité d’interroger le socket afin de déterminer l’adresse du distant.
La primitive getsockname Cette primitive rend le nom associé au socket qui est spécifié en
paramètre.
![Page 61: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/61.jpg)
61Jean-Christophe Lapayre
Sockets : gestion de nomsSockets : gestion de noms
Lorsque ces fonctions sont exécutées sur des machines ayant accès à un serveur de noms de domaines, elles fonctionnent elles-mêmes en mode client/serveur en émettant une requête vers le serveur de nom de domaines et attendent la réponse.
Lorsqu’elles sont utilisées sur des machines qui n’ont pas accès à un serveur de noms, elles obtiennent les informations à partir d’une base de données ( simple fichier) locale.
gethostbyname spécifie un nom de domaine et retourne un pointeur vers une structure hostent qui contient les informations propres à ce nom de domaine.
gethostbyaddr permet d’obtenir les mêmes informations à partir de l’adresse spécifiée.
getnetbyname spécifie un nom de réseau et retourne une structure netent renseignant les caractéristiques du réseau.
getnetbyaddr spécifie une adresse réseau et renseigne la structure netent
![Page 62: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/62.jpg)
62Jean-Christophe Lapayre
Sockets exemple : fichier serveurSockets exemple : fichier serveur
/* SERVEUR */#include <string.h>#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <netdb.h>#include <stdio.h>#include <errno.h>/* Utilise pour les codes d'erreurs */extern int errno;
main() { int sock_cont,sock_cli,err; struct sockaddr_in nom_control,/* adresse de la sochet de
controle */nom_transmis; /* adresse de la socket de transmission */
int size_addr_cont, /* taille de l'adresse d'une socket */size_addr_trans;
char myHost[20]; /* Pour memoriser mon nom */ struct hostent myHostEnt; /* hostent de ma machine */ struct hostent *hostEnt; struct hostent *gethostent(); size_addr_cont = sizeof(struct sockaddr_in); size_addr_trans = sizeof(struct sockaddr_in);
![Page 63: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/63.jpg)
63Jean-Christophe Lapayre
Sockets exemple : fichier serveurSockets exemple : fichier serveur
/* Creation de la socket, protocole TCP */ sock_cont = socket(AF_INET, SOCK_STREAM, 0); if (sock_cont < 0)
{ printf("serveur: erreur de socket\n"); exit();}
/* Initialisation de l'adresse de la socket */ err = gethostname(myHost, sizeof(myHost)); if (err < 0)
{ printf("Erreur %d dans gethostname", errno); exit();}
else { printf("Sur le host : %s\n", myHost);}
hostEnt = gethostbyname(myHost); if ((int) hostEnt < 0)
{ printf("Erreur %d in gethostbyname", errno); exit();}
nom_control.sin_family = AF_INET; nom_control.sin_port = 0; bcopy(hostEnt->h_addr, &nom_control.sin_addr, hostEnt->h_length); bzero(nom_control.sin_zero, 8);
![Page 64: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/64.jpg)
64Jean-Christophe Lapayre
Sockets exemple : fichier serveurSockets exemple : fichier serveur
/* Association socket-adresse */ err = bind(sock_cont, &nom_control, size_addr_cont); if (err < 0) {
printf("Erreur %d sur le bind\n", errno); exit();}
/* Recupere l'adresse de la socket */ err = getsockname(sock_cont, &nom_control, &size_addr_cont); if (err < 0) {
printf("Error %d in getsockname", errno); exit();}
printf("Port number : %d\n", nom_control.sin_port); /* Utilisation en socket de controle */ err = listen(sock_cont,1); if (err < 0) {
printf("Erreur %d sur listen\n", errno); exit();}
/* Attente et acceptation de la demande de connexion */ sock_cli = accept(sock_cont, &nom_transmis, &size_addr_trans); if (sock_cli < 0) {
printf("Erreur %d sur accept\n", errno); perror("accept"); exit();}
i=0; printf("client connecte\n")
![Page 65: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/65.jpg)
65Jean-Christophe Lapayre
Sockets exemple : fichier serveurSockets exemple : fichier serveur/* envoi du numero au client : pour la numerotation */ send(sock_cli,&i,sizeof(i),0); printf("Num client envoye\n");
/* attente des accuses-reception */ recv(sock_cli,&num,sizeof(num),0); if (err < 0) {
printf("Erreur %d dans la reception\n", errno); exit();}
printf("j'ai recu l'accuses \n"); /* envoi du message de fin=-1 */ num=-1; send(sock_cli,&num,sizeof(num),0); if (err < 0) {
printf("Erreur %d dans l'envoi\n", errno); exit();}
printf("fin envoye\n"); printf("j'attends les fermetures\n"); /* attente pour que les clients ferment avant */ recv(sock_cli,&num,sizeof(num),0); if (err < 0) {
printf("Erreur %d dans la reception\n", errno); exit();}
/*on peut fermer le serveur */ printf("OK tout est recu\n"); sleep(3); printf("Fin\n"); /* arret de la connexion */ shutdown(sock_cli, 2); /* Fermeture de la socket client */ close(sock_cont); /* fermeture de la socket de controle */}
![Page 66: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/66.jpg)
66Jean-Christophe Lapayre
Sockets exemple : fichier clientSockets exemple : fichier client
/* CLIENT */
#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <stdio.h>#include <errno.h>#include <netdb.h>#include <string.h>
#define OK 1#define QUIT -1
/* Utilise pour les codes d'erreurs */extern int errno;
/* Chaine envoyee au serveur-recepteur */#define chaine "Hello world !"
main(argc,argv)char **argv;int argc;{ int sock, /* descipteur de la socket locale */ err,num; /* code d'erreur */ struct sockaddr_in nom; /* adresse de la sochet */ int size_addr_in = sizeof(struct sockaddr_in);
int port;
![Page 67: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/67.jpg)
67Jean-Christophe Lapayre
Sockets exemple : fichier clientSockets exemple : fichier client
char remHost[20], /* nom de la machine distante */ reponse[2]; /* test d'envoi de message */ struct hostent remHostEnt; struct hostent *hostEnt; struct hostent *gethostbyname();
/* Creation de la socket, protocole TCP */ sock = socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { printf("Erreur %d a la creation de socket\n", errno); exit(); } /* Initialisation de l'adresse de la socket */ nom.sin_family = AF_INET;
/* Recherche de l'adresse de la machine */ hostEnt = gethostbyname(argv[1]); if ((int) hostEnt < 0) { printf("Error %d in gethostbyname", errno); exit(); } bcopy(hostEnt->h_addr, &nom.sin_addr, hostEnt->h_length);
![Page 68: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/68.jpg)
68Jean-Christophe Lapayre
Sockets exemple : fichier clientSockets exemple : fichier client
/* Recherche du numero de port du serveur */ nom.sin_port = atoi(argv[2]); bzero(nom.sin_zero, 8);
/* Connection au serveur */ err = connect(sock, &nom, size_addr_in); if (err < 0) { printf("Erreur %d a la connection de socket\n",
errno); exit(); }/* Reception et affichage du numero du client */ err = recv( sock, &num, sizeof(num),0); if (err < 0) { printf("Erreur %d dans la reception\n", errno); exit(); } printf("je suis le %d connecte\n",num); /* envoi de l'accuse-reception */ num = OK; err = send( sock, &num, sizeof(num), 0); if (err < 0) { printf("Erreur %d dans l'envoi\n", errno); exit(); }
![Page 69: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/69.jpg)
69Jean-Christophe Lapayre
printf("ack envoye\n");
/* reception du -1 de QUIT */ err = recv( sock, &num, sizeof(num),0); if (err < 0) { printf("Erreur %d dans la reception\n", errno); exit(); } printf("quit recu\n");
/* envoi de la confirmation de quit */ num = QUIT; err = send( sock, &num, sizeof(num), 0); if (err < 0) { printf("Erreur %d dans l'envoi\n", errno); exit(); } printf("quit confirme\n");
printf("Fin\n"); /* Fermeture de la connexion */ shutdown( sock, 2); /* Fermeture de la socket */ close(sock);}
Sockets exemple : fichier clientSockets exemple : fichier client
![Page 70: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/70.jpg)
70Jean-Christophe Lapayre
Serveur itératifServeur itératif
Dans un système avec un serveur et n clients, plusieurs solutions sont possibles : Le nombre de clients est fixe Le système peut fonctionner dès le premier client
L'attente des clients dans la première solution est bloquante, dans le deuxième cas l'attente est dite passive.
![Page 71: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/71.jpg)
71Jean-Christophe Lapayre
Mode connecté : multiclientMode connecté : multiclient
SERVEURSERVEUR
Sockcont=socket(…
bind
Listen(sockcont,4)
Num=0
Cli[Num]=accept(…
send
Num++
socket
connect
recv
Recv
de so
n pr
opre
num
socket
connect
recv
Recv de son propre num
socket
connect
recv
Recv de s
on propre num
Recv de son propre num
socket
connect
recv
![Page 72: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/72.jpg)
72Jean-Christophe Lapayre
L'attente passive : selectL'attente passive : select
Dans l'exemple précédent il faut attendre les quatre connections pour quitter la boucle.
La fonction select(…) permet l'attente passive sur différents "descripteurs" : écriture clavier, demande de connexion, réception de message. Les listes de descripteurs sont de type fd_set comme par exemple
fd_set lire, ecrire;
FD_ZERO mise à zéro d'une liste de descripteurs FD_ZERO(&lire); FD_ZERO(&ecrire);
FD_SET définition d'une liste de descripteurs FD_SET(0,&lire); /* attente clavier */ FD_SET(sock_cont,&lire); /* attente sur */ FD_SET(sock_cont,&ecrire); /*sock_cont pour connexion*/ for (i=0;i<nbcli;i++){
FD_SET(sock_cli[i],&lire);
} /* attente de message du client i */
![Page 73: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/73.jpg)
73Jean-Christophe Lapayre
Mise en attente passive :
n = select(32, &lire, &ecrire, NULL, NULL);
Déclenchement des descripteurs if (FD_ISSET(0,&lire))
{… /* déclenchement clavier */ /* connection d'un nouveau */ if ((FD_ISSET(sock_cont,&lire)) || (FD_ISSET(sock_cont,&ecrire)))
{
sock_cli[nbcli]=accept(sock_cont,&nom_transmis,&taille); err = send( sock_cli[nbcli],&nbcli, sizeof(nbcli), 0);
nbcli ++;
} /* demandes de connection */ for (i=0;i<nbcli;i++) /* réception d'un message */
{
if (FD_ISSET(sock_cli[i],&lire))
{
err = recv(sock_cli[i], buffer, TAIL_BUF, 0);
printf("%s de %d \n",buffer,i);
}
}
L'attente passive : selectL'attente passive : select
![Page 74: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/74.jpg)
74Jean-Christophe Lapayre
L'attente passive : selectL'attente passive : select
…err = listen(sock_cont, 5); if (err < 0) { printf("serveur: Erreur %d sur listen\n", errno); exit(); } nbcli=0; /* debut du select */ for (;;) {
FD_ZERO(&lire);FD_ZERO(&ecrire);FD_SET(0,&lire);FD_SET(sock_cont,&lire);FD_SET(sock_cont,&ecrire);for (i=0;i<nbcli;i++)
FD_SET(sock_cli[i],&lire);n = select(32, &lire, &ecrire, NULL, NULL);
if (FD_ISSET(0,&lire)) { printf("saisie clavier\n"); scanf("%s", buffer); if (strcmp("quit",buffer)==0) {
/* diffusion du message "quit" aux clients */for (i=0;i<nbcli;i++) err = send( sock_cli[i], buffer, (strlen(buffer) + 1), 0);/* attente des fermetures */printf("j'attends les fermetures\n");
![Page 75: Jean-Christophe Lapayre 1 Unix pour l'utilisateur Les commandes fondamentales](https://reader035.vdocuments.net/reader035/viewer/2022081602/551d9da4497959293b8d5120/html5/thumbnails/75.jpg)
75Jean-Christophe Lapayre
L'attente passive : selectL'attente passive : select
for (i=0;i<nbcli;i++) err = recv( sock_cli[i], buffer, (strlen(buffer) + 1), 0);sleep(3);printf("Fin\n"); /* arret de la connexion */for (i=0;i<nbcli;i++) shutdown(sock_cli[i], 2); /* Fermeture de la socket */close(sock_cont);exit(0);
} else {
/* diffusion du message aux clients */for (i=0;i<nbcli;i++) err = send( sock_cli[i], buffer, (strlen(buffer) + 1), 0);
} }/* connection d'un nouveau */if ((FD_ISSET(sock_cont,&lire)) || (FD_ISSET(sock_cont,&ecrire))) { sock_cli[nbcli]=accept(sock_cont,&nom_transmis,&taille); err = send( sock_cli[nbcli],&nbcli, sizeof(nbcli), 0); nbcli ++; }for (i=0;i<nbcli;i++) { if (FD_ISSET(sock_cli[i],&lire)) {
err = recv(sock_cli[i], buffer, TAIL_BUF, 0);printf("%s de %d \n",buffer,i);
} }
}}