The Test Connection come testare la connettività in C

La Test Connection di questo post è un po' meno pericolosa della French Connection di cui parla il capolavoro di W.Friedkin. Ma è comunque una attività molto importante in alcuni tipi di applicazioni, quindi lungi da noi sottovalutarla.

...facce da connettività avanzata...

Quando usiamo interattivamente un computer e vogliamo verificare lo stato della rete abbiamo molti semplici modi per farlo: ad esempio con un bel ping verso google.com sappiamo se siamo connessi a Internet, e, se non funziona, possiamo usare qualche utility del sistema per scoprire cosa c'è che non va. Supponiamo, però, di dover sviluppare una applicazione per un sistema embedded (siamo o non siamo programmatori C?) e questa applicazione è collegata in rete e, nel caso che non ci sia comunicazione, deve segnalarlo in qualche maniera (chessoio, accendendo un led di errore, certamente non inviando un messaggio in rete!). Ok, e... come facciamo? Vediamolo, vai col codice!

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <arpa/inet.h>

int main(int argc, char *argv[])
{
    int sock;

    // test interfaces
    //

    // ottiene tutti i network devices configurati
    struct ifaddrs *addrs;
    getifaddrs(&addrs);

    // loop sui network devices configurati
    int i_alr = 0;
    struct ifaddrs *tmpaddrs = addrs;
    while (tmpaddrs) {
        // test interface
        if (tmpaddrs->ifa_addr && tmpaddrs->ifa_addr->sa_family == AF_PACKET) {
            // apre un socket per il test
            if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
                // mostra errore e continua
                printf("test interfaces: errore socket per la interface %s: %s\n", 
                       tmpaddrs->ifa_name, strerror(errno));
                continue;
            }

            // prepara i dati per ioctl()
            struct ethtool_value edata;
            edata.cmd = ETHTOOL_GLINK;
            struct ifreq ifr;
            strncpy(ifr.ifr_name, tmpaddrs->ifa_name, sizeof(ifr.ifr_name) - 1);
            ifr.ifr_data = (char *)&edata;

            // esegue ioctl()
            if (ioctl(sock, SIOCETHTOOL, &ifr) == -1) {
                // errore ioctl: chiude il socket e continua
                printf("test interfaces: errore ioctl per la interface %s: %s\n", 
                       tmpaddrs->ifa_name, strerror(errno));
                close(sock);
                continue;
            }

            // mostra i risultati e chiude il socket
            printf("test interfaces: interface %s: %s\n", 
                   tmpaddrs->ifa_name, edata.data ? "OK" : "NOK");
            close(sock);
        }

        // passa al prossimo device
        tmpaddrs = tmpaddrs->ifa_next;
    }

    // libera la devices list
    freeifaddrs(addrs);

    // test connettività
    //

    // apre un socket per il test
    if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        // errore socket
        printf("test di connettività: socket error: %s\n", strerror(errno));
        return EXIT_FAILURE;
    }

    // set di un timeout per send() (in questo caso in realtà lo usa connect()) per 
    // evitare un blocco su errore di connessione)
    struct timeval tv;
    tv.tv_sec  = 1;     // set timeout in secondi
    tv.tv_usec = 0;     // set timeout in usecondi
    if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&tv, sizeof(tv)) < 0) {
        // errore ioctl
        printf("test di connettività: setsockopt error: %s\n", strerror(errno));
        close(sock);
        return EXIT_FAILURE;
    }

    // NOTE: alternativa (non portabile) all'uso di SO_SNDTIMEO:
    //int syn_retries = 1;     // send di un totale di 1 SYN packets => timeout ~2s
    //if (setsockopt(sock, IPPROTO_TCP, TCP_SYNCNT, &syn_retries, sizeof(syn_retries)) < 0) {
    //  ...

    // prepara la struttura sockaddr_in per il server remoto
    struct sockaddr_in server;                  // server (remoto) socket info
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;                // set famiglia indirizzi
    server.sin_addr.s_addr = inet_addr("216.58.214.174");   // set indirizzo server
    server.sin_port = htons(80);                // set numero port server

    // connessione al server remoto
    if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
        // errore connect
        printf("test di connettività: errore connect: %s\n", strerror(errno));
        close(sock);
        return EXIT_FAILURE;
    }

    // mostra i risultati ed esce
    printf("test di connettività: connettività OK\n");
    close(sock);
    return EXIT_SUCCESS;
}

