\documentclass[beamer, 10pt]{beamer}
 
\usepackage{amsfonts, amssymb, amsmath,amscd}
\usepackage{graphicx}
\usepackage{color}

\usepackage{listings}

\mode<presentation>
{
  \usetheme{Warsaw}

  \setbeamercovered{transparent}
}

\lstset{% general command to set parameter(s)
   basicstyle=\small,          % print whole listing small
   keywordstyle=\color{black}\bfseries,
                               % underlined bold black keywords
   identifierstyle=,           % nothing happens
   commentstyle=\color{white}, % white comments
   stringstyle=\ttfamily,      % typewriter type for strings
   language={C},
   emphstyle=\color{red},
   showstringspaces=false}     % no special string spaces

\def\shell#1{\textbf{#1}}
\def\gcc#1{\texttt{#1}}
\def\tty#1{\texttt{#1}}
\def\nullptr{\textsc{null}}
\def\lref#1#2{\href{file:///home/drmichko/web-docs/cours/SOCKET/#1}{#2}}

\title{Quelques Exemples de Programmation R\'eseau}
\author{Philippe Langevin}
\date{Octobre 2007.}


\input listings.tex

\begin{document}

\begin{frame} 
\titlepage
\end{frame}

\begin{frame} 
\tableofcontents
\end{frame}

\section{Introduction}

\begin{frame}[containsverbatim]
\frametitle{Motivation}
L'objectif de ces notes est de pr\'esenter la communication
interprocessus sur un r\'eseau en utilisant les outils 
\emph{socket BSD}. Nous implanterons \emph{\`a la main} une
architecture \emph{client/serveur} pour r\'ealiser des
grandes boucles :


\begin{lstlisting}
for( i = 0; i < n; i++ )
   calcul( i );
\end{lstlisting}

Typiquement, si $n=2^{40}$ et si le temps de calcul pour chaque
it\'eration est de l'ordre de $2^{20}$ cycles, sur une machine 
usuelle le temps d'ex\'ecution de cette boucle vaut :
$$
2^{40} \times 2^{20} \times 2^{-31} \sec = 6213\, \hbox{jours} 
$$ 
En \emph{distribuant} les calculs sur 256 processeurs, le temps
de r\'ealisation de l'\emph{exp\'erience num\'erique} ne d\'epassera
pas 4 jours !
\end{frame}


\begin{frame}
\frametitle{Mod\`ele Client/Serveur}

Les applications r\'eseaux sont class\'ees en deux cat\'egories:
\begin{itemize}
\item{Serveur} qui attend une communication~: attente d'une
demande d'ouverture de communication, r\'eception d'une requ\^ete et 
envoie d'une r\'eponse.
\item{Client}  qui initie le lancement d'une communication~: 
demande d'ouverture de connexion, d'une requ\^ete, attente de la r\'eponse
et traitement.
\end{itemize}
Ouvrage de r\'ef\'erence : 
\begin{itemize}
\item Programmation Syst\`eme en Langage C sous Linux,
par Christophe Blaess.
\item Le chapitre VII du BSD-Handbook developer.
\href{http://www.freebsd.org/doc/en_US.ISO8859-1/books/developers-handbook/sockets-essential-functions.html}{\textcolor{blue}{socket bsd}}
\end{itemize}
\end{frame} 
 

\section{Un petit protocole}

\begin{frame}
\frametitle{Connexion}

Les sockets ( \emph{prises} ) s'appuient sur les deux principaux
protocoles de transports TCP/IP :
\begin{itemize}
\item{UDP:} application orient\'ee sans connexion.
\item{TCP:} application orient\'ee connexion.
\end{itemize}

Le protocole UDP est particuli\`erement bien adapt\'e \`a notre
but, \'echange de petits paquets d'information entre les processus
clients et un processus serveur.
\end{frame}

\begin{frame}
\frametitle{Protocole BigLoop}
{\includegraphics[scale=0.4]{bigloop}}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Architectures}
\lstinputlisting[firstline=1]{bigloop/cpu.txt}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Structure}
\ticketINbigloop.h
\end{frame}

\begin{frame}
\frametitle{Boucle du client}
{\includegraphics[scale=0.5]{loopc}}
\end{frame}

\begin{frame}
\frametitle{Boucle du serveur}
{\includegraphics[scale=0.5]{loops}}
\end{frame}

\begin{frame}
\frametitle{Application : Nombre Parfait}
Un nombre entier $z$ est dit \emph{parfait} quand
il est \'egal \`a la somme de ses diviseurs stricts
$$
z = \sum_{z\not = d\mid z} d 
$$
En lan\c cant, 
\begin{itemize}
\item \tty{server.exe -i1 -p31415  -f1 -L30 -S25}
\item \tty{client.exe -i1 -p31415  -a adresse-serveur}
\end{itemize}
sur la \lref{bigloop/all.grp}{\textcolor{blue}{grappe}} de
machines, on d\'etermine les nombres parfaits inf\'erieurs
\`a $2^{30}$ en quelques minutes.
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{client.c: Parfait}
\parfaitINclient.c
\begin{itemize}
\item source : \lref{bigloop/client.c}{\textcolor{blue}{client.c}}
\end{itemize}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{client.c: main}
\mainINclient.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{server.c: main (1/3)}
\prologueINserver.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{server.c: main (2/3)}
\boucleINserver.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{server.c: main (3/3)}
\epilogueINserver.c
\end{frame}


\section{Initialisation des sockets}

\subsection{Format des adresses}
\begin{frame}
\frametitle{Adresses}

Les adresses existent sous forme de chaine de caract\`eres,
$$\tty{mail.univ-tln.fr}\quad\tty{127.0.0.1}$$
o\`u encore de mots de 32 bits.
$$
1 * 256^3 + 0*256^2 + 0*256^1 + 127 =  16777343
$$

\begin{tabular}{lcl}
 ./whoami.exe          &\quad &./whoami.exe mail.univ-tln.fr\\
hote :msnet.sollies.fr &      &hote :mail.univ-tln.fr\\
addr :16777343         &      &addr :39858625\\
ip   :127.0.0.1        &      &ip   :193.49.96.2\\
\end{tabular}

\begin{itemize}
\item Pour une communication socket l'adresse IP doit compl\'et\'ee 
par un num\'ero de \emph{port} de 16 bits.
\end{itemize}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Who am I ?}
\mainINwhoami.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{structures hostent  \& in\_addr}
\begin{lstlisting}
struct in_addr { unsigned long int s_addr; }
#include <netdb.h>
struct hostent {
   char    *h_name;      /* Nom officiel de l'hote.*/
   char   **h_aliases;   /* Liste d'alias. */
   int      h_addrtype;  /* Type d'adresse de l'hote.*/
   int      h_length;    /* Longueur de l'adresse.*/
   char   **h_addr_list; /* Liste d'adresses.*/
 }              
#define h_addr  h_addr_list[0] /* pour retro-compatibilit\'e. */
\end{lstlisting}
\begin{itemize}
\item  h\_aliases: table d'alternatives au nom officiel de l'h\^ote, termin\'ee par un pointeur \nullptr.
\item h\_addrtype : toujours AF\_INET ou AF\_INET6.
\item h\_length   : la longueur, en octets, de l'adresse.
\item h\_addr\_list: une table, termin\'ee par un pointeur \nullptr, d'adresses r\'eseau pour l'h\^ote, avec l'ordre des octets du r\'eseau.
\item h\_addr: premi\`ere adresse dans h\_addr\_list pour respecter la compatibilite ascendante.
\end{itemize}
\end{frame}

\subsection{Boutisme r\'eseau}

\begin{frame}[containsverbatim]
\frametitle{Boutisme r\'eseau}
Le boutisme r\'eseau est \emph{big indian} comme sur
les architectures motorola 68000, sparc et syst\`eme IBM/370, 
mais ce n'est pas forc\'ement pas le point de vue de votre processeur ! 
$$
1 + 2*256 + 3*256^2 + 3*256^3 
$$
\begin{verbatim}
memory  byte order: 1 2 3 4
network byte order: 4 3 2 1
\end{verbatim}
Pour param\'etrer les fonctionnalit\'es du r\'eseau, il convient
d'utiliser le bon boutisme !
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Indianness test}
\lstinputlisting[ emph={ htonl }]{indian.c}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Conversion des entiers}
\begin{lstlisting}
#include 	 <arpa/inet.h>

ulong 	htonl (ulong) ;  /* host to network -- long  */
ushort  htons (ushort) ; /* host to network -- short */
ulong 	ntohl (ulong) ;  /* network to host -- long  */
ushort  ntohs (ushort) ; /* network to host -- short */
\end{lstlisting}

\begin{itemize}
\item  La fonction  \tty{ntohl()}  convertit  un  entier  non-sign\'e  netlong  depuis
       l'ordre des octets du r\'eseau vers celui de l'h\^ote.
\item  \tty{ntohl()} 	fait le contraire.
\item Pour affecter le num\'ero de port 13 (service ``daytime'') au champ \tty{sin\_port}
  d'une structure de type \tty{sockaddr\_in} :
\end{itemize}

\begin{lstlisting}
saddr.sin_port = htons(13) ; 
\end{lstlisting}
\end{frame}

\subsection{R\'esolution des noms}

\begin{frame}[containsverbatim]
\frametitle{R\'esolution des noms}
\begin{lstlisting}
struct hostent *gethostbyname(const char *name);
\end{lstlisting}
\begin{itemize}
\item  La fonction \tty{gethostbyname()} renvoie une structure de type \tty{hostent}  pour
       l'h\^ote name. La cha\^{i}ne name est soit un nom d'h\^ote, soit une adresse
       IPv4 en notation point\'ee standard, soit une adresse IPv6 avec la  notation  
       points-virgules  et  points.  Si name est une adresse IPv4 ou IPv6, aucune recherche
       suppl\'ementaire  n'a  lieu et \tty{gethostbyname()} copie simplement la cha\^{i}ne
       name dans le champ h\_name et le champ \'equivalent \tty{struct in\_addr} dans le
       champ \tty{h\_addr\_list[0] }de la structure hostent renvoy\'ee.
\end{itemize}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{R\'esolution inverse}
\begin{lstlisting}
#include <sys/types.h> #include <sys/socket.h>
extern int h_errno;
struct hostent *gethostbyaddr(const void *addr, 
       int len, int type);
\end{lstlisting}
\begin{itemize}
\item  La  fonction \tty{gethostbyaddr()} renvoie une structure du type hostent pour
       l'h\^ote d'adresse addr.  Cette adresse est de longueur len  et  du  type
       donn\'e.  Les  types d'adresse valides sont AF\_INET et AF\_INET6.  L'argument 
adresse de l'h\^ote est un  pointeur  vers  une  structure  de  type
       d\'ependant du type de l'adresse, par exemple \tty{struct in\_addr *} 
       (probablement obtenu via un appel  à  \tty{inet\_addr()})  pour  une  adresse  de  type
       AF\_INET.
\item  Retour:
       Les fonctions \tty{gethostbyname()} et \tty{gethostbyaddr()} renvoient un  pointeur
       sur  la  structure  hostent , ou bien un pointeur \nullptr\ si une erreur se
       produit, auquel cas \tty{h\_errno} contient  le  code  d'erreur.
\end{itemize}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Manipulation des adresses}

\begin{lstlisting}
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

struct in_addr {
               unsigned long int s_addr;
           }

in_addr_t inet_addr (const char * cp);
char * inet_ntoa (struct in_addr in);
\end{lstlisting}
\begin{itemize}
\item  La fonction \tty{inet\_ntoa()} convertit l'adresse Internet de l'h\^ote in donn\'ee
       dans l'ordre des octets du r\'eseau en une cha\^{i}ne de caract\`eres  dans  la
       notation  avec nombres et points. La chaine est renvoy\'ee dans un buffer
\item  La fonction \tty{inet\_addr()}  convertit  l'adresse  Internet  de  l'h\^ote  cp
       depuis  la  notation  standard  avec  nombres  et  points en une donn\'ee
       binaire dans l'ordre des octets du r\'eseau. 
\end{itemize}
\end{frame}

\subsection{Op\'eration sur les adresses}
\begin{frame}[containsverbatim]
\frametitle{Manipulation des adresses}


\begin{lstlisting}
#include ...

int inet_aton (const char *cp, struct in_addr *inp);
in_addr_t inet_network (const char * cp);

\end{lstlisting}
\begin{itemize}
\item  \tty{inet\_aton()}  convertit  l'adresse Internet de l'h\^ote cp depuis la nota-
       tion standard avec nombres et points  en  une  donn\'ee  binaire,  et  la
       stocke  dans la structure point\'ee par inp. \tty{inet\_aton} renvoie une valeur
       non nulle si l'adresse est valide, et z\'ero sinon.

\item  La fonction \tty{inet\_network()} extrait la partie  r\'eseau  de  l'adresse  cp
       fournie  dans  la  notation  avec  nombres  et points, et renvoie cette
       valeur dans l'ordre des octets de l'h\^ote. Si l'adresse est invalide, -1
       est renvoy\'e.

\end{itemize}

\end{frame}

\section{Communication sur UDP}

\subsection{Sch\'ema UDP}
\begin{frame}
\frametitle{Mode non connect\'e}
\rotatebox{0}{\includegraphics[scale=0.6]{udp}}
\end{frame}


\subsection{Point de communication}

\begin{frame}[containsverbatim]
\frametitle{Cr\'eer un point de communication.}

\begin{lstlisting}
 #include <sys/types.h>
 #include <sys/socket.h>
 
 int socket(int domain, int type, int protocol);
\end{lstlisting}

Cr\'eation d'un point de communication, et renvoie un descripteur.
\begin{itemize}
\item{domain} indique un domaine de communication,  à l'int\'erieur duquel 
s'\'etablira le dialogue PF-INET  pour IPv4 et PF-INET6 pour IPv6.
\item{type} fixe la s\'emantique du dialogue : SOCK-STREAM, SOCK-DGRAM
\item{protocol} num\'ero de protocol. 
\item{Quand une session se termine, on referme la socket avec close.}
\item{retour} un descripteur r\'ef\'erençant la socket 
cr\'e\'ee en cas de r\'eussite. En cas d'\'echec -1 est renvoy\'e, 
et \tty{errno} contient  le code d'erreur.
\end{itemize}
\end{frame}

\subsection{Assignation}

\begin{frame}[containsverbatim]
\frametitle{Assigner un nom \`a une socket.}

\begin{lstlisting}
#include <sys/types.h>
#include <sys/socket.h>

int bind(int sockfd, struct sockaddr *my_addr, 
    socklen_t addrlen);
\end{lstlisting}

       Fournit \`a la socket sockfd, l'adresse locale my\_addr.  my\_addr est
       longue  de  addrlen  octets.  Traditionnellement  cette  op\'eration  est
       appel\'ee  ``assignation  d'un  nom  \`a  une  socket''.

\begin{itemize}
\item  La plage de port 1--511 est r\'eserv\'ee au root.

\item  Plage des ports libres:   5001--65535

\item  Attention \`a l'ordre des octets.

\item  retour :renvoie  0 s'il r\'eussit, ou -1 s'il \'echoue, auquel cas errno con-
       tient le code d'erreur.
\end{itemize}
\end{frame}


\subsection{Envoyer et Recevoir}

\begin{frame}[containsverbatim]
\frametitle{Recevoir un message}

\begin{lstlisting}
#include <sys/types.h>     #include <sys/socket.h>
int recvfrom(int s, void *buf, int len, uint flags,
    struct sock_addr *from, socklen_t *fromlen);
\end{lstlisting}
       L'appel-syst\`eme \tty{recvfrom} est utilis\'e pour recevoir  un
       message depuis une socket s (socket orient\'ee connexion ou non).
\begin{itemize}
\item  L'adresse  de  la source du messages est ins\'er\'ee dans from.  L'argument fromlen
       est un param\`etre r\'esultat, initialis\'e \`a la taille du  buffer  from,  et
       modifi\'e  en  retour  pour indiquer la taille r\'eelle de l'adresse enregistr\'ee.
\item La r\'eception  se  mettent  en attente, \`a moins que la socket soit non blo-
       quante  auquel cas la valeur  -1 est renvoy\'ee, et  \tty{errno}
       est  positionn\'ee  \`a  EAGAIN.  Les fonctions de r\'eception renvoient nor-
       malement les donn\'ees disponibles sans attendre d'avoir re\c u  le  nombre
       exact r\'eclam\'e.
\item  La routine renvoie le nombre d'octets lus si elle r\'eussit. 
       Si un message est trop long pour tenir dans le buffer, les octets
       suppl\'ementaires  peuvent  \^etre  abandonn\'es.
\end{itemize}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Serveur en mode non connect\'e}
\mainINudpservmin.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Structure sockaddr \&sockaddr\_in}
\begin{lstlisting}
struct sockaddr {
 unsigned short sa_family; 
 char          sa_data[14]; /* protocol address */
};
struct sockaddr_in {
  short int          sin_family;
  unsigned short int sin_port;  
  struct in_addr     sin_addr;    
  unsigned char      sin_zero[8];   
};
\end{lstlisting}
\begin{itemize}
\item \tty{sa\_family} : AF\_UNIX et AF\_INET sont les plus courantes.
\item \tty{sa\_data}   : addresse de destination et num\'ero de port, nom de
fichier dans le cas AF\_UNIX.
\item La structure g\'en\'erique \tty{sockaddr} est plut\^ot le difficile \`a manier, 
\tty{sockaddr\_in} sp\'ecifique au socket ``internet''.
\item taille identique, transtypage.
\end{itemize}
\end{frame}

\subsection{Test}

\begin{frame}[containsverbatim]
\frametitle{netstat \& client dig}
\begin{lstlisting}
[pl@ou812] ./udpserveur.exe &
           [2] 4078

[pl@ou812] netstat -ap | grep 31415
           udp 0 0 ou812.univ-tln.fr:31415 *:* 
           16257/sdcserv.exe

[pl@ou812] ssh maitinfo1
[pl@maiti] dig HelloWorld @10.2.73.86 -p31415
           28 octets <- 10.9.185.217xHelloWorld
           28 octets <- 10.9.185.217xHelloWorld

; <<>> DiG 9.3.2 <<>> HelloWorld @10.2.73.86 -p31415
; (1 server found)
;; global options:  printcmd
;; connection timed out; no servers could be reached
\end{lstlisting}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{client telnet \& nmap}
\begin{lstlisting}
[pl@ou812] telnet 10.2.73.86  31415
Trying 10.2.73.86...
telnet: connect to address 10.2.73.86: Connection refused
telnet: Unable to connect to remote host: Connection refused

[pl@ou812] su
[ root   ] nmap -sU -p31414-31416 10.2.73.86

Starting Nmap 4.03

           0 octets <- 10.2.73.86

Interesting ports on (10.2.73.86):
PORT      STATE         SERVICE
31414/udp closed        unknown
31415/udp open|filtered unknown
31416/udp closed        unknown

Nmap finished: 1 IP address (1 host up)
\end{lstlisting}
\end{frame}

\section{Implantation bigloop}


\begin{frame}[containsverbatim]
\frametitle{bigloop.c: socket server}
\priseINbigloop.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{bigloop.c: recevoir un ticket}
\recevoirINbigloop.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{bigloop.c: envoyer un ticket}
\envoyerINbigloop.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{bigloop.c: lecture non bloquante}
\zombieINbigloop.c
\end{frame}

\subsection{Synchronisation}

\begin{frame}[containsverbatim]
\frametitle{Grappe de machines}
\lstinputlisting[]{bigloop/master.grp}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Hosts file}
\lstinputlisting[]{bigloop/hosts}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Synchronisation des codes}
\lstinputlisting[language={bash}, emph={sync}]{bigloop/install.sh}
\end{frame}

\subsection{Lancement}

\begin{frame}[containsverbatim]
\frametitle{Lancement du serveur}
\lstinputlisting[language={bash}, emph={nohup}]{bigloop/startbigloop.sh}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Lancement des clients}
\lstinputlisting[firstline=1, language={bash}]{bigloop/joinbigloop.sh}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Surveiller la marmite}
\lstinputlisting[firstline=1, language={bash}]{bigloop/status.sh}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Log des \'echanges}
\lstinputlisting[]{bigloop/nohup.out}
\end{frame}

\subsection{traces}

\begin{frame}[containsverbatim]
\frametitle{Trace des communications}
\lstinputlisting[]{bigloop/tcpdump.txt}
\end{frame}

\subsection{output}

\begin{frame}[containsverbatim]
\frametitle{Valeurs collect\'ees}
\lstinputlisting[]{bigloop/bigloop-1.out}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Facteur de travail}
\lstinputlisting[]{bigloop/bigloop-1.txt}
\end{frame}

\section{Gestion d\'etach\'ee}

\begin{frame}
\frametitle{Mini client/serveur}
\rotatebox{0}{\includegraphics[scale=0.6]{sdc}}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{option : sdcserveur}
\argokINsocktools.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{main : sdcserveur}
\mainINsdcserv.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{sockaddrinlocal:socktools.c}
\sockaddrinlocalINsocktools.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{sdcnet : sdcserveur}
\sdcnetINsdcserv.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{paquet : socktools.c}
\paquetINsocktools.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{Envoyer un message}
\begin{lstlisting}
int sendto(int s, const void *buf, size_t len, int flags,
    const struct sockaddr *to, socklen_t tolen);
\end{lstlisting}
    Les appels syst\`emes \tty{send()}, \tty{sendto()}, et \tty{sendmsg()}
    permettent  de transmettre un message \`a destination d'une autre socket.  
    Si  \tty{sendto()}  est  utilis\'ee  sur une socket en mode connexion 
    (SOCK\_STREAM, SOCK\_SEQPACKET), les param\`etres to et
       tolen sont ignor\'es. Autrement, l'adresse de la cible est fournie 
      par to, tolen sp\'ecifiant sa taille.  

\begin{itemize}
\item Retour :
       S'ils  r\'eussissent, ces appels syst\`emes renvoient le nombre de caract\`eres \'emis.  
       S'ils \'echouent, ils renvoient -1
       et \tty{errno} contient le code d'erreur.
\end{itemize}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{main:sdclient}
\mainINsdclient.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{sockaddrinbyname:socktools.c}
\sockaddrinbynameINsocktools.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{calcul:sdclient}
\calcINsdclient.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{Output}
\lstinputlisting[firstline=1]{jobs.txt}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Capture de trames tcpdump}
\lstinputlisting[firstline=1]{tcpdump.txt}
\end{frame}


\begin{frame}
\frametitle{Gestion d\'etach\'ee}


Les clients lancent leur requ\^ete sur le serveur
qui d\'etache un processus pour la gestion du client.

\begin{itemize}
\item communication interprocessus par socket
\item communication interprocessus par tube
\item m\'emoire partag\'ee.
\end{itemize}

\end{frame}

\begin{frame}
\frametitle{Communication interprocessus par tube}
\rotatebox{-90}{\includegraphics[scale=0.5]{sdcfork}}
\end{frame}

\begin{frame}
\frametitle{Tube de communication, pipe}
\rotatebox{0}{\includegraphics[scale=0.5]{tube}}
\end{frame}

\begin{frame}
\frametitle{Signal SIGCHILD, zombie}
\rotatebox{0}{\includegraphics[scale=0.5]{zombie}}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Nouveau client}
\calculINsdclientfork.c
\end{frame}

\subsection{Utilisation de fork}

\begin{frame}[containsverbatim]
\frametitle{Code du serveur fork}
\sdcINsdcservforktube.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{Tache du fork serveur}
\tacheINsdcservforktube.c
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{Output}
\lstinputlisting[firstline=1]{outputfork.txt}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{[root@ou812]tcpdump -n host ou812 and udp}
\lstinputlisting[firstline=1]{tcpdumpfork.txt}
\end{frame}

\subsection{Code de retour ?}

\begin{frame}[containsverbatim]
\frametitle{tcpdump -n -X -t host ou812 and udp and not port 53}
\lstinputlisting[firstline=1]{tcpdumpexit.txt}
\end{frame}


\begin{frame}[containsverbatim]
\frametitle{Code du serveur fork bas\'e sur code de retour}
\sdcINsdcservforkexit.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Tache du fork serveur bas\'e sur code de retour}
\tacheINsdcservforkexit.c
\end{frame}

\subsection{Utilisation des threads}

\begin{frame}
\frametitle{Utilisation de la m\'emoire partag\'ee}
\rotatebox{0}{\includegraphics[scale=0.5]{sdcthread}}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Tache du thread serveur}
\tacheINsdcservthread.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Thread serveur}
\sdcINsdcservthread.c
\end{frame}

\subsection{Communication TCP}

\begin{frame}
\frametitle{Mode connect\'e}
\rotatebox{-90}{\includegraphics[scale=0.6]{tcp}}
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Mod\`ele de code serveur TCP}
\listenINtcpserv.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Boucle du serveur TCP}
\loopINtcpserv.c
\end{frame}

\begin{frame}[containsverbatim]
\frametitle{Mod\`ele de code client TCP}
\lstinputlisting[emph={connect, write, read}]{clienttcp.c}
\end{frame}


\begin{frame}
\frametitle{Liens vers les sources}
\input urls.tex
\end{frame}

\section{Travaux Pratiques}
\begin{frame}
\frametitle{R\'esolveur}
\begin{enumerate}
\item Reprendre le programme \gcc{whoami.c}. 
\item Compiler, tester.
\item Faire des modifications pour tester les diff\'erents champs
de la variable \gcc{infos}.
\end{enumerate}
\end{frame}

\begin{frame}
\frametitle{Messagerie}
\begin{enumerate}
\item Utiliser le protocole \gcc{udp} pour \'ecrire
un syst\`eme de messagerie entre deux utilisateurs
sur deux h\^otes.
\item D\'ecrire un protocole de communication pour g\'erer
les messages entre plusieurs utilisateurs : un serveur
qui re\c coit les messages, et les renvoie vers les
clients abonn\'es.
\item Modifier votre code pour g\'erer les communications
entre plusieurs utilisateurs.
\item Changer d'approche en vous basant sur la diffusion IP.
\end{enumerate}
\end{frame}

\begin{frame}
\frametitle{Un mini DNS}
\begin{enumerate}
\item Trouver les RFCs qui d\'ecrivent la structure des
paquets DNS.
\item  Quels sont les fondateurs du DNS ?
\item Ecrire un serveur qui lit un paquet DNS, puis affiche
son contenu en utilisant la description des RFCs.
\item Modifier le serveur pour donner une r\'eponse
correctement format\'ee.
\item Transformer votre serveur pour qu'il r\'eponde
correctement aux requ\^etes qui lui sont adress\'e.
\end{enumerate}
\end{frame}

\begin{frame}
\frametitle{Connection TCP}
\begin{enumerate}
\item Ecrire un client \shell{nc}, v\'erifier le
fonctionnement du code client en utilisant un
serveur \shell{nc}.
\item Ecrire un serveur \shell{nc}.
\item V\'erifier le fonctionnement de votre
application.
\end{enumerate}
\end{frame}

\end{document}



