Programmation multitâche sous unix -...

02/11/06Programmation multitâche sous Unix Isaip-Esaip 1

Groupe Isaip-EsaipP. Trégouët – A. Schaal

remerciements à M. Benzaïd pour sa contribution à la rédaction de ce document

Programmation multitâche Programmation multitâche sous unixsous unix


PLAN

Processus

Signaux

Tubes entre processus de filiation commune

Tubes nommés entre processus de filiation différente

File de messages

Segments de mémoire partagée

Sémaphores

Sockets


Livre de référenceLivre de référence

Programmationsystème en C

sous Linux

Auteur : Christophe BlaessÉdition EYROLLES


ProcessusProcessusUn processus est un programme en cours d’exécutionUn système multi-utilisateurs peut exécuter le même programme sous plusieurs processus, pour plusieurs utilisateursL'espace mémoire alloué à un processus est constitué :

du Code du programme en cours d’exécution (segment code ou segment text)des Données manipulées par le programme (segment data)du Descripteur du processus (informations relatives au processus, pile d’exécution,…)

pid_t getpid(void)pid_t getppid(void)uid_t getuid(void)uid_t getuid(void)

pid_t PID : numéro de processus,pid_t PPID: numéro de processus parent,uid_t UID : numéro de l’utilisateur réel,uid_t EUID:numéro de l’utilisateur effectif, etc.

PrimitivesTypes d’informations : <unistd.h>


Manipulation des processus (1)Manipulation des processus (1)Création ou duplication de processus

pid_t fork(void) La valeur retournée est le pid du fils pour le processus père, ou 0 pour le processus fils. La valeur -1 est retournée en cas d'erreur.Le fils hérite de presque tous les attributs du parent : segment code (partagé, copié), segment data (copié), PID/PPID (modifiées), signaux interceptés (conservés), descripteur de fichiers/tubes ouverts (copiés), pointeurs de fichiers (partagés)

Terminaison de processusvoid exit (int code_retour)

Attente de terminaison de processus enfantpid_t wait (int * code _retour), pid_t waitpid (pid_t pid_enfant, int * code_retour, int options)


Manipulation des processus (2)Manipulation des processus (2)Sommeil de processus

Unsigned int sleep (unsigned int nb_secondes)Un signal reçu interrompt le sommeil du processus. Le programme continue alors son exécution après l'appel de sleep(). La valeur retournée par sleep() est le nombre de secondes restantes

Recouvrement de processus = changement du programme exécuté par un processus (exec)

modification de l’image (le segment de code) du processus courantToutes les variables de l’ancien programme sont perduesIl n’est pas possible de revenir d’un exec. Les instructions qui suivent exec ne seront exécutés que si exec échouePassage de valeurs : par les variables d’environnement ou les paramètres du nouveau programmePrimitives correspondantes: exec{l|v}[e|p] man 3 exec l : liste d’arguments : fournir la liste (char *arg0, char *arg1, …, 0) v : tableau d’arguments : fournir un pointeur sur le tableau (char ** argv avec

denier élément = ‘0’) Etc.


Deux processus peuvent éventuellement partager le même code (ceci est sous le contrôle du système) mais les espaces mémoires réservés aux variables sont complètement étanches : un processus n'a aucun accès aux variables d’un autre processus

On peut néanmoins créer une application multitâche et avoir besoin de synchroniser ces tâches ou d’échanger des informations entre ces tâches. Les systèmes d’exploitations sont donc munis de mécanismes appropriés

Synchronisation par signaux ou sémaphoresCommunication de données par fichiers, tubes (pipes) files de messages (queues ou boîtes à lettres) variables implantées dans un segment de mémoire partagée

Besoins de communication Besoins de communication entre processusentre processus


Communications Communications locales ou distanteslocales ou distantes

ProcessusUtilisateur


Noyau du S.E

Hôte

Communication intra-système



Noyau S.E

Hôte 2

Noyau S.E

Hôte 1

Communication inter-systèmes

Réseau


La communication par signaux (1)La communication par signaux (1)

Un signal peut être assimilé à une interruption logicielle (par analogie avec les interruptions matérielles)

