Programmazione di rete: esempi in Java, C e PHP

[airex]

Quello che vi presento è il quarto e ultimo episodio della serie di Articoli "Le basi di Internet" che a partire dal 2003 ho pubblicato sulle pagine di Forum.Lithium.it.

Nelle prime 3 puntate avevo parlato dell'organizzazione della rete e dei protocolli TCP, ICMP, IP(v4) e IPv6 mentre in quest'ultimo mi sono soffermato sull'aspetto pratico, ossia come realizzare un'applicazione client-server che dialoghi attraverso la rete e sia in grado di monitorare lo stato di diversi host.

Vediamo ora come può essere organizzato questo sistema per tenere sotto controllo lo stato di alcuni host.

- Host da controllare (client)

* invia ogni TOT secondi un pacchetto UDP alla porta 30000 del controllore per notificare la propria presenza (ALIVE)
* puo' interrogare il controllore per avere informazioni circa lo stato degli altri client dialogando con il server attraverso la porta TCP 30006

- Host controllore (server)

* ascolta sulla porta UDP 30000
* per ogni pacchetto UDP ricevuto e indicante un host in stato ALIVE aggiorna le informazioni relative a tale client
* ascolta sulla porta TCP 30006
* per ogni connessione ricevuta su tale porta invia al client richiedente le informazioni sullo stato dei vari host

Schematicamente:

- Aggiornamento stato del Client
Client ---> UDP:30000 ---> Server

I dati inviati dal client sono contenuti in un pacchetto nel quale e' indicato l'indirizzo IP del mittente.


- Richiesta stato degli host
Client <---> TCP:30006 <---> Server

Il client non invia alcun dato al server in quanto quest'ultimo appena avra' accettato la connessione inviera' al client i dati sullo stato dei vari host.
Le informazioni saranno codificate per righe ed in ciascuna di esse sarà presente il nome dell'host, uno spazio vuoto e lo stato dell'host.

La parte pratica che ora vi mostrero' è stata suddivisa in 3 sezioni, in modo da darvi un quadro d'insieme su diversi linguaggi: JAVA, C e PHP

 

[airex]

Linguaggio Java

Per quanto riguarda gli esempi in Java vedremo ora 3 file, uno per il server, uno per il client che deve segnalare ogni TOT secondi se stesso come ancora attivo e infine uno che implementa un semplice meccanismo per interrogare il server e ottenere le informazioni relative allo stato degli host monitorati.

Server

NetCheckServer.java

import java.net.*;

public class NetCheckServer {
    
    static int tcp_port = 30006;
    static int udp_port = 30000;
    
    HashMap clientStatus = null;
    
    public static void main(String[] args) {

        // Avviamo il server        
        NetCheckServer server = new NetCheckServer();

    }
    
    public NetCheckServer() {
        
        try {
        
            // inizializziamo i dati sui client
            clientStatus = new HashMap();
            
            // mettiamo il server in ascolto sulla porta TCP specifica
            ServerSocket server_tcp = new ServerSocket(tcp_port);
            
            // mettiamo il server in ascolto sulla porta UDP specifica
            DatagramSocket server_udp = new DatagramSocket(udp_port);
            
            // creiamo il thread che gestirà la ricezione delle segnalazioni
            // di stato dei client e avviamolo. 
            UDPThread udpT = new UDPThread(server_udp,clientStatus);
            udpT.start();

         // adesso che abbiamo avviato il gestore dei pacchetti UDP
         // entriamo in un loop nel quale gestiremo le richieste ricevute
         // sulla nostra porta TCP
         while (true) {
         
            // accettiamo una richiesta (nota: questa chiamata resta
            // in attesa fino a quando non riceviamo una richiesta
            // di connessione)
            Socket s = server_tcp.accept();
            // creiamo il thread che gestirà le comunicazioni relative
            // alla connessiamo appena accettata e avviamolo
            TCPThread tcpT = new TCPThread(s,clientStatus);
            tcpT.start();                 

            }
            
        }    
        catch (Exception ex) {
            
            // c'è stato un errore, chiudiamo tutto!
            ex.printStackTrace();
            
        }
        
    }

}

class UDPThread extends Thread {
    
    HashMap status  = null;
    DatagramSocket sck = null;
    byte [] buffer = new byte[4096];
    
    static long death_time = 30000000L; // 30 secondi
    
