From 2e715e70ba0df8224ec1bf118ba34a73a21df5c5 Mon Sep 17 00:00:00 2001
From: Simone Piccardi <piccardi@gnulinux.it>
Date: Fri, 28 Jun 2002 23:07:38 +0000
Subject: [PATCH] Messo nuovo esempio e figura corretta.

---
 img/pipeuse.dia | Bin 1653 -> 1692 bytes
 ipc.tex         | 275 +++++++++++++++++++++++++++++++-----------------
 2 files changed, 176 insertions(+), 99 deletions(-)

diff --git a/img/pipeuse.dia b/img/pipeuse.dia
index dcd771a25cd73c0a4420bd31f272107f1cb1d95a..9f4d609ae2a7353bf3d21c232d0edf2d52cce9b2 100644
GIT binary patch
literal 1692
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

literal 1653
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

diff --git a/ipc.tex b/ipc.tex
index e563153..40c9fad 100644
--- a/ipc.tex
+++ b/ipc.tex
@@ -86,8 +86,8 @@ capo della pipe, l'altro pu
 \begin{figure}[htb]
   \centering
   \includegraphics[height=5cm]{img/pipefork}
-  \caption{Schema dell'uso di una pipe come mezzo di comunicazione fra
-  processo attraverso una \func{fork}.}
+  \caption{Schema dei collegamenti ad una pipe, condivisi fra processo padre e
+    figlio dopo l'esecuzione \func{fork}.}
   \label{fig:ipc_pipe_fork}
 \end{figure}
 
@@ -109,45 +109,58 @@ Per capire meglio il funzionamento di una pipe faremo un esempio di quello che
 è il loro uso più comune, analogo a quello effettuato della shell, e che
 consiste nell'inviare l'output di un processo (lo standard output) sull'input
 di un'altro. Realizzaremo il programma nella forma di un
-\textit{CGI}\footnote{Un CGI (\textit{Common Gateway Interface} è un programma
+\textit{CGI}\footnote{Un CGI (\textit{Common Gateway Interface}) è un programma
   che permette la creazione dinamica di un oggetto da inserire all'interno di
   una pagina HTML.}  per apache, che genera una immagine JPEG di un codice a
 barre, specificato come parametro di input.
 
-Un programma che deve essere eseguito come \textit{cgi} per apache deve
-rispondere a delle caratteristiche specifiche, esso infatti non viene lanciato
-da una shell, ma dallo stesso web server, alla richiesta di una specifica URL
-che di solito ha la forma:
+Un programma che deve essere eseguito come \textit{CGI} deve rispondere a
+delle caratteristiche specifiche, esso infatti non viene lanciato da una
+shell, ma dallo stesso web server, alla richiesta di una specifica URL, che di
+solito ha la forma:
 \begin{verbatim}
-http://www.sito.it/cgi-bin/programma?parametro
+    http://www.sito.it/cgi-bin/programma?parametro
 \end{verbatim}
 ed il risultato dell'elaborazione deve essere presentato (con una intestazione
-che ne descrive il mime-type) sullo standard output, in modo che apache possa
-reinviarlo al browser che ha effettuato la richiesta.
+che ne descrive il mime-type) sullo standard output, in modo che il web-server
+possa reinviarlo al browser che ha effettuato la richiesta, che in questo modo
+è in grado di visualizzarlo opportunamente.
 
 Per fare questo useremo in sequenza i programmi \cmd{barcode} e \cmd{gs}, il
 primo infatti è in grado di generare immagini postscript di codici a barre
 corrispondenti ad una qualunque stringa, mentre il secondo serve per poter
-effettuare la conversione della stessa immagine in formato JPEG.
+effettuare la conversione della stessa immagine in formato JPEG. Usando una
+pipe potremo inviare l'output del primo sull'input del secondo, secondo lo
+schema mostrato in \figref{fig:ipc_pipe_use}, in cui la direzione del flusso
+dei dati è data dalle frecce continue.
+
+\begin{figure}[htb]
+  \centering
+  \includegraphics[height=5cm]{img/pipeuse}
+  \caption{Schema dell'uso di una pipe come mezzo di comunicazione fra
+    due processi attraverso attraverso l'esecuzione una \func{fork} e la
+    chiusura dei capi non utilizzati.}
+  \label{fig:ipc_pipe_use}
+\end{figure}
 
 Si potrebbe obiettare che sarebbe molto più semplice salvare il risultato
-intermedio su un file temporaneo. Questo però non tiene conto del fatto che il
-\textit{cgi} deve poter gestire più richieste in concorrenza, e si avrebbe una
+intermedio su un file temporaneo. Questo però non tiene conto del fatto che un
+\textit{CGI} deve poter gestire più richieste in concorrenza, e si avrebbe una
 evidente race condition in caso di accesso simultaneo a detto
-file.\footnote{la questione potrebbe essere evitata creando prima dei file
-  temporanei, da comunicare poi ai vari sotto-processi, da cancellare alla
-  fine dell'esecuzione; ma a questo punto avremmo perso tutta la semplicità.}
-L'uso di una pipe invece permette di risolvere il problema in maniera semplice
-ed elegante.
-
-Il programma ci servirà anche come esempio dell'uso di alcune delle funzioni
-di manipolazione dei file descriptor, come \func{dup} e \func{dup2}, viste in
-\secref{sec:file_dup}; è attraverso queste funzioni che è possibile dirottare
-gli stream standard dei processi (che abbiamo visto in
-\secref{sec:file_std_descr} e \secref{sec:file_std_stream}) sulla pipe. Le
-sezioni significative del programma è riportato in
-\figref{fig:ipc_barcode_code}, il codice è disponibile nel file
-\file{BarCode.c} nella directory dei sorgenti.
+file.\footnote{il problema potrebbe essere superato determinando in anticipo
+  un nome appropiato per il file temporaneo, che verrebbe utilizzato dai vari
+  sotto-processi, e cancellato alla fine della loro esecuzione; ma a questo le
+  cose non sarebbero più tanto semplici.}  L'uso di una pipe invece permette
+di risolvere il problema in maniera semplice ed elegante.
+
+Il programma ci servirà anche come esempio dell'uso delle funzioni di
+duplicazione dei file descriptor che abbiamo trattato in
+\secref{sec:file_dup}, in particolare di \func{dup2}. È attraverso queste
+funzioni infatti che è possibile dirottare gli stream standard dei processi
+(che abbiamo visto in \secref{sec:file_std_descr} e
+\secref{sec:file_std_stream}) sulla pipe. In \figref{fig:ipc_barcode_code}
+abbiamo riportato il corpo del programm, il cui codice completo è disponibile
+nel file \file{BarCodePage.c} che si trova nella directory dei sorgenti.
 
 
 \begin{figure}[!htb]
@@ -204,47 +217,46 @@ int main(int argc, char *argv[], char *envp[])
     \end{lstlisting}
   \end{minipage} 
   \normalsize 
-  \caption{Codice del \textit{cgi-bin} \cmd{BarCode}.}
+  \caption{Codice del \textit{CGI} \cmd{BarCodePage}.}
   \label{fig:ipc_barcode_code}
 \end{figure}
 
-Il primo passo (\texttt{\small 4--12}) è quello di creare le due pipe che
-servono per la comunicazione fra i due programmi che verranno utilizzati per
-produrre il codice a barre; si ha cura di controllare la riuscita della
+La prima operazione del programma (\texttt{\small 4--12}) è quella di creare
+le due pipe che serviranno per la comunicazione fra i due comandi utilizzati
+per produrre il codice a barre; si ha cura di controllare la riuscita della
 chiamata, inviando in caso di errore un messaggio invece dell'immagine
 richiesta.\footnote{la funzione \func{WriteMess}, non è riportata in
-  \ref{fig:ipc_barcode_code}, ma si incarica semplicemente di formattare
-  l'uscita, aggiungendo un \textit{mime type}, in modo che possa essere
-  interpretata direttamente da un browser.}
+  \secref{fig:ipc_barcode_code}; essa si incarica semplicemente di formattare
+  l'uscita alla maniera dei CGI, aggiungendo l'opportuno \textit{mime type}, e
+  formattando il messaggio in HTML, in modo che quest'ultimo possa essere
+  visualizzato correttamente da un browser.}
 
-Una volta create le pipe il programma può creare (\texttt{\small 13-17}) il
+Una volta create le pipe, il programma può creare (\texttt{\small 13-17}) il
 primo processo figlio, che si incaricherà (\texttt{\small 19--25}) di eseguire
-il programma \cmd{barcode}: quest'ultimo funziona ricevendo dallo standard
-input la stringa da convertire nell'immagine postscript del codice a barre,
-che sarà scritta sullo standard output.
-
-Per utilizzare queste caratteristiche il primo figlio chiude (\texttt{\small
-  20}) il capo aperto in scrittura della prima pipe, dato che userà il capo
-aperto in lettura per ricevere dal padre la stringa da codificare; per far
-questo collega (\texttt{\small 21}) il capo in lettura della pipe allo
-standard input usando \func{dup2}. Dato che \cmd{barcode} scrive l'immagine
-postscript del codice a barre sullo standard output per poter effettuare una
-ulteriore redirezione il capo in lettura della seconda pipe viene chiuso
-(\texttt{\small 22}) mentre il capo in scrittura viene collegato allo standard
-output (\texttt{\small 23}).  
+\cmd{barcode}. Quest'ultimo legge dallo standard input una stringa di
+caratteri, la converte nell'immagine postscript del codice a barre ad essa
+corrispondente, e poi scrive il risultato direttamente sullo standard output.
+
+Per poter utilizzare queste caratteristiche prima di eseguire \cmd{barcode} si
+chiude (\texttt{\small 20}) il capo aperto in scrittura della prima pipe, e se
+ne collega (\texttt{\small 21}) il capo in lettura allo standard input, usando
+\func{dup2}. Dato che \cmd{barcode} scrive l'immagine postscript del codice a
+barre sullo standard output, per poter effettuare una ulteriore redirezione il
+capo in lettura della seconda pipe viene chiuso (\texttt{\small 22}) mentre il
+capo in scrittura viene collegato allo standard output (\texttt{\small 23}).
 
 In questo modo all'esecuzione (\texttt{\small 25}) di \cmd{barcode} (cui si
-passa in \var{size} la dimensione per l'immagine) quest'ultimo leggerà la
-stringa da codificare che gli viene inviata dal padre dalla prima pipe e
-scriverà l'immagine postscript del codice a barre sulla seconda.
-
-Dall'altra parte il processo padre prima chiude (\texttt{\small 26}) il capo
-inutilizzato della prima pipe (quello in input), poi scrive (\texttt{\small
-  27}) la stringa da convertire sul capo in output, così che \cmd{barcode}
-possa riceverla dallo standard input; a questo punto l'uso della prima pipe è
-finito ed essa può essere definitivamente chiusa (\texttt{\small 28}), si
-attende poi (\texttt{\small 29}) che l'esecuzione di \cmd{barcode} sia
-completata.
+passa in \var{size} la dimensione della pagina per l'immagine) quest'ultimo
+leggerà dalla prima pipe la stringa da codificare che gli sarà inviata dal
+padre, e scriverà l'immagine postscript del codice a barre sulla seconda.
+
+Al contempo una volta lanciato il primo figlio, il processo padre prima chiude
+(\texttt{\small 26}) il capo inutilizzato della prima pipe (quello in input) e
+poi scrive (\texttt{\small 27}) la stringa da convertire sul capo in output,
+così che \cmd{barcode} possa riceverla dallo standard input. A questo punto
+l'uso della prima pipe è finito ed essa può essere definitivamente chiusa
+(\texttt{\small 28}), si attende poi (\texttt{\small 29}) che l'esecuzione di
+\cmd{barcode} sia completata.
 
 Alla conclusione della sua esecuzione \cmd{barcode} avrà inviato l'immagine
 postscript del codice a barre sul capo in scrittura della seconda pipe; a
@@ -254,24 +266,25 @@ processo figlio, che poi (\texttt{\small 35--42}) eseguir
 leggendo l'immagine postscript creata da \cmd{barcode} dallo standard input,
 per convertirla in JPEG.
 
-Per fare tutto ciò il secondo figlio anzitutto chiude (\texttt{\small 37}) il
-capo in scrittura della seconda pipe, e ne collega (\texttt{\small 38}) il
-capo in lettura allo standard input. Per poter formattare l'output del
-programma in maniera utilizzabile da un browser, si provvede anche
-\texttt{\small 40}) alla scrittura dell'apposita stringa di mime-type in testa
-allo standard output. A questo punto si può invocare \texttt{\small 41}) il
-programma \cmd{gs}, provvedendo gli appositi switch che consentono di leggere
-il file da convertire dallo standard input, ed inviare la conversione sullo
-standard output.
-
-Per concludere le operazioni il processo padre chiude \texttt{\small 44}) il
+Per fare tutto ciò anzitutto si chiude (\texttt{\small 37}) il capo in
+scrittura della seconda pipe, e se ne collega (\texttt{\small 38}) il capo in
+lettura allo standard input. Per poter formattare l'output del programma in
+maniera utilizzabile da un browser, si provvede anche \texttt{\small 40}) alla
+scrittura dell'apposita stringa di identificazione del mime-type in testa allo
+standard output. A questo punto si può invocare \texttt{\small 41}) \cmd{gs},
+provvedendo gli appositi switch che consentono di leggere il file da
+convertire dallo standard input e di inviare la conversione sullo standard
+output.
+
+Per completare le operazioni il processo padre chiude \texttt{\small 44}) il
 capo in scrittura della seconda pipe, e attende la conclusione del figlio