Comme pour une interruption matérielle, la réception d'un signal interrompt le traitement en cours et exécute automatiquement la fonction associée au signal (programmation événementielle).

En langage C, l'association entre le numéro du signal et la fonction est réalisé par un appel à la fonction système signal().

Note : la fonction sigaction() peut être utilisée à la place de signal(). Voir man sigaction.


La communication par signaux (2)La communication par signaux (2)Un signal est

Envoyé par un processusReçu par un autre processus (éventuellement le même)Véhiculé par le noyau

Comment réagit un processus qui reçoit un signal ?Il interrompt le traitement en coursil exécute la fonction de traitement du signalil reprend l'exécution du traitement interrompu

Si le processus était endormi, il est réveillé par le signal. Après l'exécution de la fonction associée au signal, dans le cas où il est réveillé avant la fin d'une temporisation il ne se rendort pas; par contre s'il attendait la fin d'une entrée-sortie, il continue à attendre.

Comportement associée à la réception d'un signal :En général un comportement par défaut est défini : Terminaison anormale du processus (ex: violation de mémoire, division par zéro)Le processus peut ignorer le signalLe processus peut redéfinir, par une fonction spécifique, son comportement à la réception d'un signal


Origine des signauxOrigine des signaux

Frappe de caractères

Erreurs du programme Violation de mémoire, SIGSEGV Division par zéro, SIGFPE

Commande killPrimitive système : kill(), alarm().

SIGINTSIGQUITSIGSTP

CTRL-CCTRL-\CTRL-Z

signaltouche


Liste des signauxListe des signaux

demo@forum:~> kill -l

1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR213) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO30) SIGPWR 31) SIGSYS 33) SIGRTMIN 34) SIGRTMIN+135) SIGRTMIN+2 36) SIGRTMIN+3 37) SIGRTMIN+4 38) SIGRTMIN+539) SIGRTMIN+6 40) SIGRTMIN+7 41) SIGRTMIN+8 42) SIGRTMIN+943) SIGRTMIN+10 44) SIGRTMIN+11 45) SIGRTMIN+12 46) SIGRTMIN+1347) SIGRTMIN+14 48) SIGRTMIN+15 49) SIGRTMAX-15 50) SIGRTMAX-1451) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-1055) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-659) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-263) SIGRTMAX-1 64) SIGRTMAX


Signaux les plus fréquemment utilisésSignaux les plus fréquemment utilisés

1 SIGHUP terminaison du processus leader 2 SIGINT frappe d’interruption (CTRL-C) 3 SIGQUIT frappe de quit (CTRL-\) 4 SIGILL instruction illégale 6 SIGABRT problème matériel 7 SIGBUS erreur sur le BUS 8 SIGFPE erreur arithmétique 9 SIGKILL signal de terminaison

la réaction à ce signal ne peut être redéfinie10 SIGUSR1 signal utilisateur11 SIGSEGV violation écriture mémoire12 SIGUSR2 signal utilisateur13 SIGPIPE écriture sur un tube non ouvert en lecture14 SIGALRM fin de temporisateur15 SIGTERM terminaison normale d’un processus17 SIGCHLD terminaison (arrêt) d’un fils18 SIGCONT continuation d’un processus arrêté par SIGSTOP19 SIGSTOP signal de suspension d’exécution de processus 20 SIGTSTP frappe du caractère de suspension sur le clavier (CTRL-Z)


Envoi de signaux en langage CEnvoi de signaux en langage C

#include <signal.h>int kill(pid_t pid,int sig)

pid : > 0 : pid de processus destinatairesig : le signal à envoyer

Envoie un signal à un processus

#include <unistd.h>unsigned alarm (unsigned nb)Envoie un signal SIGALRM au processus en cours dans nb secondes.

Attention : ne pas mélanger l'utilisation de alarm et de sleep qui partagent le même "timer" (voir man alarm)


Préparer la réception des signaux en langage CPréparer la réception des signaux en langage C

#include <signal.h> void (*signal(int signum, void (*handler)(int)))(int); signum : le signal à intercepterhandler : pointeur sur une fonction qui gère le signal

c'est simplement en C l'identificateur de cette fonctionou constante correspondant à un comportement prédéfini:

SIG_DFL : comportement par défaut SIG_IGN : ignorer le signal