    public UDPThread(DatagramSocket listener,HashMap status) {

        // in fase di creazione dell'oggetto salviamoci 
        // i riferimenti agli oggetti che ci serviranno!
        this.status = status;
        this.sck = listener;
        
    }
    
    public void run() {
        
        DatagramPacket data = null;
        long x = 0;
        int i = 0;
        
        // aspettiamo i pacchetti e per ognuno di essi
        // registriamo lo stato dei client
        
        while (true) {
            
            try {
                
                sck.setSoTimeout(500);
                try {
                    
                    data = new DatagramPacket(buffer,4096);
                    sck.receive(data);
                    
                }
                catch (SocketTimeoutException ste) {
                    
                    // è passato del tempo e non abbiamo pacchetti
                    // non segnaliamo l'errore dato che non è rilevante
                    // (a dire il vero NON è un errore)
                    
                    data = null;
                }
                
                synchronized (status) {
                    
                    // cerchiamo e "segnamo" gli host che da troppo tempo 
                    // non danno segni di vita
                    Object[] arr = status.keySet().toArray();
                    
                    for (i=0;i<arr.length;i++) {
                        
                            // se sono passati più di 30 secondi dall'ultimo pacchetto
                            // impostiamo l'host come "non attivo"
                            x = Long.valueOf(status.get(arr[i]).toString()).longValue();
                            
                            if ((x > 0L) && ((Calendar.getInstance().getTimeInMillis() - x) > death_time)) {
                                status.put(arr[i],"0");
                                // per motivi di debug mandiamo a video un messaggio
                                System.out.println("Impostiamo come 'non attivo' "+((InetAddress)arr[i]).toString());
                            }
                        
                    }
                    
                }
                
                if (data!=null && data.getLength() > 0) {
                
                    synchronized (status) {

                        // abbiamo ricevuto un pacchetto, registriamo
                        // l'host che l'ha inviato come attivo
                        status.put(data.getAddress().toString(),String.valueOf(Calendar.getInstance().getTimeInMillis()));
                        // per motivi di debug mandiamo a video un messaggio
                        System.out.println("Impostiamo come 'attivo' "+data.getAddress().toString());
                        
                    }
                    
                }
                
                
            }
            catch (Exception ex) {
                
                // c'è stato un errore ... non facciamo nulla se non segnalarlo!
                ex.printStackTrace();
                
            }
            
        }
        
    }
    
}

class TCPThread extends Thread {

    HashMap status  = null;
    Socket sck = null;
    byte [] buffer = new byte[4096];

    
    public TCPThread(Socket listener,HashMap status) {

        // in fase di creazione dell'oggetto salviamoci 
        // i riferimenti agli oggetti che ci serviranno!
        this.status = status;
        this.sck = listener;        

    }

    public void run() {
    
        String st = "";
        int i = 0;
        
        try {
            
            // per debug mandiamo a video qualche dato di chi ci
            // ha contattato 
            System.out.println("Richiesta dati da parte di "+sck);
            
            // ok, dobbiamo inviare lo stato dei client!
            // creaiamo il canale per l'invio dati
            PrintWriter pw = new PrintWriter(sck.getOutputStream());
            
            synchronized (status) {

                // prendiamo tutti gli "stati" e inviamoli!
                Object[] arr = status.keySet().toArray();
                
                for (i=0;i<arr.length;i++) {
                    pw.write( arr[i].toString() );
                    pw.write(" ");
                    st = status.get(arr[i]).toString();
                    if (st.equals("0"))
                        pw.write("NON ATTIVO");
                    else
                        pw.write("ATTIVO");
                    pw.write("\n");
                }
                
                
            }
            
            // chiudiamo il canale
            pw.flush();
            pw.close();
            
            // chiudiamo la socket
            sck.close();
            
            // abbiamo finito il nostro compito!
        }
        catch (Exception ex) {
            
            // si è verificato un errore, segnaliamolo e terminiamo l'esecuzione del thread
            ex.printStackTrace();
            
        }
        
    }
    
}

Client che a intervalli regolari segnala la propria presenza

NetCheckClientAlive.java

import java.net.*;

public class NetCheckClientAlive extends Thread {

    static int udp_port = 30000;
    static long wait_for = 20000000L; // 20 secondi
    
    String server = "";
    
    public static void main(String[] args) {

        // come primo parametro ci aspettiamo il nome del server!
        
        // creiamo il thread per l'invio dei messaggi
        NetCheckClientAlive ncc = new NetCheckClientAlive(args[0]);
        // avviamo il thread!
        ncc.start();

    }

