Corretti i commenti ai listati in una forma piu' leggibile (spero).
authorSimone Piccardi <piccardi@gnulinux.it>
Tue, 29 Apr 2003 15:33:39 +0000 (15:33 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Tue, 29 Apr 2003 15:33:39 +0000 (15:33 +0000)
Proseguito nella revisione dei nomi dei programmi. Inseriti gli opportuni
link all'IETF per tutti gli RFC

31 files changed:
elemtcp.tex
listati/ComputeValues.c
listati/DirMonitor.c
listati/DirScan.c
listati/EchoServerWrong.c [deleted file]
listati/ElemDaytimeTCPCuncServ.c [deleted file]
listati/ElemDaytimeTCPServer.c [deleted file]
listati/Flock.c
listati/FortuneClient.c
listati/FortuneServer.c
listati/LockFile.c
listati/MQFortuneClient.c
listati/MQFortuneServer.c
listati/MemShared.c
listati/Mutex.c
listati/MutexLocking.c
listati/ReadMonitor.c
listati/SharedMem.c
listati/Signal.c
listati/TCP_cunc_daytimed.c [new file with mode: 0644]
listati/TCP_echo_client.c [new file with mode: 0644]
netlayer.tex
network.tex
sources/ElemDaytimeTCPCuncServ.c [deleted file]
sources/ElemDaytimeTCPServer.c [deleted file]
sources/ElemEchoTCPClient.c
sources/Makefile
sources/TCP_cunc_daytimed.c [new file with mode: 0644]
sources/TCP_daytime.c
sources/TCP_iter_daytimed.c [new file with mode: 0644]
system.tex

index c57bbcf6f8aa0080bd5cb92878eb8c37b59242ba..b074cb0fbb39a6712b371d3d2a440349284f9a26 100644 (file)
@@ -9,7 +9,7 @@
 %% License".
 %%
 \chapter{Socket TCP}
 %% License".
 %%
 \chapter{Socket TCP}
-\label{cha:elem_TCP_sock}
+\label{cha:TCP_socket}
 
 In questo capitolo iniziamo ad approfondire la conoscenza dei socket TCP,
 iniziando con una descrizione delle principali caratteristiche del
 
 In questo capitolo iniziamo ad approfondire la conoscenza dei socket TCP,
 iniziando con una descrizione delle principali caratteristiche del
@@ -1108,7 +1108,6 @@ scritti nella struttura puntata da \param{name}. Si tenga presente che se si 
 utilizzato un buffer troppo piccolo per \param{name} l'indirizzo risulterà
 troncato.
 
 utilizzato un buffer troppo piccolo per \param{name} l'indirizzo risulterà
 troncato.
 
-
 La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un
 socket; ad esempio può essere usata da un client (che usualmente non chiama
 \func{bind}) per ottenere numero IP e porta locale associati al socket
 La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un
 socket; ad esempio può essere usata da un client (che usualmente non chiama
 \func{bind}) per ottenere numero IP e porta locale associati al socket
@@ -1146,7 +1145,8 @@ restituisce l'indirizzo remoto del socket, cio
 capo della connessione.  Ci si può chiedere a cosa serva questa funzione dato
 che dal lato client l'indirizzo remoto è sempre noto quando si esegue la
 \func{connect} mentre dal lato server si possono usare, come vedremo in
 capo della connessione.  Ci si può chiedere a cosa serva questa funzione dato
 che dal lato client l'indirizzo remoto è sempre noto quando si esegue la
 \func{connect} mentre dal lato server si possono usare, come vedremo in
-\figref{fig:TCP_cunc_serv_code}, i valori di ritorno di \func{accept}.
+\figref{fig:TCP_daytime_cunc_server_code}, i valori di ritorno di
+\func{accept}.
 
 Il fatto è che in generale quest'ultimo caso non è sempre possibile.  In
 particolare questo avviene quando il server, invece di gestire la connessione
 
 Il fatto è che in generale quest'ultimo caso non è sempre possibile.  In
 particolare questo avviene quando il server, invece di gestire la connessione
@@ -1299,11 +1299,12 @@ nell'\href{http://www.ietf.org/rfc/rfc0867.txt}{RFC~867}, che restituisce
 l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
 alla porta 13.
 
 l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
 alla porta 13.
 
-In \figref{fig:TCP_cli_code} è riportata la sezione principale del codice del
-nostro client. Il sorgente completo del programma (\file{TCP_daytime.c}, che
-comprende il trattamento delle opzioni ed una funzione per stampare un
-messaggio di aiuto) è allegato alla guida nella sezione dei codici sorgente e
-può essere compilato su una qualunque macchina GNU/Linux.
+In \figref{fig:TCP_daytime_client_code} è riportata la sezione principale del
+codice del nostro client. Il sorgente completo del programma
+(\file{TCP\_daytime.c}, che comprende il trattamento delle opzioni ed una
+funzione per stampare un messaggio di aiuto) è allegato alla guida nella
+sezione dei codici sorgente e può essere compilato su una qualunque macchina
+GNU/Linux.
 
 \begin{figure}[!htb]
   \footnotesize \centering
 
 \begin{figure}[!htb]
   \footnotesize \centering
@@ -1350,9 +1351,10 @@ ritorna (\texttt{\small 31}).
 
 Completata con successo la connessione il passo successivo (\texttt{\small
   34--40}) è leggere la data dal socket; il protocollo prevede che il server
 
 Completata con successo la connessione il passo successivo (\texttt{\small
   34--40}) è leggere la data dal socket; il protocollo prevede che il server
-invii sempre una stringa alfanumerica di 26 caratteri, nella forma giorno
-della settimana, mese, ora minuto e secondo, anno, seguita dai caratteri di
-terminazione \verb|\r\n|, cioè qualcosa del tipo:
+invii sempre una stringa alfanumerica, il formato della stringa non è
+specificato dallo standard, per cui noi useremo il formato usato dalla
+funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè
+qualcosa del tipo:
 \begin{verbatim}
 Wed Apr 4 00:53:00 2001\r\n
 \end{verbatim}
 \begin{verbatim}
 Wed Apr 4 00:53:00 2001\r\n
 \end{verbatim}
@@ -1399,7 +1401,7 @@ elementare, che sia anche in grado di rispondere al precedente client. Come
 primo esempio realizzeremo un server iterativo, in grado di fornire una sola
 risposta alla volta. Il codice del programma è nuovamente mostrato in
 \figref{fig:TCP_daytime_iter_server_code}, il sorgente completo
 primo esempio realizzeremo un server iterativo, in grado di fornire una sola
 risposta alla volta. Il codice del programma è nuovamente mostrato in
 \figref{fig:TCP_daytime_iter_server_code}, il sorgente completo
-(\file{TCP_iter_daytimed.c}) è allegato insieme agli altri file degli esempi.
+(\file{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli esempi.
 
 \begin{figure}[!htbp]
   \footnotesize \centering
 
 \begin{figure}[!htbp]
   \footnotesize \centering
@@ -1477,36 +1479,37 @@ non 
 \subsection{Un server \textit{daytime} concorrente}
 \label{sec:TCP_daytime_cunc_server}
 
 \subsection{Un server \textit{daytime} concorrente}
 \label{sec:TCP_daytime_cunc_server}
 
-Il server \texttt{daytime} dell'esempio in \secref{sec:TCP_daytime_client} è un
-tipico esempio di server iterativo, in cui viene servita una richiesta alla
-volta; in generale però, specie se il servizio è più complesso e comporta uno
-scambio di dati più sostanzioso di quello in questione, non è opportuno
-bloccare un server nel servizio di un client per volta; per questo si ricorre
-alle capacità di multitasking del sistema.
+Il server \texttt{daytime} dell'esempio in
+\secref{sec:TCP_daytime_iter_server} è un tipico esempio di server iterativo,
+in cui viene servita una richiesta alla volta; in generale però, specie se il
+servizio è più complesso e comporta uno scambio di dati più sostanzioso di
+quello in questione, non è opportuno bloccare un server nel servizio di un
+client per volta; per questo si ricorre alle capacità di multitasking del
+sistema.
 
 Come accennato anche in \secref{sec:proc_gen} una delle modalità più comuni di
 funzionamento da parte dei server è quella di usare la funzione \func{fork}
 per creare, ad ogni richiesta da parte di un client, un processo figlio che si
 incarichi della gestione della comunicazione.  Si è allora riscritto il server
 
 Come accennato anche in \secref{sec:proc_gen} una delle modalità più comuni di
 funzionamento da parte dei server è quella di usare la funzione \func{fork}
 per creare, ad ogni richiesta da parte di un client, un processo figlio che si
 incarichi della gestione della comunicazione.  Si è allora riscritto il server
-\texttt{daytime} dell'esempio precedente in forma concorrente, inserendo anche
+\textit{daytime} dell'esempio precedente in forma concorrente, inserendo anche
 una opzione per la stampa degli indirizzi delle connessioni ricevute.
 
 una opzione per la stampa degli indirizzi delle connessioni ricevute.
 
-In \figref{fig:TCP_cunc_serv_code} è mostrato un estratto del codice, in cui
-si sono tralasciati il trattamento delle opzioni e le parti rimaste invariate
-rispetto al precedente esempio (cioè tutta la parte riguardante l'apertura
-passiva del socket). Al solito il sorgente completo del server, nel file
-\file{ElemDaytimeTCPCuncServ.c}, è allegato insieme ai sorgenti degli altri
-esempi.
+In \figref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del
+codice, in cui si sono tralasciati il trattamento delle opzioni e le parti
+rimaste invariate rispetto al precedente esempio (cioè tutta la parte
+riguardante l'apertura passiva del socket). Al solito il sorgente completo del
+server, nel file \file{TCP\_cunc\_daytimed.c}, è allegato insieme ai sorgenti
+degli altri esempi.
 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15cm}
-    \includecodesample{listati/ElemDaytimeTCPCuncServ.c}
+    \includecodesample{listati/TCP_cunc_daytimed.c}
   \end{minipage} 
   \normalsize
   \caption{Esempio di codice di un server concorrente elementare per il 
     servizio daytime.}
   \end{minipage} 
   \normalsize
   \caption{Esempio di codice di un server concorrente elementare per il 
     servizio daytime.}
-  \label{fig:TCP_cunc_serv_code}
+  \label{fig:TCP_daytime_cunc_server_code}
 \end{figure}
 
 Stavolta (\texttt{\small 21--25}) la funzione \func{accept} è chiamata
 \end{figure}
 
 Stavolta (\texttt{\small 21--25}) la funzione \func{accept} è chiamata
@@ -1577,6 +1580,7 @@ torneremo su questo pi
 complessi.
 
 
 complessi.
 
 
+
 \section{Un esempio più completo: il servizio \textit{echo}}
 \label{sec:TCP_echo_application}
 
 \section{Un esempio più completo: il servizio \textit{echo}}
 \label{sec:TCP_echo_application}
 
@@ -1587,54 +1591,58 @@ un po' pi
 le direzioni, implementando il servizio standard \textit{echo}, così come
 definito dall'\href{http://www.ietf.org/rfc/rfc0862.txt}{RFC~862}.  
 
 le direzioni, implementando il servizio standard \textit{echo}, così come
 definito dall'\href{http://www.ietf.org/rfc/rfc0862.txt}{RFC~862}.  
 
-Si è scelto di usare questo servizio, seguendo l'esempio di \cite{UNP1},
-perché costituisce il prototipo ideale di una generica applicazione di rete in
-cui un server risponde alle richieste di un client; nel caso di una
-applicazione più complessa si potrà avere in più una elaborazione dell'input
-del client da parte del server nel fornire le risposte in uscita.
+Si è scelto, seguendo l'esempio di \cite{UNP1}, di usare questo servizio, che
+si limita a restituire in uscita quanto immesso in ingresso, perché nonostante
+la sua estrema semplicità costituisce il prototipo ideale di una generica
+applicazione di rete in cui un server risponde alle richieste di un client;
+nel caso di una applicazione più complessa si potrà avere in più una
+elaborazione dell'input del client da parte del server nel fornire le risposte
+in uscita.
 
 
-Ci limiteremo ad un esempio elementare, che usi solo le funzioni di base, ma
-prenderemo in esame, oltre al comportamento in condizioni normali, anche tutti
-i possibili scenari particolari (errori, sconnessione della rete, crash del
-client o del server durante la connessione) che possono avere luogo durante
-l'impiego di un'applicazione di rete.  
+Ci limiteremo per ora ad una implementazione elementare, che usi solo le
+funzioni di base, ma prenderemo in esame, oltre al comportamento in condizioni
+normali, anche tutti i possibili scenari particolari (errori, sconnessione
+della rete, crash del client o del server durante la connessione) che possono
+avere luogo durante l'impiego di un'applicazione di rete, partendo da una
+versione primitiva che dovrà essere rimaneggiata di volta in volta per poter
+tenere conto di tutte le evenienze che si possono manifestare nella vita reale
+di un'applicazione di rete, fino ad arrivare ad un'implementazione completa.
 
 
-Partiremo da un'implementazione elementare che dovrà essere rimaneggiata di
-volta in volta per poter tenere conto di tutte le evenienze che si possono
-manifestare nella vita reale di un'applicazione di rete, fino ad arrivare ad
-un'implementazione completa.
 
 \subsection{Il client: prima versione}
 \label{sec:TCP_echo_client}
 
 
 \subsection{Il client: prima versione}
 \label{sec:TCP_echo_client}
 
-Il codice del client è riportato in \figref{fig:TCPsimpl_client_elem}, anche
-esso ricalca la struttura del precedente client per il servizio
-\texttt{daytime} (vedi \secref{sec:TCP_daytime_client}) ma, come per il
-server, lo si è diviso in due parti, inserendo la parte relativa alle
-operazioni specifiche previste per il protocollo \textit{echo} in una funzione
-a parte.
+Il codice della prima versione client per il servizio \textit{echo} è
+riportato in \figref{fig:TCP_echo_client_1}. Esso ricalca la struttura del
+precedente client per il servizio \textit{daytime} (vedi
+\secref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27}) è
+sostanzialmente identica, a parte l'uso di una porta diversa.
 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15.6 cm}
 
 \begin{figure}[!htb]
   \footnotesize \centering
   \begin{minipage}[c]{15.6 cm}
-    \includecodesample{listati/EchoServerWrong.c}
+    \includecodesample{listati/TCP_echo_client.c}
   \end{minipage} 
   \normalsize
   \caption{Codice della prima versione del client \textit{echo}.}
   \end{minipage} 
   \normalsize
   \caption{Codice della prima versione del client \textit{echo}.}
-  \label{fig:TCPsimpl_client_elem}
+  \label{fig:TCP_echo_client_1}
 \end{figure}
 
 \end{figure}
 
-La funzione \code{main} si occupa della creazione del socket e della
-connessione (linee \texttt{\small 10--27}) secondo la stessa modalità spiegata
-in \secref{sec:TCP_daytime_client}, il client si connette sulla porta 7
-all'indirizzo specificato dalla linea di comando (a cui si è aggiunta una
-elementare gestione delle opzioni non riportata in figura).
-
-Completata la connessione, al ritorno di \func{connect}, la funzione
-\code{ClientEcho}, riportata in \figref{fig:TCPsimpl_client_echo_sub}, si
-preoccupa di gestire la comunicazione, leggendo una riga alla volta dallo
-\file{stdin}, scrivendola sul socket e ristampando su \file{stdout} quanto
-ricevuto in risposta dal server.
+Al solito si è tralasciata la sezione relativa alla gestione delle opzioni a
+riga di comando; una volta dichiarate le variabili, si prosegue
+(\texttt{\small 10--13}) con della creazione del socket, la preparazione
+(\texttt{\small 14--17}) la struttura per l'indirizzo, con la relativa
+conversione (\texttt{\small 18--22}) di quanto specificato a riga di comando.
+
+A questo punto (\texttt{\small 23--27}) si può eseguire la connessione al
+server secondo la stessa modalità usata in \secref{sec:TCP_daytime_client}.
+Completata la connessione, al ritorno di \func{connect}, si usa la funzione
+\code{ClientEcho}, il cui codice è riportato in
+\figref{fig:TCPsimpl_client_echo_sub}. Questa si preoccupa di gestire tutta la
+comunicazione, leggendo una riga alla volta dallo standard input \file{stdin},
+scrivendola sul socket e ristampando su \file{stdout} quanto ricevuto in
+risposta dal server. Al ritorno dalla funzione (\texttt{\small 30--31}) anche
+il programma termina.
 
 \begin{figure}[!htb]
   \footnotesize \centering
 
 \begin{figure}[!htb]
   \footnotesize \centering
