Interfacciarsi con TCPServer e XINETD

Quest'articolo è dedicato a tutti quelli che hanno le manine lunghe come me e nelle domeniche pomeriggio invece di lavorare spendono il proprio tempo a studiare come funzionano i software che giornalmente utilizziamo!
Era da tempo che ero curioso di capire come di preciso TCPServer e XINETD funzionassero!

Premetto che già un po conoscevo il funzionamento base di questi 2 applicativi per linux però se non si prova, non si può essere certi!
Qui farò le prove solo con TCPServer, comunque, sia TCPServer sia XINETD hanno un funzionamento abbastanza simile.

TCPServer e XINETD sono due utilissimi software che consentono di sviluppare, con una certa semplicità, software di rete: entrambi sono infatti un semplice ponte, un tramite, tra il client che effettua la richiesta ed il vostro applicativo.

In pratica:

  1. Internet ----> Sistema Operativo ----> TCPServer\XINETD ----> Il vs. software

Mettiamo che TCPServer sia stato configurato per avviare il software chiamato XYZ quando arriva una richiesta di connessione all'indirizzo IP 0.0.0.0 (quindi tutti quelli disponibili) e alla porta 1234: nel momento in cui arriverà una richiesta TCPServer avvierà il software che avete indicato!
Prima di avviare il programma, in realtà, imposterà una serie di variabili di ambiente per poter fornire al software maggiori informazioni senza doverlo fare però attraverso la linea di comando o lo standard input: questo piccolo particolare, in realtà, è molto importante perché virtualmente qualsiasi software che lavora con dei dati in ingresso dallo standard input e restituisce i dati tramite lo standard output può essere utilizzato.
Ogni cosa che il client invierà sarà disponibile sullo standard input ed ogni che vorrete inviare dovrà essere inviata allo standard output.

Se ad esempio si volesse scrivere un server di rete che trasformi del testo in un altro usando TCPServer o XINETD e sed sarebbe possibile.

Per chiarirvi un po l'idea su cosa sono lo standard input e lo standard output e come si usano con php, date un occhio a:
http://www.phpfreaks.com/tutorials/86/0.php
http://www.phpbuilder.com/columns/darrell20000319.php3

Ho realizzato un piccolo script nel quale ogni volta che viene ricevuto il un carattere di ritorno a capo, questo viene reinviato al client inserendo come suffisso "### Echo:".
Lo script è veramente banale, in ogni caso, di seguito, il software è analizzato nel dettaglio

  1. #!/usr/bin/php -q

Trattandosi di scripting con linux questa riga è fondamentale perché dice al sistema operativo che cosa va usato per interpretare ed eseguire il file stesso, in questo caso php

  1. <?php
  2.  
  3.         // Definisco la configurazione
  4.         define('MAX_BUFFER', 100);
  5.  
  6.         // Definisco le costanti per lo standard INPUT e lo standard OUTPUT
  7.         define('STDIN', 'php//stdin');
  8.         define('STDOUT', 'php//stdout');
  9.  
  10.         // Definisco alcune stringhe standard
  11.         define('MSGS_BEGIN', '### Server ECHO sviluppato in PHP ' . phpversion());
  12.         define('MSGS_BEGIN2', '### Connessione proveniente da: %s:%s');
  13.         define('MSGS_ECHO', '### Echo: %s');

Vengono definite alcune costanti tra cui lo standard input e lo standard output e delle stringhe utilizzate dopo.
Le costanti MSGS_BEGIN2 e MSGS_ECHO contenegono delle %s perché verranno utilizzate con sprintf.
Molto importante è notare che le due costanti STDIN e STDOUT non contengono una stringa ma bensi una risorsa! PHP ha riconosciuto che php://stdin e php://stdout non erano 2 stringhe qualsiasi ma bensi lo standard input e lo standard output e si è comportato di conseguenza

  1.         // Invio una stringa di riconoscimento
  2.         fwrite($fp['output'], MSGS_BEGIN . "\r\n");
  3.         fwrite($fp['output'], sprintf(MSGS_BEGIN2, $_ENV['TCPREMOTEIP'], $_ENV['TCPREMOTEPORT']) . "\r\n");

Invia i due messaggi di benvenuto al client inviando le stringe allo standard output. I messaggi sono definite nelle costanti di su.
Le due variabili $_ENV['TCPREMOTEIP'] e $_ENV['TCPREMOTEPORT'] le definisce TCPServer al momento della connessione

  1.         // Inizializzo il buffer
  2.         $buffer = '';
  3.  
  4.         // Raccolgo i dati
  5.         while($data = fread($fp['input'], 1)) {

Inizializzo il buffer, ovvero imposto la variabile, e leggo un carattere per volta dallo stdin. Questo per evitare problemi, infatti non essendo una socket, ma un file non l'ho impostato sulla modalità non blocking.
Se avessi usato gli stream per gestire il tutto avrei potuto impostare la modalità non blocking e quindi leggere blocchi di dato maggiori. Se avessi messo 10 al posto di uno finche sullo standard input non ci sarebberò stati 10 byte a me non sarebbe ritornato nulla. Quindi, anche premendo invio, non sarebbe successo niente.
Invece in questo modo ogni volta che arriva un carattare viene processato.

  1.                 // Controllo se il byte letto corrisponde all'invio
  2.                 if ($data != "\n") {
  3.  
  4.                         // Se non corrisponde controlla la dimensione del buffer
  5.                         if (strlen($buffer) > MAX_BUFFER) {
  6.  
  7.                                 // Se la dimensione massima del buffer e' superata resetta
  8.                                 // il buffer con il dato appena letto
  9.                                 $buffer = $data;
  10.                         } else {
  11.  
  12.                                 // Se la dimensione massima non e' stata superata aggiunge
  13.                                 // il dato al buffer attuale
  14.                                 $buffer .= $data;
  15.                         }

A questo punto devo processare il byte ricevuto, quindi controllo se è un carattere di invio, ovvero se contiene uno \n o meno.
Se non contiene lo \n, quindi l'andata a capo processo se la stringa ha superato la lunghezza massima del buffer con un semplice if. Se il buffer è stato riempito tutto lo svuoto e lo riempo con il nuovo carattere, alrtimenti, se c'è ancora spazio, aggiungo il byte appena letto.

  1.                 } else {
  2.  
  3.                         // E' arrivato il momento di replicare i dati
  4.                         // quindi stampiamo il buffer e poi lo svuotiamo
  5.                         fwrite($fp['output'], sprintf(MSGS_ECHO, $buffer) . "\r\n");
  6.  
  7.                         // Svuotiamo il buffer
  8.                         $buffer = '';
  9.                 }
  10.         }
  11.  
  12.         // --- Esecuzione terminata ---
  13. ?>