    public NetCheckClientAlive(String server) {
        this.server = server;
    }

    public void run() {

        
        byte buffer [] = new byte[4096];
        
        try {

            
            // creiamo il pacchetto udp
            DatagramPacket dp = new DatagramPacket(buffer,4096);
            dp.setData(buffer);
    
            // creiamo la socket udp
            DatagramSocket ds = new DatagramSocket();
        
            // indichiamo la destinazione del pacchetto, trasformando
            // il nome del server in un indirizzo e fornendo la porta
            ds.connect(InetAddress.getByName(server),udp_port);

            
            while (true) {
            
                // inviamo il pacchetto!
                ds.send(dp);
            
                try {
                    
                    // restiamo in attesa per un po'
                    sleep(wait_for);
                    
                }
                catch (Exception e1) {
                    // Ignoriamo gli errori dovuti all'attesa
                    
                }
                
            }
        
        }
        catch (Exception ex) {
            
            // segnaliamo l'errore
            ex.printStackTrace();
            
        }

    }
    
    
}

 

[airex]

Client che interroga il server per ottenere informazioni

NetCheckClient.java

import java.net.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class NetCheckClient  {

    static int tcp_port = 30006;
    
    public static void main(String[] args) {
        
        // come primo parametro ci aspettiamo il nome del server!
        String server = args[0];            
        String buffer = "";
        
        try {
                // creiamo la socket per connetterci al server, trasformando
                // il nome del server in un indirizzo e fornendo la porta
                Socket sck = new Socket(InetAddress.getByName(server),tcp_port);
                
                // creiamo il canale per la ricezione dei dati
                BufferedReader br = new BufferedReader(new InputStreamReader(sck.getInputStream()));
                
                // leggiamo tutti i dati che il server ci manda
                // e mandiamoli a video
                while (( buffer = br.readLine()) != null) {
                    System.out.print(buffer);
                }
                System.out.println("\n");
                
                // chiudiamo la connessione e terminiamo
                br.close();
                sck.close();
                
        }
        catch (Exception ex) {
            
            // segnaliamo l'errore
            ex.printStackTrace();
            
        }

    }
    
    
}

 

[airex]

Linguaggio C

Anche in questa sezione dedicata al C avremo 3 file, uno per il server, uno per il client che deve segnalare ogni TOT secondi se stesso come ancora attivo e infine uno che implementa un semplice meccanismo per interrogare il server e ottenere le informazioni relative allo stato degli host monitorati.

Server