@@ -1647,27 +1655,28 @@ ricevuto in risposta dal server.
   \label{fig:TCPsimpl_client_echo_sub}
 \end{figure}
 
   \label{fig:TCPsimpl_client_echo_sub}
 \end{figure}
 
-La funzione utilizza due buffer per gestire i dati inviati e letti sul socket
-(\texttt{\small 3}).  La comunicazione viene gestita all'interno di un ciclo
-(linee \texttt{\small 5--10}), i dati da inviare sulla connessione vengono
-presi dallo \file{stdin} usando la funzione \func{fgets} che legge una
-linea di testo (terminata da un \texttt{CR} e fino al massimo di
-\const{MAXLINE} caratteri) e la salva sul buffer di invio, la funzione
-\func{FullWrite} (\texttt{\small 3}) scrive detti dati sul socket (gestendo
-l'invio multiplo qualora una singola \func{write} non basti, come spiegato
-in \secref{sec:sock_io_behav}).
+La funzione \code{ClientEcho} utilizza due buffer (\texttt{\small 3}) per
+gestire i dati inviati e letti sul socket.  La comunicazione viene gestita
+all'interno di un ciclo (\texttt{\small 5--10}), i dati da inviare sulla
+connessione vengono presi dallo \file{stdin} usando la funzione \func{fgets},
+trattata in \secref{sec:file_line_io}, che legge una linea di testo (terminata
+da un \texttt{CR} e fino al massimo di \const{MAXLINE} caratteri) e la salva
+sul buffer di invio, la funzione \func{FullWrite}, già vista in
+\figref{fig:sock_FullWrite_code}, scrive (\texttt{\small 6}) i dati sul socket
+(gestendo l'invio multiplo qualora una singola \func{write} non basti, come
+spiegato in \secref{sec:sock_io_behav}).
 
 
-I dati che vengono riletti indietro con una \func{FullRead} sul buffer di
-ricezione e viene inserita la terminazione della stringa (\texttt{\small
-  7--8}) e per poter usare la funzione \func{fputs} per scriverli su
-\file{stdout}. 
+I dati vengono riletti indietro (\texttt{\small 7}) con una \func{FullRead}
+sul buffer di ricezione e viene inserita (\texttt{\small 8}) la terminazione
+della stringa e per poter usare (\texttt{\small 9}) la funzione \func{fputs}
+per scriverli su \file{stdout}.
 
 
-Un end of file inviato su \file{stdin} causa il ritorno di \func{fgets}
-con un puntatore nullo e l'uscita dal ciclo, al che la subroutine ritorna ed
-il client esce.
+Un end-of-file inviato su \file{stdin} (ad esempio con la pressione di
+\texttt{C-d}) causa il ritorno di \func{fgets} con un puntatore nullo e la
+conseguente uscita dal ciclo, al che la subroutine ritorna ed il client esce.
 
 
 
 
-\subsection{La struttura del server}
+\subsection{Il server: prima versione}
 \label{sec:TCPsimp_server_main}
 
 Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti
 \label{sec:TCPsimp_server_main}
 
 Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti
@@ -1705,7 +1714,7 @@ nel precedente esempio esaminato in \secref{sec:TCP_daytime_cunc_server}.
 La struttura di questa prima versione del server è sostanzialmente identica a
 quella dell'esempio citato, ed ad esso si applicano le considerazioni fatte in
 \secref{sec:TCP_daytime_cunc_server}. Le uniche differenze rispetto
 La struttura di questa prima versione del server è sostanzialmente identica a
 quella dell'esempio citato, ed ad esso si applicano le considerazioni fatte in
 \secref{sec:TCP_daytime_cunc_server}. Le uniche differenze rispetto
-all'esempio in \figref{fig:TCP_daytime_iter_server_code} sono che in questo
+all'esempio in \figref{fig:TCP_daytime_cunc_server_code} sono che in questo
 caso per il socket in ascolto viene usata la porta 7 e che tutta la gestione
 della comunicazione è delegata alla funzione \code{ServEcho}.
 %  Per ogni connessione viene creato un
 caso per il socket in ascolto viene usata la porta 7 e che tutta la gestione
 della comunicazione è delegata alla funzione \code{ServEcho}.
 %  Per ogni connessione viene creato un
