[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


207. Exim: introduzione

In questo capitolo si introduce l'utilizzo di Exim, un MTA che offre qualche piccolo vantaggio rispetto all'uso di Sendmail: è abbastanza compatibile con le consuetudini di quest'ultimo; ha un sistema di configurazione meno criptico; è predisposto per IPv6; quando possibile utilizza processi senza i privilegi dell'utente `root', in modo da lasciare meno occasioni alle aggressioni.

207.1 Compatibilità con Sendmail e differenze importanti

Exim è compatibile con Sendmail per tutti quegli aspetti che coinvolgono gli utenti comuni e anche per ciò che riguarda gli amministratori che non hanno o non desiderano avere conoscenze troppo approfondite sulla gestione della posta elettronica. Questa compatibilità riguarda tre punti fondamentali: il file `/etc/aliases', i file `~/.forward', e un collegamento che simula la presenza dell'eseguibile `sendmail'. Per di più, l'eseguibile `exim' accetta buona parte delle opzioni standard di `sendmail', in modo da permettere il funzionamento di programmi come Mailx, o il funzionamento di script che si affidano alla presenza dell'eseguibile `sendmail'.

I file `/etc/aliases' e `~/.forward' si comportano in modo quasi identico rispetto a quando è in funzione Sendmail. In particolare, con `~/.forward' si possono usare anche delle estensioni.

Un'eccezione, rispetto alla compatibilità di questi file, riguarda l'indicazione di pipeline. Con Sendmail, si presume che il comando sia elaborato da una shell; con Exim, no. Di conseguenza, i comandi interni di questa non sono accessibili. Si osservino gli esempi seguenti, riferiti al contenuto del file `/etc/aliases': si tratta della stessa pipeline a cui vengono ridiretti i messaggi giunti per l'utente ipotetico, denominato `lista-pippo'.

# con Sendmail
lista-pippo:  "| exec /home/liste/bin/ricezione-messaggi lista-pippo"

# con Sendmail senza exec
lista-pippo:  "| /home/liste/bin/ricezione-messaggi lista-pippo"

# con Exim non si può usare exec che è un comando interno di shell
lista-pippo:  "| /home/liste/bin/ricezione-messaggi lista-pippo"

# con Exim, avviando prima una shell e quindi il comando
lista-pippo:  "| /bin/sh -c '/home/liste/bin/ricezione-messaggi lista-pippo'"

Se si deve inserire una pipeline in un file `~/.forward', vale lo stesso ragionamento, con la differenza che qui non si mette più l'indicazione del destinatario perché è implicita (ma questo vale anche per Sendmail).

Il primo vantaggio che si osserva rispetto a Sendmail è che il file `/etc/aliases' non deve essere «ricompilato» attraverso `newaliases': basta modificarlo e non occorre nemmeno riavviare il servizio perché viene riletto ogni volta dal sistema di consegna locale.

Se nel file `~/.forward' si inserisce un indirizzo che crea un circolo senza fine, come per esempio quando si indica lo stesso indirizzo dell'utente per il quale è stato creato il file, i messaggi vengono consegnati presso quello stesso recapito, invece di ignorarli semplicemente.

I permessi del file `~/.forward' non possono concedere la scrittura al gruppo e al resto degli utenti. Questo particolare va considerato quando si utilizza una maschera dei permessi pari a 002 (è così, solitamente, quando si usano i gruppi privati), che tende a concedere la scrittura al gruppo in modo predefinito.

Come si è detto, Exim fornisce un collegamento denominato `sendmail', per favorire il funzionamento dei programmi che dipendono dalla presenza di questo; inoltre, offre il collegamento `mailq', come fa Sendmail, per permettere la verifica dei messaggi in coda.

207.2 Installazione

L'installazione di Exim può costituire un problema se non si parte da un pacchetto già predisposto per la propria distribuzione GNU/Linux; quindi è decisamente preferibile cercare un tale pacchetto già pronto. Purtroppo, in certi casi, anche questo non basta: occorre preparare qualcosa prima, forse è necessario definire la configurazione, e infine occorre fare delle sistemazioni finali dopo alcune prove di verifica.

207.2.1 Utente specifico

Quando possibile, se la configurazione lo consente, Exim cerca di avviare processi con privilegi inferiori a quelli dell'utente `root'. Per esempio, la consegna locale della posta avviene normalmente con un processo che utilizza i privilegi dell'utente destinatario. In tutte le altre circostanze, si può stabilire un utente e un gruppo che Exim deve utilizzare: nei sistemi che utilizzano i gruppi privati (un gruppo per ogni utente), si potrebbe creare l'utente e il gruppo `exim'; negli altri sistemi, può essere conveniente creare solo l'utente `exim', a cui abbinare il gruppo `mail'.

Pertanto, la prima cosa da fare è la creazione di questo utente, ed eventualmente del gruppo corrispondente (se non è già previsto, o se si utilizzano i gruppi privati). Nel file `/etc/passwd' potrebbe apparire una riga come quella seguente, dove il numero GID 12 è inteso corrispondere a `mail'.

exim:*:501:12:Exim mailer:/:

Se si usano i gruppi privati, si potrebbero avere i record seguenti, rispettivamente nei file `/etc/passwd' e `/etc/group'.

exim:*:501:501:Exim mailer:/:

exim:x:501:

In ogni caso, come si è visto, è importante che l'accesso sia impossibile, e questo si ottiene con l'asterisco nel campo della password.

207.2.2 /etc/aliases

Dopo l'installazione di Exim, si può fare in modo di recuperare il vecchio `/etc/aliases', se c'era, oppure se ne deve creare uno nuovo. Per il momento, fino a che non è stata vista la configurazione di Exim, è meglio lasciare stare gli alias che si traducono in file o in pipeline.

Exim può essere configurato per utilizzare un file diverso da `/etc/aliases' con questo stesso scopo, ma in generale dovrebbe essere conveniente mantenere questa convenzione. In ogni caso, Exim ha bisogno della definizione di alcuni alias indispensabili: in generale, Exim non permette la consegna di messaggi direttamente all'utente `root', quindi è necessario definire chi sia l'utente corrispondente che deve ricevere la posta diretta a `root'. Di seguito viene mostrato un esempio che dovrebbe andare bene in tutte le piattaforme GNU/Linux: l'alias di `root' deve essere modificato opportunamente.

# Obbligatori
MAILER-DAEMON:	postmaster
abuse:		postmaster
postmaster:	root

# Ridirezione per evitare trucchi con gli utenti speciali di sistema.
bin:		root
daemon:		root
adm:		root
lp:		root
sync:		root
shutdown:	root
halt:		root
mail:		root
news:		root
uucp:		root
operator:	root
games:		root
gopher:		root
ftp:		root
nobody:		root
postgres:	root
exim:		root

# Chi è root (modificare in base alla realtà del proprio sistema)
#root:		daniele

207.2.3 ~/.forward

Anche la gestione dei file `~/.forward' può essere controllata (e stravolta) attraverso la configurazione di Exim; tuttavia, se si desidera mantenere le consuetudini, si possono recuperare questi file che gli utenti potrebbero avere già utilizzato con Sendmail. Valgono naturalmente le stesse riserve già espresse in riferimento a destinatari costituiti da file o da pipeline.

In ogni caso, perché tali file `~/.forward' possano essere accettati da Exim, occorre che siano assenti i permessi in scrittura per il gruppo e per gli altri utenti. Utilizzando la shell Bash, si potrebbe usare un comando come quello seguente:

find /home -name .forward -exec chmod go-w \{\} \;

207.2.4 Directory di destinazione dei messaggi locali

Sendmail utilizza una directory comune a tutti gli utenti per inserirvi i file contenenti i messaggi di questi, quando giungono a destinazione. In passato si è trattato di `/var/spool/mail/', e attualmente dovrebbe essere `/var/mail/', per conformità con lo standard FHS (capitolo 56). Exim può funzionare nello stesso modo, oppure può consegnare i messaggi direttamente nelle directory personali degli utenti. In generale, qualunque sia la scelta, è necessario che la variabile di ambiente `MAIL' contenga il percorso assoluto per raggiungere il file di destinazione, in modo che i programmi di lettura della posta vi si possano adeguare. Questo lo si fa normalmente nella definizione del profilo della shell personale.

Per esempio, se si utilizza la shell Bash, il file `/etc/profile' potrebbe contenere le righe seguenti per indicare che i file dei messaggi si trovano nella directory `/var/mail/'.

MAIL="/var/mail/$USER"
export MAIL

Nel caso la posta venisse consegnata nel file `~/Messaggi' della directory personale di ogni utente, l'istruzione per definire la variabile `MAIL' potrebbe essere la seguente:

MAIL="$HOME/Messaggi"
export MAIL

Detto questo, si deve tenere presente che Exim utilizza i privilegi dell'utente destinatario per aprire i file di destinazione, per cui i premessi della directory devono essere regolati convenientemente. Il problema si pone quando si usa la directory `/var/mail/', o un'altra simile, per tutti i file di destinazione: è necessario che sia attribuita a questa directory la modalità 1777. Infatti, l'attivazione del bit Sticky, permette il blocco dei file (lock). Se non si ha l'accortezza di sistemare questo particolare, la posta elettronica non può essere consegnata.

chmod 1777 /var/mail

207.3 Configurazione

La configurazione di Exim è più semplice di Sendmail, ma resta comunque una cosa piuttosto delicata, dati i problemi che sono coinvolti nella gestione della posta elettronica. Alla fine di questo gruppo di sezioni viene mostrato un esempio completo di configurazione che dovrebbe funzionare correttamente nella maggior parte delle situazioni.

La documentazione di Exim è voluminosa e abbastanza dettagliata. Questo è un fatto positivo; purtroppo occorre dedicarvi un po' di tempo per la sua lettura. Se si desidera utilizzare Exim a livello professionale, ciò diventa necessario.

Il file di configurazione di Exim, volendo seguire lo standard di GNU/Linux (e non solo), dovrebbe trovarsi nella directory `/etc/'. In pratica però, potrebbe non essere così. Una volta installato il pacchetto di Exim, occorre cercare il file di configurazione. Nel caso di distribuzioni RPM si può vedere facilmente l'elenco dei file che compongono il pacchetto, utilizzando l'opzione `-ql'. *1*

Il file di configurazione deve appartenere all'utente `root', oppure all'utente specificato in fase di compilazione dei sorgenti di Exim, attraverso l'opzione `EXIM_UID', e non può essere accessibile in scrittura dal gruppo né dagli altri utenti.

Quando si avvia Exim, se il file di configurazione contiene errori sintattici, viene emesso un messaggio di errore attraverso lo standard error, specificando anche la riga in cui questo si trova. Dopo tale segnalazione, Exim termina di funzionare, e il servizio non viene avviato.

207.3.1 Struttura

Il file di configurazione si divide in sei parti che devono apparire nell'ordine previsto. Ognuna di queste termina con la parola chiave `end', posta da sola in una riga. Le varie parti sono elencate di seguito.

  1. Configurazione principale. Si tratta di direttive in cui si assegnano dei valori a delle opzioni di funzionamento.

  2. Configurazione dei driver di trasporto. Si tratta della definizione dei meccanismi attraverso cui i messaggi vengono recapitati alla destinazione, copiandoli all'interno dei file, o inserendoli nelle pipeline.

  3. Configurazione dei driver di direzione (director). Si tratta dei processi di consegna all'interno dei domini locali, cosa che include la gestione degli alias e del forward.

  4. Configurazione dei driver di instradamento. Si tratta dei processi di consegna a destinazioni remote, ovvero, quelle destinazioni che non sono classificate come appartenenti ai domini locali.

  5. Configurazione delle regole per i tentativi ripetuti (retry).

  6. Configurazione delle regole di riscrittura. Si tratta della definizione di modifiche sistematiche a elementi dell'intestazione dei messaggi.

In ogni parte della configurazione possono apparire dei commenti; questi sono introdotti dal simbolo `#', all'inizio della riga, e conclusi dalla fine della riga stessa. Non sono ammessi commenti alla fine delle direttive; in pratica, i commenti possono apparire solo su righe apposite. Inoltre, le righe bianche, e quelle vuote, vengono ignorate come di consueto.

207.3.2 Elementi comuni

Prima di affrontare la descrizione di alcune direttive importanti che possono essere usate nel file di configurazione, conviene conoscere alcune convenzioni comuni, o direttive particolari che coinvolgono tutto l'insieme della configurazione.

207.3.2.1 Macro

All'interno della prima parte del file di configurazione, quella che riguarda le definizioni generali, è possibile inserire delle direttive che dichiarano delle macro. Queste si distinguono perché devono avere l'iniziale maiuscola. In generale, per convenzione comune derivante da altri linguaggi di programmazione, le macro si dichiarano con nomi composti esclusivamente da lettere maiuscole.

<nome> = <valore-da-sostituire>

Il nome può essere composto da lettere numeri e dal simbolo di sottolineatura (`_'), e come accennato, la prima lettera deve essere maiuscola. Il valore che si abbina a questo nome, è tutto ciò che appare dopo il simbolo `=', escludendo eventuali spazi iniziali, fino alla fine della riga.

207.3.2.2 Assegnamento

In molti punti del file di configurazione si usano delle direttive che rappresentano in pratica l'assegnamento di un valore a una sorta di variabile. La sintassi è semplice e intuitiva.

<nome> = <valore>

La differenza rispetto alla dichiarazione di macro sta nel fatto che i nomi utilizzati in questo caso sono prestabiliti, e non iniziano mai con una lettera maiuscola.

207.3.2.3 Valori booleani

Quando una variabile è fatta per definire l'attivazione o la disattivazione di qualcosa, può ricevere solo i valori Vero o Falso, espressi attraverso le solite parole chiave: `true' o `yes' rappresenta il valore Vero; `false' o `no' rappresenta il valore Falso.

In particolare, in presenza di variabili di questo tipo, è possibile fare a meno di indicare espressamente l'assegnamento, lasciando intuire il valore predefinito derivante dal nome della variabile. In generale, comunque, sarebbe bene esplicitare l'intenzione, se si vogliono utilizzare tali variabili.

207.3.2.4 Interi

I numeri interi possono essere annotati utilizzando diverse basi di numerazione:

Tali numeri interi possono essere seguiti dalla lettera `K' (maiuscola) o dalla lettera `M', e in tali casi si intende esprimere un multiplo di 1024, o di 1024x1024 rispettivamente (Kilo e Mega delle convenzioni che si usano in informatica).

207.3.2.5 Numeri con parte decimale

Un numero contenente una parte decimale può essere espresso solo utilizzando la numerazione a base 10 (base decimale), indicando le cifre della parte frazionaria dopo un punto. Sono consentite un massimo di tre cifre decimali dopo la parte intera.

207.3.2.6 Intervalli orari

Le indicazioni di valori riferiti a intervalli orari (periodi di tempo), fanno uso di una serie di suffissi che descrivono il significato del numero che li precede.

Per esempio, il valore `3h45m' rappresenta 3 ore e 45 minuti. Questo formato di rappresentazione viene usato anche nell'output.

207.3.2.7 Stringhe

Le stringhe possono essere rappresentate con o senza apici doppi di delimitazione. L'utilizzo o meno di tale delimitazione ha delle conseguenze diverse.

Le stringhe non delimitate sono rappresentate da tutto ciò che appare dopo il simbolo `=' utilizzato nell'assegnamento, letteralmente, escludendo eventuali spazi iniziali, e continuando fino alla fine della riga. Questo significa in pratica che una stringa di questo tipo non può proseguire nella riga successiva.

Si utilizzano le stringhe delimitate tutte le volte in cui occorre rappresentare qualcosa di particolare, come dei caratteri speciali, attraverso il prefisso `\' che assume il ruolo di carattere di escape, oppure quando è necessario proseguire la stringa nella riga successiva.

La tabella 207.1 mostra l'uso di queste sequenze di escape ottenute con la barra obliqua inversa.

Simbolo Significato
\\ Rappresenta una barra obliqua inversa singola.
\n Il carattere <NL>.
\r Il carattere <CR>.
\t Una tabulazione orizzontale (<HT>).
\<n-ottale> Identifica un carattere attraverso il suo numero ottale.
\x<n-esadecimale> Identifica un carattere attraverso il suo numero esadecimale.

Tabella 207.1: Elenco delle sequenze di escape utilizzabili all'interno delle stringhe delimitate da apici doppi.

Inoltre, una barra obliqua inversa posta alla fine della riga, subito prima del codice di interruzione di riga, rappresenta la continuazione della stringa nella riga successiva, eliminando gli spazi iniziali aggiunti nella riga successiva.

Se si utilizza una barra obliqua inversa davanti a un carattere con il quale non forma alcuna sequenza di escape prevista, si conferma semplicemente il carattere successivo alla barra. Dal momento che all'interno delle stringhe possono essere usati altri simboli con significati speciali, si può usare la barra obliqua inversa per dare loro un significato puramente letterale.

207.3.2.8 Elenchi di stringhe

In situazioni determinate si può indicare un elenco di stringhe. La rappresentazione di tali elenchi avviene di fatto in una sola stringa, i cui elementi sono separati attraverso due punti verticali (`:'). Per esempio, `uno:due:tre' è un elenco composto dalle sottostringhe `uno', `due' e `tre'. È importante sapere subito che attorno ai due punti verticali, possono essere inseriti degli spazi, che poi vengono eliminati dalle sottostringhe; quindi, tornando all'esempio già presentato, sarebbe stata esattamente la stessa cosa scrivere `uno: due :tre'

A seconda delle esigenze, tali elenchi possono essere racchiusi globalmente attraverso gli apici doppi delle stringhe normali, oppure possono farne senza, con le stesse considerazioni già fatte su questo argomento.

Da quanto descritto, si intende che i due punti verticali abbiano un significato speciale, e che non possano essere usati per altri scopi, a meno che questi appaiano in coppia (`::'), perché in tal caso rappresentano esattamente due punti verticali testuali.

Gli elenchi di stringhe vengono usati per rappresentare vari tipi di informazioni, per i quali si distinguono una serie di particolari che possono essere molto utili per una configurazione efficace di Exim. Qui viene trascurata la descrizione di queste indicazioni, che possono essere approfondite leggendo la documentazione originale.

207.3.2.9 Espansione delle stringhe

All'interno delle stringhe possono essere inseriti degli elementi che vengono sostituiti in qualche modo, in base a ciò che questi rappresentano. Per identificare tali elementi si utilizza il simbolo dollaro (`$') seguito da un nome, che eventualmente può anche essere racchiuso tra parentesi graffe, in caso si temano delle ambiguità.

$<nome-di-variabile> | ${<nome-di-variabile>}

Esistono poi una serie di operazioni che possono essere compiute attraverso l'operatore di sostituzione (il dollaro), che qui non vengono descritte.

Nel caso si debba inserire il simbolo `$' in una stringa con un significato letterale, occorre indicare `\$' se si tratta di una stringa non delimitata, oppure `\\$' se si tratta di una stringa delimitata (incoerente, ma è così).

207.3.2.10 Espressioni regolari

In alcune situazioni, le stringhe possono servire a esprimere delle espressioni regolari. Tali espressioni regolari si distinguono per il fatto che iniziano con l'accento circonflesso (`^'), e possono terminare o meno con il simbolo dollaro, che in tal caso rappresenta la fine della stringa con cui avviene il confronto.

Le regole per la realizzazione di tali espressioni regolari sono simili a quelle di Perl 5, facendo attenzione però alle barre oblique inverse, che se si trovano racchiuse tra apici doppi, devono essere raddoppiate.

207.3.3 Configurazione principale

La prima parte del file di configurazione, fino al primo `end', riguarda la definizione delle opzioni principali. Come è già stato accennato, è in questa parte che possono essere create delle macro, e la loro definizione si distingue in quanto i nomi di queste devono iniziare con una lettera maiuscola.

Questa parte della configurazione è la più semplice, perché richiede solo l'assegnamento di qualche valore a delle variabili prestabilite. L'elenco di tali variabili è molto lungo, e in ogni caso, è sufficiente definire gli assegnamenti riferiti alle opzioni che si vogliono modificare rispetto a quanto risulta predefinito.

Alcune opzioni

exim_user = <utente-usato-da-exim>

exim_group = <gruppo-usato-da-exim>

Quando possibile, Exim funziona utilizzando i privilegi dell'utente e del gruppo specificati attraverso la definizione di queste variabili.

exim_path = <percorso-completo-di-exim>

Permette di specificare il percorso assoluto dell'eseguibile `exim'. Questa informazione serve quando la collocazione del programma non corrisponde all'informazione indicata in fase di compilazione. La conoscenza di tale percorso serve a Exim quando deve avviare una copia di se stesso.

host_lookup_nets = <indirizzo-ip>/<n-bit-maschera>

Permette di definire un gruppo di indirizzi per i quali verificare sempre il nome attraverso il DNS. Generalmente, viene assegnato `0.0.0.0/0' che rappresenta ogni indirizzo IP possibile.

local_domains = <nome-locale>[:<nome-locale>]...

Permette di definire i nomi di dominio completo che fanno capo al sistema locale, per i quali la posta elettronica viene consegnata localmente, senza attivare una connessione SMTP. In pratica, consente di definire anche i domini virtuali che fanno capo allo stesso nodo locale.

Come si vede dalla sintassi, si tratta di un elenco di stringhe, separato attraverso due punti verticali.

Dovrebbe essere conveniente indicare sempre almeno i domini `localhost' e `localhost.localdomain', nell'ipotesi che qualcuno usi indirizzi del tipo `tizio@localhost', per quanto ciò possa essere assurdo.

local_domains_include_host = {true|false}

Attivando questa opzione (`true'), si fa in modo che il nome del nodo locale ottenuto dal sistema operativo, venga incluso automaticamente nell'elenco di domini locali (`local_domains').

log_level = <n-livello>

Permette di definire il livello di dettaglio per le informazioni memorizzate nei file delle registrazioni. Il valore zero corrisponde al minimo; valori superiori aumentano le informazioni (sei dovrebbe essere il valore che genera la massima quantità di notizie). Se questa opzione non viene dichiarata, il livello predefinito è cinque.

message_size_limit = <dimensione>

Permette di fissare un tetto massimo alla dimensione dei messaggi in transito. Qui si usano normalmente i moltiplicatori `K' o `M'.

never_users = <utente>[:<utente>]...

Permette di escludere il recapito di messaggi a utenti determinati, a meno che sia stato specificato un alias adatto nel file `/etc/aliases'. In pratica, serve per indicare l'elenco degli utenti di sistema, a cominciare da `root', che non possono o non dovrebbero ricevere posta.

primary_host_name = <nome-canonico>

Permette di definire esplicitamente il nome canonico primario del nodo locale. Se non viene specificata questa opzione, tale nome viene ottenuto dal sistema operativo, attraverso la funzione `uname()'.

relay_domains_include_local_mx = {true|false}

Attivando l'opzione, si fa in modo di consentire il relay verso i domini che, secondo il DNS, dovrebbero essere serviti dal nodo locale. In pratica, si fa in modo di seguire la configurazione definita attraverso il DNS, con i record `MX', con cui si stabilisce che tale servente SMTP si deve occupare della consegna presso quei domini, accettando messaggi provenienti da qualunque dominio esterno.

sender_host_accept_relay = <modello-domini>[:<modello-domini>]...

Permette di definire verso quali domini è consentito il relay in uscita, ovvero, verso cui è consentito inviare messaggi. Se si vuole permettere la trasmissione di posta elettronica verso qualunque indirizzo, è necessario assegnare un asterisco, che si traduce in qualunque dominio.

spool_directory = <directory>

Definisce il percorso della directory usata come coda dei messaggi da Exim. Generalmente potrebbe trattarsi di `/var/spool/exim/', che poi si articola ulteriormente.

trusted_users = <utente-fidato>[:<utente-fidato>]...

trusted_groups = <gruppo-fidato>[:<gruppo-fidato>]...

Definisce quali processi possono passare messaggi a Exim, specificando il mittente attraverso l'opzione `-f' della riga di comando. Tali processi sono accettati in quanto avviati con i privilegi dell'utente o del gruppo indicati. Se non viene specificata alcuna di queste due opzioni, ciò può essere fatto solo da un processo con i privilegi dell'utente `root'.

Solitamente si definisce in questo modo l'utente `exim' (senza indicare alcun gruppo); potrebbe essere conveniente aggiungere altri utenti nel caso si vogliano gestire delle liste (mailing-list) con caratteristiche particolari.

207.3.4 Configurazione dei driver

La seconda, la terza e la quarta parte del file di configurazione sono dedicate alla definizione delle istanze dei driver di trasporto, di direzione (director), e di instradamento.

In queste parti, le direttive del file di configurazione sono suddivise a gruppetti, ognuno riferito alla definizione di un'istanza particolare. In pratica, appare la dichiarazione del nome dell'istanza che termina con due punti verticali, seguita da una riga contenente la dichiarazione del driver di riferimento, e da una serie di altre righe opzionali, contenenti le impostazioni che gli si devono applicare (quando quelle predefinite non vanno bene).

<nome-di-istanza-del-driver>:
	driver = <nome-del-driver>
	[<direttiva-di-opzione>]
	[<direttiva-di-opzione>]
	...

Le opzioni che possono essere indicate, si distinguono in generiche e private. Le opzioni generiche possono essere utilizzate con tutti i driver di uno stesso tipo (trasporto, direzione, instradamento), mentre quelle private si riferiscono solo a driver particolari. La direttiva che definisce il driver è un'opzione generica, che deve essere posta all'inizio, come mostra lo schema sintattico.

In passato, nelle prime versioni di Exim, era necessario separare le opzioni con una virgola, mettendo prima le opzioni generiche e dopo quelle specifiche; inoltre, il passaggio da opzioni generiche a opzioni specifiche doveva essere segnalato con un punto e virgola. Attualmente, queste restrizioni non esistono più, e non è richiesta l'indicazione di virgole o punti e virgola. Questa informazione viene riportata a spiegazione del motivo per il quale diversi esempi di configurazione in circolazione hanno ancora queste virgole e questi punti e virgola, qua e la, senza un motivo apparente.

A titolo di esempio vengono mostrate e descritte un paio di dichiarazioni significative, che appaiono anche nell'esempio completo mostrato più avanti.

local_delivery:
  driver = appendfile
  file = /var/mail/${local_part}

Nella configurazione del trasporto, definisce l'istanza `local_delivery' del driver `appendfile'. Dal nome si intende che si tratta del trasporto che si deve occupare di consegnare localmente la posta elettronica.

Attraverso il driver `appendfile' si ottiene di aggiungere i messaggi a un file già esistente, specificato attraverso l'opzione `file': in questo caso si tratta di `/var/mail/${local_part}', che in pratica si espande in un file denominato come l'utente che deve riceverlo, collocato nella directory `/var/mail/'. *2*

localuser:
  driver = localuser
  transport = local_delivery

Questo esempio fa riferimento alla configurazione del sistema di direzione; il nome dell'istanza è lo stesso di quello del driver, ma si tratta di cose differenti. Si può osservare la dichiarazione del trasporto utilizzato: `local_delivery', cioè il tipo di trasporto (l'istanza) già vista nell'esempio precedente.

207.3.5 Configurazione dei tentativi ripetuti

La penultima parte del file di configurazione, serve a definire il modo in cui scandire la ripetizione dei tentativi di invio (o di consegna) della posta. Ciò permette di distinguere il comportamento in base al dominio di destinazione e al tipo di errore che ha impedito la consegna del messaggio. Generalmente si trova già un esempio generico sufficiente.

Gli intervalli con cui vengono ripetuti i tentativi, devono tenere conto della frequenza con cui viene riavviato il processo di scansione della coda. Per esempio, se viene avviato `exim' con l'opzione `-q30m', che, come verrà descritto, richiede il controllo della coda ogni 30 minuti, è poco sensato specificare nella configurazione intervalli inferiori, perché non potrebbero essere rispettati.

207.3.6 Configurazione della riscrittura degli indirizzi

L'ultima parte della configurazione è generalmente assente, o senza direttive. Serve a definire delle regole di alterazione sistematica degli indirizzi.

Per comprendere il problema viene descritto un caso pratico che potrebbe interessare. Quando si passa da Sendmail a Exim, potrebbe sentirsi la necessità di fare in modo che gli indirizzi <nome>+<qualcosa>@<dominio>, vengano consegnati a <nome>@<dominio>. Alcuni utenti potrebbero utilizzare questo trucco (comune per Sendmail) per distinguere la fonte da cui lo scrivente può avere tratto il loro indirizzo, e avere implicitamente un'idea del contesto per il quale viene inviato ogni messaggio.

Exim ha dei meccanismi più potenti, ma quando si passa da Sendmail a Exim, gli utenti potrebbero desiderare di mantenere le vecchie convenzioni. La direttiva seguente dovrebbe risolvere il problema.

^(..*?)\+(.*)@(..*)$ $1@$3 T

Come si vede, attraverso un'espressione regolare vengono estratti gli elementi che contano dall'indirizzo, che poi viene ricostruito senza la parte superflua che ne impedirebbe il recapito.

207.3.7 Configurazione generica

Lo scopo dell'esempio di configurazione che viene allegato è quello di impedire il relay generalizzato. In pratica, è necessario attivare un DNS con il record `MX', e se il servente SMTP locale è quello indicato in questo record `MX', allora è consentita la ricezione di messaggi destinati a utenti collocati nel gruppo di nodi di competenza, secondo quanto stabilito dal DNS. L'invio dei messaggi provenienti dall'interno del gruppo di nodi stabilito in questo modo, è consentito per qualunque destinazione.

########################################################################
# CONFIGURAZIONE PRINCIPALE                                            #
########################################################################

#-----------------------------------------------------------------------
# Definisce il tempo massimo di attesa per accettare un messaggio che
# non provenga dal protocollo SMTP. Si tratta in pratica del tempo
# massimo concesso per i messaggi che provengono dallo standard input.
# Il valore predefinito è 0, corrispondente a un tempo infinito.
#-----------------------------------------------------------------------
accept_timeout = 15m

#-----------------------------------------------------------------------
# Se la coda non è controllata regolarmente, assicura che sia tentata
# una nuova consegna dei messaggi congelati (frozen).
#-----------------------------------------------------------------------
auto_thaw = 1d

#-----------------------------------------------------------------------
# Previene la corruzione dei file assicurando che ci sia abbastanza
# spazio nell'unità utilizzata per la coda dei messaggi.
# Questo valore deve essere un po' superiore alla dimensione massima
# consentita per i messaggi.
#-----------------------------------------------------------------------
check_spool_space = 5M

#-----------------------------------------------------------------------
# Previene il sovraccarico del sistema, definendo un limite massimo
# al carico medio, durante il quale viene rifiutata la consegna
# dei messaggi.
#-----------------------------------------------------------------------
# deliver_load_max = 6

#-----------------------------------------------------------------------
# Quando possibile, i processi avviati da Exim hanno solo i privilegi
# dell'utente e del gruppo indicato.
#-----------------------------------------------------------------------
exim_user = exim
exim_group = mail

#-----------------------------------------------------------------------
# La direttiva seguente fa in modo che Exim traduca tutti i numeri IP
# delle chiamate in ingresso in nomi, utilizzando il DNS.
# Ciò permette di ottenere il nome vero di ogni host mittente.
#-----------------------------------------------------------------------
host_lookup_nets = 0.0.0.0/0

#-----------------------------------------------------------------------
# Permette di evitare che vengano congelati i messaggi contenenti
# un errore nell'indirizzo.
#-----------------------------------------------------------------------
ignore_errmsg_errors = true
 
#-----------------------------------------------------------------------
# Permette di specificare esplicitamente il dominio o i domini locali.
#-----------------------------------------------------------------------
local_domains = "localhost:localhost.localdomain"

#-----------------------------------------------------------------------
# Permette di includere automaticamente il nome dell'host nell'elenco
# di local_domains, come definito con la direttiva primary_hostname,
# oppure, in sua mancanza attraverso una chiamata alla funzione uname().
#-----------------------------------------------------------------------
local_domains_include_host = true

#-----------------------------------------------------------------------
# Permette di registrare i destinatari a cui viene rifiutato
# l'invio del messaggio, per un qualunque motivo di politica
# amministrativa.
#-----------------------------------------------------------------------
log_refused_recipients = true

#-----------------------------------------------------------------------
# Permette di registrare tutte le modifiche apportate ai messaggi. 
#-----------------------------------------------------------------------
log_rewrites = true

#-----------------------------------------------------------------------
# Permette di annotare il risultato finale di una connessione SMTP.
#-----------------------------------------------------------------------
log_smtp_confirmation = true                 

#-----------------------------------------------------------------------
# Permette di definire il limite massimo della dimensione dei messaggi
# in transito.
#-----------------------------------------------------------------------
message_size_limit = 4M

#-----------------------------------------------------------------------
# Permette di specificare un elenco di utenti che non possono essere
# usati per la consegna locale dei messaggi.
# Tali utenti possono comunque essere ridiretti attraverso il
# file /etc/aliases.
#-----------------------------------------------------------------------
never_users = "root:bin:daemon:adm:lp:sync:shutdown:halt:mail:news:\
		uucp:operator:games:gopher:ftp:nobody:exim"

#-----------------------------------------------------------------------
# Permette di definire il nome canonico dell'host locale.
# Se non viene utilizzata questa direttiva, si utilizza la funzione
# uname() per ottenere tale nome.
#-----------------------------------------------------------------------
# primary_hostname = 

#-----------------------------------------------------------------------
# Previene il sovraccarico del sistema, definendo un limite massimo
# al carico medio, durante il quale la consegna dei messaggi viene
# ritardata.
#-----------------------------------------------------------------------
queue_only_load = 4

#-----------------------------------------------------------------------
# Consente il relay in ingresso, verso i domini di competenza, secondo
# quanto stabilito dal DNS attraverso i record MX.
# In pratica, se l'host locale è indicato in un record MX, questo
# diviene automaticamente il relay per tutte le destinazioni
# previste attraverso il DNS.
#-----------------------------------------------------------------------
relay_domains_include_local_mx = true

#-----------------------------------------------------------------------
# Permette di stabilire il limite massimo della dimensione dei messaggi
# che «rimbalzano» al mittente. Se tali messaggi dovessero essere di
# dimensione maggiore, verrebbero troncati.
#-----------------------------------------------------------------------
return_size_limit = 20K

#-----------------------------------------------------------------------
# Permette si stabilire a quali host possono essere inviati i messaggi
# in uscita.
# Utilizzando l'asterisco, si consente l'invio di messaggi a qualunque
# destinazione.
#-----------------------------------------------------------------------
sender_host_accept_relay = *

#-----------------------------------------------------------------------
# Definisce la directory usata da Exim per la gestione delle code.
#-----------------------------------------------------------------------
spool_directory = /var/spool/exim

#-----------------------------------------------------------------------
# Permette di eliminare automaticamente le parentesi angolari eccessive,
# utilizzate eventualmente per circoscrivere un indirizzo e-mail.
# In pratica, <<xxx@a.b.c.d>> viene trasformato in <xxx@a.b.c.d>.
#-----------------------------------------------------------------------
strip_excess_angle_brackets = true

#-----------------------------------------------------------------------
# Permette di eliminare automaticamente un punto finale aggiunto
# (erroneamente) a un indirizzo e-mail.
#-----------------------------------------------------------------------
strip_trailing_dot = true

#-----------------------------------------------------------------------
# Se è stato stabilito di fare funzionare Exim con il suo proprio
# UID (e non root), solitamente «exim», conviene definire tale utente
# come trusted_users.
#-----------------------------------------------------------------------
trusted_users = exim

end

########################################################################
# CONFIGURAZIONE DEL TRASPORTO                                         #
########################################################################

#-----------------------------------------------------------------------
# Viene definito il trasporto per la consegna locale dei messaggi.
# In modo predefinito, il processo relativo funziona con i privilegi
# (UID e GID) dell'utente locale destinatario. Per questo, se la
# directory di destinazione del messaggio fosse comune a tutti
# gli utenti, questa dovrebbe avere i permessi 1777.
#-----------------------------------------------------------------------
local_delivery:
  driver = appendfile
  file = /var/mail/${local_part}
# group = mail
# mode = 0660

#-----------------------------------------------------------------------
# Viene definito il trasporto per la gestione delle pipeline generate
# attraverso gli alias (il file /etc/aliases o .forward).
# Se la pipeline genera qualcosa attraverso lo standard output, questo
# viene restituito al mittente, in qualità di errore.
#-----------------------------------------------------------------------
address_pipe:
  driver = pipe
  return_output

#-----------------------------------------------------------------------
# Viene definito il trasporto per la gestione dei file generati
# attraverso gli alias e i forward personali (il file /etc/aliases e
# i file .forward).
#-----------------------------------------------------------------------
address_file:
  driver = appendfile

#-----------------------------------------------------------------------
# Viene definito il trasporto per la gestione dei file generati
# attraverso gli alias e i forward personali (/etc/aliases e .forward),
# quando i percorsi terminano con la barra obliqua (/). In tal caso,
# questi percorsi vengono trattati come directory, e i messaggi vengono
# memorizzati su file distinti.
#-----------------------------------------------------------------------
address_directory:
  driver = appendfile
  no_from_hack
  prefix = ""
  suffix = ""
# maildir_format

#-----------------------------------------------------------------------
# Viene definito il trasporto per la gestione delle risposte automatiche
# generate da opzioni di filtro...
#-----------------------------------------------------------------------
address_reply:
  driver = autoreply

#-----------------------------------------------------------------------
# Viene definito il trasporto per la gestione della consegna di messaggi
# attraverso connessioni SMTP.
#-----------------------------------------------------------------------
remote_smtp:
  driver = smtp
  command_timeout = 1m
  connect_timeout = 10s
  
end

########################################################################
# CONFIGURAZIONE DEL SISTEMA DI CONSEGNA LOCALE: «DIRECTOR»            #
########################################################################

#-----------------------------------------------------------------------
# Viene definito il director per la gestione degli alias del file
# /etc/aliases.
# In particolare, se si vogliono usare le pipeline, è necessario
# definire l'utente e il gruppo proprietari del processo che verrà
# avviato in conseguenza della prosecuzione (forward) di un messaggio a
# tali forme di destinatari.
#-----------------------------------------------------------------------
system_aliases:
  driver = aliasfile
  file = /etc/aliases
  search_type = lsearch
# user = exim
# group = mail

#-----------------------------------------------------------------------
# Viene definito il director per la gestione della ridirezione dei
# messaggi attraverso i file .forward personali di ogni utente.
#-----------------------------------------------------------------------
userforward:
  driver = forwardfile
  file = .forward
  no_verify
  check_ancestor
  filter

#-----------------------------------------------------------------------
# Viene definito il director per la gestione delle caselle personali
# degli utenti.
#-----------------------------------------------------------------------
localuser:
  driver = localuser
  transport = local_delivery

end

########################################################################
# CONFIGURAZIONE DEGLI INSTRADAMENTI                                   #
########################################################################

#-----------------------------------------------------------------------
# Viene definito l'instradamento verso host remoti attraverso il
# protocollo SMTP, utilizzando nomi di dominio normali.
#-----------------------------------------------------------------------
lookuphost:
  driver = lookuphost
  transport = remote_smtp

#-----------------------------------------------------------------------
# Viene definito l'instradamento verso host remoti attraverso il
# protocollo SMTP, utilizzando indirizzi IP numerici.
#-----------------------------------------------------------------------
literal:
  driver = ipliteral
  transport = remote_smtp

end

########################################################################
# CONFIGURAZIONE DEI TENTATIVI RIPETUTI                                #
########################################################################

#-----------------------------------------------------------------------
# Quella seguente è la regola standard di ripetizione dei tentativi
# di invio di un messaggio, a seguito di un errore.
# Inizialmente, per 2 ore, i tentativi vengono ripetuti ogni 15 minuti;
# successivamente, per 16 ore, i tentativi vengono ripetuti a intervalli
# crescenti, a iniziare dopo 2 ore, crescendo con un fattore di 1,5;
# infine, per un massimo di 4 giorni, vengono ripetuti i tentativi
# ogni otto ore.
#-----------------------------------------------------------------------
# Dominio              Errore      Ripetizione dei tentativi
# -------              ------      -------------------------

*                      *           F,2h,15m; G,16h,2h,1.5; F,4d,8h

end

########################################################################
# CONFIGURAZIONE DELLA RISCRITTURA DEGLI INDIRIZZI                     #
########################################################################

#-----------------------------------------------------------------------
# L'esempio seguente, che appare commentato, permette di trasformare
# l'indirizzo di destinazione di ogni messaggio, in modo da non
# tenere in considerazione il segno «+».
# Per esempio, tizio+archivio@mio.dominio viene consegnato a
# tizio@mio.dominio.
# Ciò può essere utile se si vuole in qualche modo consentire agli
# utenti l'uso del simbolo «+» per contestualizzare l'indirizzo
# e-mail, come si può fare con Sendmail.
#-----------------------------------------------------------------------
# ^(..*?)\+(.*)@(..*)$ $1@$3 T

end

########################################################################

207.4 Avvio di Exim

L'avvio di Exim, allo scopo di attivare il servizio SMTP, avviene di solito attraverso la procedura di inizializzazione del sistema, come processo indipendente da `inetd', anche se quest'ultima possibilità è comunque consentita. Ma Exim può essere avviato anche per altri motivi, in particolare per ricevere un messaggio dallo standard input, da recapitare in qualche modo, oppure per ripassare i messaggi rimasti in coda, per ritentare il loro invio.

A seconda dello scopo per il quale viene avviato l'eseguibile `exim', possono essere richiesti dei privilegi particolari. Per la precisione, si distingue tra utenti comuni e amministratori. L'amministratore è l'utente `root', l'utente abbinato a Exim (normalmente `exim'), e gli utenti definiti attraverso l'opzione `trusted_users'.

Uno dei motivi per cui può essere più conveniente avviare il servizio SMTP di Exim, in modo indipendente da `inetd', è il fatto di poter affidare al demone Exim, così avviato, anche il compito di provvedere alla gestione dei messaggi in coda in modo automatico. Se si utilizza il controllo di `inetd', occorre affidare il lavoro di gestione della coda a un altro processo.

Quando si usa Exim come demone, cioè in modo autonomo da `inetd', si usa l'opzione `-bd', seguita quasi sempre da `-q<tempo>', che serve a specificare l'intervallo di scansione della coda di messaggi in attesa.

Se si vuole gestire il servizio SMTP attraverso il controllo di `inetd', occorre specificare l'opzione `-bs' e si deve dichiarare una riga simile a quella seguente nel file `/etc/inetd.conf'.

smtp	stream  tcp 	nowait  root    /usr/sbin/in.smtpd  in.smtpd -bs

In particolare, `/usr/sbin/in.smtpd' deve essere un collegamento all'eseguibile `exim' reale.

207.4.1 # exim

exim [<opzioni>]

`exim' è l'eseguibile che svolge tutto il lavoro dell'applicativo Exim (a parte qualche script, i collegamenti e alcuni programmi di contorno per la gestione dei file DBM). A seconda delle opzioni utilizzate può funzionare come demone, come programma dipendente da `inetd', può ricevere messaggi attraverso lo standard input, e può scandire la coda in attesa.

Di seguito vengono elencate solo alcune opzioni assolutamente indispensabili, che servono a rendere l'idea delle funzioni di questo eseguibile.

Alcune opzioni

-bd

Avvia `exim' come demone in attesa di connessioni SMTP. `exim' può essere avviato in questo modo solo da un amministratore, e di solito avviene per mezzo della procedura di inizializzazione del sistema. Quando `exim' viene avviato con questa opzione, ma in modo manuale, può essere conveniente aggiungere l'uso delle opzioni diagnostiche `-d' o `-dm'.

-bs

Avvia `exim' in modo che questo si metta in attesa di ricevere messaggi dallo standard input, rispondendo poi a questi attraverso lo standard output. Questa opzione viene usata normalmente per gestire l'avvio di `exim' attraverso `inetd'.

-bp

Questa opzione permette di visualizzare l'elenco dei messaggi rimasti in coda per qualche motivo. Il funzionamento non è perfettamente identico a Sendmail, in quanto ci sono circostanze in cui, per qualche motivo, i messaggi in coda non vengono visualizzati.

-bt [<indirizzo>]

Avvia `exim' in una modalità di verifica degli indirizzi. Se viene indicato un indirizzo come argomento dell'opzione, si ottengono le informazioni essenziali sulla consegna verso tale destinazione. Ciò permette di verificare la correttezza della configurazione, dal momento che si ottiene anche l'indicazione del tipo di direzione e di trasporto utilizzati.

Se non viene specificato l'indirizzo nella riga di comando, `exim' funziona in modo interattivo, proponendo un invito (il simbolo `>') per l'inserimento di ogni indirizzo da verificare (per terminare si può utilizzare la combinazione [Ctrl+c]).