NetCheckServer.c

   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>
   #include <stdio.h>
   #include <errno.h>
   #include <sys/select.h>
   #include <unistd.h>
   #include <time.h>
   
   struct host_status
   {
     char ip[16];            // kkk.xxx.yyy.zzz\0
     unsigned long last_activity;
     struct host_status *next;
   };
   
   #define TCP_PORT 30006
   #define UDP_PORT 30000
   #define MAX_TIME 30L
   
   int
   main (int argc, char **argv)
   {
     int tcp_socket;
     int udp_socket;
     int conn, n;
     char buffer_to_send[32];
     char buffer_to_read[32];
     struct sockaddr_in tcp_serv;
     struct sockaddr_in udp_server;
     struct sockaddr_in client;
     struct timeval tv_tcp;
     struct timeval tv_udp;
     struct host_status *lista = NULL;
     struct host_status *host = NULL;
     struct host_status *last = NULL;
     fd_set read_udp_status;
     fd_set read_tcp_status;
     socklen_t clilen;
     int flags;
     int error;
   
     // creiamo la socket di ascolto per TCP
     tcp_socket = socket (AF_INET, SOCK_STREAM, 0);
     if (tcp_socket <= 0)
       {
         printf ("Errore nella creazione della socket tcp!\n");
         exit (-1);
       }
     // azzeriamo la struttura dati con le informazioni ...
     bzero (&tcp_serv, sizeof (tcp_serv));
     // impostiamo come "famiglia" quella di rete ...
     tcp_serv.sin_family = AF_INET;
     // associamo la socket a qualsiasi interfaccia di rete ...
     tcp_serv.sin_addr.s_addr = htonl (INADDR_ANY);
     // impostiamo la porta di ascolto ...
     tcp_serv.sin_port = htons (TCP_PORT);
     // associamo alla socket le informazioni appena create ...
     if (bind (tcp_socket, (struct sockaddr *) &tcp_serv, sizeof (tcp_serv)) < 0)
       {
         printf ("Errore nell'associazione della socket tcp!\n");
         exit (-1);
       }
     // mettiamo in ascolto la socket, dando come massimo numero
     // di richieste "in coda" 1024
     if (listen (tcp_socket, 1024) < 0)
       {
         printf ("Errore nella messa in ascolto della socket tcp!\n");
         exit (-1);
       }
   
     // ora e' il turno della socket in ascolto per UDP 
     udp_socket = socket (AF_INET, SOCK_DGRAM, 0);
     if (udp_socket <= 0)
       {
         printf ("Errore nella creazione della socket udp!\n");
         exit (-1);
       }
     // azzeriamo la struttura dati con le informazioni ...
     bzero (&udp_server, sizeof (udp_server));
     // impostiamo come "famiglia" quella di rete ...
     udp_server.sin_family = AF_INET;
     // associamo la socket a qualsiasi interfaccia di rete ... 
     udp_server.sin_addr.s_addr = htonl (INADDR_ANY);
     // impostiamo la porta di ascolto ...
     udp_server.sin_port = htons (UDP_PORT);
     // associamo alla socket le informazioni appena create ...
     if (bind (udp_socket, (struct sockaddr *) &udp_server, sizeof (udp_server))
         < 0)
       {
         printf ("Errore nell'associazione della socket udp!\n");
         exit (-1);
       }
   
     // a questo punto le socket di ascolto sono pronte,
     // entriamo nel loop infinito dedicato a rispondere
     // ai vari client
   
     for (;;)
       {
   
         // impostiamo quali descrittori monitorare per vedere 
         // se possiamo operare su qualche socket
         FD_ZERO (&read_tcp_status);
         FD_SET (tcp_socket, &read_tcp_status);
         FD_ZERO (&read_udp_status);
         FD_SET (udp_socket, &read_udp_status);
   
         // impostiamo il massimo tempo di attesa a 2 secondi
         // per tcp ...
         tv_tcp.tv_sec = 2;
         tv_tcp.tv_usec = 0;
         // e per udp ...
         tv_udp.tv_sec = 2;
         tv_udp.tv_usec = 0;
   
         printf ("TCP %d...\n", tcp_socket);
   
         // stiamo in attesa fino a quando non ci sono connessioni da accettare 
         // sulla nostra porta TCP o fino alla scadenza del tempo prefissato
         flags = select(tcp_socket+1, &read_tcp_status,NULL,NULL,&tv_tcp);
   
         if (flags < 0)
       {
         // non e' stato possibile mettersi in attesa e quindi terminiamo qui!
         printf
           ("Si e' verificato un errore in fase di attesa sulla socket tcp!\n");
         exit (-1);
       }
   
         if (flags > 0)
       {
         // possiamo accettare una connessione, facciamolo!
         clilen = sizeof (client);
         conn = accept (tcp_socket, (struct sockaddr *) &client, &clilen);
         printf ("TCP accettata %d\n", conn);
         if (conn > 0)
           {
             // abbiamo una richiesta da soddisfare e quindi inviamo
             // al client i dati sullo stato degli host, per fare
             // questo scorriamo tutta la lista e usiamo le informazioni
             // di ciascun elemento
             host = lista;
             printf ("Invio dei dati sullo stato degli host ...\n");
             while (host != NULL)
           {
             strcpy (buffer_to_send, "\0");
             sprintf (buffer_to_send, "%s %s\n", host->ip,
                  (host->last_activity ==
                   0L ? "INATTIVO" : "ATTIVO"));
             if (send (conn, buffer_to_send, strlen (buffer_to_send), 0)
                 < 0)
               {
                 // c'e' stato un errore, diamo l'avviso ma non terminiamo
                 printf ("Errore nell'invio dello stato degli host!\n");
               }
             host = host->next;
           }
             close (conn);
           }
   
       }
   
         printf ("UDP %d...\n", udp_socket);
   
         // stiamo in attesa fino a quando non ci sono pacchetti da leggere 
         // arrivati sulla nostra porta UDP o fino allo scadere del tempo prefissato
         flags = select (udp_socket + 1, &read_udp_status, NULL, NULL, &tv_udp);
   
         if (flags < 0)
       {
         // non e' stato possibile stare in attesa, terminamo l'esecuzione
         printf
           ("Si e' verificato un errore in fase di attesa sulla socket udp!\n");
         exit (-1);
       }
   
         if (flags > 0)
       {
         // possiamo leggere il pacchetto udp, facciamolo!
         strcpy (buffer_to_read, "\0");
         if (recvfrom
             (udp_socket, buffer_to_read, 32, 0, (struct sockaddr *) &client,
              &clilen) < 0)
           {
             // c'e' stato un errore, diamo l'avviso ma non terminiamo
             printf ("Errore nella ricezione di un pacchetto udp!\n");
           }
         else
           {
             sprintf (buffer_to_read, "%s", inet_ntoa (client.sin_addr));
             printf ("Ricevuto messaggio UDP da %s\n", buffer_to_read);
             // andiamo ad aggiornare la lista degli host ...
             if (lista == NULL)
           {
             // la lista e' vuota, creiamo un primo elemento e in esso
             // mettiamo le informazioni
             lista =
               (struct host_status *)
               malloc (sizeof (struct host_status));
             if (lista == NULL)
               {
                 // non possiamo allocare memoria, terminiamo
                 printf ("Impossibile allocare memoria!\n");
                 exit (-1);
               }
             sprintf (lista->ip, "%s", buffer_to_read);
             lista->last_activity = (unsigned long) time (NULL);
             lista->next = NULL;
           }
             else
           {
             // la lista non e' vuota, cerchiamo il giusto
             // elemento e in esso mettiamo le informazioni
             host = lista;
             while (host != NULL)
               {
                 last = host;
                 if (strcmp (host->ip, buffer_to_read) == 0)
               {
                 host->last_activity = (unsigned long) time (NULL);
                 break;
               }
                 host = host->next;
               }
             if (host == NULL)
               {
                 // non abbiamo trovato l'elemento, creiamolo!
                 host =
               (struct host_status *)
               malloc (sizeof (struct host_status));
                 if (host == NULL)
               {
                 // non possiamo allocare memoria, terminiamo
                 printf ("Impossibile allocare memoria!\n");
                 exit (-1);
               }
                 sprintf (host->ip, "%s", buffer_to_read);
                 host->last_activity = (unsigned long) time (NULL);
                 host->next = NULL;
                 last->next = host;
               }
           }
           }
   
       }
   
         // aggiorniamo lo stato degli host
         host = lista;
         while (host != NULL)
       {
         if (host->last_activity > 0L
             && (unsigned long) time (NULL) - host->last_activity > MAX_TIME)
           {
             // l'host e' inattivo da parecchio!
             printf ("Imposto %s come INATTIVO\n", host->ip);
             host->last_activity = 0L;
           }
         host = host->next;
       }
   
       }
   
   
   }

 

