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.
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 |
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 |
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.
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.
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.
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 |
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 \{\} \;
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
51). 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 completo 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
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
|
Il file di configurazione deve appartenere all'utente |
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.
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.
Configurazione principale. Si tratta di direttive in cui si assegnano dei valori a delle opzioni di funzionamento.
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.
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.
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.
Configurazione delle regole per i tentativi ripetuti (retry).
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.
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.
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.
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.
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.
I numeri interi possono essere annotati utilizzando diverse basi di numerazione:
un numero che inizia con il prefisso 0x... viene inteso essere espresso in base esadecimale;
un numero che inizia con uno zero viene inteso essere espresso in base ottale;
un numero che inizia con una cifra diversa da zero viene inteso essere espresso in base decimale.
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).
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 3 cifre decimali dopo la parte intera.
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.
s secondi;
m minuti;
h ore;
d giorni;
w settimane.
Per esempio, il valore 3h45m rappresenta 3 ore e 45 minuti. Questo formato di rappresentazione viene usato anche nell'output.
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 174.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. |
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.
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.
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 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 doppi apici, devono essere raddoppiate.
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.
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 completo 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 |
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 0 (zero) corrisponde al minimo; valori superiori aumentano le informazioni (6 dovrebbe essere il valore che genera la massima quantità di notizie). Se questa opzione non viene dichiarata, il livello predefinito è 5.
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 server 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 -froot.
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.
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.
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 |
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.
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 server 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 8 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
########################################################################
|
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-q<tempo>
Se si vuole gestire il servizio SMTP attraverso il controllo di inetd, occorre specificare l'opzione -bs/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.
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.
|
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-dm
|
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.
|
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.
|
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]).
|
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: 1 (uno) rappresenta un livello minimo, che viene utilizzato se non si specifica alcun numero, mentre un valore più grande rappresenta più informazioni.
|
Permette di ottenere informazioni diagnostiche riferite all'allocazione e alla deallocazione di memoria.
|
L'opzione -qexim 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.
|
L'opzione -qexim 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. |
|
È sinonimo di -d1
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.
/usr/lib/sendmail, /usr/sbin/sendmail
Questi due collegamenti sono praticamente indispensabili se si vogliono utilizzare gli MUA comuni, cioè i programmi come Mailx (mail), che per l'invio dei messaggi si avvalgono proprio dell'eseguibile sendmail. Exim riconosce molte delle opzioni di Sendmail, e in tal modo è possibile usare tali collegamenti.
Secondo la logica di GNU/Linux, l'eseguibile sendmail dovrebbe trovarsi esclusivamente nella directory /usr/sbin/, ma per rispettare la tradizione è meglio aggiungere anche l'altro (/usr/lib/sendmail) perché si vedono ancora script che fanno affidamento su questo.
/usr/bin/mailq
Quando exim viene avviato con il nome mailq, permette di conoscere lo stato della coda, come se fosse stato avviato con l'opzione -bp
/usr/bin/runq
Quando exim viene avviato con il nome runq, fa in modo che exim esegua una singola scansione della coda, cercando di inviare i messaggi rimasti in attesa. Ciò, in pratica, come se fosse stato avviato con l'opzione -q
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.
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 1999.09.21 --- Copyright © 1997-1999 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.