Esercizio - Echo TCP e UDP, client e server (sul modello della prova pratica)

/* echo_tcp_server.c - server TCP iterativo: rimanda indietro tutto quello che riceve.
 * Compilare:  gcc -Wall -Wextra -o echo_tcp_server echo_tcp_server.c
 * Avviare:    ./echo_tcp_server 7777
 * Provare:    nc 127.0.0.1 7777      (si scrive una riga, il server la rimanda)
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Scrive tutti i byte: write puo' fermarsi prima (buffer del socket pieno, segnale). */
static int write_all(int fd, const char *buf, size_t n)
{
    while (n > 0) {
        ssize_t w = write(fd, buf, n);
        if (w < 0) {
            if (errno == EINTR)
                continue;
            return -1;
        }
        buf += w;
        n -= (size_t)w;
    }
    return 0;
}

int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "uso: %s porta\n", argv[0]);
        return 1;
    }
    signal(SIGPIPE, SIG_IGN);                       /* niente morte improvvisa se il client sparisce */

    /* 1) socket(): crea il "telefono". AF_INET = IPv4, SOCK_STREAM = TCP. */
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd < 0) {
        perror("socket");
        return 1;
    }

    /* Senza SO_REUSEADDR un riavvio subito dopo la chiusura fallisce con "Address already in use" (TIME_WAIT). */
    int yes = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);

    /* 2) bind(): assegna al socket l'indirizzo locale (tutte le interfacce) e la porta. */
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);                  /* azzera anche i campi di riempimento */
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons((unsigned short)atoi(argv[1]));   /* host order -> network order (big endian) */
    if (bind(lfd, (struct sockaddr *)&addr, sizeof addr) < 0) {
        perror("bind");
        return 1;
    }

    /* 3) listen(): il socket diventa "passivo"; il kernel completa gli handshake e mette in coda fino a 5 connessioni. */
    if (listen(lfd, 5) < 0) {
        perror("listen");
        return 1;
    }

    for (;;) {
        /* 4) accept(): blocca finche' arriva una connessione completata e restituisce un NUOVO socket per quel client. */
        struct sockaddr_in cli;
        socklen_t clen = sizeof cli;                /* in ingresso: dimensione del buffer; in uscita: dimensione scritta */
        int cfd = accept(lfd, (struct sockaddr *)&cli, &clen);
        if (cfd < 0) {
            if (errno == EINTR)
                continue;
            perror("accept");
            break;
        }
        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &cli.sin_addr, ip, sizeof ip);
        printf("connesso %s:%d\n", ip, ntohs(cli.sin_port));

        /* 5) dialogo: read restituisce 0 quando il client chiude (EOF), -1 su errore. */
        char buf[1024];
        ssize_t n;
        while ((n = read(cfd, buf, sizeof buf)) > 0)
            if (write_all(cfd, buf, (size_t)n) < 0)
                break;
        printf("chiuso %s:%d\n", ip, ntohs(cli.sin_port));
        close(cfd);                                 /* si chiude il socket del client, non quello in ascolto */
    }
    close(lfd);
    return 0;
}

/* echo_tcp_client.c - client TCP: legge righe dalla tastiera, le manda al server e stampa la risposta.
 * Compilare:  gcc -Wall -Wextra -o echo_tcp_client echo_tcp_client.c
 * Usare:      ./echo_tcp_client 127.0.0.1 7777
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

static int write_all(int fd, const char *buf, size_t n)
{
    while (n > 0) {
        ssize_t w = write(fd, buf, n);
        if (w < 0) {
            if (errno == EINTR)
                continue;
            return -1;
        }
        buf += w;
        n -= (size_t)w;
    }
    return 0;
}

/* Legge ESATTAMENTE n byte (TCP e' uno stream: una read puo' restituirne meno). Torna -1 su errore o EOF anticipato. */
static int read_exact(int fd, char *buf, size_t n)
{
    while (n > 0) {
        ssize_t r = read(fd, buf, n);
        if (r < 0 && errno == EINTR)
            continue;
        if (r <= 0)
            return -1;
        buf += r;
        n -= (size_t)r;
    }
    return 0;
}