[airex]

Client che a intervalli regolari segnala la propria presenza

NetCheckClientAlive.c

   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>
   #include <stdio.h>
   #include <errno.h>
   #include <unistd.h>
   #include <unistd.h>
  
   #define UDP_PORT 30000
   #define SLEEP_TIME 10
  
   int
   main (int argc, char **argv)
   {
     int udp_socket;
     struct sockaddr_in udp_server;
  
     if (argc < 2)
       {
         // non e' possibile leggere l'indirizzo IP del server!
         printf ("Nessun IP del server indicato!\n");
         exit (-1);
       }
  
     // creiamo la socket per UDP
     udp_socket = socket (AF_INET, SOCK_DGRAM, 0);
     if (udp_socket <= 0)
       {
         printf ("Errore nella creazione della socket udp!\n");
         exit (-1);
       }
     // azzeriamo la struttura dati con le informazioni ...
     bzero (&udp_server, sizeof (udp_server));
     // impostiamo come "famiglia" quella di rete ...
     udp_server.sin_family = AF_INET;
     // associamo la socket a qualsiasi interfaccia di rete ...
     udp_server.sin_addr.s_addr = inet_addr (argv[1]);
     // impostiamo la porta remota di ascolto ...
     udp_server.sin_port = htons (UDP_PORT);
  
     for (;;)
       {
         // aspettiamo qualche secondo tra un invio e l'altro
         sleep (SLEEP_TIME);
         // inviamo i dati
         if (sendto
         (udp_socket, "", 0, 0, (struct sockaddr *) &udp_server,
          sizeof (udp_server)) < 0)
       {
         // segnaliamo l'errore ma non terminiamo
         printf ("Errore nel tentativo di comunicazione con il server!\n");
       }
       }
  
  
   }

Client che interroga il server per ottenere informazioni