index bc11c2850a7c965b1e13768f781bec8e5491ea05..e3c61f1419e135589de83a16682966460c435bfa 100644 (file)
@@ -2,7 +2,7 @@
 int ComputeValues(struct dirent * direntry) 
 {
     struct stat data;
 int ComputeValues(struct dirent * direntry) 
 {
     struct stat data;
-    stat(direntry->d_name, &data);                          /* get stat data */
+    stat(direntry->d_name, &data);      /* get stat data */
     shmptr->tot_size += data.st_size;
     shmptr->tot_files++;
     if (S_ISREG(data.st_mode)) shmptr->tot_regular++;
     shmptr->tot_size += data.st_size;
     shmptr->tot_files++;
     if (S_ISREG(data.st_mode)) shmptr->tot_regular++;
index edd5bb9eae458c0216207eb5cd794070dcaace30..65173c86ddef116fcf188c8d4d578efb7949d7d0 100644 (file)
@@ -17,33 +17,33 @@ int main(int argc, char *argv[])
 {
     int i, pause = 10;
     ...
 {
     int i, pause = 10;
     ...
-    if ((argc - optind) != 1) {          /* There must be remaing parameters */
+    if ((argc - optind) != 1) {   /* There must be remaing parameters */
         printf("Wrong number of arguments %d\n", argc - optind);
         usage();
     }
         printf("Wrong number of arguments %d\n", argc - optind);
         usage();
     }
-    if (chdir(argv[1])) {                      /* chdir to be sure dir exist */
+    if (chdir(argv[1])) {         /* chdir to be sure dir exist */
         perror("Cannot find directory to monitor");
     }
         perror("Cannot find directory to monitor");
     }
-    Signal(SIGTERM, HandSIGTERM);            /* set handlers for termination */
+    Signal(SIGTERM, HandSIGTERM); /* set handlers for termination */
     Signal(SIGINT, HandSIGTERM);
     Signal(SIGQUIT, HandSIGTERM);
     Signal(SIGINT, HandSIGTERM);
     Signal(SIGQUIT, HandSIGTERM);
-    key = ftok("~/gapil/sources/DirMonitor.c", 1);           /* define a key */
-    shmptr = ShmCreate(key, 4096, 0666, 0);   /* get a shared memory segment */
+    key = ftok("~/gapil/sources/DirMonitor.c", 1); /* define a key */
+    shmptr = ShmCreate(key, 4096, 0666, 0); /* get a shared memory segment */
     if (!shmptr) {
         perror("Cannot create shared memory");
         exit(1);
     }
     if (!shmptr) {
         perror("Cannot create shared memory");
         exit(1);
     }
-    if ((mutex = MutexCreate(key)) == -1) {                   /* get a Mutex */
+    if ((mutex = MutexCreate(key)) == -1) {        /* get a Mutex */
         perror("Cannot create mutex");
         exit(1);
     }
     /* main loop, monitor directory properties each 10 sec */
         perror("Cannot create mutex");
         exit(1);
     }
     /* main loop, monitor directory properties each 10 sec */
-    daemon(1, 0);              /* demonize process, staying in monitored dir */
+    daemon(1, 0);           /* demonize process, staying in monitored dir */
     while (1) {
     while (1) {
-        MutexLock(mutex);                              /* lock shared memory */
-        memset(shmptr, 0, sizeof(struct DirProp));    /* erase previous data */
-        DirScan(argv[1], ComputeValues);                     /* execute scan */
-        MutexUnlock(mutex);                          /* unlock shared memory */
-        sleep(pause);                              /* sleep until next watch */
+        MutexLock(mutex);   /* lock shared memory */
+        memset(shmptr, 0, sizeof(struct DirProp)); /* erase previous data */
+        DirScan(argv[1], ComputeValues);           /* execute scan */
+        MutexUnlock(mutex); /* unlock shared memory */
+        sleep(pause);       /* sleep until next watch */
     }
 }
     }
 }
index 725b524c4892d0dce9af3a167337641e40aae1c2..b54b15da866c75efd2cabd574b621be93a1d9e59 100644 (file)
@@ -15,17 +15,17 @@ int DirScan(char * dirname, int(*compute)(struct dirent *))
     DIR * dir;
     struct dirent *direntry;
 
     DIR * dir;
     struct dirent *direntry;
 
-    if ( (dir = opendir(dirname)) == NULL) {               /* oper directory */
-        printf("Opening %s\n", dirname);          /* on error print messages */
-        perror("Cannot open directory");                  /* and then return */
+    if ( (dir = opendir(dirname)) == NULL) { /* open directory */
+        printf("Opening %s\n", dirname);     /* on error print messages */
+        perror("Cannot open directory");     /* and then return */
         return -1;
     }
         return -1;
     }
-    fd = dirfd(dir);                                  /* get file descriptor */
-    fchdir(fd);                                          /* change directory */
+    fd = dirfd(dir);                        /* get file descriptor */
+    fchdir(fd);                             /* change directory */
     /* loop on directory entries */
     /* loop on directory entries */
-    while ( (direntry = readdir(dir)) != NULL) {               /* read entry */
-        if (compute(direntry)) {                   /* execute function on it */
-            return -1;                                    /* on error return */
+    while ( (direntry = readdir(dir)) != NULL) { /* read entry */
+        if (compute(direntry)) {            /* execute function on it */
+            return -1;                      /* on error return */
         }
     }
     closedir(dir);
         }
     }
     closedir(dir);
diff --git a/listati/EchoServerWrong.c b/listati/EchoServerWrong.c
deleted file mode 100644 (file)
index f9a67b6..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-int main(int argc, char *argv[])
-{
-/* 
- * Variables definition  
- */
-    int sock_fd, i;
-    struct sockaddr_in serv_add;
-    ...
-    /* create socket */
-    if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-        perror("Socket creation error");
-        return -1;
-    }
-    /* initialize address */
-    memset((void *) &serv_add, 0, sizeof(serv_add)); /* clear server address */
-    serv_add.sin_family = AF_INET;                   /* address type is INET */
-    serv_add.sin_port = htons(7);                    /* echo port is 7 */
-    /* build address using inet_pton */
-    if ( (inet_pton(AF_INET, argv[optind], &serv_add.sin_addr)) <= 0) {
-        perror("Address creation error");
-        return -1;
-    }
-    /* extablish connection */
-    if (connect(sock_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
-        perror("Connection error");
-        return -1;
-    }
-    /* read daytime from server */
-    ClientEcho(stdin, sock_fd);
-    /* normal exit */
-    return 0;
-}
diff --git a/listati/ElemDaytimeTCPCuncServ.c b/listati/ElemDaytimeTCPCuncServ.c
deleted file mode 100644 (file)
index 9af8cc7..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <sys/types.h>   /* predefined types */
-#include <unistd.h>      /* include unix standard library */
-#include <arpa/inet.h>   /* IP addresses conversion utililites */
-#include <sys/socket.h>  /* socket library */
-#include <stdio.h>       /* include standard I/O library */
-#include <time.h>
-
-int main(int argc, char *argv[])
-{
-    int list_fd, conn_fd;
-    int i;
-    struct sockaddr_in serv_add, client;
-    char buffer[MAXLINE];
-    socklen_t len;
-    time_t timeval;
-    pid_t pid;
-    int logging=0;
-     ...
-    /* write daytime to client */
-    while (1) {
-        if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len)) 
-             <0 ) {
-            perror("accept error");
-            exit(-1);
-        }
-        /* fork to handle connection */
-        if ( (pid = fork()) < 0 ){
-            perror("fork error");
-            exit(-1);
-        }
-        if (pid == 0) {                 /* child */
-            close(list_fd);
-            timeval = time(NULL);
-            snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
-            if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
-                perror("write error");
-                exit(-1);
-            }
-            if (logging) {
-                inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
-                printf("Request from host %s, port %d\n", buffer,
-                       ntohs(client.sin_port));
-            }
-            close(conn_fd);
-            exit(0);
-        } else {                        /* parent */
-            close(conn_fd);
-        }
-    }
-    /* normal exit, never reached */
-    exit(0);
-}
diff --git a/listati/ElemDaytimeTCPServer.c b/listati/ElemDaytimeTCPServer.c
deleted file mode 100644 (file)
index 5f9b116..0000000
+++ /dev/null
@@ -1,56 +0,0 @@
-#include <sys/types.h>   /* predefined types */
-#include <unistd.h>      /* include unix standard library */
-#include <arpa/inet.h>   /* IP addresses conversion utilities */
-#include <sys/socket.h>  /* socket library */
-#include <stdio.h>       /* include standard I/O library */
-#include <time.h>
-#define MAXLINE 80
-#define BACKLOG 10
-int main(int argc, char *argv[])
-{
-/* 
- * Variables definition  
- */
-    int list_fd, conn_fd;
-    int i;
-    struct sockaddr_in serv_add;
-    char buffer[MAXLINE];
-    time_t timeval;
-    ...
-    /* create socket */
-    if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-        perror("Socket creation error");
-        exit(-1);
-    }
-    /* initialize address */
-    memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
-    serv_add.sin_family = AF_INET;                  /* address type is INET */
-    serv_add.sin_port = htons(13);                  /* daytime port is 13 */
-    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
-    /* bind socket */
-    if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
-        perror("bind error");
-        exit(-1);
-    }
-    /* listen on socket */
-    if (listen(list_fd, BACKLOG) < 0 ) {
-        perror("listen error");
-        exit(-1);
-    }
-    /* write daytime to client */
-    while (1) {
-        if ( (conn_fd = accept(list_fd, (struct sockaddr *) NULL, NULL)) <0 ) {
-            perror("accept error");
-            exit(-1);
-        }
-        timeval = time(NULL);
-        snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
-        if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
-            perror("write error");
-            exit(-1);
-        }
-        close(conn_fd);
-    }
-    /* normal exit */
-    exit(0);
-}
index cf85d3bcac7723dd2dcab34c06ecfae18a4b3863..59bc48a55f769e7ca0abb4948cdedd70516b97cf 100644 (file)
@@ -1,52 +1,52 @@
 int main(int argc, char *argv[])
 {
 int main(int argc, char *argv[])
 {
-    int type = F_UNLCK;            /* lock type: default to unlock (invalid) */
-    off_t start = 0;             /* start of the locked region: default to 0 */
-    off_t len = 0;              /* length of the locked region: default to 0 */
-    int fd, res, i;                                    /* internal variables */
-    int bsd = 0;                          /* semantic type: default to POSIX */
-    int cmd = F_SETLK;              /* lock command: default to non-blocking */
-    struct flock lock;                                /* file lock structure */
+    int type = F_UNLCK; /* lock type: default to unlock (invalid) */
+    off_t start = 0;    /* start of the locked region: default to 0 */
+    off_t len = 0;      /* length of the locked region: default to 0 */
+    int fd, res, i;     /* internal variables */
+    int bsd = 0;        /* semantic type: default to POSIX */
+    int cmd = F_SETLK;  /* lock command: default to non-blocking */
+    struct flock lock;  /* file lock structure */
     ...
     ...
-    if ((argc - optind) != 1) {          /* There must be remaing parameters */
+    if ((argc - optind) != 1) {      /* There must be remaing parameters */
         printf("Wrong number of arguments %d\n", argc - optind);
         usage();
     }
         printf("Wrong number of arguments %d\n", argc - optind);
         usage();
     }
-    if (type == F_UNLCK) {            /* There must be a -w or -r option set */
+    if (type == F_UNLCK) {           /* There must be a -w or -r option set */
         printf("You should set a read or a write lock\n");
         usage();
     }
         printf("You should set a read or a write lock\n");
         usage();
     }
-    fd = open(argv[optind], O_RDWR);           /* open the file to be locked */
-    if (fd < 0) {                                           /* on error exit */
+    fd = open(argv[optind], O_RDWR); /* open the file to be locked */
+    if (fd < 0) {                    /* on error exit */
         perror("Wrong filename");
         exit(1);
     }
     /* do lock */
         perror("Wrong filename");
         exit(1);
     }
     /* do lock */
-    if (bsd) {                                             /* if BSD locking */
+    if (bsd) {   /* if BSD locking */
         /* rewrite cmd for suitables flock operation values */ 
         /* rewrite cmd for suitables flock operation values */ 
-        if (cmd == F_SETLKW) {                             /* if no-blocking */
-            cmd = LOCK_NB;              /* set the value for flock operation */
-        } else {                                                     /* else */
-            cmd = 0;                                      /* default is null */
+        if (cmd == F_SETLKW) {       /* if no-blocking */
+            cmd = LOCK_NB;           /* set the value for flock operation */
+        } else { /* else */
+            cmd = 0;                 /* default is null */
         }
         }
-        if (type == F_RDLCK) cmd |= LOCK_SH;          /* set for shared lock */
-        if (type == F_WRLCK) cmd |= LOCK_EX;       /* set for exclusive lock */
-        res = flock(fd, cmd);                                /* esecute lock */
-    } else {                                             /* if POSIX locking */
+        if (type == F_RDLCK) cmd |= LOCK_SH; /* set for shared lock */
+        if (type == F_WRLCK) cmd |= LOCK_EX; /* set for exclusive lock */
+        res = flock(fd, cmd);                /* esecute lock */
+    } else {     /* if POSIX locking */
         /* setting flock structure */
         /* setting flock structure */
-        lock.l_type = type;                       /* set type: read or write */
+        lock.l_type = type;          /* set type: read or write */
         lock.l_whence = SEEK_SET;    /* start from the beginning of the file */
         lock.l_whence = SEEK_SET;    /* start from the beginning of the file */
-        lock.l_start = start;          /* set the start of the locked region */
-        lock.l_len = len;             /* set the length of the locked region */
-        res = fcntl(fd, cmd, &lock);                              /* do lock */
+        lock.l_start = start;        /* set the start of the locked region */
+        lock.l_len = len;            /* set the length of the locked region */
+        res = fcntl(fd, cmd, &lock); /* do lock */
     }
     /* check lock results */
     }
     /* check lock results */
-    if (res) {                                              /* on error exit */
+    if (res) {   /* on error exit */
         perror("Failed lock");
         exit(1);
         perror("Failed lock");
         exit(1);
-    } else {                                           /* else write message */
+    } else {     /* else write message */
         printf("Lock acquired\n");
     }
         printf("Lock acquired\n");
     }
-    pause();                       /* stop the process, use a signal to exit */
+    pause();     /* stop the process, use a signal to exit */
     return 0;
 }
     return 0;
 }
index f0c1030ab27842b47b427f74adc6748a81d81eb0..6baad6197f16b1abb6503be08cdc0bccb408a4db 100644 (file)
@@ -9,28 +9,28 @@ int main(int argc, char *argv[])
     int nread;
     char buffer[PIPE_BUF];
     ...
     int nread;
     char buffer[PIPE_BUF];
     ...
-    snprintf(fifoname, 80, "/tmp/fortune.%d", getpid());     /* compose name */
-    if (mkfifo(fifoname, 0622)) {                        /* open client fifo */
+    snprintf(fifoname, 80, "/tmp/fortune.%d", getpid()); /* compose name */
+    if (mkfifo(fifoname, 0622)) { /* open client fifo */
         if (errno!=EEXIST) {
             perror("Cannot create well known fifo");
             exit(-1);
         }
     }
         if (errno!=EEXIST) {
             perror("Cannot create well known fifo");
             exit(-1);
         }
     }
-    fifo_server = open(fortunefilename, O_WRONLY);       /* open server fifo */
+    fifo_server = open(fortunefilename, O_WRONLY); /* open server fifo */
     if (fifo_server < 0) {
         perror("Cannot open well known fifo");
         exit(-1);
     }
     if (fifo_server < 0) {
         perror("Cannot open well known fifo");
         exit(-1);
     }