#include<unistd.h>int pause(void); Endort le processus appelant jusqu'à ce qu'il reçoive un signal.

on peut aussi utiliser sleep() si on veut limiter l’attente


Communication par signaux : exempleCommunication par signaux : exemple#include<signal.h>void standard(int numero){ printf("standard Signal %d recu : \n",numero); }void message(int numero){ printf("message Signal %d recu\n",numero); }main(){int numero; // traitements spécifiques for (numero=1;numero<32;numero++)signal(numero,standard); signal(SIGINT,message); signal(SIGQUIT,message); //traitements prédéfinis signal(1,SIG_DFL); signal(4,SIG_IGN); // Rien à faire, sauf réagir aux signaux: attente passive while (1) pause();}


Un tube est traité comme un fichier ouvertIl est transmis aux processus enfants de la même manière que les fichiers ouvertsUn tube est cependant un fichier particulier :

Il n’a pas de nom dans l’arborescence des fichiers Il est connu par deux descripteurs (lecture, écriture)

On lit/écrit dans un tube comme on lit/écrit dans un fichier séquentiel

Utilisation des fonctions read et write (éventuellement fscanf, fprintf etc…)Les données ne sont pas structurées: le pipe ne contient qu’une suite d’octets

Un tube est comme un "tuyau" avec une entrée et une sortie :Plusieurs processus peuvent y écrire des donnéesPlusieurs processus peuvent y lire des données

Tubes : principe (1)Tubes : principe (1)


Le fonctionnement est de type FIFO : On lit toujours les octets dans l'ordre où ils ont été déposés dans le tubeIl n’est pas possible de lire un octet sans voir lu tous ceux qui le précèdentUne donnée lue par un processus ne pourra jamais être relue par un autre processus

Les droits d’accès sont du même genre que les droits d’accès Unix sur les fichiers (rwx, rwx, rwx)Si un tube est vide, ou si tous les descripteurs susceptibles d’y écrire sont fermés, la primitive read() renvoie la valeur 0 (fin de fichier atteinte).Un processus qui écrit dans un tube qui n’a plus de lecteurs (tous les descripteurs susceptibles de lire sont fermés) reçoit le signal SIGPIPE

Tubes : principe (2)Tubes : principe (2)


TUBES : primitives utilesTUBES : primitives utiles

Création : #include <unistd.h> int pipe(int p_desc[2])

p_desc[0] pour la lecture, p_desc[1] pour l’écriture

Entrées/Sorties :write (p_desc[1], buf_ecrire, nbre_octets)read (p_desc[0], buf_lire, nbre_octets)FILE * fdopen():fprintf(), fscanf(),etc...fflush : écrire la zone tampon dans le tube avant qu’elle ne soit remplie

Pour éviter l’interblocage fermer le côté de tube non utilisé, par la primitive close()


TUBES : exempleTUBES : exemple

#include <signal.h>main(){int i, ret, p_desc[2];char c;pipe(p_desc); write(p_desc[1],"AB",2); close(p_desc[1]); for (i=1; i<=4; i++) {

ret = read(p_desc[0],&c,1) ;if (ret == 1) printf("valeur lue: %c\n",c) ;else perror("impossible de lire dans le tube\n") ;}

} Résultat de l’exécution :valeur lue : Avaleur lue: Bimpossible de lire dans le tube : Successimpossible de lire dans le tube: Illegal seek


TUBES NommésTUBES NommésLes tubes ordinaires, sont non visibles dans l’arborescence desfichiers, et accessibles uniquement aux processus d’une mêmeaffiliation

Tubes nommés : visibles dans l’arborescence de fichiers, utilisables entre processus ne partageant pas la même filiationPar contre, aucune information n’est enregistrée sur disque, le transfert d’information s’effectue toujours en mémoire.Primitives correspondantes :

int mknod(const char *nom_fich,mode_t mode, dev_t dev)int mkfifo (const char *pathname, mode_t mode);

Ouverture de tube par les processus connaissant le nom du tube :En lecture/écriture par open()Par défaut, ouverture bloquante : lecteurs et écrivains s’attendent synchronisation


IPC = Inter Process CommunicationTrois types d’objets IPC :