-d[<n-livello>]

Permette di avviare `exim' in modo diagnostico, allo scopo di visualizzare informazioni attraverso lo standard error. Dopo la lettera dell'opzione, può essere aggiunto un numero che serve a rappresentare l'entità di informazioni desiderate: uno rappresenta un livello minimo, che viene utilizzato se non si specifica alcun numero, mentre un valore più grande rappresenta più informazioni.

-dm

Permette di ottenere informazioni diagnostiche riferite all'allocazione e alla deallocazione di memoria.

-q

L'opzione `-q' può avere un argomento, ma se usata da sola, fa in modo che `exim' esegua una scansione (una soltanto) dei messaggi in coda, tentando di consegnare ogni messaggio trovato al suo interno. La scansione non segue un ordine preciso, e alla sua conclusione, `exim' termina di funzionare. Questa opzione può essere usata solo da un amministratore.

-q<tempo>

L'opzione `-q', seguita dall'indicazione di una durata temporale, fa in modo che `exim' esegua una scansione della coda in modo ripetitivo, a intervalli della durata specificata dall'argomento. In questo modo, `exim' deve continuare a funzionare a tempo indeterminato.

Questa opzione, con argomento, viene usata preferibilmente per l'avvio di `exim' come demone, in modo tale che possa prendersi cura sia del servizio SMTP che della verifica della coda.

