From a0184b68ca9dced41be95342ffd8a8ee04d2b861 Mon Sep 17 00:00:00 2001 From: Simone Piccardi Date: Sat, 1 May 2004 17:53:42 +0000 Subject: [PATCH] Client per il servizio echo su UDP e relative chiacchiere --- listati/UDP_ClientEcho.c | 31 ++++++++ listati/UDP_echo.c | 31 ++++++++ othersock.tex | 98 ++++++++++++++++++++++++- sources/Makefile | 5 +- sources/UDP_echo.c | 149 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 312 insertions(+), 2 deletions(-) create mode 100644 listati/UDP_ClientEcho.c create mode 100644 listati/UDP_echo.c create mode 100644 sources/UDP_echo.c diff --git a/listati/UDP_ClientEcho.c b/listati/UDP_ClientEcho.c new file mode 100644 index 0000000..746d5a7 --- /dev/null +++ b/listati/UDP_ClientEcho.c @@ -0,0 +1,31 @@ +void ClientEcho(FILE * filein, int socket, struct sockaddr_in * serv_addr) +{ + char sendbuff[MAXLINE+1], recvbuff[MAXLINE+1]; + int nread, nwrite; + /* initialize file descriptor set */ + while (1) { + if (fgets(sendbuff, MAXLINE, filein) == NULL) { + return; /* if no input just return */ + } else { /* else we have to write to socket */ + nwrite = sendto(socket, sendbuff, strlen(sendbuff), 0, + (struct sockaddr *) serv_addr, sizeof(*serv_addr)); + if (nwrite < 0) { /* on error stop */ + printf("Errore in scrittura: %s", strerror(errno)); + return; + } + } + nread = recvfrom(socket, recvbuff, strlen(sendbuff), 0, NULL, NULL); + if (nread < 0) { /* error condition, stop client */ + printf("Errore in lettura: %s\n", strerror(errno)); + return; + } + if (nread == 0) { /* server closed connection, stop */ + return; + } + recvbuff[nread] = 0; /* else read is ok, write on stdout */ + if (fputs(recvbuff, stdout) == EOF) { + perror("Errore in scrittura su terminale"); + return; + } + } +} diff --git a/listati/UDP_echo.c b/listati/UDP_echo.c new file mode 100644 index 0000000..943ec75 --- /dev/null +++ b/listati/UDP_echo.c @@ -0,0 +1,31 @@ +void ClientEcho(FILE * filein, int socket, struct sockaddr_in *serv_add); +void SigTERM_hand(int sig); + +/* Program begin */ +int main(int argc, char *argv[]) +{ +/* + * Variables definition + */ + int sock, i; + struct sockaddr_in serv_add; + ... + /* create socket */ + if ( (sock = socket(AF_INET, SOCK_DGRAM, 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; + } + /* do read/write operations */ + ClientEcho(stdin, sock, &serv_add); + /* normal exit */ + return 0; +} diff --git a/othersock.tex b/othersock.tex index 5af4f66..3a64aa7 100644 --- a/othersock.tex +++ b/othersock.tex @@ -13,7 +13,7 @@ Dopo aver trattato in \capref{cha:TCP_socket} i socket TCP, che costituiscono l'esempio più comune dell'interfaccia dei socket, esamineremo in questo -capitolo gli altri tipi di socket, a partire dai socket UDP, e i socket deiit +capitolo gli altri tipi di socket, a partire dai socket UDP, e i socket \textit{Unix domain} già incontrati in \secref{sec:ipc_socketpair}. @@ -477,6 +477,102 @@ compito del server distribuire le risposte sulla base dell'indirizzo da cui provengono le richieste. +\subsection{Le problematiche dei socket UDP} +\label{sec:UDP_problems} + +L'esempio del servizio \textit{daytime} illustrato nelle precedenti sezioni +è in realtà piuttosto particolare, e non evidenzia quali possono essere i +problemi collegati alla mancanza di affidabilità e all'assenza del concetto di +connessione che sono tipiche dei socket UDP. In tal caso infatti il protocollo +è estremamente semplice, dato che la comunicazione consiste sempre in una +richiesta seguita da una risposta, per uno scambio di dati effettuabile con un +singolo pacchetto, per cui tutti gli eventuali problemi sarebbero assai più +complessi da rilevare. + +Anche qui però possiamo notare che se il pacchetto di richiesta del client, o +la risposta del server si perdono, il client resterà permanentemente bloccato +nella chiamata a \func{recvfrom}. Per evidenziare meglio quali problemi si +possono avere proviamo allora con un servizio leggermente più complesso come +\textit{echo}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15.6cm} + \includecodesample{listati/UDP_echo.c} + \end{minipage} + \normalsize + \caption{Sezione principale del client per il servizio \textit{echo} su + UDP.} + \label{fig:UDP_echo_client} +\end{figure} + +In \figref{fig:UDP_echo_client} è riportato un estratto del corpo principale +del nostro client elementare per il servizio \textit{echo} (al solito il +codice completo è con i sorgenti allegati). Le uniche differenze con l'analogo +client visto in \figref{fig:TCP_echo_client_1} sono che al solito si crea +(\texttt{\small 14}) un socket di tipo \const{SOCK\_DGRAM}, e che non è +presente nessuna chiamata a \func{connect}. Per il resto il funzionamento del +programma è identico, e tutto il lavoro viene effettuato attraverso la +chiamata (\texttt{\small 28}), alla funzione \func{ClientEcho} che stavolta +però prende un argomento in più, che è l'indirizzo del socket. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15.6cm} + \includecodesample{listati/UDP_ClientEcho.c} + \end{minipage} + \normalsize + \caption{Codice della funzione \func{ClientEcho} usata dal client per il + servizio \textit{echo} su UDP.} + \label{fig:UDP_echo_clientecho} +\end{figure} + +Ovviamente in questo caso il funzionamento della funzione, il cui codice è +riportato in \figref{fig:UDP_echo_clientecho}, è completamente diverso +rispetto alla analoga del server TCP, e dato che non esiste una connessione +questa necessita anche di un terzo parametro, che è l'indirizzo del server cui +inviare i pacchetti. + +Data l'assenza della connessione il meccanismo è molto più semplice da +gestire. Al solito si esegue un ciclo infinito (\texttt{\small 6--30}) che +parte dalla lettura (\texttt{\small 7}) di una stringa dallo standard input + + + + + +In genere fintanto che si esegue il nostro client in locale non sorgerà nessun +problema, se però si prova ad eseguirlo attraverso un collegamento remoto (nel +caso una VPN, attraverso una ADSL abbastanza congestionata) e in modalità non +interattiva, la probabilità di perdere qualche pacchetto aumenta, ed infatti, +eseguendo il comando come: +\begin{verbatim} +[piccardi@gont sources]$ cat UDP_echo.c | ./echo 192.168.1.120 +/* UDP_echo.c + * + * Copyright (C) 2004 Simone Piccardi +... +... +/* + * Include needed headers + +\end{verbatim}%$ +si otterrà che dopo aver correttamente stampato alcune righe il programma si +bloccherà completamente senza stampare più niente. Se al contempo si fosse +tenuto sotto controllo il traffico UDP con \cmd{tcpdump} si sarebbe ottenuto: +\begin{verbatim} +[root@gont gapil]# tcpdump \( dst port 7 or src port 7 \) +... +... +18:48:16.390255 gont.earthsea.ea.32788 > 192.168.1.120.echo: udp 4 (DF) +18:48:17.177613 192.168.1.120.echo > gont.earthsea.ea.32788: udp 4 (DF) +18:48:17.177790 gont.earthsea.ea.32788 > 192.168.1.120.echo: udp 26 (DF) +18:48:17.964917 192.168.1.120.echo > gont.earthsea.ea.32788: udp 26 (DF) +18:48:17.965408 gont.earthsea.ea.32788 > 192.168.1.120.echo: udp 4 (DF) +\end{verbatim} +che come si vede termina con l'invio di un pacchetto UDP per il quale non si è +ricevuto risposta. + \subsection{L'uso della funzione \func{connect} con i socket UDP} diff --git a/sources/Makefile b/sources/Makefile index b620e0c..0b4b5a9 100644 --- a/sources/Makefile +++ b/sources/Makefile @@ -67,7 +67,10 @@ forktest: ForkTest.c errcode: ErrCode.c $(CC) $(CFLAGJ) $^ -o $@ -echo: TCP_echo.c +echo: UDP_echo.c + $(CC) $(CFLAGJ) $(CFLAGS) $^ -o $@ + +techo: TCP_echo.c $(CC) $(CFLAGJ) $(CFLAGS) $^ -o $@ echod: TCP_echod.c diff --git a/sources/UDP_echo.c b/sources/UDP_echo.c new file mode 100644 index 0000000..8de9087 --- /dev/null +++ b/sources/UDP_echo.c @@ -0,0 +1,149 @@ +/* UDP_echo.c + * + * Copyright (C) 2004 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 UDP_echo.c + * Simple UDP client for echo service (port 7) + * + * Author: Simone Piccardi + * May 2004 + * + * Usage: echo -h give all info's + * + * $Id: UDP_echo.c,v 1.1 2004/05/01 17:53:42 piccardi Exp $ + * + ****************************************************************/ +/* + * Include needed headers + */ +#include /* predefined types */ +#include /* include unix standard library */ +#include /* IP addresses conversion utiliites */ +#include /* socket library */ +#include /* include standard I/O library */ +#include /* include error codes */ +#include /* include erroro strings definitions */ + +#include "macros.h" + +#define MAXLINE 256 +void usage(void); +void ClientEcho(FILE * filein, int socket, struct sockaddr_in *serv_add); +void SigTERM_hand(int sig); + +/* Program begin */ +int main(int argc, char *argv[]) +{ +/* + * Variables definition + */ + int sock, i; + struct sockaddr_in serv_add; + /* + * 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(1); + 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 ( (sock = socket(AF_INET, SOCK_DGRAM, 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; + } + /* do read/write operations */ + ClientEcho(stdin, sock, &serv_add); + /* normal exit */ + return 0; +} +/* + * routine to print usage info and exit + */ +void usage(void) { + printf("Take daytime from a remote host \n"); + printf("Usage:\n"); + printf(" daytime [-h] [-v] [host in dotted decimal form] \n"); +// printf(" -v set verbosity on\n"); + printf(" -r require reset on closing\n"); + printf(" -h print this help\n"); + exit(1); +} + +void ClientEcho(FILE * filein, int socket, struct sockaddr_in * serv_addr) +{ + char sendbuff[MAXLINE+1], recvbuff[MAXLINE+1]; + int nread, nwrite; + /* initialize file descriptor set */ + while (1) { + if (fgets(sendbuff, MAXLINE, filein) == NULL) { + return; /* if no input just return */ + } else { /* else we have to write to socket */ + nwrite = sendto(socket, sendbuff, strlen(sendbuff), 0, + (struct sockaddr *) serv_addr, sizeof(*serv_addr)); + if (nwrite < 0) { /* on error stop */ + printf("Errore in scrittura: %s", strerror(errno)); + return; + } + } + nread = recvfrom(socket, recvbuff, strlen(sendbuff), 0, NULL, NULL); + if (nread < 0) { /* error condition, stop client */ + printf("Errore in lettura: %s\n", strerror(errno)); + return; + } + if (nread == 0) { /* server closed connection, stop */ + return; + } + recvbuff[nread] = 0; /* else read is ok, write on stdout */ + if (fputs(recvbuff, stdout) == EOF) { + perror("Errore in scrittura su terminale"); + return; + } + } +} -- 2.30.2