1 / 92

SYSTÈME D’EXPLOITATION I

SYSTÈME D’EXPLOITATION I. SIF-1015. Contenu du cours 7. Communication par socket Concepts et opérations de base Communication réseau par socket Autre implantation Concepts et opérations de base IPC par socket Communication réseau par socket LECTURES: Chapitre 3 (OSC)

cheung
Télécharger la présentation

SYSTÈME D’EXPLOITATION I

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. SYSTÈME D’EXPLOITATION I SIF-1015

  2. Contenu du cours 7 • Communication par socket • Concepts et opérations de base • Communication réseau par socket • Autre implantation • Concepts et opérations de base • IPC par socket • Communication réseau par socket • LECTURES: • Chapitre 3 (OSC) • Chapitre 14 (Mitchell) • Chapitres 5 et 8 (Beck) • Chapitre 16 (Johnson) • http://csapp.cs.cmu.edu/

  3. Concepts et opérations de base • Les IPC étudiés jusqu’à maintenant (tube anonyme, tube nommé, messages, mémoire partagée) supportent seulement la communication entre processus sur un même ordinateur • Les sockets offrent pour leur part une interface de program-mation permettant de communiquer par réseau et aussi localement sur un ordinateur • Cette interface offre l’avantage de programmer des applications réseaux en utilisant le concept de descripteur de fichier UNIX • Les échanges par sockets sont alors effectués par des opérations standards d’I/O (read(), write()) en utilisant les descripteurs de socket appropriés

  4. Concepts et opérations de base • Communication réseau • Un ordinateur branché à un réseau peut communiquer avec un autre ordinateur en créant par exemple un paquet (données et informations protocolaires) et en l’acheminant vers le routeur le plus proche, qui lui achemine le paquet vers le prochain routeur jusqu’à l’ordinateur de destination • L’échange d’informations entre ordinateurs est régit par des protocoles • Les principaux protocoles: • IP (Internet Protocol) : supporte un mode d’identification de base et le transfert non fiable de paquets de données (datagrams) d’un hôte à un autre • UDP (Unreliable Datagram Protocol): Protocole orienté-paquet ne supportant pas le séquençage des paquets et le contrôle d’erreurs • TCP de TCP/IP: Protocole à flot de données (streaming) qui supporte le séquençage et le contrôle des erreurs

  5. Concepts et opérations de base • Les applications réseaux sont basées sur le modèle client-serveur: • Un processus serveur et un ou plusieurs processus client • Le serveur gère des ressources • Le serveur offre des services en manipulant des ressources pour les clients 1. client sends request client process server process resource 4. client handles response 2. server handles request 3. server sends response Note: clients et serveurs sont des processus s’exécutant sur un ou plusieurs hôtes

  6. Concepts et opérations de base:Organisation matérielle d’un hôte en réseau register file CPU chip ALU system bus memory bus main memory MI I/O bridge Expansion slots I/O bus USB controller network adapter graphics adapter disk controller mouse keyboard monitor disk network

  7. Concepts et opérations de base: Réseaux d’ordinateurs • Un réseau est un ensemble hiérarchique de machines interreliées et organisées en fonction de leur proximité géographique • LAN (local area network): réseau local d’un édifice ou d’un campus • Réseau Ethernet • WAN (wide-area network): réseau étendu à une province, un pays, au monde • Typiquement des liens haute-vitesse comme les réseaux à fibres optiques • L’internet est une interconnectiond’un ensemble de réseaux • Réseau INTERNET IP

  8. Concepts et opérations de base: Segment ETHERNET • Le segment Ethernet consiste en une collection d’hôtes (hosts) connectés (twisted pairs) à des hub (répétiteurs) • Peut déservir un laboratoire ou un étage dans un édifice • Opération • Chaque adapteur Ethernet possède une adresse de 48 bits • Les hôtes acheminent les bits aux autres hôtes en blocs appelés frames • Les hub copient chaque bit de chaque port à tous les autres ports • Chaque hôte voit alors chaque bit host host host 100 Mb/s 100 Mb/s hub ports

  9. Concepts et opérations de base • Communication réseau

  10. Concepts et opérations de base: Les ponts • Permet d’étendre un réseau à un édifice • Les ponts permettent de distribuer les paquets d’information en associant les ports entre eux A B host host host host host X bridge hub hub 100 Mb/s 100 Mb/s 1 Gb/s host host 100 Mb/s 100 Mb/s bridge hub hub Y host host host host host C

  11. Concepts et opérations de base: INTERNETs • Les routeurs permettent de connectés plusieurs LAN • Les réseaux interconnectés sont appelés internet. ... ... host host host host host host LAN 1 LAN 2 router router router WAN WAN LAN 1 et LAN 2 peuvent être complètement différents (ex: Ethernet et ATM)

  12. Concepts et opérations de base: La notion de protocole internet • Comment est-il possible de transférer des bits entre LANs ou WANs incompatibles ? • Solution: Le protocol software s’exécutant dans chaque hôte et routeur permet d’harmoniser les différences entre les réseaux • Ce logiciel implémente un protocole internet (i.e., un ensemble de règles d’échange) qui gouverne la manière dont les hôtes et les routeurs doivent coopérer lorsqu’ils échangent des données d’un réseau à un autre • TCP/IP est le protocole de l’internet global

  13. Concepts et opérations de base: La notion de protocole internet • Identification uniforme • Le protocole internet définit un format uniforme d’identification des hôtes (adresse) • Chaque hôte (et routeur) est associé à au moins une de ces adresses internet qui les identifient de façon unique • Mécanisme de transfert • Le protocole internet définit le format de l’unité de transfert de base: le paquet (packet) • Les paquets sont composés d’une en-tête et des données • en-tête: contient de l’information comme la dimension du paquet, les adresses source et la destination • données: contient les bits de données échangées entre les hôtes

  14. Concepts et opérations de base: Transfert de données sur un internet Host A Host B client server (1) (8) data data protocol software protocol software internet packet (2) (7) data PH FH1 data PH FH2 LAN1 frame LAN1 adapter LAN2 adapter Router (3) (6) data PH FH1 data PH FH2 LAN1 adapter LAN2 adapter LAN1 LAN2 LAN2 frame (4) data PH FH1 (5) data PH FH2 protocol software

  15. Concepts et opérations de base: Internet IP Global • L’exemple le plus important d’un internet • Basé sur la famille de protocoles TCP/IP • IP (Protocole Internet) • Permet l’identification et le transfert non-fiable de paquets (datagrams) d’un hôte à l’autre • UDP (Unreliable Datagram Protocol) • Utilise l’IP pour l’échange non-fiable de paquets de processus à processus • TCP (Transmission Control Protocol) • Utilise l’IP pour transférer de façon sécuritaire des flots d’octets (ex: fichiers) de processus à processus • Accessible par un mélange d’I/O fichier UNIX et d’appels de fonction à l’interface socket de Berkeley

  16. Concepts et opérations de base: Organisation d’une application Internet Internet client host Internet server host client server user code sockets interface (system calls) TCP/IP TCP/IP kernel code hardware interface (interrupts) network adapter network adapter hardware Global IP Internet

  17. Concepts et opérations de base: L’INTERNET vu par le programmeur • Chaque hôte est représenté par une adresse IP de 32 bits • 128.2.203.179 • Un ensemble d’adresses IP peut être associé à un d’identificateur de domaine (domain names) • 128.2.203.179 est associé au nom de domaine www.cs.cmu.edu • Un processus sur un hôte communique avec un autre hôte via une connexion

  18. Concepts et opérations de base: Adresses IP • Les adresses IP de 32 bits sont stockées dans une structure in_addr • Les adresses IP sont toujours stockées en mémoire selon un ordonnancement d’octet réseau (big-endian) /* Internet address structure */ struct in_addr { unsigned int s_addr; /* network byte order (big-endian) */ }; • Fonctions d’ordonnancement d’octets réseau: • htonl: convertir des long int du format hôte à réseau • htons: convertir des short int du format hôte à réseau • ntohl: convertir des long int du format réseau à hôte • ntohs: convertir des short int du format réseau à hôte

  19. Concepts et opérations de base: Adresses IP • Par convention, chaque adresse IP peut être représentée dans une chaîne de nombres décimaux séparés par des points • Adresse IP 0x8002C2F2 = 128.2.194.242 • Fonctions permettant la conversion d’adresses IP d’un format binaire à un format dotted-decimal: • inet_aton: convertir une chaîne dotted-decimal à une adresse IP binaire en ordre réseau • inet_ntoa: convertir une adresse IP en ordre réseau à une chaîne dotted-decimal • “n” pour réprésentation réseau et “a” pour une représentation application

  20. Concepts et opérations de base: Noms de domaines IP unnamed root first-level domain names mil edu gov com second-level domain names mit cmu berkeley amazon third-level domain names cs ece www 208.216.181.15 cmcl pdl kittyhawk 128.2.194.242 imperial 128.2.189.40

  21. Concepts et opérations de base: Domain Naming System (DNS) • L’Internet maintient dans une base de données distribuée appelée DNS, une correspondance entre les adresses IP et le nom de domaine • Conceptuellement, cette base de données DNS est en fait un ensemble de structures hostent (host entry): /* DNS host entry structure */ struct hostent { char *h_name; /* official domain name of host */ char **h_aliases; /* null-terminated array of domain names */ int h_addrtype; /* host address type (AF_INET) */ int h_length; /* length of an address, in bytes */ char **h_addr_list; /* null-terminated array of in_addr structs*/ }; • Fonctions permettant d’obtenir une structure hostent du DNS: • gethostbyname: recherche avec le nom de domaine DNS • gethostbyaddr: recherche par l’adresse IP

  22. Concepts et opérations de base: Domain Naming System (DNS) • Chaque structure hostent est une classe d’équivalence entre des noms de domaine et des adresses IP • Chaque hôte possède un nom de domaine local localhost lequel correspond à l’adresse loopback 127.0.0.1 • Différents types de correspondance sont possibles: • Correspondance 1-1 entre le nom de domaine et l’adresse IP: • kittyhawk.cmcl.cs.cmu.edu correspond à 128.2.194.242 • Correspondance de plusieurs noms de domaine à une adresse IP : • eecs.mit.edu et cs.mit.edu correspondent à 128.62.1.6 • Correspondance de plusieurs noms de domaines à plusieurs adresses IP: • aol.com et www.aol.com correspondent à trois différentes adresses IP

  23. Concepts et opérations de base: Domain Naming System (DNS) int main(int argc, char **argv) { /* argv[1] is a domain name char **pp; * or dotted decimal IP addr */ struct in_addr addr; struct hostent *hostp; if (inet_aton(argv[1], &addr) != 0) hostp = Gethostbyaddr((const char *)&addr, sizeof(addr), AF_INET); else hostp = Gethostbyname(argv[1]); printf("official hostname: %s\n", hostp->h_name); for (pp = hostp->h_aliases; *pp != NULL; pp++) printf("alias: %s\n", *pp); for (pp = hostp->h_addr_list; *pp != NULL; pp++) { addr.s_addr = *((unsigned int *)*pp); printf("address: %s\n", inet_ntoa(addr)); } }

  24. Concepts et opérations de base: Connexions Internet • Clients et serveurs échangent des flots d’octets par des connexions: • point-to-point, full-duplex, et fiable • Un socket est une terminaison d’une connexion • L’adresse d’un socket est une paire IPaddress:port • Un port est un entier de 16 bits qui identifie un processus: • Ports éphémères: assignés automatiquement à un client qui demande une connexion • Ports connus: associés à des services offerts par un serveur (ex: port 80 associé aux serveurs WEB) • Une connexion est identifiée de façon unique par les adresses socket de ses terminaisons • (cliaddr:cliport, servaddr:servport)

  25. Concepts et opérations de base: Connexions Internet client socket address 128.2.194.242:51213 server socket address 208.216.181.15:80 client server (port 80) connection socket pair (128.2.194.242 :51213, 208.216.181.15:80) client host address 128.2.194.242 server host address 208.216.181.15

  26. Communication réseau par socket: Modèle Client-server • Les applications réseaux sont basées sur le modèle client-server: • L’application est un processus serveur et un ou plusieurs processus clients • Le serveur gère des ressources, et offre des services en manipulant des ressources pour les clients. • Chaque client fait des requêtes pour un service • Le serveur offre des services en manipulant des ressources au nom du client et en retournant une réponse 1. client sends request client process server process resource 4. client handles response 2. server handles request 3. server sends response

  27. Communication réseau par socket: Clients • Examples de programme client • Web browsers, ftp, telnet, ssh • Comment le client trouve-t-il le serveur? • L’addresse du processus serveur a deux parties: IPaddress:port • L’ IP address est un entier positif de 32 bits qui identifie l’hôte • Forme dotted-decimal: 0x8002C2F2 = 128.2.194.242 • Le port est un entier positif associé à un service donc à un processus serveur sur un machine • port 7: echo server • port 23: telnet server • port 25: mail server • port 80: web server

  28. Communication réseau par socket: Ports comme identificateur de service server machine 128.2 194.242 client machine Web server (port 80) service request for 128.2.194.242:80 (i.e., the Web server) kernel client Echo server (port 7) Web server (port 80) service request for 128.2.194.242:7 (i.e., the echo server) kernel client Echo server (port 7)

  29. Communication réseau par socket: Serveurs • Les serveurs sont des processus qui s’exécutent sur une longue période de temps (daemons) • Créer au boot-time (typiquement) par le processus init (process 1) • Roule continuellement • Chaque serveur attend des requêtes sur des ports connus, chacun associé à un service • port 7: echo server • port 25: mail server • port 80: http server • port 20, 21: FTP server • Port 23: Telnet server • Voir le répertoire /etc/services pour obtenir la liste des services disponibles sur une machine Linux

  30. Communication réseau par socket:L’interfaceSockets Berkeley • Créer au début des années 80, et faisait partie de la distribution de UNIX Berkeley qui contenait les prémices des protocoles Internet • Offrait une interface usager au réseau • Constitue la base de toutes les applications Internet • Basée sur le modèle client/server

  31. Communication réseau par socket:Socket • Un socket est un descripteur qui permet à une application de faire des I/O du/au réseau • Unix utilise la même abstraction pour les I/O fichier et celles réseau • Les clients et serveurs communiquent entre eux en effectuant des I/O sur les descripteurs de socket • Utilisant des opérations UNIX read et write • La seule différence réside dans la manière d’ouvrir le socket (création du descripteur)

  32. Communication réseau par socket:Structures de données importantes • Définit dans /usr/include/netinet/in.h • Les sockets Internet sont caractérisés par une adresse IP de 32 bits et un numéro de port /* Internet address */ struct in_addr { unsigned int s_addr; /* 32-bit IP address */ }; /* Internet style socket address */ struct sockaddr_in { unsigned short int sin_family; /* Address family (AF_INET) */ unsigned short int sin_port; /* Port number */ struct in_addr sin_addr; /* IP address */ unsigned char sin_zero[...]; /* Pad to sizeof “struct sockaddr” */ };

  33. Communication réseau par socket:Structures de données importantes • Définie dans /usr/include/netdb.h • hostentest un descripteur d’hôte qui associe un domain name (ex:, cmu.edu) avec une adresse IP (128.2.35.186) • Peut être obtenue par programmation • gethostbyname() [par le domain name] • gethostbyaddr() [par l’adresse IP] • Aussi par la commande shell nslookup ou dig /* Domain Name Service (DNS) host entry */ struct hostent { char *h_name; /* official name of host */ char **h_aliases; /* alias list */ int h_addrtype; /* host address type */ int h_length; /* length of address */ char **h_addr_list; /* list of addresses */ }

  34. Communication réseau par socket: Client local simple // Créer un socket // Nommer le socket

  35. Communication réseau par socket: Serveur local simple Exécution: >server1 & [1] 1094 server waiting >client1 server waiting char from server = B // Supprimer un socket existant // Donner un nom au socket // Écouter une connexion // Créer une connexion active

  36. Communication réseau par socket: Client local simple

  37. Communication réseau par socket: Serveur local simple

  38. Communication réseau par socket:L’interface Client Server socket socket bind open_listenfd open_clientfd listen connection request connect accept writen readline Await connection request from next client readline writen EOF readline close close

  39. Communication réseau par socket: Client Echo int main(int argc, char **argv) { int clientfd, port; char *host, buf[MAXLINE]; if (argc != 3) { fprintf(stderr, "usage: %s <host> <port>\n", argv[0]); exit(0); } host = argv[1]; port = atoi(argv[2]); clientfd = open_clientfd(host, port); while (Fgets(buf, MAXLINE, stdin) != NULL) { Writen(clientfd, buf, strlen(buf)); Readline(clientfd, buf, MAXLINE); Fputs(buf, stdout); } Close(clientfd); }

  40. Communication réseau par socket: Client Echoopen_clientfd() int open_clientfd(char *hostname, int port) { int clientfd; struct hostent *hp; struct sockaddr_in serveraddr; clientfd = Socket(AF_INET, SOCK_STREAM, 0); /* fill in the server's IP address and port */ hp = Gethostbyname(hostname); bzero((char *) &serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; bcopy((char *)hp->h_addr, (char *)&serveraddr.sin_addr.s_addr, hp->h_length); serveraddr.sin_port = htons(port); /* establish a connection with the server */ Connect(clientfd, (SA *) &serveraddr, sizeof(serveraddr)); return clientfd; }

  41. Communication réseau par socket: Client Echoopen_clientfd() (socket) • Le client crée un socket qui sera utilisé comme terminaison d’une connexion (SOCK_STREAM) Internet (AF_INET) • socket() retoune un entier qui représente le descipteur de socket int clientfd; /* socket descriptor */ clientfd = Socket(AF_INET, SOCK_STREAM, 0);

  42. Communication réseau par socket: Client Echoopen_clientfd()(gethostbyname) • Le client construit alors l’adresse Internet du serveur int clientfd; /* socket descriptor */ struct hostent *hp; /* DNS host entry */ struct sockaddr_in serveraddr; /* server’s IP address */ typedef struct sockaddr SA; /* generic sockaddr */ ... /* fill in the server's IP address and port */ hp = Gethostbyname(hostname); bzero((char *) &serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; bcopy((char *)hp->h_addr, (char *)&serveraddr.sin_addr.s_addr, hp->h_length); serveraddr.sin_port = htons(port);

  43. Communication réseau par socket: Client Echoopen_clientfd()(connect) • Le client crée alors une connexion avec le serveur • Le processus client est suspendu (blocks) tant que la connexion n’est pas créée avec le serveur • Le client est alors prêt à échanger des messages avec le serveur par des appels d’I/O UNIX sur le descripteur sockfd int clientfd; /* socket descriptor */ struct sockaddr_in serveraddr; /* server address */ ... /* establish a connection with the server */ Connect(clientfd, (SA *) &serveraddr, sizeof(serveraddr));

  44. Communication réseau par socket: Server Echo int main(int argc, char **argv) { int listenfd, connfd, port, clientlen; struct sockaddr_in clientaddr; struct hostent *hp; char *haddrp; port = atoi(argv[1]); /* the server listens on a port passed on the command line */ listenfd = open_listenfd(port); while (1) { clientlen = sizeof(clientaddr); connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr, sizeof(clientaddr.sin_addr.s_addr), AF_INET); haddrp = inet_ntoa(clientaddr.sin_addr); printf("server connected to %s (%s)\n", hp->h_name, haddrp); echo(connfd); Close(connfd); } }

  45. Communication réseau par socket: Server Echoopen_listenfd() int open_listenfd(int port) { int listenfd; int optval; struct sockaddr_in serveraddr; /* create a socket descriptor */ listenfd = Socket(AF_INET, SOCK_STREAM, 0); /* eliminates "Address already in use" error from bind. */ optval = 1; Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval , sizeof(int)); ... (more)

  46. Communication réseau par socket: Server Echoopen_listenfd()suite ... /* listenfd will be an endpoint for all requests to port on any IP address for this host */ bzero((char *) &serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); serveraddr.sin_port = htons((unsigned short)port); Bind(listenfd, (SA *)&serveraddr, sizeof(serveraddr)); /* make it a listening socket ready to accept connection requests */ Listen(listenfd, LISTENQ); return listenfd; }

  47. Communication réseau par socket: Server Echoopen_listenfd() (socket) • socket() crée un descripteur de socket • AF_INET: indique que le socket est associé à un protocole Internet • SOCK_STREAM: sélectionne une connexion à flot d’octets fiable int listenfd; /* listening socket descriptor */ listenfd = Socket(AF_INET, SOCK_STREAM, 0);

  48. Communication réseau par socket: Server Echoopen_listenfd() (setsockopt) • Le socket peut avoir des attributs • Truc permettant de redémarrer le serveur immédiatement après l’avoir arrêté: • Sinon, il faut attendre 15 secs • Élimine l’erreur “Address already in use” du bind() /* eliminates "Address already in use" error from bind. */ optval = 1; Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval , sizeof(int));

  49. Communication réseau par socket: Server Echoopen_listenfd() (init. adresse du socket) • Initialisation du socket avec l’adresse Internet du serveur (adresse IP et port) • L’adresse IP et le port sont stockés en ordre réseau (big-endian) • htonl() convertir des longs du format hôte au format réseau • htons() convertir des shorts du format hôte au format réseau struct sockaddr_in serveraddr; /* server's socket addr */ /* listenfd will be an endpoint for all requests to port on any IP address for this host */ bzero((char *) &serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); serveraddr.sin_port = htons((unsigned short)port);

  50. Communication réseau par socket: Server Echoopen_listenfd() (bind) • bind() associe le socket avec l’adresse correspondante du serveur int listenfd; /* listening socket */ struct sockaddr_in serveraddr; /* server’s socket addr */ /* listenfd will be an endpoint for all requests to port on any IP address for this host */ Bind(listenfd, (SA *)&serveraddr, sizeof(serveraddr));

More Related