L'intervallo specificato in questo modo, determina in pratica il tempo minimo che può essere indicato nella configurazione dei tentativi ripetuti.

-v

È sinonimo di `-d1' (diagnosi di livello minimo).

207.4.2 Collegamento a exim

Come accade spesso nei sistemi Unix, l'eseguibile `exim' può essere avviato utilizzando nomi diversi che definiscono implicitamente l'uso di opzioni determinate, che potrebbero essere difficili da ricordare. Non sempre i pacchetti di Exim includono tutti i collegamenti possibili che potrebbero essere utili. Vale quindi la pena di riassumere quelli più comuni, che potrebbero essere realizzati utilmente se mancano nel proprio pacchetto.

207.5 Code e registri

Molto probabilmente (dipende da come è stato configurato in fase di compilazione), la directory `/var/spool/exim/' si articola in varie sottodirectory destinate a contenere informazioni variabili di vario tipo, tra cui le code dei messaggi e i file delle registrazioni.

La directory `input/' contiene precisamente i file delle code. Per ogni singolo messaggio che venga messo in attesa, si formano almeno due file: uno che termina con la sigla `-D' (data), che contiene il corpo del messaggio, e uno che termina con la sigla `-H' (head), che contiene le altre informazioni. Se un messaggio è diretto a diversi destinatari, la sua consegna può richiedere molto tempo, e l'annotazione delle destinazioni presso cui è stato recapitato con successo. In tal caso viene creato un terzo file, che termina con la sigla `-J' (journal), all'interno del quale si annotano gli indirizzi già raggiunti.