files de message, segments de mémoire partagée sémaphores

En général ces objets sont créés par un processus et utilisés par d’autres, sans qu’il y ait de liens de parenté entre ces processus.A chaque objet IPC sera associée une clé d’identification de 8 chiffres hexadécimaux

Cette identification externe, définie au moment où on écrit le programme est analogue à un nom de fichier : on crée ou on cherche un sémaphore d’une valeur de clé donnée comme on ouvre un fichier de nom donnéCependant, on ne peut prévoir si un autre programmeur n’a pas par hasard utilisé la même clé pour un autre objet IPC dans une autre application multitâche. On pourra donc utiliser une fonction spéciale, ftok(), pour créer une clé unique à partir d’un nom de fichier existant dans le système de fichiers et d’un numéro de projet (ceci n'est donc définit qu’au moment de l’exécution, sur une machine donnée).

# include <sys/ipc.h>key_t ftok(const char *pathname,int proj_id);

Nommage des objets IPCNommage des objets IPC


Drapeaux :IPC_CREAT : créer un objet s'il n’existe pasIPC_EXCL : échouer si l'objet existe déjàIPC_NOWAIT : ne pas attendreIPC_PRIVATE : clé privée, pas de lien avec le système de fichiers

Commandes :IPC_RMID : suppressionIPC_SET : mise à jour des attributsIPC_STAT : lecture des attributs

Permissions : Analogues à celles du système de fichiers UNIX

Constantes communes relatives Constantes communes relatives aux primitives IPCaux primitives IPC


ipcs : liste des objets ipc existantsipcrm : suppression d’un objet ipc

mail:/home/demo # ipcs------ Shared Memory Segments --------key shmid owner perms bytes nattch statu 0x00000001 720896 root 600 33554432 6 dest 0x00000012 753665 root 600 262144 1 dest 0x00000034 819202 root 600 33554432 11 dest

------ Semaphore Arrays --------key semid owner perms nsems0x00000005 98304 wwwrun 600 10x00000006 131073 wwwrun 600 1

------ Message Queues --------key msqid owner perms used-bytes messages0x00001f58 0 root 600 0 0

Commandes de manipulation des objets IPCCommandes de manipulation des objets IPC


Contrairement aux tubes une file de message contient des données structurées composées

D’un type de messageD’un message de longueur variable

A la différence des pipes, il sera possible d’attendre uniquement des messages d’un type donné: s’il n’y a que des messages d’un autre type, le processus sera bloqué (attente passive)Comme les pipes, les files de message sont gérées selon un algorithme FIFO : on lit toujours le message du type cherché qui a séjourné le plus longtemps dans la fileL’attente est par défaut bloquante, mais, comme pour les pipes, et si cela est nécessaire, le processus peut ne pas attendre en positionnant le drapeau IPC_NOWAIT. Il recevra un code d’erreur lui indiquant s'il a ou non obtenu un message.Comme les pipes, les files de messages ont des droits d’accès de type Unix (rwx,rwx,rwx)

Files de messages : principeFiles de messages : principe


Files de messages : primitivesFiles de messages : primitives

Création : int msgget(key_t key, int flg) : retour = msq_id

Emission : (bloquante si file pleine et flg ne contient pas IPC_NOWAIT) int msgsnd(int msqid,struct msgbuf *msgp,int msgsz,int flg);

Avec struct msgbuf {long msgtyp; char * msgtext;}Réception : (bloquante si file vide et flg ne contient pas IPC_NOWAIT)

int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msgtyp = 0 : premier message lumsgtyp > 0 : premier message de type msgtypmsgtyp < 0 : premier message avec un type ≤ |msgtyp|

Opérations de contrôle :int msgctl(int f_id, int cmde, struct msqid_ds *structure)

cmde = IPC_RMID, IPC_STAT, IPC_SETmsqid_ds : structure définie dans <sys/msg.h> qui donne des informations sur la file comme les droits d’accès, le dernier processus écrivain,etc.


Création d'une File de messages : exempleCréation d'une File de messages : exemple

#include <errno.h>#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>#define ID 123main(){int msqid ;

char *path = "nom_de_fichier_existant";

if (( msqid = msgget(ftok(path,ID),IPC_CREAT|IPC_EXCL|MSG_R|MSG_W))== -1)

{perror("Echec de msgget");exit(1);}

printf("identificateur de la file: %d\n",msqid);

printf("cette file est identifiée par la clé unique : %ld\n", ftok(path,ID)) ;}