-    nread = write(fifo_server, fifoname, strlen(fifoname)+1);  /* write name */
-    close(fifo_server);                                 /* close server fifo */
-    fifo_client = open(fifoname, O_RDONLY);              /* open client fifo */
+    nread = write(fifo_server, fifoname, strlen(fifoname)+1); /* write name */
+    close(fifo_server);                     /* close server fifo */
+    fifo_client = open(fifoname, O_RDONLY); /* open client fifo */
     if (fifo_client < 0) {
         perror("Cannot open well known fifo");
         exit(-1);
     }
     if (fifo_client < 0) {
         perror("Cannot open well known fifo");
         exit(-1);
     }
-    nread = read(fifo_client, buffer, sizeof(buffer));        /* read answer */
-    printf("%s", buffer);                                   /* print fortune */
-    close(fifo_client);                                      /* close client */
-    close(fifo_server);                                      /* close server */
-    unlink(fifoname);                                  /* remove client fifo */
+    nread = read(fifo_client, buffer, sizeof(buffer)); /* read answer */
+    printf("%s", buffer);   /* print fortune */
+    close(fifo_client);     /* close client */
+    close(fifo_server);     /* close server */
+    unlink(fifoname);       /* remove client fifo */
 }
 }
index 7c45d230c2ead1b7668c3720d50c4e15c9801058..40ee3d95af1838be739085cd56d3c67bf081d030 100644 (file)
@@ -9,12 +9,12 @@ int main(int argc, char *argv[])
     int fifo_server, fifo_client;
     int nread;
     ...
     int fifo_server, fifo_client;
     int nread;
     ...
-    if (n==0) usage();          /* if no pool depth exit printing usage info */
-    Signal(SIGTERM, HandSIGTERM);            /* set handlers for termination */
+    if (n==0) usage();  /* if no pool depth exit printing usage info */
+    Signal(SIGTERM, HandSIGTERM); /* set handlers for termination */
     Signal(SIGINT, HandSIGTERM);
     Signal(SIGQUIT, HandSIGTERM);
     Signal(SIGINT, HandSIGTERM);
     Signal(SIGQUIT, HandSIGTERM);
-    i = FortuneParse(fortunefilename, fortune, n);          /* parse phrases */
-    if (mkfifo(fifoname, 0622)) {  /* create well known fifo if does't exist */
+    i = FortuneParse(fortunefilename, fortune, n); /* parse phrases */
+    if (mkfifo(fifoname, 0622)) { /* create well known fifo if does't exist */
         if (errno!=EEXIST) {
             perror("Cannot create well known fifo");
             exit(1);
         if (errno!=EEXIST) {
             perror("Cannot create well known fifo");
             exit(1);
@@ -33,20 +33,20 @@ int main(int argc, char *argv[])
     }
     /* Main body: loop over requests */
     while (1) {
     }
     /* Main body: loop over requests */
     while (1) {
-        nread = read(fifo_server, line, 79);                 /* read request */
+        nread = read(fifo_server, line, 79); /* read request */
         if (nread < 0) {
             perror("Read Error");
             exit(1);
         }
         if (nread < 0) {
             perror("Read Error");
             exit(1);
         }
-        line[nread] = 0;                       /* terminate fifo name string */
-        n = random() % i;                             /* select random value */
-        fifo_client = open(line, O_WRONLY);              /* open client fifo */
+        line[nread] = 0;                     /* terminate fifo name string */
+        n = random() % i;                    /* select random value */
+        fifo_client = open(line, O_WRONLY);  /* open client fifo */
         if (fifo_client < 0) {
             perror("Cannot open");
             exit(1);
         }
         if (fifo_client < 0) {
             perror("Cannot open");
             exit(1);
         }
-        nread = write(fifo_client,                           /* write phrase */
+        nread = write(fifo_client,           /* write phrase */
                       fortune[n], strlen(fortune[n])+1);
                       fortune[n], strlen(fortune[n])+1);
-        close(fifo_client);                             /* close client fifo */
+        close(fifo_client);                  /* close client fifo */
     }
 }
     }
 }
index 7cd07d39bdf203340e693ae19eb8904005a6ec3e..24bbccf27a3be9723be3530faec15b9361e73aa4 100644 (file)
@@ -1,6 +1,6 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <unistd.h>                               /* unix standard functions */
+#include <unistd.h>    /* Unix standard functions */
 /*
  * Function LockFile:
  */
 /*
  * Function LockFile:
  */
index 84f86c61d9fede64f81bfd038c6e68a8f58585a0..8b8216c46aab21fcd4f9c589ee8ac5c948b02304 100644 (file)
@@ -8,10 +8,10 @@ int main(int argc, char *argv[])
         exit(1);
     }
     /* Main body: do request and write result */
         exit(1);
     }
     /* Main body: do request and write result */
-    msg_read.mtype = 1;                      /* type for request is always 1 */
-    msg_read.pid = getpid();                   /* use pid for communications */
+    msg_read.mtype = 1;                /* type for request is always 1 */
+    msg_read.pid = getpid();           /* use pid for communications */
     size = sizeof(msg_read.pid);  
     size = sizeof(msg_read.pid);  
-    msgsnd(msgid, &msg_read, size, 0);               /* send request message */
+    msgsnd(msgid, &msg_read, size, 0); /* send request message */
     msgrcv(msgid, &msg_write, MSGMAX, msg_read.pid, MSG_NOERROR);
     printf("%s", msg_write.mtext);
 }
     msgrcv(msgid, &msg_write, MSGMAX, msg_read.pid, MSG_NOERROR);
     printf("%s", msg_write.mtext);
 }
index cd0dd1ee430bc203193ec9a3bdfa15cfd77e9f0f..aec0e1eb713d6bf40d555e01ea9966909c0096e8 100644 (file)
@@ -1,26 +1,26 @@
-int msgid;                                       /* Message queue identifier */
+int msgid;          /* Message queue identifier */
 int main(int argc, char *argv[])
 {
 /* Variables definition */
     int i, n = 0;
 int main(int argc, char *argv[])
 {
 /* Variables definition */
     int i, n = 0;
-    char **fortune;                       /* array of fortune message string */
-    char *fortunefilename = "/usr/share/games/fortunes/linux";  /* file name */
-    struct msgbuf_read {      /* message struct to read request from clients */
-        long mtype;                               /* message type, must be 1 */
-        long pid;             /* message data, must be the pid of the client */
+    char **fortune;       /* array of fortune message string */
+    char *fortunefilename = "/usr/share/games/fortunes/linux"; /* file name */
+    struct msgbuf_read {  /* message struct to read request from clients */
+        long mtype;       /* message type, must be 1 */
+        long pid;         /* message data, must be the pid of the client */
     } msg_read;
     } msg_read;
-    struct msgbuf_write {       /* message struct to write result to clients */
-        long mtype;            /* message type, will be the pid of the client*/
-        char mtext[MSGMAX];             /* message data, will be the fortune */
+    struct msgbuf_write { /* message struct to write result to clients */
+        long mtype;       /* message type, will be the pid of the client*/
+        char mtext[MSGMAX]; /* message data, will be the fortune */
     } msg_write;
     } msg_write;
-    key_t key;                                          /* Message queue key */
-    int size;                                                /* message size */
+    key_t key;            /* Message queue key */
+    int size;             /* message size */
     ...
     ...
-    Signal(SIGTERM, HandSIGTERM);            /* set handlers for termination */
+    Signal(SIGTERM, HandSIGTERM); /* set handlers for termination */
     Signal(SIGINT, HandSIGTERM);
     Signal(SIGQUIT, HandSIGTERM);
     Signal(SIGINT, HandSIGTERM);
     Signal(SIGQUIT, HandSIGTERM);
-    if (n==0) usage();          /* if no pool depth exit printing usage info */
-    i = FortuneParse(fortunefilename, fortune, n);          /* parse phrases */
+    if (n==0) usage();    /* if no pool depth exit printing usage info */
+    i = FortuneParse(fortunefilename, fortune, n); /* parse phrases */
     /* Create the queue */
     key = ftok("./MQFortuneServer.c", 1); 
     msgid = msgget(key, IPC_CREAT|0666);
     /* Create the queue */
     key = ftok("./MQFortuneServer.c", 1); 
     msgid = msgget(key, IPC_CREAT|0666);
@@ -32,10 +32,10 @@ int main(int argc, char *argv[])
     daemon(0, 0);
     while (1) {
         msgrcv(msgid, &msg_read, sizeof(int), 1, MSG_NOERROR);
     daemon(0, 0);
     while (1) {
         msgrcv(msgid, &msg_read, sizeof(int), 1, MSG_NOERROR);
-        n = random() % i;                             /* select random value */
+        n = random() % i;             /* select random value */
         strncpy(msg_write.mtext, fortune[n], MSGMAX);
         size = min(strlen(fortune[n])+1, MSGMAX);  
         strncpy(msg_write.mtext, fortune[n], MSGMAX);
         size = min(strlen(fortune[n])+1, MSGMAX);  
-        msg_write.mtype=msg_read.pid;             /* use request pid as type */
+        msg_write.mtype=msg_read.pid; /* use request pid as type */
         msgsnd(msgid, &msg_write, size, 0);
     }
 }
         msgsnd(msgid, &msg_write, size, 0);
     }
 }
@@ -43,6 +43,6 @@ int main(int argc, char *argv[])
  * Signal Handler to manage termination
  */
 void HandSIGTERM(int signo) {
  * Signal Handler to manage termination
  */
 void HandSIGTERM(int signo) {
-    msgctl(msgid, IPC_RMID, NULL);                   /* remove message queue */
+    msgctl(msgid, IPC_RMID, NULL);    /* remove message queue */
     exit(0);
 }
     exit(0);
 }
index dfeea8db164abea0cd65daa4e62e69576dff8fca..fa72c32a07d79fe327cb0c89c862634d53b0b09b 100644 (file)
@@ -6,7 +6,7 @@ void * CreateShm(char * shm_name, off_t shm_size, mode_t perm, int fill)
     int flag;
     /* first open the object, creating it if not existent */
     flag = O_CREAT|O_EXCL|O_RDWR;
     int flag;
     /* first open the object, creating it if not existent */
     flag = O_CREAT|O_EXCL|O_RDWR;
-    fd = shm_open(shm_name, flag, perm);    /* get object file descriptor */
+    fd = shm_open(shm_name, flag, perm); /* get object file descriptor */
     if (fd < 0) { 
         return NULL;
     }
     if (fd < 0) { 
         return NULL;
     }
@@ -19,14 +19,14 @@ void * CreateShm(char * shm_name, off_t shm_size, mode_t perm, int fill)
     if (shm_ptr == MAP_FAILED) {
         return NULL;
     }
     if (shm_ptr == MAP_FAILED) {
         return NULL;
     }
