\chapter{L'interfaccia base con i processi}
\label{cha:process_interface}

Come accennato nell'introduzione il processo è l'unità di base con cui un
sistema unix alloca ed utilizza le risorse.  Questo capitolo tratterà
l'interfaccia base fra il sistema e i processi, su come vengono passati i
parametri, come viene gestita e allocata la memoria, su come un processo può
richiedere servizi al sistema, su cosa deve fare quando ha finito la sua
esecuzione.

In genere un programma viene eseguito quando un processo lo fa partire
eseguendo una funzione della famiglia \texttt{exec}; torneremo su questo e
sulla la creazione e gestione dei processi nel prossimo capitolo, in questo
affronteremo l'avvio e il funzionamento di un programma dal punto di vista del
programma posto in esecuzione.


\section{La funzione \texttt{main}} 
\label{sec:proc_main}



\subsection{}
\label{sec:proc_}



\subsection{La funzione \texttt{exit}}
\label{sec:proc_exit}


\section{La gestione della memoria}
\label{sec:proc_mem_manag}



\section{Gestione di parametri e opzioni}
\label{sec:parameter_options}

Il passaggio dei parametri e delle variabili di ambiente dalla riga di comando
al singolo programma quando viene lanciato è effettuato attraverso le
variabili \texttt{argc}, \texttt{argv} che vengono passate al programma
come argomenti della funzione principale:

\subsection{Il formato dei parametri}
\label{sec:proc_par_format}
In genere passaggio dei parametri al programma viene effettuato dalla shell,
che si incarica di leggere la linea di comando e di effettuarne la scansione
(il cosiddetto \textit{parsing}) per individuare le parole che la compongono,
ciascuna delle quali viene considerata un parametro; di default per
individuare le parole viene usato come separatore lo spazio (comportamento
modificabile attraverso il settaggio della variabile di ambiente IFS).

Nella scansione viene costruito l'array di puntatori \texttt{argv} inserendo
in successione il puntatore alla stringa costituente l'$n$-simo parametro; la
variabile \texttt{argc} viene inizializzata al numero di parametri trovati, in
questo modo il primo parametro è sempre il nome del programma (vedi \nfig).

\subsection{La gestione delle opzioni}
\label{sec:proc_opt_handling}

In generale un programma unix riceve da linea di comando sia i parametri che
le opzioni, queste ultime sono standardizzate per essere riconosciute come
tali: un elemento di \texttt{argv} che inizia con \texttt{-} e che non sia un
singolo \texttt{-} o \texttt{--} viene considerato un'opzione.  In in genere
le opzioni sono costituite da un lettera preceduta dal meno e possono avere o
no un parametro associato; un comando tipico può essere cioè qualcosa del
tipo:
\begin{verbatim}
touch -r riferimento.txt -m questofile.txt
\end{verbatim}
ed in questo caso le opzioni sono \texttt{m} ed \texttt{r}.

Per gestire le opzioni all'interno dei parametri passati in \texttt{argv} le
librerie standard del C forniscono la funzione \texttt{getopt} (accessibile
includendo \texttt{unistd.h}), che ha il prototipo:
\begin{verbatim}
int getopt(int argc, char * const argv[], const char * optstring);
\end{verbatim}

Questa funzione prende come argomenti le due variabili \texttt{argc} e
\texttt{argv} ed una stringa che indica quali sono le opzioni valide; la
funzione effettua la scansione della lista dei parametri ricercando ogni
stringa che comincia con \texttt{-} e ritorna ogni volta che trova una opzione
valida.

La stringa \texttt{optstring} indica quali sono le opzioni riconosciute ed è
costituita da tutti i caratteri usati per identificare le singole opzioni, se
l'opzione ha un parametro al carattere deve essere fatto seguire un segno di
due punti \texttt{:} nel caso appena accennato ad esempio la stringa di
opzioni sarebbe \texttt{"r:m"}.

La modalità di uso è pertanto quella di chiamare più volte la funzione
all'interno di un ciclo di while fintanto che essa non ritorna il valore
\texttt{-1} che indica che non ci sono più opzioni. Nel caso si incontri
un'opzione non dichiarata in \texttt{optstring} viene ritornato un \texttt{?}
mentre se l'opzione non è seguita da un parametro viene ritornato un
\texttt{:} infine se viene incontrato il valore \texttt{--} la scansione viene
considerata conclusa.

Quando la funzione trova un'opzione essa ritorna il valore numerico del
carattere, in questo modo si possono prendere le azioni relative usando un
case; la funzione inizializza inoltre alcune varibili globali:
\begin{itemize}
\item \texttt{char * optarg} contiene il puntatore alla stringa argomento
  dell'opzione.
\item \texttt{int optind} alla fine della scansione restituisce l'indice del
  primo argomento che non è un'opzione.
\item \texttt{int opterr} previene, se posto a zero, la stampa di un messaggio
  di errore in caso di riconoscimento di opzioni non definite.
\item \texttt{int optopt} contiene il carattere dell'opzione non riconosciuta.
\end{itemize}

In \nfig è mostrato un programma di esempio, 


\begin{figure}[htbp]
  \footnotesize
    \begin{lstlisting}{}
    opterr = 0;  /* don't want writing to stderr */
    while ( (i = getopt(argc, argv, "o:a:i:hve")) != -1) {
        switch (i) {
        case 'i':   /* input file */
            in_file=open(optarg,O_RDONLY);
            if (in_file<0) {
                perror("Cannot open input file");
                exit(1);
            }
            break;
        case 'o':   /* output file (overwrite) */
            out_file=open(optarg,O_WRONLY|O_CREAT);
            if (out_file<0) {
                perror("Cannot open output file");
                exit(1);
            }
            break;
            break;
        case 'a':   /* output file (append) */
            out_file=open(optarg,O_WRONLY|O_CREAT|O_APPEND);
            break;
        case 'h':   /* print help usage */
            usage();
            break;
        case 'v':   /* set verbose mode */
            debug("Option -v active\n");
            verbose=1;
            break;
        case '?':   /* unrecognized options */
            printf("Unrecognized options -%c\n",optopt);
            usage();
        default:    /* should not reached */
            debug("default option\n");
            usage();
        }
    }
    debug("Optind %d, argc %d\n",optind,argc);
  \end{lstlisting}
  \caption{Esempio di codice per la gestione delle opzioni.}
  \label{fig:proc_options_code}
\end{figure}

\subsection{Opzioni in formato esteso}
\label{sec:proc_opt_extended}

Un'estensione di questo schema è costituito dalle cosiddette
\textit{long-options} espresse nella forma \texttt{--option=parameter}, anche
la gestione di queste ultime è stata standardizzata attraverso l'uso di una
versione estesa di \texttt{getopt}.


\subsection{Le variabili di ambiente}
\label{sec:proc_env_var}

Questo va fatto.