Résultat de l’exécution :identificateur de la file: 700cette file est identifiée par la clé

unique : 2064941749


Un segment de mémoire partagé est un espace de mémoire dans lequel un processus pourra "allouer" des variables accessibles par des pointeurs.

Un processus crée un segment de mémoire partagée ou demande à utiliser un segment déjà créé. (shmget)

Un processus (le même ou un autre) demande au système d’initialiser un pointeur sur cet espace (shmat)

•Ce pointeur contiendra en fait une adresse de mémoire virtuelle différente pour chaque processus - •qui sera traduite au moment de l’exécution en adresse physique identique pour tous les processus utilisant cette mémoire partagée. L'adresse physique est inaccessible au programmeur.

L’accès à des variables définies dans un segment de mémoire partagée nécessite en général une synchronisation rigoureuse entre les processus: cette synchronisation sera réalisée le plus souvent par des sémaphores

Aux segments de mémoire partagée sont associés des droits d'accès de type Unix

Mémoire partagéeMémoire partagée


Mémoires partagées: primitivesMémoires partagées: primitives

Création :int shmget(key_t key, int size, int flg) : retour = shm_idAttachement :int shmat(int shmid, const void *shmadr, int flg);

adr = 0 choix de l’adresse par le système d’exploitationUne même région peut être attachée plusieurs fois à des adresses différentesRetour : adresse d’attachement effective ou -1

Détachement :int shmdt(const void *shmadr) : retour = 0 ou -1

Libération de l’espace mémoire uniquement lors du dernier détachementOpérations de contrôle :

int shmctl(int shm_id,int cmde,struct shmid_ds *structure)cmde = IPC_RMID, IPC_STAT, IPC_SET, SHM_(UN)LOCK (verrouillage en mémoire = pas de swap autorisé)


Mémoires partagées : exempleMémoires partagées : exemple#include <sys/types.h>#include <sys/ipc.h>#include <sys/shm.h>#include <sys/wait.h>#include <stdio.h>#include <string.h>void main(){ int pid,shmid ; char *mem ; int flag = 0 ; key_t clef ; printf("donnez la clé:");scanf("%ld",&clef);shmid = shmget(clef,100,IPC_CREAT|IPC_EXCL|SHM_R|SHM_W);printf("Identificateur du segment est %d \n",shmid);