Se un messaggio finisce in coda, ci deve essere un motivo. Nella directory `msglog/' vengono annotati file con gli stessi nomi utilizzati per i dati in coda, senza sigle finali, contenenti l'elenco degli insuccessi accumulati durante i vari tentativi ripetuti.

Se si decide di intervenire in modo brutale nei file delle code, cancellandoli, ci si deve ricordare di eliminare anche i file corrispondenti della directory `msglog/'.

Naturalmente sono disponibili anche dei file di registrazioni veri e propri, che potrebbero trovarsi in `/var/spool/exim/log/', oppure, più convenientemente, in `/var/log/exim/'. Si tratta di tre file: `mainlog', `rejectlog', `processlog' e `paniclog'. Il significato, e quindi il contenuto, dovrebbe essere intuitivo: `mainlog' è l'archivio principale delle operazioni compiute, in cui si segnalano l'arrivo e la consegna di ogni messaggio; `rejectlog' registra le informazioni sui messaggi il cui transito è rifiutato in funzione della configurazione; `processlog' serve a segnalare l'effetto della ricezione di alcuni segnali (come `SIGHUP' e `SIGUSR1'); infine, `paniclog' permette di annotare le situazioni di errore che Exim non riesce a gestire.

Attraverso l'opzione `log_level' del file di configurazione, è possibile definire il livello di dettaglio delle informazioni che appaiono nel file delle registrazioni. Il valore predefinito corrisponde comunque a un buon livello di dettaglio.

