Rappel sur les pipes et FIFO

$ ls -lh /dev | more

Concepts generaux des pipes

Pipe nommé: Commande mkfifo(1)

mkfifo [OPTION]... NOM...

$ mkfifo -m 0640 /tmp/fifo1
$ ls -lh /dev > /tmp/fifo1

$ more /tmp/fifo1  # Dans un autre shell
                        

Fonction POSIX mkfifo(2)

On peut créer un FIFO avec l'appel système:

int mkfifo(const char *pathname, mode_t mode);

• pathname est le nom du fichier à créer
• mode représente les permissions (modifiées mode & ~umask)
• Un FIFO peut être ouvert en lecture/écriture comme n'importe quel fichier (open/read) mais il faut veiller à respecter la directionalité du fifo
• Pas d'accès aléatoire possible.

Exemple - producer

Include example there (see script)

Exemple - consumer

Include example there (see script)

Architecture Réseau

Sockets

• Abstraction d'un canal de communication à travers le réseau
• Descripteur de fichier:
  • Ecriture avec read()
  • Lecture avec write()
  • Pas d'accès aléatoire possible
• Modèle client-serveur

Domaine d'adressage

• Un socket est peut-être lié à une adresse.
• Il existe deux domaines d'adressages:

  internet domain	communication réseau (AF_INET)
  unix domain	communication locale (AF_UNIX)

Types de sockets

Adressage Internet

L'adresse est composée d'une adresse IP et d'un numéro de port (16bits).

struct sockaddr_in {
    sa_family_t     sin_family; /* famille: AF_INET */
    in_port_t       sin_port;   /*port: big-endian */
    struct in_addr  sin_addr;   /* adresse internet */
};

struct in_addr {
    uint32_t        s_addr;     /*adresse ip: big-endian
}
                        

Obtenir une adresse IP (inet_pton)

int inet_pton(int af, const char *src, void *dst);

Obtenir la représentation d'une adresse IP (inet_ntop)

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

Obtenir un numéro de port valide (htons)

uint16_t htons(uint16_t hostshort);

Client TCP

Le fonctionement d'un client TCP est le suivant:

1. Crée un socket (socket)
2. Connecte un socket à un serveur (connect)
3. Lecture/Ecriture à parir du socket (read/write)
4. Ferme le socket (close)

Créer un socket (socket)

int socket(int domain, int type, int protocol);

Initier une connection (connect)

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

Exemple de client TCP

struct sockaddr_in address;
memset( &address, 0, sizeof(address) );
inet_pton( AF_INET, "192.168.1.1", &(address.sin_addr) );
address.sin_family = AF_INET;
address.sin_port = htons(8080);

int sock = socket(AF_INET, SOCK_STREAM, 0);
connect(sock, (struct sockaddr *) &address, sizeof(address));
...
read(sock, ...)
write(sock, ...)
                    

Serveur TCP

Le fonctionement d'un serveur TCP est le suivant:

1. Crée un socket serveur (socket)
2. Attache le socket serveur à une adresse (bind)
3. Ecoute le début d'une connection (listen)
4. Accepte une connection et obtient un socket client (accept)
5. Lecture/Ecriture à parir du socket client (read/write)
6. Ferme le socket client (close)
7. Répète l'étape 4 si nécéssaire
8. Ferme le socket serveur (close)

Créer un socket (socket)

On utilise l'appel système socket pour créer un socket serveur (cf. client).

Lier un socket à une adresse (bind)

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

Ecouter les connection (listen)

int listen(int sockfd, int backlog);

Accepter les connections (accept)

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

Exemple de serveur TCP (1)

struct sockaddr_in address;
memset(&address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_addr.s_addr = htonl(INADDR_ANY);
address.sin_port = htons(8080);

int serverSock = socket(AF_INET, SOCK_STREAM, 0);
bind(serverSock, (struct sockaddr *) &address, sizeof(address));
listen(serverSock, 5);

while( 1 ) {
    struct sockaddr_in clientAddress;
    unsigned int clientLength = sizeof(clientAddress);
    int clientSock = accept(serverSock,
                            (struct sockaddr *) &clientAddress,
                            &clientLength);

    /* Lectures/Ecritures sure clientSock (read/write) */

    close( clientSock );
}
                    

Remarque

• L'utilisation de INADDR_ANY permet de se lier à toutes les interfaces réseaux de la machine.
• On utilise la fonction htonl pour obtenir une adresse numérique valide:

address.sin_addr.s_addr = htonl(INADDR_ANY)

Exemple: a file server

• Common code: file_transmission.c and file_transmission.h
• Sever code: file_server.c
• Client code: file_client.c

Problèmes

Quasi-Universelles

• Les sockets sont implémentés au niveau de l'OS, par presque tous les OS.
• La grande majorité des languages de programation ont une librairie permettant d'utiliser les sockets.

• Les sockets permettent la communication entre processus écrits dans des langages différents.
• Les sockets permettent la communication entre OS différents.

Sockets en Python

#CLIENT
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("www.mcmillan-inc.com", 80))

#SERVEUR
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind((socket.gethostname(), 80))
serversocket.listen(5)
                    

Sockets en Java

try {
    serverSocket = new ServerSocket(4444);
}
catch (IOException e) {
    System.out.println("Could not listen on port: 4444");
    System.exit(-1);
}
Socket clientSocket = null;
try {
    clientSocket = serverSocket.accept();
}
catch (IOException e) {
    System.out.println("Accept failed: 4444");
    System.exit(-1);
}
                    

Sockets en Scheme

(define (id-server)
   (let ((socket (open-socket)))
    (display "Waiting on port ")
    (display (socket-port-number socket))
    (newline)
    (let loop ((next-id 0))
      (call-with-values
	(lambda ()
	  (socket-accept socket))
	 (lambda (in out)
	  (display next-id out)
	  (close-input-port in)
	  (close-output-port out)
	  (loop (+ next-id 1)))))))
                    

Send/Receive

ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
                        

Sendfile (non POSIX)

ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count)

UDP

Unix Socket

• Un socket Unix permet d'établir une communication locale entre deux processus au moyen d'un inode.
• Il faut passer le domaine AF_UNIX à l'appel système socket.
• L'adressage est différent, mais tout le reste est identique aux sockets internet.

#define UNIX_PATH_MAX    108
struct sockaddr_un {
    sa_family_t sun_family;        /* Famille: AF_UNIX*/
    char sun_path[UNIX_PATH_MAX];  /* Chemin sur le systeme de fichiers */
};
                        

Résolution des noms de domaine (gethostbyname)

La fonction suivante permet de résoudre un nom de domaine:

struct hostent *gethostbyname(const char *name);

struct hostent {
    char  *h_name;     /* nom officiel */
    char **h_aliases;  /* tableau d'alias */
    int    h_addrtype; /* type: AF_INET ou AF_INET6 */
    int    h_length;   /* longueur de l'adresse */
    char **h_addr_list;/* tableau d'adresses */
};