pid =fork() ;if(pid == 0){/*processus fils*/ mem = shmat(shmid,0,flag); strcpy(mem,"Message pour le pere"); shmdt(mem);}else {/*processus père*/mem = shmat(shmid,0,flag) ;printf("message reçu de fils :

%s\n",mem);shmdt(mem);}wait(0) ;shmctl(shmid,IPC_RMID,NULL) }


D'une manière générale, un sémaphore sert à la synchronisation entre les processusUn sémaphore utilisé pour l’exclusion mutuelle (garantir qu’un seul processus accède à un moment donné à une variable partagée), utilisera 2 primitives

Attendre l’accès exclusif à la ressource partagée : si la ressource est déjà utilisée par un processus, le processus qui fait cette demande sera endormi et mis dans une file d’attente de processusLibérer l’accès exclusif à la ressource partagée : si la file d’attente des processus attendant cette ressource est non vide, le processus qui a dormi le plus longtemps est réveillé

La section de programme qui se trouve entre les 2 primitives attendre la ressource et libérer la ressource s’appelle une section critiqueLes sémaphores n’empêchent pas les processus d’accéder à une ressource: un processus « qui ne respecterait pas la discipline» et accéderait à la ressources sans attendre son tour pourrait le faire sans aucune restrictionAux sémaphores sont associés des droits d’accès de type Unix

Pourquoi utiliser un Pourquoi utiliser un sémaphore ?sémaphore ?


Le "mécanisme" des sémaphoresLe "mécanisme" des sémaphores

Sémaphore = objet composé :une variable (la valeur du sémaphore)une file d’attente (les processus bloqués attendant la ressource)

Primitives associées :Initialisation (avec une valeur positive ou nulle)Manipulation : Prendre (P ou Wait) = demande d’autorisation Vendre (V ou Signal) = fin d’utilisation

Principe : sémaphore associé à une ressourcePrendre = demande d’autorisation (puis-je utiliser la ressource?)

Si valeur > = 0 accord, sinon blocageVendre = restitution d’autorisation (je n'ai plus besoin de la ressource)

Si valeur < 0 déblocage d’un processus


Sémaphores : exempleSémaphores : exempleParking de N places contrôlé par un feu


Sémaphores : algorithmes des primitives P et VSémaphores : algorithmes des primitives P et V

Initialisation(sémaphore,n)valeur[sémaphore] = n

P(sémaphore)valeur[sémaphore] = valeur[sémaphore] - 1si (valeur[sémaphore] < 0) alors

étatProcessus = Bloquémettre processus en file d’attente

finSiinvoquer l’ordonnanceurV(sémaphore)valeur[sémaphore] = valeur[sémaphore] + 1si (valeur[sémaphore] == 0) alors

extraire processus de file d’attenteétatProcessus = Prêt

finSiinvoquer l’ordonnanceur


UNIX IPC : tableau de sémaphores (1) UNIX IPC : tableau de sémaphores (1) Création ou attachement :int semget(key_t clé,int nsems,int semflg) : retour = semid

Opérations sur le compteur de sémaphore :int semop (int semid, struct sembuf *spos, int nsops)

Avec struct sembuf { u_short sem_num;short sem_op;short sem_flg; }sem_op > 0 : La valeur du sémaphore est augmentée de sem_op. "sem_op ressources sont rendues disponibles". Un ou plusieurs processus bloqués pourront être libérés s'il y a suffisamment de ressources. Analogue à V, le processus appelant n'est jamais bloqué.sem_op = 0 : Teste si le sémaphore a la valeur 0. Si ce n'est pas le cas, le processus est mis en attente de la mise à zéro du sémaphore."exemple : un écrivain attend que tous les lecteurs aient fini de lire"sem_op < 0 : La valeur du sémaphore est diminuée de |sem_op|."le processus demande sem_op ressources". Si le résultat est nul, tous les processus en attente de cet événement sont réveillés. Si le résultat est négatif, le processus est bloqué "en attendant de disposer de suffisamment de ressources".


Sémaphores IPC (2)Sémaphores IPC (2)

Opérations de base : exlusion mutuelleP(s) : semop(sem_num, -1, 0)V(s) : semop(sem_num, +1, 0)

Opérations de contrôle : int semctl(int semid,int semnum,int cmd,

union semun arg)IPC_RMID, IPC_STAT, IPC_SET,Commandes spécifiques aux sémaphore : GETVAL : retourne la valeur d’un sémaphore, GETPID : retourne le PID du processus effectuant dernière opération,

etc.


SocketsSocketsLes "sockets", ("prise" ou "connecteur" en anglais), fournissent une interface de programmation qui permet de définir facilement un canal de communication entre 2 processus locaux ou distants

Chaque extrémité d’un canal de communication, est définie par un numéro de port

Un descripteur de socket est analogue à un descripteur de fichier Mêmes primitives read et write que pour les fichiers

Communication bidirectionnelle (contrairement aux pipes)

N°PORT 2

N°PORT 1

Adresse IP 1 Adresse IP 2

Format réseau

Format machine 1 Format machine 2

processus CLIENT

processus SERVEUR

Socket Socket


Communication en mode connecté (TCP)Communication en mode connecté (TCP)

CLIENT SERVEUR

socket() socket()

connect()

bind()

listen()

accept()

write()/Send()

read()/Recv()

read()/Recv()

write()/Send()

close() close()

Transfert de données

Attente nouvelle

connexion


Communication en mode non connecté (UDP)Communication en mode non connecté (UDP)

CLIENT SERVEUR

socket() socket()

bind()

Sendto() Recvfrom()

Recvfrom() Sendto()

close() close()

Transfert de données

Programmation multitâche sous unix -...

Documents

Transcript of Programmation multitâche sous unix -...