-    memset((void *) shm_ptr, fill, shm_size);                /* fill segment */
+    memset((void *) shm_ptr, fill, shm_size); /* fill segment */
     return shm_ptr;
 }
 /* Function FindShm: Find a POSIX shared memory segment  */
 void * FindShm(char * shm_name, off_t shm_size) 
 {
     void * shm_ptr;
     return shm_ptr;
 }
 /* Function FindShm: Find a POSIX shared memory segment  */
 void * FindShm(char * shm_name, off_t shm_size) 
 {
     void * shm_ptr;
-    int fd;                           /* ID of the IPC shared memory segment */
+    int fd;           /* ID of the IPC shared memory segment */
     /* find shared memory ID */
     if ((fd = shm_open(shm_name, O_RDWR|O_EXCL, 0)) < 0) {
         return NULL;
     /* find shared memory ID */
     if ((fd = shm_open(shm_name, O_RDWR|O_EXCL, 0)) < 0) {
         return NULL;
index 3d0c4c0f709f1461f7cb04879993fd813b40c074..2855c75989ea526e1cb3c0c0d7f1f666d7f92023 100644 (file)
@@ -1,13 +1,13 @@
 /* Function MutexCreate: create a mutex/semaphore */
 int MutexCreate(key_t ipc_key) 
 {
 /* Function MutexCreate: create a mutex/semaphore */
 int MutexCreate(key_t ipc_key) 
 {
-    const union semun semunion={1};             /* semaphore union structure */
+    const union semun semunion={1}; /* semaphore union structure */
     int sem_id, ret;
     int sem_id, ret;
-    sem_id = semget(ipc_key, 1, IPC_CREAT|0666);         /* get semaphore ID */
-    if (sem_id == -1) {                              /* if error return code */
+    sem_id = semget(ipc_key, 1, IPC_CREAT|0666); /* get semaphore ID */
+    if (sem_id == -1) {             /* if error return code */
         return sem_id;
     }
         return sem_id;
     }
-    ret = semctl(sem_id, 0, SETVAL, semunion);             /* init semaphore */
+    ret = semctl(sem_id, 0, SETVAL, semunion);   /* init semaphore */
     if (ret == -1) {
         return ret;
     }
     if (ret == -1) {
         return ret;
     }
@@ -24,14 +24,14 @@ int MutexRead(int sem_id)
     return semctl(sem_id, 0, GETVAL);
 }
 /* Define sembuf structures to lock and unlock the semaphore  */
     return semctl(sem_id, 0, GETVAL);
 }
 /* Define sembuf structures to lock and unlock the semaphore  */
-struct sembuf sem_lock={                                /* to lock semaphore */
-    0,                                   /* semaphore number (only one so 0) */
-    -1,                                    /* operation (-1 to use resource) */
-    SEM_UNDO};                                /* flag (set for undo at exit) */
-struct sembuf sem_ulock={                             /* to unlock semaphore */
-    0,                                   /* semaphore number (only one so 0) */
-    1,                                  /* operation (1 to release resource) */
-    SEM_UNDO};                                      /* flag (in this case 0) */
+struct sembuf sem_lock={  /* to lock semaphore */
+    0,                    /* semaphore number (only one so 0) */
+    -1,                   /* operation (-1 to use resource) */
+    SEM_UNDO};            /* flag (set for undo at exit) */
+struct sembuf sem_ulock={ /* to unlock semaphore */
+    0,                    /* semaphore number (only one so 0) */
+    1,                    /* operation (1 to release resource) */
+    SEM_UNDO};            /* flag (in this case 0) */
 /* Function MutexLock: to lock a mutex/semaphore */
 int MutexLock(int sem_id) 
 {
 /* Function MutexLock: to lock a mutex/semaphore */
 int MutexLock(int sem_id) 
 {
index 1b453154f2a9f51026d8dbb0ab524bebac52a9a4..e1c2e0aef72e38c6ea3e89dca55931c00be8a971 100644 (file)
@@ -11,24 +11,24 @@ int FindMutex(const char *path_name)
 /* Function LockMutex: lock mutex using file locking. */
 int LockMutex(int fd)
 {
 /* Function LockMutex: lock mutex using file locking. */
 int LockMutex(int fd)
 {
-    struct flock lock;                                /* file lock structure */
+    struct flock lock;        /* file lock structure */
     /* set flock structure */
     /* set flock structure */
-    lock.l_type = F_WRLCK;                        /* set type: read or write */
-    lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
-    lock.l_start = 0;                  /* set the start of the locked region */
-    lock.l_len = 0;                   /* set the length of the locked region */
+    lock.l_type = F_WRLCK;    /* set type: read or write */
+    lock.l_whence = SEEK_SET; /* start from the beginning of the file */
+    lock.l_start = 0;         /* set the start of the locked region */
+    lock.l_len = 0;           /* set the length of the locked region */
     /* do locking */
     return fcntl(fd, F_SETLKW, &lock);
 }
 /* Function UnlockMutex: unlock a file. */
 int UnlockMutex(int fd)
 {
     /* do locking */
     return fcntl(fd, F_SETLKW, &lock);
 }
 /* Function UnlockMutex: unlock a file. */
 int UnlockMutex(int fd)
 {
-    struct flock lock;                                /* file lock structure */
+    struct flock lock;        /* file lock structure */
     /* set flock structure */
     /* set flock structure */
-    lock.l_type = F_UNLCK;                               /* set type: unlock */
-    lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
-    lock.l_start = 0;                  /* set the start of the locked region */
-    lock.l_len = 0;                   /* set the length of the locked region */
+    lock.l_type = F_UNLCK;    /* set type: unlock */
+    lock.l_whence = SEEK_SET; /* start from the beginning of the file */
+    lock.l_start = 0;         /* set the start of the locked region */
+    lock.l_len = 0;           /* set the length of the locked region */
     /* do locking */
     return fcntl(fd, F_SETLK, &lock);
 }
     /* do locking */
     return fcntl(fd, F_SETLK, &lock);
 }
@@ -41,12 +41,12 @@ int RemoveMutex(const char *path_name)
 int ReadMutex(int fd)
 {
     int res;
 int ReadMutex(int fd)
 {
     int res;
-    struct flock lock;                                /* file lock structure */
+    struct flock lock;        /* file lock structure */
     /* set flock structure */
     /* set flock structure */
-    lock.l_type = F_WRLCK;                               /* set type: unlock */
-    lock.l_whence = SEEK_SET;        /* start from the beginning of the file */
-    lock.l_start = 0;                  /* set the start of the locked region */
-    lock.l_len = 0;                   /* set the length of the locked region */
+    lock.l_type = F_WRLCK;    /* set type: unlock */
+    lock.l_whence = SEEK_SET; /* start from the beginning of the file */
+    lock.l_start = 0;         /* set the start of the locked region */
+    lock.l_len = 0;           /* set the length of the locked region */
     /* do locking */
     if ( (res = fcntl(fd, F_GETLK, &lock)) ) {
         return res;
     /* do locking */
     if ( (res = fcntl(fd, F_GETLK, &lock)) ) {
         return res;
index 888179515fa496fad315626ef85d759dbb223d7d..e057ee230b96404420a53d390df361ad4f7b1475 100644 (file)
@@ -3,17 +3,17 @@ int main(int argc, char *argv[])
     key_t key;
     ...
     /* create needed IPC objects */
     key_t key;
     ...
     /* create needed IPC objects */
-    key = ftok("~/gapil/sources/DirMonitor.c", 1);           /* define a key */
-    if (!(shmptr = ShmFind(key, 4096))) {     /* get a shared memory segment */
+    key = ftok("~/gapil/sources/DirMonitor.c", 1); /* define a key */
+    if (!(shmptr = ShmFind(key, 4096))) { /* get a shared memory segment */
         perror("Cannot find shared memory");
         exit(1);
     }
         perror("Cannot find shared memory");
         exit(1);
     }
-    if ((mutex = MutexFind(key)) == -1) {                   /* get the Mutex */
+    if ((mutex = MutexFind(key)) == -1) { /* get the Mutex */
         perror("Cannot find mutex");
         exit(1);
     }
     /* main loop */
         perror("Cannot find mutex");
         exit(1);
     }
     /* main loop */
-    MutexLock(mutex);                                  /* lock shared memory */
+    MutexLock(mutex);                     /* lock shared memory */
     printf("Ci sono %d file dati\n", shmptr->tot_regular);
     printf("Ci sono %d directory\n", shmptr->tot_dir);
     printf("Ci sono %d link\n", shmptr->tot_link);
     printf("Ci sono %d file dati\n", shmptr->tot_regular);
     printf("Ci sono %d directory\n", shmptr->tot_dir);
     printf("Ci sono %d link\n", shmptr->tot_link);
@@ -23,5 +23,5 @@ int main(int argc, char *argv[])
     printf("Ci sono %d device a blocchi\n", shmptr->tot_block);
     printf("Totale  %d file, per %d byte\n",
            shmptr->tot_files, shmptr->tot_size);
     printf("Ci sono %d device a blocchi\n", shmptr->tot_block);
     printf("Totale  %d file, per %d byte\n",
            shmptr->tot_files, shmptr->tot_size);
-    MutexUnlock(mutex);                              /* unlock shared memory */
+    MutexUnlock(mutex);                   /* unlock shared memory */
 }
 }
index 9f5b438525062302744cd2be227959896989741e..872a5bc72532f4fc81a7a83dcb3699f64ba04174 100644 (file)
@@ -2,28 +2,28 @@
 void * ShmCreate(key_t ipc_key, int shm_size, int perm, int fill) 
 {
     void * shm_ptr;
 void * ShmCreate(key_t ipc_key, int shm_size, int perm, int fill) 
 {
     void * shm_ptr;
-    int shm_id;                       /* ID of the IPC shared memory segment */
-    shm_id = shmget(ipc_key, shm_size, IPC_CREAT|perm);        /* get shm ID */
+    int shm_id;     /* ID of the IPC shared memory segment */
+    shm_id = shmget(ipc_key, shm_size, IPC_CREAT|perm); /* get shm ID */
     if (shm_id < 0) { 
         return NULL;
     }
     if (shm_id < 0) { 
         return NULL;
     }
-    shm_ptr = shmat(shm_id, NULL, 0);                  /* map it into memory */
+    shm_ptr = shmat(shm_id, NULL, 0);         /* map it into memory */
     if (shm_ptr < 0) {
         return NULL;
     }
     if (shm_ptr < 0) {
         return NULL;
     }
-    memset((void *)shm_ptr, fill, shm_size);                 /* fill segment */
+    memset((void *)shm_ptr, fill, shm_size);  /* fill segment */
     return shm_ptr;
 }
 /* Function ShmFind: Find a SysV shared memory segment  */
 void * ShmFind(key_t ipc_key, int shm_size) 
 {
     void * shm_ptr;
     return shm_ptr;
 }
 /* Function ShmFind: Find a SysV shared memory segment  */
 void * ShmFind(key_t ipc_key, int shm_size) 
 {
     void * shm_ptr;
-    int shm_id;                      /* ID of the SysV shared memory segment */
-    shm_id = shmget(ipc_key, shm_size, 0);          /* find shared memory ID */
+    int shm_id;     /* ID of the SysV shared memory segment */
+    shm_id = shmget(ipc_key, shm_size, 0);    /* find shared memory ID */
     if (shm_id < 0) {
         return NULL;
     }
     if (shm_id < 0) {
         return NULL;
     }
-    shm_ptr = shmat(shm_id, NULL, 0);                  /* map it into memory */
+    shm_ptr = shmat(shm_id, NULL, 0);         /* map it into memory */
     if (shm_ptr < 0) {
         return NULL;
     }
     if (shm_ptr < 0) {
         return NULL;
     }
@@ -32,18 +32,18 @@ void * ShmFind(key_t ipc_key, int shm_size)
 /* Function ShmRemove: Schedule removal for a SysV shared memory segment  */
 int ShmRemove(key_t ipc_key, void * shm_ptr) 
 {
 /* Function ShmRemove: Schedule removal for a SysV shared memory segment  */
 int ShmRemove(key_t ipc_key, void * shm_ptr) 
 {
-    int shm_id;                      /* ID of the SysV shared memory segment */
+    int shm_id;     /* ID of the SysV shared memory segment */
     /* first detach segment */
     if (shmdt(shm_ptr) < 0) {
         return -1;
     }
     /* schedule segment removal */
     /* first detach segment */
     if (shmdt(shm_ptr) < 0) {
         return -1;
     }
     /* schedule segment removal */
-    shm_id = shmget(ipc_key, 0, 0);                 /* find shared memory ID */
+    shm_id = shmget(ipc_key, 0, 0);           /* find shared memory ID */
     if (shm_id < 0) {
         if (errno == EIDRM) return 0;
         return -1;
     }
     if (shm_id < 0) {
         if (errno == EIDRM) return 0;
         return -1;
     }
-    if (shmctl(shm_id, IPC_RMID, NULL) < 0) {             /* ask for removal */
+    if (shmctl(shm_id, IPC_RMID, NULL) < 0) { /* ask for removal */
         if (errno == EIDRM) return 0;
         return -1;
     }
         if (errno == EIDRM) return 0;
         return -1;
     }
index e2d617b248df424f5940f00fd6e9efc4bccf7aae..855faa0356557b73568da11909992a41404bdc76 100644 (file)
@@ -4,10 +4,10 @@ inline SigFunc * Signal(int signo, SigFunc *func)
     struct sigaction new_handl, old_handl;
     new_handl.sa_handler = func;
     /* clear signal mask: no signal blocked during execution of func */
     struct sigaction new_handl, old_handl;
     new_handl.sa_handler = func;
     /* clear signal mask: no signal blocked during execution of func */
-    if (sigemptyset(&new_handl.sa_mask)!=0){        /* initialize signal set */
+    if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */
         return SIG_ERR;
     }
         return SIG_ERR;
     }
-    new_handl.sa_flags=0;                             /* init to 0 all flags */
+    new_handl.sa_flags=0;                    /* init to 0 all flags */
     /* change action for signo signal */
     if (sigaction(signo, &new_handl, &old_handl)){ 
         return SIG_ERR;
     /* change action for signo signal */
     if (sigaction(signo, &new_handl, &old_handl)){ 
         return SIG_ERR;
diff --git a/listati/TCP_cunc_daytimed.c b/listati/TCP_cunc_daytimed.c
new file mode 100644 (file)
index 0000000..9af8cc7
--- /dev/null
@@ -0,0 +1,52 @@
+#include <sys/types.h>   /* predefined types */
+#include <unistd.h>      /* include unix standard library */
+#include <arpa/inet.h>   /* IP addresses conversion utililites */
+#include <sys/socket.h>  /* socket library */
+#include <stdio.h>       /* include standard I/O library */
+#include <time.h>
+
+int main(int argc, char *argv[])
+{
+    int list_fd, conn_fd;
+    int i;
+    struct sockaddr_in serv_add, client;
+    char buffer[MAXLINE];
+    socklen_t len;
+    time_t timeval;
+    pid_t pid;
+    int logging=0;
+     ...
+    /* write daytime to client */
+    while (1) {
+        if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len)) 
+             <0 ) {
+            perror("accept error");
+            exit(-1);
+        }
+        /* fork to handle connection */
+        if ( (pid = fork()) < 0 ){
+            perror("fork error");
+            exit(-1);
+        }
+        if (pid == 0) {                 /* child */
+            close(list_fd);
+            timeval = time(NULL);
+            snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
+            if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
+                perror("write error");
+                exit(-1);
+            }
+            if (logging) {
+                inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
+                printf("Request from host %s, port %d\n", buffer,
+                       ntohs(client.sin_port));
+            }
+            close(conn_fd);
+            exit(0);
+        } else {                        /* parent */
+            close(conn_fd);
+        }
+    }
+    /* normal exit, never reached */
+    exit(0);
+}
diff --git a/listati/TCP_echo_client.c b/listati/TCP_echo_client.c
new file mode 100644 (file)
index 0000000..f9a67b6
--- /dev/null
@@ -0,0 +1,32 @@
+int main(int argc, char *argv[])
+{
+/* 
+ * Variables definition  
+ */
+    int sock_fd, i;
+    struct sockaddr_in serv_add;
+    ...
+    /* create socket */
+    if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+        perror("Socket creation error");
+        return -1;
+    }
+    /* initialize address */
+    memset((void *) &serv_add, 0, sizeof(serv_add)); /* clear server address */
+    serv_add.sin_family = AF_INET;                   /* address type is INET */
+    serv_add.sin_port = htons(7);                    /* echo port is 7 */
+    /* build address using inet_pton */
+    if ( (inet_pton(AF_INET, argv[optind], &serv_add.sin_addr)) <= 0) {
+        perror("Address creation error");
+        return -1;
+    }
+    /* extablish connection */
+    if (connect(sock_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
+        perror("Connection error");
+        return -1;
+    }
+    /* read daytime from server */
+    ClientEcho(stdin, sock_fd);
+    /* normal exit */
+    return 0;
+}
index 2934e6382bc9af8f29d1ef41494f28610237c8c4..86f4276c22d57262a9f24f8e3df3e1fd5c350f4e 100644 (file)
@@ -32,10 +32,11 @@ nuova versione denominata IPv6.
 \label{sec:ip_protocol}
 
 L'attuale \textit{Internet Protocol} (IPv4) viene standardizzato nel 1981
 \label{sec:ip_protocol}
 
 L'attuale \textit{Internet Protocol} (IPv4) viene standardizzato nel 1981
-dall'RFC~719; esso nasce per disaccoppiare le applicazioni della struttura
-hardware delle reti di trasmissione, e creare una interfaccia di trasmissione
-dei dati indipendente dal sottostante substrato di rete, che può essere
-realizzato con le tecnologie più disparate (Ethernet, Token Ring, FDDI, etc.).
+dall'\href{http://www.ietf.org/rfc/rfc0719.txt}{RFC~719}; esso nasce per
+disaccoppiare le applicazioni della struttura hardware delle reti di
+trasmissione, e creare una interfaccia di trasmissione dei dati indipendente
+dal sottostante substrato di rete, che può essere realizzato con le tecnologie
+più disparate (Ethernet, Token Ring, FDDI, etc.).
 
 
 \subsection{Introduzione}
 
 
 \subsection{Introduzione}
@@ -207,11 +208,11 @@ apparecchio elettronico sarebbe stato inserito all'interno della rete.
 Per questo motivo si iniziò a progettare una nuova versione del protocollo 
 
 L'attuale Internet Protocol (IPv4) viene standardizzato nel 1981
 Per questo motivo si iniziò a progettare una nuova versione del protocollo 
 
 L'attuale Internet Protocol (IPv4) viene standardizzato nel 1981
-dall'RFC~719; esso nasce per disaccoppiare le applicazioni della struttura
-hardware delle reti di trasmissione, e creare una interfaccia di trasmissione
-dei dati indipendente dal sottostante substrato di rete, che può essere
-realizzato con le tecnologie più disparate (Ethernet, Token Ring, FDDI,
-etc.).
+dall'\href{http://www.ietf.org/rfc/rfc0719.txt}{RFC~719}; esso nasce per
+disaccoppiare le applicazioni della struttura hardware delle reti di
+trasmissione, e creare una interfaccia di trasmissione dei dati indipendente
+dal sottostante substrato di rete, che può essere realizzato con le tecnologie
+più disparate (Ethernet, Token Ring, FDDI, etc.).
 
 
 \subsection{I motivi della transizione}
 
 
 \subsection{I motivi della transizione}
@@ -619,7 +620,8 @@ allocazione degli indirizzi unicast.
 \label{sec:IP_ipv6_unicast}
 
 Gli indirizzi \textit{provider-based} sono gli indirizzi usati per le
 \label{sec:IP_ipv6_unicast}
 
 Gli indirizzi \textit{provider-based} sono gli indirizzi usati per le
-comunicazioni globali, questi sono definiti nell'RFC 2073 e sono gli
+comunicazioni globali, questi sono definiti
+nell'\href{http://www.ietf.org/rfc/rfc2073.txt}{RFC~2073} e sono gli
 equivalenti degli attuali indirizzi delle classi da A a C.
 
 L'autorità che presiede all'allocazione di questi indirizzi è la IANA; per
 equivalenti degli attuali indirizzi delle classi da A a C.
 
 L'autorità che presiede all'allocazione di questi indirizzi è la IANA; per
@@ -975,16 +977,20 @@ per il funzionamento della rete.
     \textbf{Uso}& \textbf{Indirizzi riservati} & \textbf{Definizione}\\
     \hline 
     \hline 
     \textbf{Uso}& \textbf{Indirizzi riservati} & \textbf{Definizione}\\
     \hline 
     \hline 
-    all-nodes & \texttt{FFxx:0:0:0:0:0:0:1} & RFC 1970\\
-    all-routers & \texttt{FFxx:0:0:0:0:0:0:2} & RFC 1970\\
-    all-rip-routers & \texttt{FFxx:0:0:0:0:0:0:9} & RFC 2080\\
-    all-cbt-routers & \texttt{FFxx:0:0:0:0:0:0:10} &\\
-    reserved &  \texttt{FFxx:0:0:0:0:0:1:0} & IANA \\
-    link-name &  \texttt{FFxx:0:0:0:0:0:1:1} &  \\
-    all-dhcp-agents & \texttt{FFxx:0:0:0:0:0:1:2} & \\
-    all-dhcp-servers & \texttt{FFxx:0:0:0:0:0:1:3} & \\
-    all-dhcp-relays & \texttt{FFxx:0:0:0:0:0:1:4} & \\
-    solicited-nodes &  \texttt{FFxx:0:0:0:0:1:0:0} & RFC 1970\\
+    all-nodes       & \texttt{FFxx:0:0:0:0:0:0:1}  & 
+                      \href{http://www.ietf.org/rfc/rfc1970.txt}{RFC~1970} \\
+    all-routers     & \texttt{FFxx:0:0:0:0:0:0:2}  & 
+                      \href{http://www.ietf.org/rfc/rfc1970.txt}{RFC~1970} \\
+    all-rip-routers & \texttt{FFxx:0:0:0:0:0:0:9}  & 
+                      \href{http://www.ietf.org/rfc/rfc2080.txt}{RFC~2080} \\
+    all-cbt-routers & \texttt{FFxx:0:0:0:0:0:0:10} & \\
+    reserved        & \texttt{FFxx:0:0:0:0:0:1:0}  & IANA \\
+    link-name       & \texttt{FFxx:0:0:0:0:0:1:1}  &  \\
+    all-dhcp-agents & \texttt{FFxx:0:0:0:0:0:1:2}  & \\
+    all-dhcp-servers& \texttt{FFxx:0:0:0:0:0:1:3}  & \\
+    all-dhcp-relays & \texttt{FFxx:0:0:0:0:0:1:4}  & \\
+    solicited-nodes & \texttt{FFxx:0:0:0:0:1:0:0}  & 
+                      \href{http://www.ietf.org/rfc/rfc1970.txt}{RFC~1970} \\
     \hline
   \end{tabular}
 \caption{Gruppi multicast predefiniti.}
     \hline
   \end{tabular}
 \caption{Gruppi multicast predefiniti.}
@@ -1078,9 +1084,11 @@ Le estensioni definite al momento sono le seguenti:
   vuole frammentare un pacchetto, ed è riprocessato automaticamente alla
   destinazione che riassembla i frammenti.
 \item \textbf{Authentication} gestisce l'autenticazione e il controllo di
   vuole frammentare un pacchetto, ed è riprocessato automaticamente alla
   destinazione che riassembla i frammenti.
 \item \textbf{Authentication} gestisce l'autenticazione e il controllo di
-  integrità dei pacchetti; è documentato dall'RFC 162.
+  integrità dei pacchetti; è documentato
+  dall'\href{http://www.ietf.org/rfc/rfc1826.txt}{RFC~1826}.
 \item \textbf{Encapsulation} serve a gestire la segretezza del contenuto
 \item \textbf{Encapsulation} serve a gestire la segretezza del contenuto
-  trasmesso; è documentato dall'RFC 1827.
+  trasmesso; è documentato
+  dall'\href{http://www.ietf.org/rfc/rfc1827.txt}{RFC~1827}.
 \end{itemize}
 
 La presenza di opzioni è rilevata dal valore del campo \textit{next header}
 \end{itemize}
 
 La presenza di opzioni è rilevata dal valore del campo \textit{next header}
@@ -1225,7 +1233,8 @@ riservatezza a un livello inferiore al primo (quello di applicazione), con
 IPv6 è stato progettata la possibilità di intervenire al livello di rete (il
 terzo) prevedendo due apposite estensioni che possono essere usate per fornire
 livelli di sicurezza a seconda degli utenti. La codifica generale di questa
 IPv6 è stato progettata la possibilità di intervenire al livello di rete (il
 terzo) prevedendo due apposite estensioni che possono essere usate per fornire
 livelli di sicurezza a seconda degli utenti. La codifica generale di questa
-architettura è riportata nell'RFC 2401.
+architettura è riportata
+nell'\href{http://www.ietf.org/rfc/rfc2401.txt}{RFC~2401}.
 
 Il meccanismo in sostanza si basa su due estensioni:
 \begin{itemize}
 
 Il meccanismo in sostanza si basa su due estensioni:
 \begin{itemize}
index 2d9186ea3a779a173ca26529ef6ea3bf622a7127..a75b786cf216457fce4f4915190e2b79688e556a 100644 (file)
@@ -518,7 +518,8 @@ trasporto.
 
 Quando si parla di IP ci si riferisce in genere alla versione attualmente in
 uso che è la versione 4 (e viene pertanto chiamato IPv4). Questa versione
 
 Quando si parla di IP ci si riferisce in genere alla versione attualmente in
 uso che è la versione 4 (e viene pertanto chiamato IPv4). Questa versione
-venne standardizzata nel 1981 dall'RFC~719.
+venne standardizzata nel 1981
+dall'\href{http://www.ietf.org/rfc/rfc0719.txt}{RFC~719}.
 
 Internet Protocol nasce per disaccoppiare le applicazioni della struttura
 hardware delle reti di trasmissione, e creare una interfaccia di trasmissione
 
 Internet Protocol nasce per disaccoppiare le applicazioni della struttura
 hardware delle reti di trasmissione, e creare una interfaccia di trasmissione
@@ -575,15 +576,16 @@ protocollo IP sono forniti nell'appendice \secref{sec:ip_protocol}.
 \label{sec:net_udp}
 
 UDP è un protocollo di trasporto molto semplice, la sua descrizione completa è
 \label{sec:net_udp}
 
 UDP è un protocollo di trasporto molto semplice, la sua descrizione completa è
-contenuta dell'RFC~768, ma in sostanza esso è una semplice interfaccia a IP
-dal livello di trasporto. Quando un'applicazione usa UDP essa scrive un
-pacchetto di dati (il cosiddetto \textit{datagram} che da il nome al
-protocollo) su un socket\index{socket}, al pacchetto viene aggiunto un header
-molto semplice (per una descrizione più accurata vedi \secref{sec:xxx_udp}), e
-poi viene passato al livello superiore (IPv4 o IPv6 che sia) che lo spedisce
-verso la destinazione.  Dato che né IPv4 né IPv6 garantiscono l'affidabilità
-niente assicura che il pacchetto arrivi a destinazione, né che più pacchetti
-arrivino nello stesso ordine in cui sono stati spediti.
+contenuta dell'\href{http://www.ietf.org/rfc/rfc0768.txt}{RFC~768}, ma in
+sostanza esso è una semplice interfaccia a IP dal livello di trasporto. Quando
+un'applicazione usa UDP essa scrive un pacchetto di dati (il cosiddetto
+\textit{datagram} che da il nome al protocollo) su un socket\index{socket}, al
+pacchetto viene aggiunto un header molto semplice (per una descrizione più
+accurata vedi \secref{sec:xxx_udp}), e poi viene passato al livello superiore
+(IPv4 o IPv6 che sia) che lo spedisce verso la destinazione.  Dato che né IPv4
+né IPv6 garantiscono l'affidabilità niente assicura che il pacchetto arrivi a
+destinazione, né che più pacchetti arrivino nello stesso ordine in cui sono
+stati spediti.
 
 Pertanto il problema principale che si affronta quando si usa UDP è la
 mancanza di affidabilità, se si vuole essere sicuri che i pacchetti arrivino a
 
 Pertanto il problema principale che si affronta quando si usa UDP è la
 mancanza di affidabilità, se si vuole essere sicuri che i pacchetti arrivino a
@@ -621,7 +623,8 @@ quelle che usano il multicasting.
 \subsection{Transport Control Protocol (TCP)}
 \label{sec:net_tcp}
 
 \subsection{Transport Control Protocol (TCP)}
 \label{sec:net_tcp}
 
-Il TCP è un protocollo molto complesso, definito nell'RFC~739 e completamente
+Il TCP è un protocollo molto complesso, definito
+nell'\href{http://www.ietf.org/rfc/rfc0739.txt}{RFC~739} e completamente
 diverso da UDP; alla base della sua progettazione infatti non stanno
 semplicità e velocità, ma la ricerca della massima affidabilità possibile
 nella trasmissione dei dati.
 diverso da UDP; alla base della sua progettazione infatti non stanno
 semplicità e velocità, ma la ricerca della massima affidabilità possibile
 nella trasmissione dei dati.
@@ -765,8 +768,10 @@ comporta inefficienza, normalmente viene utilizzato un procedimento, detto
 \textit{path MTU discovery} che permette di determinare il \textit{path MTU}
 fra due stazioni; per la realizzazione del procedimento si usa il flag DF di
 IPv4 e il comportamento normale di IPv6 inviando delle opportune serie di
 \textit{path MTU discovery} che permette di determinare il \textit{path MTU}
 fra due stazioni; per la realizzazione del procedimento si usa il flag DF di
 IPv4 e il comportamento normale di IPv6 inviando delle opportune serie di
-pacchetti (per i dettagli vedere l'RFC~1191 per IPv4 e l'RFC~1981 per IPv6)
-fintanto che non si hanno più errori.
+pacchetti (per i dettagli vedere
+l'\href{http://www.ietf.org/rfc/rfc1191.txt}{RFC~1191} per IPv4 e
+l'\href{http://www.ietf.org/rfc/rfc1981.txt}{RFC~1981} per IPv6) fintanto che
+non si hanno più errori.
 
 Il TCP usa sempre questo meccanismo, che per le implementazioni di IPv4 è
 opzionale, mentre diventa obbligatorio per IPv6.  Per IPv6 infatti, non
 
 Il TCP usa sempre questo meccanismo, che per le implementazioni di IPv4 è
 opzionale, mentre diventa obbligatorio per IPv6.  Per IPv6 infatti, non
diff --git a/sources/ElemDaytimeTCPCuncServ.c b/sources/ElemDaytimeTCPCuncServ.c
deleted file mode 100644 (file)
index 9da060e..0000000
+++ /dev/null
@@ -1,159 +0,0 @@
-/* ElemDaytimeTCPCuncServ.c
- * 
- * Copyright (C) 2001 Simone Piccardi
- * 
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/****************************************************************
- *
- * Program ElemDaytimeTCPCuncServ.c 
- * Elementary TCP cuncurrent server for daytime service (port 13)
- *
- * Author: Simone Piccardi
- * May. 2001
- *
- * Usage: daytimed -h give all info
- *
- * $Id: ElemDaytimeTCPCuncServ.c,v 1.2 2001/09/09 17:39:15 piccardi Exp $ 
- *
- ****************************************************************/
-/* 
- * Include needed headers
- */
-#include <sys/types.h>   /* predefined types */
-#include <unistd.h>      /* include unix standard library */
-#include <arpa/inet.h>   /* IP addresses conversion utiliites */
-#include <sys/socket.h>  /* socket library */
-#include <stdio.h>      /* include standard I/O library */
-#include <time.h>
-
-#define MAXLINE 80
-#define BACKLOG 10
-/* Program begin */
-void usage(void);
-int main(int argc, char *argv[])
-{
-/* 
- * Variables definition  
- */
-    int list_fd, conn_fd;
-    int i;
-    struct sockaddr_in serv_add, client;
-    char buffer[MAXLINE];
-    socklen_t len;
-    time_t timeval;
-    pid_t pid;
-    int logging=0;
-    /*
-     * Input section: decode parameters passed in the calling 
-     * Use getopt function
-     */
-    opterr = 0;         /* don't want writing to stderr */
-    while ( (i = getopt(argc, argv, "hv")) != -1) {
-       switch (i) {
-       /* 
-        * Handling options 
-        */ 
-       case 'h':  
-           printf("Wrong -h option use\n");
-           usage();
-           return(0);
-           break;
-       case '?':   /* unrecognized options */
-           printf("Unrecognized options -%c\n",optopt);
-           usage();
-           return(0);
-           break;
-       case 'v':
-           logging = 1;
-           break;
-       default:    /* should not reached */
-           usage();
-           return(0);
-       }
-    }
-    /* ***********************************************************
-     * 
-     *          Options processing completed
-     *
-     *               Main code beginning
-     * 
-     * ***********************************************************/
-    /* create socket */
-    if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-       perror("Socket creation error");
-       exit(-1);
-    }
-    /* initialize address */
-    memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
-    serv_add.sin_family = AF_INET;                  /* address type is INET */
-    serv_add.sin_port = htons(13);                  /* daytime port is 13 */
-    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
-    /* bind socket */
-    if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
-       perror("bind error");
-       exit(-1);
-    }
-    /* listen on socket */
-    if (listen(list_fd, BACKLOG) < 0 ) {
-       perror("listen error");
-       exit(-1);
-    }
-    /* write daytime to client */
-    while (1) {
-       if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len)) 
-            <0 ) {
-           perror("accept error");
-           exit(-1);
-       }
-       /* fork to handle connection */
-       if ( (pid = fork()) < 0 ){
-           perror("fork error");
-           exit(-1);
-       }
-       if (pid == 0) {                 /* child */
-           close(list_fd);
-           timeval = time(NULL);
-           snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
-           if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
-               perror("write error");
-               exit(-1);
-           }
-           if (logging) {
-               inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
-               printf("Request from host %s, port %d\n", buffer,
-                      ntohs(client.sin_port));
-           }
-           close(conn_fd);
-           exit(0);
-       } else {                        /* parent */
-           close(conn_fd);
-       }
-    }
-    /* normal exit, never reached */
-    exit(0);
-}
-/*
- * routine to print usage info and exit
- */
-void usage(void) {
-    printf("Simple daytime server\n");
-    printf("Usage:\n");
-    printf("  daytimed [-hv] \n");
-    printf("  -h          print this help\n");
-    printf("  -v          print request source on stdout\n");
-    exit(1);
-}
-
diff --git a/sources/ElemDaytimeTCPServer.c b/sources/ElemDaytimeTCPServer.c
deleted file mode 100644 (file)
index 9ab656a..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-/* ElemDaytimeTCPServer.c
- * 
- * Copyright (C) 2001 Simone Piccardi
- * 
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/****************************************************************
- *
- * Program daytimed: 
- * Elementary TCP server for daytime service (port 13)
- *
- * Author: Simone Piccardi
- * Apr. 2001
- *
- * Usage: daytimed -h give all info
- *
- * $Id: ElemDaytimeTCPServer.c,v 1.3 2001/09/09 22:45:34 piccardi Exp $ 
- *
- ****************************************************************/
-/* 
- * Include needed headers
- */
-#include <sys/types.h>   /* predefined types */
-#include <unistd.h>      /* include unix standard library */
-#include <arpa/inet.h>   /* IP addresses conversion utiliites */
-#include <sys/socket.h>  /* socket library */
-#include <stdio.h>      /* include standard I/O library */
-#include <time.h>
-
-#define MAXLINE 80
-#define BACKLOG 10
-/* Program begin */
-void usage(void);
-int main(int argc, char *argv[])
-{
-/* 
- * Variables definition  
- */
-    int list_fd, conn_fd;
-    int i;
-    struct sockaddr_in serv_add;
-    char buffer[MAXLINE];
-    time_t timeval;
-    /*
-     * Input section: decode parameters passed in the calling 
-     * Use getopt function
-     */
-    opterr = 0;         /* don't want writing to stderr */
-    while ( (i = getopt(argc, argv, "h")) != -1) {
-       switch (i) {
-       /* 
-        * Handling options 
-        */ 
-       case 'h':  
-           printf("Wrong -h option use\n");
-           usage();
-           return(0);
-           break;
-       case '?':   /* unrecognized options */
-           printf("Unrecognized options -%c\n",optopt);
-           usage();
-       default:    /* should not reached */
-           usage();
-       }
-    }
-    /* ***********************************************************
-     * 
-     *          Options processing completed
-     *
-     *               Main code beginning
-     * 
-     * ***********************************************************/
-    /* create socket */
-    if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-       perror("Socket creation error");
-       exit(-1);
-    }
-    /* initialize address */
-    memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
-    serv_add.sin_family = AF_INET;                  /* address type is INET */
-    serv_add.sin_port = htons(13);                  /* daytime port is 13 */
-    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
-    /* bind socket */
-    if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
-       perror("bind error");
-       exit(-1);
-    }
-    /* listen on socket */
-    if (listen(list_fd, BACKLOG) < 0 ) {
-       perror("listen error");
-       exit(-1);
-    }
-    /* write daytime to client */
-    while (1) {
-       if ( (conn_fd = accept(list_fd, (struct sockaddr *) NULL, NULL)) <0 ) {
-           perror("accept error");
-           exit(-1);
-       }
-       timeval = time(NULL);
-       snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
-       if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
-           perror("write error");
-           exit(-1);
-       }
-       close(conn_fd);
-    }
-
-    /* normal exit */
-    exit(0);
-}
-/*
- * routine to print usage info and exit
- */
-void usage(void) {
-    printf("Simple daytime server\n");
-    printf("Usage:\n");
-    printf("  daytimed [-h] \n");
-    printf("  -h          print this help\n");
-    exit(1);
-}
index 3529cd792203a3d5348bab470a79f6c50cd4926c..19f62650766bbdfd6846e9c4d4da930e04ee6a43 100644 (file)
@@ -26,7 +26,7 @@
  *
  * Usage: echo -h give all info's
  *
  *
  * Usage: echo -h give all info's
  *
- * $Id: ElemEchoTCPClient.c,v 1.5 2003/02/02 20:35:33 piccardi Exp $
+ * $Id: ElemEchoTCPClient.c,v 1.6 2003/04/29 15:33:39 piccardi Exp $
  *
  ****************************************************************/
 /* 
  *
  ****************************************************************/
 /* 
@@ -99,7 +99,7 @@ int main(int argc, char *argv[])
        return -1;
     }
     /* read daytime from server */
        return -1;
     }
     /* read daytime from server */
-    EchoClient(stdin, sock_fd);
+    ClientEcho(stdin, sock_fd);
     /* normal exit */
     return 0;
 }
     /* normal exit */
     return 0;
 }