Se invece al programma arriva l'invio invia alla risorsa dello standard output la stringa che contiene il messaggio ripetuto e svuota il buffer. Come vedete anche qui uso sprintf per impostare il dato dentro la stringa.
Il programma poi termina e li potete fare quello che volete, tcpserver non termina il processo fin quando non è il processo stesso a morire quindi potete fare quello di cui avete bisogno

Di seguito il codice per intero.

  1. #!/usr/bin/php -q
  2. <?php
  3.  
  4.         // Definisco la configurazione
  5.         define('MAX_BUFFER', 100);
  6.  
  7.         // Definisco le costanti per lo standard INPUT e lo standard OUTPUT
  8.         define('STDIN', 'php//stdin');
  9.         define('STDOUT', 'php//stdout');
  10.  
  11.         // Definisco alcune stringhe standard
  12.         define('MSGS_BEGIN', '### Server ECHO sviluppato in PHP ' . phpversion());
  13.         define('MSGS_BEGIN2', '### Connessione proveniente da: %s:%s');
  14.         define('MSGS_ECHO', '### Echo: %s');
  15.  
  16.         // Invio una stringa di riconoscimento
  17.         fwrite($fp['output'], MSGS_BEGIN . "\r\n");
  18.         fwrite($fp['output'], sprintf(MSGS_BEGIN2, $_ENV['TCPREMOTEIP'], $_ENV['TCPREMOTEPORT']) . "\r\n");
  19.  
  20.         // Inizializzo il buffer
  21.         $buffer = '';
  22.  
  23.         // Raccolgo i dati
  24.         while($data = fread($fp['input'], 1)) {
  25.  
  26.                 // Controllo se il byte letto corrisponde all'invio
  27.                 if ($data != "\n") {
  28.  
  29.                         // Se non corrisponde controlla la dimensione del buffer
  30.                         if (strlen($buffer) > MAX_BUFFER) {
  31.  
  32.                                 // Se la dimensione massima del buffer e' superata resetta
  33.                                 // il buffer con il dato appena letto
  34.                                 $buffer = $data;
  35.                         } else {
  36.  
  37.                                 // Se la dimensione massima non e' stata superata aggiunge
  38.                                 // il dato al buffer attuale
  39.                                 $buffer .= $data;
  40.                         }
  41.                 } else {
  42.  
  43.                         // E' arrivato il momento di replicare i dati
  44.                         // quindi stampiamo il buffer e poi lo svuotiamo
  45.                         fwrite($fp['output'], sprintf(MSGS_ECHO, $buffer) . "\r\n");
  46.  
  47.                         // Svuotiamo il buffer
  48.                         $buffer = '';
  49.                 }
  50.         }
  51.  
  52.         // --- Esecuzione terminata ---
  53. ?>

Utilizzando le funzioni per la gestione dei file in accoppiata allo stdin e stdout e questi applicativi è possibile scrivere svariati tipi di server! Ovviamente se avete dovete sviluppare soluzioni più avanzate e complesse non è la strada da seguire ma se non avete particolari necessità potrebbe essere una strada da seguire: e' possibile realizzare server di posta, server ftp, server web e via dicendo. E' importante comunque ricordarsi che questa tipologia di applicativi consuma più risorse rispetto ad una soluzione ad hoc!

Il pacchetto che contiene TCPServer si chiama uscpi-tcp ed è usatissimo con QMAIL, un buon server di posta elettronica, anche se per la sua infrastruttura è abbastanza pesante, mentre XINETD è standard in qualsiasi distribuzione, e sostituisce il vecchio INETD che eseguiva lo stesso dipo di operazioni.

Per aggiungere il vostro server a XINETD basta che creiate un file dentro la dir /etc/xinetd.d e li dentro aggiungiate una configurazione. Per maggiori info lanciate il comando:

  1. man xinetd.conf

Vi mostrerà come scrivere un file di configurazione per xinetd per lanciare i vostri programmi

TCPServer invece non ha un man, per avere maggiori info guardate qui
http://cr.yp.to/ucspi-tcp/tcpserver.html

Per scaricare i vari sorgenti
http://cr.yp.to/ucspi-tcp.html

Per avere altre info sulle variabili di ambiente...
http://cr.yp.to/ucspi-tcp/environment.html

E' codice molto vecchio, scritto a inizio 2004, che non rispecchia la mia attuale metodologia di scrittura del codice, non rispecchia le mie attuali conoscenze e soprattutto potrebbe contenere codice che potrebbe non funzionare correttamente ad oggi.