-\texttt{\small 45}), per poi uscire \texttt{\small 46}). Si tenga conto che,
-l'operazione di chiudere il capo in scrittura della seconda pipe è necessaria,
-infatti non chiudendola \cmd{gs}, che legge il suo stardard input da detta
-pipe, resterebbe bloccato in attesa di ulteriore input (l'unico modo che un
-programma ha per sapere che l'input è terminato è rilevare che lo standard
-input è stato chiuso), e la \func{wait} non ritornerebbe. 
+\texttt{\small 45}); a questo punto può \texttt{\small 46}). Si tenga conto
+che l'operazione di chiudere il capo in scrittura della seconda pipe è
+necessaria, infatti se non venisse chiusa \cmd{gs}, che legge il suo stardard
+input da detta pipe, resterebbe bloccato in attesa di ulteriori dati in
+ingresso (l'unico modo che un programma ha per sapere che l'input è terminato
+è rilevare che lo standard input è stato chiuso), e la \func{wait} non
+ritornerebbe.
 
 
 \subsection{Le funzioni \func{popen} e \func{pclose}}
@@ -294,13 +307,12 @@ stream restituito come valore di ritorno.
   potrà assumere i valori relativi alle sottostanti invocazioni di \func{pipe}
   e \func{fork} o \macro{EINVAL} se \param{type} non è valido.}
 \end{prototype}