NetCheckClient.c

   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>
   #include <stdio.h>
   #include <errno.h>
   #include <unistd.h>
   #include <unistd.h>
  
   #define TCP_PORT 30006
  
   int
   main (int argc, char **argv)
   {
     int tcp_socket;
     struct sockaddr_in tcp_server;
     char buffer[1024];
  
     if (argc < 2)
       {
         // non e' possibile leggere l'indirizzo IP del server!
         printf ("Nessun IP del server indicato!\n");
         exit (-1);
       }
  
     // creiamo la socket per UDP
     tcp_socket = socket (AF_INET, SOCK_STREAM, 0);
     if (tcp_socket <= 0)
       {
         printf ("Errore nella creazione della socket tcp!\n");
         exit (-1);
       }
     // azzeriamo la struttura dati con le informazioni ...
     bzero (&tcp_server, sizeof (tcp_server));
     // impostiamo come "famiglia" quella di rete ...
     tcp_server.sin_family = AF_INET;
     // associamo la socket a qualsiasi interfaccia di rete ...
     tcp_server.sin_addr.s_addr = inet_addr (argv[1]);
     // impostiamo la porta remota di ascolto ...
     tcp_server.sin_port = htons (TCP_PORT);
  
     // apriamo la connessione
     if (connect
         (tcp_socket, (struct sockaddr *) &tcp_server, sizeof (tcp_server)) < 0)
       {
         // errore nella connessione, interrompiamo l'esecuzione
         printf ("Errore nella connessione al server!\n");
         exit (-1);
       }
  
     // leggiamo tutti i dati che ci invia il server e mettiamoli a video!    
     while (recv (tcp_socket, buffer, 1024, 0))
       {
         printf ("%s", buffer);
       }
     printf ("\n");
  
     // chiudiamo la connessione!
     close (tcp_socket);
  
     return 0;
  
   }

Linguaggio PHP

Per questa sezione dedicata a PHP vedremo come realizzare un semplice client con interfaccia web che si connetta al server "controllore" indicato per prelevare lo stato degli
host e poi fornisca all'utente le informazioni raccolte.

Suddividiamo per comodità il programma in due parti, una dedicata a raccogliere l'input dell'utente (questa sarà in semplice HTML) e l'altra (HTML+PHP) dedicata a presentare i risultati dell'elaborazione.

Raccolta input dall'utente

input.html

<html>
  <head><title>NetCheck: Input Utente</title></head>
  <body>
     <script type="text/javascript">
         function controlla_form() {
        objF = document.getElementById('FormDati');
        objT = document.getElementById('server_name');
        if (objT.value == '') {
            alert('Indicare un nome (hostname) per il server');'
            return false;
        }
        return true;
    }
     </script>
     <form action="risultati.php" method="post" onsubmit="controlla_form();" id="FormDati">
        Nome Server (hostname): <input type="text" id="server_name" name="server_name" /><br/>
    <input type="submit" value="Controlla Stato" />
     </form>
  </body>
</html>

Raccolta dati e presentazione all'utente

risultati.php

<html>
   <head><title>NetCheck: Stato Rete</title></head>
   <body>
   <?php
      
    $porta_tcp_server = 30006;
   
    // apro la socket sulla porta TCP 30006 del server indicato precedentemente
    $f = fsockopen ( $_POST['server_name'], $porta_tcp_server);

    if (!$f) {

             // c'è stato un errore!
             echo 'Errore nell\'apertura della comunicazione con '.$_POST['server_name'].':'.$porta_tcp_server;

    } else {
   
       // ok, socket aperta!
       $data = '';
       while (!feof($f)) {
          
                // leggiamo 4KB alla volta fino a che non abbiamo finito
                $data .= fread($f,4096);
       
       }
       // abbiamo letto, chiudiamo la connessione
       fclose($f);

       // presentiamo i dati all'utente!
       $info = split("\n",$data);
      
       foreach ($info as $info_line) {
           $info_line_info = split(' ',$info_line);
           echo 'Stato dell\'host '.$info_line_info[0].' = '.$info_line_info[1].'<br/>';
       }

    }
   
   ?>
   </body>
</html>

Note
Tutto quanto riportato in questo messaggio è rilasciato sotto licenza Creative Commons "Attribuzione - Non commerciale - Condividi allo stesso modo 2.5" e puo' essere trovato all'indirizzo forum.lithium.it/cms_view_article.php?aid=338