una premessa: questo codice è pensato per applicazioni Linux Embedded, quindi tutto ciò che segue si riferisce a un intorno Linux (beh, come sempre, ed è inutile che mi dilunghi sull'argomento...). Il codice è ampiamente commentato, così non devo dilungarmi eccessivamente in spiegazioni. In questo esempio il codice di test è scritto direttamente nel main() ma, in un progetto reale, si dovrebbe trasformarlo in una funzione che si può chiamare, periodicamente, nella posizione più opportuna, magari direttamente nel main() della applicazione. Visto il tipo di test che si esegue si dovrebbe chiamare ogni tanto, in base a quanto deve essere immediata la segnalazione di allarme che necessitiamo. Normalmente l'uso è a bassa frequenza (parliamo di secondi, non di millisecondi), se no la nostra funzione si mangerebbe molto tempo di CPU solo per controllare la connettività (e non mi sembra il caso).

Il test avviene in due fasi: test delle interfacce di rete e test di connettività. La prima verifica eventuali problemi, diciamo, Hardware: se ho sulla stessa macchina una connessione WiFi e una Ethernet potrei avere connessione Internet anche se, per esempio, il cavo di rete è staccato, e a me interessa segnalare questa situazione, quindi il solo test di connessione non sarebbe sufficiente. La seconda fase verifica la connettività vera e propria e, nel caso che questa manchi, possiamo sapere se non c'è connettività nonostante che le interfacce di rete siano ben collegate, così isoliamo meglio le possibili cause (insomma, è già un test abbastanza completo, ma si può sofisticare a piacere).

La fase di test delle interfacce si esegue con una funzione (relativamente nuova) della sempre indispensabile (in casi come questo) ioctl(). Grazie alla funzione SIOCETHTOOL possiamo verificare il funzionamento a basso livello di ogni interfaccia, visto che il nostro codice include un loop con cui si analizzano tutte le interfacce che, normalmente, sono due (loopback e Ethernet) e a volte sono di più (il WiFi, un altra scheda di rete, ecc.). L'interfaccia loopback c'è sempre e, nel caso che non ci interessi testarla, si può saltare facendo un semplice test sul nome (che è sempre "lo", ma comunque il nome si può verificare previamente, a scanso di equivoci, nel file /etc/network/interfaces).

Il test di connettività si basa, invece, su una semplice connessione tipo Client verso una direzione "sicura": nell'esempio ho usato IP e Port di google.com, ma si può usare quella che ci sembra più opportuna, ad esempio per un dispositivo collegato solo in rete locale si può usare la connessione a un server della rete, oppure ci si può collegare all'indirizzo del gateway locale, ecc. Dipende anche se quello che necessitiamo testare è la connettività Internet o una semplice connettività locale. Notare che tutto ruota sulla system call connect(), che attua inviando dati e ricevendo una risposta, quindi è un test più che sufficiente (senza ricorrere a un ben più complicato ping). Visto che la connect() si blocca per molto tempo quando non riceve subito una risposta ho inserito un opportuno timeout (leggere il commento nel codice) usando setcsockopt() + SO_SNDTIMEO, ma (leggere l'altro commento) si poteva usare anche il flag TCP_SYNCNT, che però è una soluzione meno ortodossa e meno portabile.

Su un normale PC (invece che su un sistema embedded) con connessione Internet via Ethernet, il risultato in condizioni normali è il seguente:

aldo@mylinux:~/blogtest$ ./conntest 
test interfaces: interface lo: OK
test interfaces: interface enp3s0: OK
test di connettività: connettivitá OK

e, se forziamo la disconnessione Software (usando, ad esempio, il NetworkManager di Linux) il risultato è:

aldo@mylinux:~/blogtest$ ./conntest 
test interfaces: interface lo: OK
test interfaces: interface enp3s0: OK
test di connettività: errore connect: Network is unreachable

mentre, se forziamo la disconnessione Hardware (staccando il cavo di rete) il risultato è:

aldo@mylinux:~/blogtest$ ./conntest 
test interfaces: interface lo: OK
test interfaces: interface enp3s0: NOK
test di connettività: errore connect: Network is unreachable

Mica male, no? Una funzione semplice semplice però molto utile. E per oggi può bastare, missione compiuta!

Ciao, e al prossimo post!

Remapped File come sincronizzare un Memory Mapped File in C - pt.2

Beh, credo che sia ora di pubblicare la seconda parte di Remapped File. Spero che vi siate ricaricate bene durante le feste, magari guardando un gran film come Primer, che contiene internamente vari remake di se stesso: potete rivederlo quante volte volete e ogni volta scoprirete dettagli nuovi e, inevitabilmente, perderete dettagli vecchi, entrando in un loop temporale senza fine come i protagonisti stessi del film. Vi assicuro che il post di questo mese non è complicato da capire come Primer, di cui si trovano in rete addirittura pagine wiki dedicate alle timeline con tanto di descrizioni grafiche...

...è nato prima l'uovo o la gallina?...

Allora, andiamo avanti con la nostra libreria per IPC. Dopo aver descritto l'header file (libmmap.h) e un doppio esempio di uso (datareader.c e datawriter.c) è venuto il momento di descrivere la vera e propria implementazione. Ovviamente chi non ha letto la prima parte deve vergognarsi e andare subito a leggerla, e poi tornare qui.

Tornati? Ok, bando alle ciance... vai col codice!

#include <string.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include "libmmap.h"

// memMapOpenMast() - apre un mapped-file come master
ShmData *memMapOpenMast(
    const char *shmname,    // nome del mapped-file
    size_t     len)         // size del campo data da condividere
{
    // apre un mapped-file (il file "shmname" é creato in /dev/shm)
    int fd;
    if ((fd = shm_open(shmname, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR)) == -1)
        return NULL;    // esce con errore

    // tronca un mapped-file
    if (ftruncate(fd, sizeof(ShmData) + len) == -1)
        return NULL;    // esce con errore

    // mappa un mapped-file
    ShmData *shmdata;
    if ((shmdata = mmap(NULL, sizeof(ShmData) + len,
            PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
        return NULL;    // esce con errore

    // init semaforo
    if (sem_init(&shmdata->sem, 1, 1) == -1)
        return NULL;    // esce con errore

    // init flag di data_ready e lunghezza
    shmdata->data_ready = false;
    shmdata->len = len;

    // ritorna il descrittore
    return shmdata;
}

// memMapOpenMast() - apre un mapped-file come slave
ShmData *memMapOpenSlav(
    const char *shmname,    // nome del mapped-file
    size_t     len)         // size del campo data da condividere
{
    // apre un mapped-file (il file "shmname" é creato in /dev/shm)
    int fd;
    if ((fd = shm_open(shmname, O_RDWR, S_IRUSR|S_IWUSR)) == -1)
        return NULL;    // esce con errore

    // mappa un mapped-file
    ShmData *shmdata;
    if ((shmdata = mmap(NULL, sizeof(ShmData) + len,
            PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
        return NULL;    // esce con errore

    // init semaforo
    if (sem_init(&shmdata->sem, 1, 1) == -1)
        return NULL;    // esce con errore

    // ritorna il descrittore
    return shmdata;
}

// memMapClose() - chiude un mapped-file
int memMapClose(
    const char *shmname,    // nome del mapped-file
    ShmData    *shmdata)    // pointer al mapped-file
{
    // elimina semaforo
    if (sem_destroy(&shmdata->sem) < 0)
        return -1;      // esce con errore

    // un-mappa un mapped-file
    if (munmap(shmdata, sizeof(ShmData)) < 0)
        return -1;      // esce con errore

    // cancella un mapped-file
    if (shm_unlink(shmname) < 0)
        return -1;      // esce con errore

    // esce con Ok
    return 0;
}

// memMapFlush() - flush di un mapped-file
int memMapFlush(
    ShmData *shmdata)       // pointer al mapped-file
{
    // sync su disco di un mapped-file
    return msync(shmdata, sizeof(ShmData) + shmdata->len, MS_SYNC);
}

// memMapRead() - legge dati dal mapped-file
int memMapRead(
    void    *dest,
    ShmData *src)
{
    // lock memoria
    sem_wait(&src->sem);

    // test presenza dati nel mapped-file
    if (src->data_ready) {
        // legge dati dal mapped-file
        memcpy(dest, src->data, src->len);
        src->data_ready = false;

        // unlock memoria ed esce
        sem_post(&src->sem);
        return 1;
    }
    else {
        // unlock memoria ed esce
        sem_post(&src->sem);
        return 0;
    }
}

// memMapWrite() - scrive dati nel mapped-file
void memMapWrite(
    ShmData    *dest,
    const void *src)
{
    // lock memoria
    sem_wait(&dest->sem);

    // scrive dati nel mapped-file
    memcpy(dest->data, src, dest->len);
    dest->data_ready = true;

    // unlock memoria ed esce
    sem_post(&dest->sem);
}

Come si nota è abbastanza semplice e conciso, e, come sempre, il codice è auto-esplicativo, ampiamente commentato e con commenti che parlano da soli.

Tutte le funzioni usano, internamente, le opportune system call Linux/POSIX per trattare il nostro Memory Mapped File. In caso di errore su una system call si ritorna immediatamente -1, e questo ci permette, a livello applicativo, di usare direttamente strerror() per verificare l'errore (e questo è un argomento che i miei lettori più affezionati dovrebbero conoscere bene...). Come si nota ci sono due funzioni di open, una master e una slave: perché? Perché, il tipo di comunicazione scelto è (leggermente) asimmetrico, quindi è necessario che uno dei due estremi (il writer) apra il canale, mentre l'altro (il reader) accede al canale sono quando lo trova creato. Quindi adesso si comprende meglio (spero) come funzionano le due funzioni descritte nella prima puntata del post. Questo meccanismo asimmetrico ricorda molto il meccanismo Client/Server che si usa coi socket (altro argomento già affrontato qui), e, infatti, questa libreria è una alternativa al classico IPC coi socket.

Le funzioni di read e write si limitano a usare memcpy() per copiare i dati dal/sul mapped-file. E, come anticipato nel post precedente, le letture e scritture usano un meccanismo di sincronizzazione (un POSIX unnamed semaphore) che viene inizializzato nelle funzioni di open: semplicemente chi accede ai dati mette in rosso (lock) il semaforo (quindi chi arriva dopo si ferma) e quando ha finito lo rimette in verde (unlock).

La funzione di flush è solo un wrapper per la chiamata msync() e, normalmente, non è necessario usarla: con questa libreria noi vogliamo trattare file mappati in memoria per condividere dati tra processi, per cui, non solo ci interessa poco che il file abbia una immagine reale sul disco, ma, per una semplice questione di prestazioni dovremmo evitare di scaricare realmente sul disco tutti i cambi effettuati in memoria, se no tanto varrebbe far comunicare i processi con dei file veri. Quindi a cosa serve il flush? Serve solo ad avere una eventuale versione reale e aggiornata del file condiviso, nel caso volessimo trattarlo anche con le classiche funzioni open(), close(), read(), ecc. Per questo nel file msgwriter.c descritto nel post precedente la chiamata memMapFlush() non viene usata.

E veniamo all'altra novità introdotta in questa nuova versione della libmmap: i dati trattati sono, ora, generici, quindi le funzioni di read e write usano dei void* come argomenti: questo è un vantaggio notevole, perché permette di scambiare dati in IPC usando qualsiasi formato; una struttura complessa oppure una singola variabile (chessoio? un int). Ad esempio nell'ultimo post ho definito un tipo Data (una struct con un campo text) da usare a livello applicativo e che si può passare come argomento alle read e write senza neppure fare un cast. Una grande flessibilità, simile a quella delle funzioni della libc come la memcpy(), ma con un qualcosa in più: la dimensione (e, indirettamente, il tipo) dei dati che si scambiano viene passata, una volta per tutte, durante la fase di open (attraverso il parametro len), quindi le funzioni di read e write non hanno il classico campo "size_t len" che uno si aspetterebbe.

Ci manca solo da descrivere una cosa: il trucco del "char data[1]" usato per rendere generici i dati da condividere. Questo campo è (non a caso) l'ultimo della struttura dati che descrive il mapped-file, e funziona così: quando si crea il file si passa, alla memMapOpenMast(), il size dei dati da scambiare (con un operatore sizeof, vedi l'esempio dell'ultimo post), e, come si nota nel codice della memMapOpenMast(), il mapped-file viene mappato usando la system call mmap() passandogli un argomento length che indica la dimensione del mapped-file in oggetto: nel nostro caso si passa "sizeof(ShmData) + len", quindi il mapped-file è impostato per scambiare dati nella sua parte variabile "char data[1]", che di base è lunga un char, ma che, in realtà, è lunga len char una volta mappato il file. Un trucchetto da niente. 

Spero che la nuova versione della libreria vi sia piaciuta. Vi assicuro che, con solo qualche miglioria (tipo la gestione di tutti gli errori interni possibili, lo sdoppiamento del semaforo per gestire lock read/write, aggiungere meccanismi di accesso blocking/nonblocking... va beh, forse un è un po' più di qualche miglioria!), si potrebbe usare anche in progetti professionali... e scusate se è poco!

Ciao, e al prossimo post!

Buone Feste!