int main(int argc, char **argv)
{
    if (argc != 3) {
        fprintf(stderr, "uso: %s host porta\n", argv[0]);
        return 1;
    }

    /* getaddrinfo traduce nome o IP + porta in una lista di indirizzi pronti per connect (IPv4 e IPv6). */
    struct addrinfo hints, *res, *p;
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    int rc = getaddrinfo(argv[1], argv[2], &hints, &res);
    if (rc != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rc));
        return 1;
    }
    int fd = -1;
    for (p = res; p != NULL; p = p->ai_next) {      /* prova gli indirizzi uno dopo l'altro */
        fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if (fd < 0)
            continue;
        if (connect(fd, p->ai_addr, p->ai_addrlen) == 0)
            break;                                  /* three-way handshake completato */
        close(fd);
        fd = -1;
    }
    freeaddrinfo(res);
    if (fd < 0) {
        fprintf(stderr, "impossibile connettersi a %s:%s\n", argv[1], argv[2]);
        return 1;
    }

    char line[1024], reply[1024];
    while (fgets(line, sizeof line, stdin) != NULL) {
        size_t n = strlen(line);
        if (write_all(fd, line, n) < 0) {
            perror("write");
            break;
        }
        /* l'echo restituisce esattamente n byte: li aspettiamo tutti */
        if (read_exact(fd, reply, n) < 0) {
            fprintf(stderr, "il server ha chiuso la connessione\n");
            break;
        }
        reply[n] = '\0';
        printf("echo: %s", reply);
    }
    close(fd);                                      /* invia FIN: il server vede read() == 0 */
    return 0;
}

/* echo_udp_server.c - server UDP: rimanda ogni datagramma al mittente. Niente listen, niente accept.
 * Compilare:  gcc -Wall -Wextra -o echo_udp_server echo_udp_server.c
 * Avviare:    ./echo_udp_server 7777
 * Provare:    echo ciao | nc -u -w1 127.0.0.1 7777
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "uso: %s porta\n", argv[0]);
        return 1;
    }
    int fd = socket(AF_INET, SOCK_DGRAM, 0);        /* SOCK_DGRAM = UDP: senza connessione */
    if (fd < 0) {
        perror("socket");
        return 1;
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons((unsigned short)atoi(argv[1]));
    if (bind(fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
        perror("bind");
        return 1;
    }

    char buf[2048];
    for (;;) {
        struct sockaddr_in cli;
        socklen_t clen = sizeof cli;
        /* recvfrom restituisce UN datagramma intero (se il buffer e' piu' piccolo il resto va perso)
         * e dice chi l'ha mandato: UDP non ha connessione, l'indirizzo del mittente arriva con ogni pacchetto. */
        ssize_t n = recvfrom(fd, buf, sizeof buf, 0, (struct sockaddr *)&cli, &clen);
        if (n < 0) {
            perror("recvfrom");
            continue;
        }
        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &cli.sin_addr, ip, sizeof ip);
        printf("%zd byte da %s:%d\n", n, ip, ntohs(cli.sin_port));
        sendto(fd, buf, (size_t)n, 0, (struct sockaddr *)&cli, clen);   /* risposta allo stesso mittente */
    }
}

/* echo_udp_client.c - client UDP: manda un datagramma per riga e aspetta la risposta per 2 secondi.
 * Compilare:  gcc -Wall -Wextra -o echo_udp_client echo_udp_client.c
 * Usare:      ./echo_udp_client 127.0.0.1 7777
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netdb.h>

int main(int argc, char **argv)
{
    if (argc != 3) {
        fprintf(stderr, "uso: %s host porta\n", argv[0]);
        return 1;
    }
    struct addrinfo hints, *res;
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;                 /* UDP */
    int rc = getaddrinfo(argv[1], argv[2], &hints, &res);
    if (rc != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rc));
        return 1;
    }
    int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    if (fd < 0) {
        perror("socket");
        return 1;
    }

    /* Se il datagramma (o la risposta) si perde, recvfrom aspetterebbe per sempre: serve un timeout. */
    struct timeval tv = {.tv_sec = 2, .tv_usec = 0};
    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);

    char line[1024], reply[2048];
    while (fgets(line, sizeof line, stdin) != NULL) {
        /* sendto: nessuna connessione, ogni datagramma porta il proprio destinatario */
        if (sendto(fd, line, strlen(line), 0, res->ai_addr, res->ai_addrlen) < 0) {
            perror("sendto");
            break;
        }
        ssize_t n = recvfrom(fd, reply, sizeof reply - 1, 0, NULL, NULL);   /* NULL: non ci interessa il mittente */
        if (n < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                printf("(nessuna risposta: datagramma perso?)\n");   /* UDP non ritrasmette: decide l'applicazione */
            else
                perror("recvfrom");
            continue;
        }
        reply[n] = '\0';
        printf("echo: %s", reply);
    }
    freeaddrinfo(res);
    close(fd);
    return 0;
}

$ gcc -Wall -Wextra -o echo_tcp_server echo_tcp_server.c
$ gcc -Wall -Wextra -o echo_tcp_client echo_tcp_client.c
$ ./echo_tcp_server 7777 &
$ ./echo_tcp_client 127.0.0.1 7777
ciao
echo: ciao
come va?
echo: come va?
^D
connesso 127.0.0.1:51514          <- stampato dal server
chiuso 127.0.0.1:51514