-\noindent e serve per semplificare l'uso di \func{pipe}. 
 
 La funzione crea una pipe, esegue una \func{fork}, ed invoca il programma
 \param{command} attraverso la shell (in sostanza esegue \file{/bin/sh} con il
-flag \code{-c}); l'argomento \param{type} deve essere una stringa \verb|"w"| o
-\verb|"r"|, per indicare se la pipe sarà collegata allo standard input o allo
-standard output del comando invocato.
+flag \code{-c}); l'argomento \param{type} deve essere una delle due stringhe
+\verb|"w"| o \verb|"r"|, per indicare se la pipe sarà collegata allo standard
+input o allo standard output del comando invocato.
 
 La funzione restituisce il puntatore allo stream associato alla pipe creata,
 che sarà aperto in sola lettura (e quindi associato allo standard output del
@@ -308,10 +320,11 @@ programma indicato) in caso si sia indicato \code{"r"}, o in sola scrittura (e
 quindi associato allo standard input) in caso di \code{"w"}.
 
 Lo stream restituito da \func{popen} è identico a tutti gli effetti ai file
-standard visti in \secref{cha:files_std_interface}, e viene sempre aperto in
-modalità \textit{fully-buffered} (vedi \secref{sec:file_buffering}); l'unica
-differenza è che deve essere chiuso dalla seconda delle due funzioni,
-\func{pclose}, il cui prototipo è:
+stream visti in \secref{cha:files_std_interface}, anche se è collegato ad una
+pipe e non ad un inode, e viene sempre aperto in modalità
+\textit{fully-buffered} (vedi \secref{sec:file_buffering}); l'unica differenza
+con gli usuali stream è che dovrà essere chiuso dalla seconda delle due nuove
+funzioni, \func{pclose}, il cui prototipo è:
 \begin{prototype}{stdio.h}
 {int pclose(FILE *stream)}
 