Con l'opzione `preserve_message_logs', attivandola, è possibile evitare la cancellazione dei file delle registrazioni collocati nella directory `msglog/'. Ciò può essere utile solo nel caso in cui si volesse fare un controllo approfondito degli errori che si verificano durante i vari tentativi di consegna.

207.5.1 Archiviazione dei file delle registrazioni

Le distribuzioni GNU/Linux dovrebbero essere organizzate per gestire in modo elegante l'archiviazione dei file delle registrazioni, spezzando i file in parti che contengono periodi relativamente brevi, solitamente distinte attraverso un'estensione numerica progressiva che indica l'età relativa del file.

Exim fornisce un proprio script per svolgere questo compito, `exicyclog', e questo può essere usato quando la propria distribuzione GNU/Linux non dovesse già provvedere per conto proprio.

Per avviarlo, si potrebbe mettere un'istruzione come quella seguente nel file `/etc/crontab' (ammesso che lo script si trovi nella directory `/usr/sbin/').

01 0 * * * root /usr/sbin/exicyclog

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


1.) Il pacchetto Exim di Red Hat, si trova solo tra i contributi esterni, e questo installa i binari a partire dalla directory `/usr/exim/', cosa decisamente insolita; inoltre, il file di configurazione è `/usr/exim/configure'.

2.) La directory in questione deve avere i permessi 1777, altrimenti non può funzionare il sistema di blocco dei file (lock), e in pratica i messaggi non vengono recapitati.


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]