index 31fff96ae7b2c015fc176a6cf8459f6d76b3a299..e5c68161c1b6972f7f2592a691bb8fb52c4da6cd 100644 (file)
@@ -72,10 +72,10 @@ echo: SimpleEchoTCPClient.c
 echod: SimpleEchoTCPServer.c
        $(CC) $(CFLAGJ) $^ -o $@
 
 echod: SimpleEchoTCPServer.c
        $(CC) $(CFLAGJ) $^ -o $@
 
-daytimed: ElemDaytimeTCPCuncServ.c 
+daytimed: TCP_cunc_daytimed.c
        $(CC) $(CFLAGJ) $^ -o $@
 
        $(CC) $(CFLAGJ) $^ -o $@
 
-iterdaytimed: ElemDaytimeTCPServer.c 
+iterdaytimed: TCP_iter_daytimed.c
        $(CC) $(CFLAGJ) $^ -o $@
 
 daytime: TCP_daytime.c 
        $(CC) $(CFLAGJ) $^ -o $@
 
 daytime: TCP_daytime.c 
diff --git a/sources/TCP_cunc_daytimed.c b/sources/TCP_cunc_daytimed.c
new file mode 100644 (file)
index 0000000..5be9d23
--- /dev/null
@@ -0,0 +1,159 @@
+/* TCP_cunc_daytimed.c
+ * 
+ * Copyright (C) 2001 Simone Piccardi
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/****************************************************************
+ *
+ * Program TCP_cunc_daytimed.c
+ * Elementary TCP cuncurrent server for daytime service (port 13)
+ *
+ * Author: Simone Piccardi
+ * May. 2001
+ *
+ * Usage: daytimed -h give all info
+ *
+ * $Id: TCP_cunc_daytimed.c,v 1.1 2003/04/29 15:33:39 piccardi Exp $
+ *
+ ****************************************************************/
+/* 
+ * Include needed headers
+ */
+#include <sys/types.h>   /* predefined types */
+#include <unistd.h>      /* include unix standard library */
+#include <arpa/inet.h>   /* IP addresses conversion utiliites */
+#include <sys/socket.h>  /* socket library */
+#include <stdio.h>      /* include standard I/O library */
+#include <time.h>
+
+#define MAXLINE 80
+#define BACKLOG 10
+/* Program begin */
+void usage(void);
+int main(int argc, char *argv[])
+{
+/* 
+ * Variables definition  
+ */
+    int list_fd, conn_fd;
+    int i;
+    struct sockaddr_in serv_add, client;
+    char buffer[MAXLINE];
+    socklen_t len;
+    time_t timeval;
+    pid_t pid;
+    int logging=0;
+    /*
+     * Input section: decode parameters passed in the calling 
+     * Use getopt function
+     */
+    opterr = 0;         /* don't want writing to stderr */
+    while ( (i = getopt(argc, argv, "hv")) != -1) {
+       switch (i) {
+       /* 
+        * Handling options 
+        */ 
+       case 'h':  
+           printf("Wrong -h option use\n");
+           usage();
+           return(0);
+           break;
+       case '?':   /* unrecognized options */
+           printf("Unrecognized options -%c\n",optopt);
+           usage();
+           return(0);
+           break;
+       case 'v':
+           logging = 1;
+           break;
+       default:    /* should not reached */
+           usage();
+           return(0);
+       }
+    }
+    /* ***********************************************************
+     * 
+     *          Options processing completed
+     *
+     *               Main code beginning
+     * 
+     * ***********************************************************/
+    /* create socket */
+    if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+       perror("Socket creation error");
+       exit(-1);
+    }
+    /* initialize address */
+    memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
+    serv_add.sin_family = AF_INET;                  /* address type is INET */
+    serv_add.sin_port = htons(13);                  /* daytime port is 13 */
+    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
+    /* bind socket */
+    if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
+       perror("bind error");
+       exit(-1);
+    }
+    /* listen on socket */
+    if (listen(list_fd, BACKLOG) < 0 ) {
+       perror("listen error");
+       exit(-1);
+    }
+    /* write daytime to client */
+    while (1) {
+       if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len)) 
+            <0 ) {
+           perror("accept error");
+           exit(-1);
+       }
+       /* fork to handle connection */
+       if ( (pid = fork()) < 0 ){
+           perror("fork error");
+           exit(-1);
+       }
+       if (pid == 0) {                 /* child */
+           close(list_fd);
+           timeval = time(NULL);
+           snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
+           if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
+               perror("write error");
+               exit(-1);
+           }
+           if (logging) {
+               inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
+               printf("Request from host %s, port %d\n", buffer,
+                      ntohs(client.sin_port));
+           }
+           close(conn_fd);
+           exit(0);
+       } else {                        /* parent */
+           close(conn_fd);
+       }
+    }
+    /* normal exit, never reached */
+    exit(0);
+}
+/*
+ * routine to print usage info and exit
+ */
+void usage(void) {
+    printf("Simple daytime server\n");
+    printf("Usage:\n");
+    printf("  daytimed [-hv] \n");
+    printf("  -h          print this help\n");
+    printf("  -v          print request source on stdout\n");
+    exit(1);
+}
+
index 18ce8d44a7d7028bbe44788f11f266e0ac497de2..4ed7e4f027cd14b6b7714ec0a5fe8cd2da4701f2 100644 (file)
@@ -1,4 +1,4 @@
-/* ElemDaytimeTCPClient.c
+/* TCP_daytime.c
  * 
  * Copyright (C) 2001 Simone Piccardi
  * 
  * 
  * Copyright (C) 2001 Simone Piccardi
  * 
@@ -26,7 +26,7 @@
  *
  * Usage: daytime -h give all info's
  *
  *
  * Usage: daytime -h give all info's
  *
- * $Id: TCP_daytime.c,v 1.1 2003/04/28 14:13:50 piccardi Exp $ 
+ * $Id: TCP_daytime.c,v 1.2 2003/04/29 15:33:39 piccardi Exp $ 
  *
  ****************************************************************/
 /* 
  *
  ****************************************************************/
 /* 
diff --git a/sources/TCP_iter_daytimed.c b/sources/TCP_iter_daytimed.c
new file mode 100644 (file)
index 0000000..e50e763
--- /dev/null
@@ -0,0 +1,132 @@
+/* TCP_iter_daytimed.c
+ * 
+ * Copyright (C) 2001 Simone Piccardi
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/****************************************************************
+ *
+ * Program daytimed: 
+ * Elementary TCP server for daytime service (port 13)
+ *
+ * Author: Simone Piccardi
+ * Apr. 2001
+ *
+ * Usage: daytimed -h give all info
+ *
+ * $Id: TCP_iter_daytimed.c,v 1.1 2003/04/29 15:33:39 piccardi Exp $
+ *
+ ****************************************************************/
+/* 
+ * Include needed headers
+ */
+#include <sys/types.h>   /* predefined types */
+#include <unistd.h>      /* include unix standard library */
+#include <arpa/inet.h>   /* IP addresses conversion utiliites */
+#include <sys/socket.h>  /* socket library */
+#include <stdio.h>      /* include standard I/O library */
+#include <time.h>
+
+#define MAXLINE 80
+#define BACKLOG 10
+/* Program begin */
+void usage(void);
+int main(int argc, char *argv[])
+{
+/* 
+ * Variables definition  
+ */
+    int list_fd, conn_fd;
+    int i;
+    struct sockaddr_in serv_add;
+    char buffer[MAXLINE];
+    time_t timeval;
+    /*
+     * Input section: decode parameters passed in the calling 
+     * Use getopt function
+     */
+    opterr = 0;         /* don't want writing to stderr */
+    while ( (i = getopt(argc, argv, "h")) != -1) {
+       switch (i) {
+       /* 
+        * Handling options 
+        */ 
+       case 'h':  
+           printf("Wrong -h option use\n");
+           usage();
+           return(0);
+           break;
+       case '?':   /* unrecognized options */
+           printf("Unrecognized options -%c\n",optopt);
+           usage();
+       default:    /* should not reached */
+           usage();
+       }
+    }
+    /* ***********************************************************
+     * 
+     *          Options processing completed
+     *
+     *               Main code beginning
+     * 
+     * ***********************************************************/
+    /* create socket */
+    if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+       perror("Socket creation error");
+       exit(-1);
+    }
+    /* initialize address */
+    memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
+    serv_add.sin_family = AF_INET;                  /* address type is INET */
+    serv_add.sin_port = htons(13);                  /* daytime port is 13 */
+    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
+    /* bind socket */
+    if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
+       perror("bind error");
+       exit(-1);
+    }
+    /* listen on socket */
+    if (listen(list_fd, BACKLOG) < 0 ) {
+       perror("listen error");
+       exit(-1);
+    }
+    /* write daytime to client */
+    while (1) {
+       if ( (conn_fd = accept(list_fd, (struct sockaddr *) NULL, NULL)) <0 ) {
+           perror("accept error");
+           exit(-1);
+       }
+       timeval = time(NULL);
+       snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
+       if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
+           perror("write error");
+           exit(-1);
+       }
+       close(conn_fd);
+    }
+
+    /* normal exit */
+    exit(0);
+}
+/*
+ * routine to print usage info and exit
+ */
+void usage(void) {
+    printf("Simple daytime server\n");
+    printf("Usage:\n");
+    printf("  daytimed [-h] \n");
+    printf("  -h          print this help\n");
+    exit(1);
+}
index 87711c0072e19469d079bc46e46d218e523ca82b..a2985c73ddf9f1b7d5995f48d93dbbd0755cbdc8 100644 (file)
@@ -1888,15 +1888,15 @@ valore nullo serve per leggere i parametri correnti; i valori diversi da zero
 devono essere specificati come OR binario delle costanti riportate in
 \secref{tab:sys_timex_mode}.
 
 devono essere specificati come OR binario delle costanti riportate in
 \secref{tab:sys_timex_mode}.
 
-La funzione utilizza il meccanismo di David L. Mills, descritto nell'RFC~1305,
-che è alla base del protocollo NTP; la funzione è specifica di Linux e non
-deve essere usata se la portabilità è un requisito, le \acr{glibc} provvedono
-anche un suo omonimo \func{ntp\_adjtime}.  La trattazione completa di questa
-funzione necessita di una lettura approfondita del meccanismo descritto
-nell'RFC~1305, ci limitiamo a descrivere in \tabref{tab:sys_timex_mode} i
-principali valori utilizzabili per il campo \var{mode}, un elenco più
-dettagliato del significato dei vari campi della struttura \struct{timex} può
-essere ritrovato in \cite{glibc}.
+La funzione utilizza il meccanismo di David L. Mills, descritto
+nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
+protocollo NTP. La funzione è specifica di Linux e non deve essere usata se la
+portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
+\func{ntp\_adjtime}.  La trattazione completa di questa funzione necessita di
+una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
+a descrivere in \tabref{tab:sys_timex_mode} i principali valori utilizzabili
+per il campo \var{mode}, un elenco più dettagliato del significato dei vari
+campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
 
 \begin{table}[htb]
   \footnotesize
 
 \begin{table}[htb]
   \footnotesize