@@ -322,23 +335,49 @@ attendendo la terminazione del processo ad essa associato.
   errore; nel quel caso il valore di \func{errno} deriva dalle sottostanti
   chiamate.}
 \end{prototype}
-\noindent che si incarica anche di attendere la conclusione del processo
-creato dalla precedente \func{popen}.
-
-Per illustrare l'uso di queste due funzioni riprendiamo l'esempio in
-\figref{fig:ipc_barcode_code}: esso per quanto funzionante, è piuttosto
-complesso; inoltre nella pratica sconta un problema di \cmd{gs} che non è in
+\noindent che oltre alla chiusura dello stream si incarica anche di attendere
+(tramite \func{wait4}) la conclusione del processo creato dalla precedente
+\func{popen}.
+
+Per illustrare l'uso di queste due funzioni riprenderemo il problema
+precedente; il programma mostrato in \figref{fig:ipc_barcode_code} per quanto
+funzionante, è (volutamente) codificato in maniera piuttosto complesso;
+inoltre nella pratica sconta un problema di \cmd{gs} che non è in
 grado\footnote{nella versione GNU Ghostscript 6.53 (2002-02-13).} di
 riconoscere correttamente l'encapsulated postscript, per cui tutte le volte
-generata una pagina intera, invece che una semplice figura.  Se si vuole
-generare una immagine di dimensioni corrette si deve allora ricorrere ad
-ulteriore programma, \cmd{epstopsf}, per convertire in PDF il file EPS
-generato da \cmd{barcode}. Utilizzando un file in PDF invece, \cmd{gs} esegue
-la conversione rispettando le dimensioni originarie del codice a barre.
-
-Ci si trova dunque davanti al classico caso dell'uso delle pipe in cui si
-devono eseguire più processi in fila, inviando l'output di ciascuno all'input
-del successivo, per poi ottenere il risultato finale sullo standard output.
+generata una pagina intera, invece che semplice figura delle dimensioni
+corrispondenti al codice a barre.
+
+Se si vuole generare una immagine di dimensioni corrette si deve usare un
+approccio diverso; una possibilità sarebbe quella di ricorrere ad ulteriore
+programma, \cmd{epstopsf}, per convertire in PDF il file EPS generato da
+\cmd{barcode} (utilizzando lo switch \cmd{-E} di quest'ultimo). Utilizzando un
+PDF al posto di un EPS \cmd{gs} esegue la conversione rispettando le
+dimensioni originarie del codice a barre e produce un JPEG delle dimensioni
+adeguate. 
+
+Questo però ci porta a scontrarci con una caratteristica peculiare delle pipe,
+che a prima vista non è evidente. Per poter effettuare la conversione di un
+PDF infatti è necessario, per la struttura del formato, dover eseguire delle
+\func{lseek} sul file da convertire; una pipe però è rigidamente sequenziale,
+ed il tentativo di eseguire detta funzioni su un file descriptor associato ad
+una pipe comporta l'immediato fallimento con un errore di \macro{ESPIPE}.
+
+Per questo motivo si è utilizzata una strada diversa, che prevede la
+conversione attraverso \cmd{gs} del PS in un altro formato intermedio, il
+PPM,\footnote{il \textit{Portable PixMap file format} è un formato usato
+  spesso come formato intermedio per effettuare conversioni, è estremamente
+  inefficiente, ma molto facile da manipolare dato che usa caratteri ASCII per
+  memorizzare le immagini.} dal quale poi si può ottenere un'immagine di
+dimensioni corrette attraverso vari programmi di manipolazione (\cmd{pnmcrop},
+\cmd{pnmmargin}) che può essere infine trasformata in PNG.
+
+In questo caso però occorre eseguire sequenza ben quattro comandi diversi,
+inviando l'output di ciascuno all'input del successivo, per poi ottenere il
+risultato finale sullo standard output, il caso più classico dell'uso delle
+pipe. 
+
+
 Dato che questo caso ciascun processo deve scrivere il suo output sullo
 standard input del successivo, occorrerà usare \func{popen} aprendo la pipe in
 scrittura.
@@ -357,6 +396,44 @@ quest'ultimo venga invocato dopo.
     \begin{lstlisting}{}
 int main(int argc, char *argv[], char *envp[])
 {
+int main(int argc, char *argv[], char *envp[])
+{
+    FILE *pipe[4];
+    FILE *pipein;
+    char *cmd_string[4]={
+        "pnmtopng",
+        "pnmmargin -white 10",
+        "pnmcrop",
+        "gs -sDEVICE=ppmraw -sOutputFile=- -sNOPAUSE -q - -c showpage -c quit"
+    };  
+    char content[]="Content-type: image/png\n\n";
+    int i;
+    /* write mime-type to stout */ 
+    write(STDOUT_FILENO, content, strlen(content));
+    /* execute chain of command */
+    for (i=0; i<4; i++) {
+        pipe[i] = popen(cmd_string[i], "w");
+        dup2(fileno(pipe[i]), STDOUT_FILENO); 
+    }
+    /* create barcode (in PS) */
+    pipein = popen("barcode", "w");
+    /* send barcode string to barcode program */
+    write(fileno(pipein), argv[1], strlen(argv[1]));
+    /* close all pipes (in reverse order) */
+    for (i=4; i==0; i--) {
+        pclose((pipe[i]));
+    }
+    exit(0);
+}
+/*
+ * Routine to produce an HTML error message on output 
+ */
+void WriteMess(char *mess)
+{
+    printf("Content-type: text/html\n\n");
+    perror(mess);
+    printf("<br>\n");
+}
 }
 
     \end{lstlisting}
-- 
2.30.2