Home / Istruzioni / Mutt  Not f'd - you won't find me on Facebook  Identi.ca  Twitter  YouTube  Flickr  Instagram  LinkedIn  Reddit  Social

E-Mail da terminale

Il protocollo SMTP

Tutti noi utilizziamo la posta elettronica, ma in quanti sappiamo come effettivamente funziona? Vediamo allora di capire come un singolo messaggio di posta elettronica - partendo dal mittente - arrivi tra mille peripezie fino ad apparire sano e salvo sul monitor del destinatario.

Introduzione

Per scrivere e ricevere le email usiamo un MUA (Mail User Agent), e' tipicamente un software col quale scrivere, spedire e ricevere i messaggi di posta elettronica. Pensate a Thunderbird, Outlook, Evolution, Eudora, ecc. Si tratta di gradevoli interfacce grafiche che semplificano e rendono meno impersonale la gestione delle email. Consentendo anche di scrivere dei messaggi offline, inserire degli allegati, scaricare messaggi ecc. Insomma, quello che fanno questi programmi lo sapete gia', cio' che magari non tutti sanno e' cosa avviene dietro la gradevole interfaccia grafica.

Ora, guardate la figura 1 (se ci riuscite, e' orribile), abbiamo tre passaggi, vediamoli uno ad uno:

Rappresentazione grafica del percorso di un messaggio di posta elettronica
Figura 1. Rappresentazione grafica
del percorso di un messaggio di posta elettronica.

1) il client di posta si occupa di collegare l'utente (voi) al MTA (Mail Transfer Agent). L'MTA e' il server di posta locale che si occupa di mandare effettivamente il messaggio in internet. Puo' dunque capitare che il nostro MUA ci dica che il messaggio e' stato inviato, mentre il MTA per qualche motivo invece non riesca a inviarlo;
2) ora che l'MTA locale ha ricevuto l'email dal nostro client lo mandera' all'MTA del destinatario. Dunque deve prima di tutto capire a quale MTA remoto mandarlo. Una volta spedito all'MTA giusto, il suo compito e' finito;
3) adesso che l'MTA remoto ha ricevuto l'email, deve spedirla all'utente destinatario.
In questo momento quando il destinatario aprira' il suo client di posta ci trovera' il nostro messaggio di posta.

Per rendere tutto piu' chiaro, poniamo il caso che il sindaco di Comune voglia mandare una email al presidente di Provincia. L'email di Sindaco e' sindaco@comune.it e l'email di Presidente e' presidente@provincia.it. Seguendo la figura di prima, Sindaco scrive una email col suo client, 1) il client di posta di Sindaco invia l'email all'MTA locale (comune.it), 2) l'MTA locale individua l'MTA remoto (provincia.it) e manda l'email, 3) infine l'MTA (provincia.it) invia l'email all'utente presidente. Ora il presidente aprendo il client di posta (appena questo si collega al server e scarica la posta) trovera' l'email del Sindaco.

L'invio della email nei suoi vari passaggi e' avvenuto grazie al protocollo SMTP (Simple Mail Transfer Protocol). Sarebbe quindi il caso di vedere alcuni dettagli di questo protocollo.

La comunicazione tra i due MTA (quello locale e quello remoto) avviene attraverso un meccanismo di codifica (NVT ASCII). Analogamente a quanto avviene con l'FTP A invia comandi a B, che risponde tramite codici di stato accompagnati da una stringa opzionale.

Per inviare un messaggio di posta dall'MTA locale a quello remoto si usano cinque comandi:

  • HELO - serve al client per presentarsi al server;
  • MAIL - serve per indicare il mittente;
  • RCPT - serve per indicare il destinatario o i destinatari;
  • DATA - serve per scrivere il corpo del messaggio (header piu' testo);
  • QUIT - serve per chiudere la connessione SMTP.

Tutta la connessione con SMTP avviene attraverso la porta 25 del protocollo TCP.

Una volta connessi alla porta 25 dell'MTA, questo (di solito) ci risponde con un messaggio di benvenuto (greeting message) che generalmente riporta il codice di stato e informazioni sul server (FQDN) con nome e versione del software usato dal server, lo stato, la data e l'ora:

220 mail.comune.it ESMTP Sendmail 8.14.1/8.14.1; ready at Thu, 21 Oct 2009 19:12:25 +0100

Adesso e' il turno del client presentarsi, e lo fa tramite il comando:

HELO nautilus.comune.it

il server rispondera':

250 mail.comune.it Hello nautilus.comune.it [125.250.250.25], pleased to meet you

Tanto per chiarire le cose, il server ci fa sapere che conosce il nostro IP indicandocelo. In piu' con queste informazioni puo' fare una richiesta al DNS per verificare l'autenticita' del client e per sapere se concedere l'accesso o no (secondo le politiche di sicurezza della rete a cui appartiene l'indirizzo IP).

Se ci viene concesso l'accesso il client potra' indicare il mittente:

MAIL From: sindaco@comune.it

e il destinatario:

RCPT To: presidente@provincia.it

Il server dopo ogni comando ci rispondera' ok, nello specifico:

250 sindaco@comune.it… Sender ok

e:

250 presidente@provincia.it… Recipient ok

Adesso il client dira' al server il contenuto vero e proprio dell'email tramite il comando:

DATA

a cui il server rispondera' con:

354 Enter mail, end with "." on a line by itself

quindi il client invia il corpo dell'email:

Alla cortese attenzione del Presidente di Provincia,
bla bla bla bla bla.
Attendo una vostra risposta,
Sindaco.
.

Il server rispondera':

250 Message accepted for delivery

A questo punto il client chiude la connessione al server tramite il comando:

QUIT

Ogni riga di testo dopo il comando DATA non puo' essere piu' lunga di 1000 Byte.

L'header (che si trova subito prima del corpo del messaggio) contiene i valori dei campi From, To, Date, Reply-To, Cc e Subject inseriti dal client di posta. A questi si aggiungono altri valori messi da ogni singolo MTA (come i campi Received e Message-Id). Tutti dati indispensabili ai diversi client di posta per riportare al destinatario le informazioni sul messaggio e il percorso da esso effettuato.

Leggendo gli header possiamo dunque capire l'host di origine, il server a cui e' stato mandato, il server di destinazione, ecc. Poi vi sono header aggiunti da applicazioni utente esterne, (antispam ad esempio) che sono precedute dalla stringa X- (X-PMX-Version e X-PerlMx-Spam).

Le fake mail e le email truffaldine (phishing ecc.) sono facilmente smascherabili, basta leggere attentamente gli header (oltre a guardare dove porta un link prima di premerlo con noncuranza).

Relay e record MX

Dopo la breve introduzione al Simple Mail Transfer Protocol (SMTP), ora mi piacerebbe scrivere un po' dei Relay. Con Relay (parlando di SMTP) si intende la possibilita' di usare un MTA che appartiene a un dominio diverso sia da quello del client del mittente sia da quello del client del destinatario.

Riprendendo l'esempio di prima, abbiamo il MUA del sindaco che si trova nella rete comune.it. Non dovrebbe poter utilizzare un MTA della rete regione.it per spedire un messaggio di posta elettronica al MUA del presidente della provincia che si trova nella rete provincia.it.

E' ovvio che il MTA della regione puo' spedire le email che gli vengono affidate da un MUA della rete regione.it (assessore@regione.it, giunta@regione.it, governatore@regione.it, ecc@regione.it). Per far si che accetti senza restrizioni, deve essere reso piu' flessibile.

Esistono meccanismi per rendere un MTA una sorta di Open Relay sicuro, rendendolo flessibile ma senza perdere in sicurezza. Per far questo e' necessaria l'autenticazione del client tramite nome utente e password. Si tratta di un'estensione del protocollo chiamata SMTPS e utilizza la porta 465/tcp. Questa estensione e' in grado di effettuare la cifratura dei messaggi di posta elettronica in uscita.

Ogni rete deve avere il suo MTA che si occupa di ricevere le email dirette ad (consegnare le email inviate da) un indirizzo del proprio dominio. Il tutto avviene sul server SMTP, indicato dal server DNS tramite uno speciale record (il record MX).

Il record MX:

is a type of resource record in the Domain Name System (DNS) specifying how Internet e-mail should be routed using the Simple Mail Transfer Protocol (SMTP). Each MX record contains a preference and a host name, so that the collection of MX records for a given domain name point to the servers that should receive e-mail for that domain, and their priority relative to each other.
[from Wikipedia]

Al MTA locale basta una query DNS per sapere il giusto MTA remoto a cui inviare l'email. Il record MX e' dunque una sorta di interfaccia di collegamento tra il sistema di posta elettronico locale e la rete internet.

Per motivi di sicurezza e protezione ormai il server corrispondente al record MX non e' il vero mail server locale, ma un Mail Hub, uno scalo dove accedono i messaggi in entrata, che dopo essere stati controllati (virus e spam) vengono smistati al vero server SMTP locale. In questo modo si evita (per quanto possibile) che arrivino email con codice malevolo o milioni di email di spam nel server locale, usando come Mail Hub un server esterno.

Inoltre il server locale (dove si trovano le email ricevute prima che gli utenti le scarichino col loro client di posta) non puo' essere raggiunto dall'esterno (perche' tra l'esterno e il server locale c'e' il Mail Hub) e questo costituisce un ulteriore elemento di protezione.

Riprendo l'orribile figura 1 aggiungendo il Mail Hub:

Rappresentazione grafica del percorso di un messaggio di posta elettronica col mail hub
Figura 2. Rappresentazione grafica
del percorso di un messaggio di posta elettronica col mail hub.

1) il client di posta si occupa di collegare l'utente (voi) al MTA (Mail Transfer Agent). L'MTA e' il server di posta locale che si occupa di mandare effettivamente il messaggio in internet. Puo' dunque capitare che il nostro MUA ci dica che il messaggio e' stato inviato, mentre il MTA per qualche motivo invece non riesca a inviarlo;
2) ora che l'MTA locale ha ricevuto l'email dal nostro client lo mandera' all'MTA del destinatario. Dunque deve prima di tutto capire a quale MTA remoto mandarlo. Una volta spedito all'MTA giusto, il suo compito e' finito;
3) l'MTA che ha ricevuto l'email e' un Mail Hub, una volta effettuato il controllo antivirus e antispam sull'email, questa vine inviata all'MTA.
4) adesso che l'MTA remoto ha ricevuto l'email, deve spedirla all'utente destinatario.
In questo momento quando il destinatario aprira' il suo client di posta ci trovera' il nostro messaggio di posta.

Di solito nel server DNS vengono indicati piu' record MX, per evitare che in caso di crash o malfunzionamenti vari del server di posta primario si perdano email. Vengono dunque indicati dei server di posta secondari, dando un ordine (priorita') a ognuno con un multiplo di 10 (10 per il server principale, 20 per il secondo, 30 per il terzo, ecc.). Se il server primario (mail.provincia.it) e' occupato, non risponde, e' andato a fuoco, ecc. l'email verra' mandata al secondo server (mail2.provincia.it), se anche questo e' irraggiungibile l'email verra' mandata al terzo server (mail3.provincia.it) e cosi' via, fino a trovare un server in grado di ricevere l'email (o finche' non finiscono i server indicati).

Perche' ricordate, alla sfiga non c'e' limite, ma se non cercate di evitarla e' peggio.

Configurazione

Dopo aver visto un po' di teoria, veniamo alla pratica. Configuriamo i programmi necessari alla ricezione e invio di posta elettronica. Principalmente si tratta della configurazione di Mutt e Fetchmail per ricevere e spedire email. Ipotizziamo che io mi chiami Tullo Ostilio e abbia tre indirizzi email, uno su Tiscali e uno su un generico sito.ext (POP3) il terzo su GMail (IMAP).

Un minimo di conoscenza del funzionamento delle email non guasterebbe (rimando a quanto scritto sopra), comunque sappiamo almeno che il server POP (e IMAP in alcuni casi) viene utilizzato per ricevere la posta, mentre il server SMTP viene usato per inviare la posta. Dobbiamo inoltre conoscere il valore da inserire per POP3 e SMTP.

Prima di tutto tenete a portata di mano i dati che vi serviranno, che sono: username; password; server in entrata, che sia POP o IMAP (come nel caso di GMail); server in uscita (SMTP).

Questi sono i dati:
- tullio.o@tiscali.it (Username: tullio.o; Password: TullioS)
- cinico@sito.ext (Username: cinico; Password: Brabalonga)
- ostiliotullio@gmail.com (Username: ostiliotullio; Password: OstilioTU)
le password sono adatte per farsi rubare le email.

Nell'esempio avendo Tiscali, in POP3 andra' pop.tiscali.it e in SMTP smtp.tiscali.it. Per GMail se volete utilizzare il protocollo POP3 seguite prima le istruzioni indicate in questa pagina.

Vediamo la configurazione di Fetchmail e Mutt (Fetchmail scarica la posta, Mutt la legge).

Fetchmail

La situazione e' la seguente: diversi account con i quali ricevere e inviare posta elettronica, le email ricevute da ciascun account saranno da suddividere nei rispettivi folder. In piu' vi sono altri account con i quali esclusivamente ricevere email, da smistare in un folder comune.

Cominciamo a installare l'occorrente (per Debian GNU/Linux):
apt-get install fetchmail procmail mutt mutt-patched
L'ultimo non e' necessario, ma e' utile per navigare tra i folder.

Creiamo il file di configurazione per Fetchmail nella nostra home (l'utente e' tullio):
touch ~/.fetchmailrc
e apriamolo con un editor (ad esempio nano):
nano ~/.fetchmailrc
Al suo interno dobbiamo scrivere i dati dei nostri account, le opzioni di ricezione e l'indicazione del programma che dovra' smistare le nostre email (nel nostro caso Procmail).

Per ciascun account POP3 dovremo scrivere (mettendo i giusti dati):

poll pop.tiscali.it timeout 60 with proto POP3
	user "tullio.o@tiscali.it" there
	with password 'TullioS'
	options keep

	mda '/usr/bin/procmail -d %T'

poll mail.sito.ext timeout 60 with proto POP3
	user "cinico" there
	with password 'Brabalonga'

	mda '/usr/bin/procmail -d %T'

L'opzione keep fa si che scaricando la posta venga mantenuta una copia sul server.

Se volete utilizzare il protocollo POP3 anche con l'account GMail allora aggiungete anche (notate l'opzione SSL):

poll pop.gmail.com timeout 60 with proto POP3
	user "ostiliotullio@gmail.com" there
	with password 'OstilioTU'
	options keep ssl

	mda '/usr/bin/procmail -d %T'

Se dovessero servire i certificati per GMail volendo potete fare cosi':
cd ~
mkdir .certs
openssl s_client -connect pop.gmail.com:995 -showcerts
vi uscira' un bel po' di roba scritta, ma a noi interessano solo i due certificati:

-----BEGIN CERTIFICATE-----
CERTIFICATO
-----END CERTIFICATE-----

dunque copiate il primo (tutto, compreso la prima e ultima riga) e incollatelo in:
nano .certs/gmail.pem
il secondo copiatelo e incollatelo qui:
nano .certs/equifax.pem
Adesso facciamoli riconoscere e verifichiamoli:
c_rehash ~/.certs/
openssl s_client -connect pop.gmail.com:995 -CApath ~/.certs/
A questo punto nel file di configurazione di fetchmail al posto di quanto scritto prima (per la parte riguardante GMail) dovremo scrivere:

poll pop.gmail.com with proto POP3
	user 'ostiliotullio@gmail.com' with password 'OstilioTU' is 'tullio' here
	options keep ssl sslcertck sslcertpath '/home/tullio/.certs/'

Qualunque procedura abbiate seguito dobbiamo ora dare i giusti permessi al file .fetchmailrc:
chmod 600 .fetchmailrc
Adesso scarichiamo la posta col comando:
fetchmail
ci sono anche varie opzioni, ad esempio se volete attivare il demone di fetchmail e fargli scaricare la posta ogni ora (3600 secondi) diamo questo comando:
fetchmail -d 3600
per far si che la posta venga scaricata ma ne rimanga una copia sul server date il comando:
fetchmail -k
per scaricare la posta ancora presente nel server anche se gia' scaricata precedentemente:
fetchmail -a
Scrivete:
man fetchmail
per conoscere le altre opzioni.
Possiamo anche utilizzare cron per automatizzare il tutto.

Dopo aver finito di riportare i dati sul file .fetchmailrc, diamogli i permessi per evitare che altri utenti vi accedano:
chmod 600 .fetchmailrc
e passiamo a Procmail.

Procmail

Come passo preliminare andiamo a crearci tutte le directory necessarie all'interno della nostra directory "Mail" (presente nella home dell'utente.
Il formato "maildir" per Mutt richiede che le directory contengano tre sottodirectory: cur, new e tmp. Da terminale dunque diamo questi comandi:
mkdir -p ~/Mail/{Inbox,Sent,Drafts,Spam,Trash,Tulliouno,Canediunfilosofo}/{cur,new,tmp}
Ora possiamo creare il nostro file di configurazione di Procmail:
touch ~/.procmailrc
apriamolo con un editor:
nano ~/.procmailrc
e scriviamoci le istruzioni che ci servono:

PATH=$HOME:/usr/bin:/usr/local/bin:.

MAILDIR=$HOME/Mail
DEFAULT=/var/spool/mail/utente
LOGFILE=$MAILDIR/.from
LOCKFILE=$HOME/.lockmail
VERBOSE=off
FORMAIL=/usr/bin/formail
NL="
"

#trova duplicati usando formail
:0 Whc: .msgid.lock
| $FORMAIL -D 16384 .msgid.cache

:0 a
$MAILDIR/duplicates

#mittenti amici
:0
* ^From:.*(antistene\@sito.ext)
$MAILDIR/friends

#mittenti nemici
:0
* ^From:.*(anco.marzio\@sito.ext)
/dev/null

#spam
:0
* ^Subject:.*(credit|cash|money|debt|sex|sale|loan)
$MAILDIR/spam

#niente mail in HTML
:0
* ^Content-Type:.*html
$MAILDIR/junk

#mailing list Debian
:0
* ^List-Id:.*debian-user
debian-user

:0
* ^List-Id:.*debian-dev
debian-dev

:0
* ^List-Id:.*debian-announce
debian-announce

:0
* ^From:.*debian.org
debian

#dividi per destinatario

:0
* ^TO_.*tullio.o@tiscali.it
Tulliouno/new

:0
* ^TO_.*cinico@sito.ext
Canediunfilosofo/new

:0
* ^TO_.*@gmail.com
Tulliotre/new


#per tutto il resto c'e' Inbox

:0
* .*
Inbox/new

Salviamo anche questo.

Forward

Per evitare problemi con Procmail creiamo questo file:
touch ~/.forward
e scriviamoci dentro:

"| IFS=' ' && p=/usr/bin/procmail && test -f $p && exec $p -Yf- || exit 75 #utente"

IMAP

Nel caso di account con protocollo IMAP, anziche' utilizzare Fetchmail possiamo usare due programmi a parte, uno per ricevere e uno per inviare email, sono OfflineIMAP e Msmtp.
Installiamoli:
apt-get install offlineimap msmtp
e configuriamoli.

OfflineIMAP

E' possibile utilizzare Fetchmail anche per il protocollo IMAP, ma OfflineIMAP essendo fatto apposta per questo e' piu' efficente.
Creiamo anche in questo caso il file di configurazione:
touch ~/.offlineimaprc
apriamolo con un editor:
nano ~/.offlineimaprc
e scriviamoci le istruzioni che ci servono:

[general]
ui = ttyui
accounts = Gmail

[Account Gmail]
localrepository = Gmail-Local
remoterepository = Gmail-Remote

[Repository Gmail-Local]
type = Maildir
localfolders = ~/Mail/Gmail

[Repository Gmail-Remote]
type = Gmail
remoteuser = ostiliotullio@gmail.com
remotepass = OstilioTU
realdelete = no
maxconnections = 3
sslcacertfile = /etc/ssl/certs/ca-certificates.crt

Msmtp

Creiamo il file di configurazione:
touch ~/.msmtprc
apriamolo con un editor:
nano ~/.msmtprc
e inseriamoci i dati:

account default
host smtp.gmail.com
port 587
protocol smtp
auth on
from ostiliotullio@gmail.com
user ostiliotullio@gmail.com
password OstilioTU
tls on
tls_nocertcheck

Mutt

Adesso vediamo come utilizzare Mutt, un programma leggero e potente che usiamo semplicemente dal terminale. Ovviamente meglio leggersi una guida ben fatta, qui espongo solo parzialmente e superficialmente alcuni punti.
Avviando per la prima volta Mutt, questo creera' la directory Mail nella nostra home. Ora dobbiamo modificare (o creare) il file di configurazione di mutt. Prima pero', per far si che Mutt gestisca piu' di un account, creiamo dei file per ciascun account nella sotto-directory "accounts" della directory ".mutt" nella home utente:
touch ~/.mutt/accounts/tulliouno
apriamolo con un editor:
nano ~/.mutt/accounts/tulliouno
e inseriamoci i dati:

#Per far si che Mutt non metta
#'username@localhost.localdomain nel From
set from="tullio.o@tiscali.it"
set use_from=yes
set envelope_from="yes"
set mbox="$HOME/Mail/Tulliouno"
set postponed="$HOME/Mail/Tulliouno/drafts"

# Cambiamo i colori di Mutt per distinguere
# immediatamente tra i vari account
# in questo caso testo nero su sfondo rosso
color status black red

# Il mio indirizzo email
set pop_user="tullio.o@tiscali.it"
set pop_host="pop.tiscali.it"

# La password del mio account email
set pop_pass="TullioS"

# Il nome che voglio appaia
# quando invio email
set realname = "Tullio Ostilio"
# I dati per l'invio della posta (attenti alla porta)
set smtp_url = "smtp://tullio.o:TullioS@smtp.tiscali.it:25"

## Hook -- IMPORTANTE!
## aggancia l'account al folder settato all'inizio
account-hook $folder "set pop_user=tullio.o@tiscali.it pop_pass=TullioS"

Facciamo lo stesso anche per l'account su sito.ext:

touch ~/.mutt/accounts/canediunfilosofo
apriamolo con un editor:
nano ~/.mutt/accounts/canediunfilosofo
e inseriamoci i dati:
#Per far si che Mutt non metta
#'username@localhost.localdomain nel From
set from="cinico@sito.ext"
set use_from=yes
set envelope_from="yes"
set mbox="$HOME/Mail/Canediunfilosofo"
set postponed="$HOME/Mail/Canediunfilosofo/drafts"

# Cambiamo i colori di Mutt per distinguere
# immediatamente tra i vari account
# in questo caso testo verde su sfondo giallo
color status green yellow

# Il mio indirizzo email
set pop_user="cinico@sito.ext"
# In questo caso il il server POP e' mail.sito.ext
set pop_host="mail.sito.ext"

# La password del mio account email
set pop_pass="Brabalonga"

# Il nome che voglio appaia
# quando invio email
set realname = "Diogene di Sinope (il Cinico)"
# I dati per l'invio della posta (attenti alla porta)
set smtp_url = "smtp://cinico:Brabalonga@smtp.sito.ext:25"
# Se volessimo usare la codifica SSL cambiamo la porta e scriviamo smtps anziché smtp
# set smtp_url = "smtps://cinico:Brabalonga@smtp.sito.ext:465"

## Hook -- IMPORTANTE!
## aggancia l'account al folder settato all'inizio
account-hook $folder "set pop_user=cinico@sito.ext pop_pass=Brabalonga"

Nel caso dell'account Gmail (con protocollo IMAP):

touch ~/.mutt/accounts/tulliogmail
apriamolo con un editor:
nano ~/.mutt/accounts/tulliogmail
e inseriamoci i dati:
#Per far si che Mutt non metta
#'username@localhost.localdomain nel From
set from="ostiliotullio@gmail.com"
set mail_check = 0

# Impostiamo secondo Gmail
set envelope_from
unset move
set delete
unset confirmappend
set quit
unset mark_old
set sort     = threads
set sort_aux = reverse-last-date-received
set sort_re
set pager_index_lines = 8
set pager_context     = 5
set pager_stop
set menu_scroll
set smart_wrap
set tilde
unset markers
set fcc_attach
unset mime_forward
set forward_format = "Fwd: %s"
set include
set forward_quote

ignore *
unignore from: to: cc: date: subject:
hdr_order from: to: cc: date: subject:

set mbox_type   = Maildir
#Invia le email con Msmtp
set sendmail    = /usr/bin/msmtp

set folder      = ~/Mail
set spoolfile   = "+INBOX"
set mbox        = "+[Gmail]/All Mail"
set postponed   = "+[Gmail]/Drafts"
unset record

mailboxes +INBOX

# Cambiamo i colori di Mutt per distinguere
# immediatamente tra i vari account
color status green blue

# Il nome che voglio appaia
# quando invio email
set realname = "Tullio Ostilio"

## Hook -- IMPORTANTE!
account-hook $folder "set imap_user=ostiliotullio@gmail.com imap_pass=OstilioTU"

.muttrc

Adesso il file principale di configurazione di Mutt. La configurazione di Mutt non e' semplice, guardate un esempio di file .muttrc bello grande o questa pagina con esempi anche per alias e altro.
Noi ci accontentiamo di meno, dunque:
touch ~/.muttrc
apriamolo con un editor:
nano ~/.muttrc
e inseriamoci:

# Indichiamo a Mutt il tipo di MBOX da usare,
# in quale directory si trova
# e dove mettere le email inviate e da inviare in seguito
set mbox_type=maildir
set mbox="$HOME/Mail/mbox"
set folder="$HOME/Mail"
set record="$HOME/Mail/sent"
set postponed="$HOME/Mail/postponed"

# Ora indichiamo i vari folder
mailboxes = "$HOME/Mail/Tulliouno"
mailboxes = "$HOME/Mail/Canediunfilosofo"
# Uno dei due il primo se usiamo POP3 il secondo se usiamo IMAP
mailboxes = "$HOME/Mail/Tulliogmail"
mailboxes = "$HOME/Mail/Gmail"

# Questo e' il folder delle email di un
# client di posta come ad esempio Sylpheed
mailboxes = "$HOME/Mail/inbox"

mailboxes = "$HOME/Mail/sent"
mailboxes = "$HOME/Mail/draft"
mailboxes = "$HOME/Mail/junk"
mailboxes = "$HOME/Mail/queue"
mailboxes = "$HOME/Mail/duplicates"
mailboxes = "$HOME/Mail/trash"
mailboxes = "$HOME/Mail/postponed"

#Facciamo vedere i folder personali a Mutt
mailboxes `echo $HOME/Mail/Tulliouno`
mailboxes `echo $HOME/Mail/Canediunfilosofo`
# Uno dei due il primo se usiamo POP3 il secondo se usiamo IMAP
mailboxes `echo $HOME/Mail/Tulliogmail`
mailboxes `echo $HOME/Mail/Gmail`
#Diciamo a Mutt di guardare in tutte le
#subdirectory create da Sylpheed
mailboxes `echo $HOME/Mail/inbox/*`
mailboxes $HOME/Mail/mbox

# Troppi headers, riducili
ignore *
unignore From To Cc Subject Date Organization X-Mailer User-Agent

#e mettili in ordine
unhdr_order *
hdr_order From: To: Cc: Date: Subject:

#Quando ti dico di cancellare un'email non chiedermi se voglio farlo
set delete=yes

#Account di default da scegliere tra quelli creati
source ~/.mutt/accounts/tulliouno

#Tasti di scelta rapida per passare da un folder all'altro
#e di conseguenza da un account all'altro, in questo caso i tasti FN da 4 a 7.
macro index,pager <f4> '<enter-command>source ~/.muttrc<enter><change-folder> =inbox<enter>'
macro index,pager <f5> '<enter-command>source ~/.mutt/accounts/tulliouno<enter><change-folder> =Tulliouno<enter>'
macro index,pager <f6> '<enter-command>source ~/.mutt/accounts/canediunfilosofo<enter><change-folder> =Canediunfilosofo<enter>'
macro index,pager <f7> '<enter-command>source ~/.mutt/accounts/tulliogmail<enter><change-folder> =Gmail<enter>'

#Gli hook dei folder che collegano il folder all'account
folder-hook Tulliouno/* source ~/.mutt/accounts/tulliouno
folder-hook Canediunfilosofo/* source ~/.mutt/accounts/canediunfilosofo
# Se per GMail usiamo POP3
folder-hook Tulliogmail/*     source ~/.mutt/accounts/tulliogmail
folder-hook Tulliogmail/*     source ~/.mutt/accounts/tulliogmail

send-hook "tullio\.o\@tiscali\.it" "source ~/.mutt/accounts/tulliouno"
reply-hook "tullio\.o\@tiscali\.it" "source ~/.mutt/accounts/tulliouno"
send-hook "cinico\@sito\.ext" "source ~/.mutt/accounts/canediunfilosofo"
reply-hook "cinico\@sito\.ext" "source ~/.mutt/accounts/canediunfilosofo"
# Se per GMail usiamo POP3
send-hook "ostiliotullio\@gmail\.com" "source ~/.mutt/accounts/tulliogmail"
reply-hook "ostiliotullio\@gmail\.com" "source ~/.mutt/accounts/tulliogmail"

# Imposta mutt per avviare fetchmail alla pressione della lettera G
macro index    G "!fetchmail\n"   "Invoke fetchmail"
macro pager    G "!fetchmail\n"   "Invoke fetchmail"


## File configurazione per apertura allegati
set mailcap_path=~/.mutt/mailcap
auto_view text/html

# File configurazione alias
set alias_file=$HOME/.mutt/mail_aliases
source $HOME/.mutt/mail_aliases

# Impostazioni della sidebar di Mutt
# Ctrl+p (precedente), Ctrl+n (successiva), Ctrl+o (entra).
# B rendi visibile/invisibile la sidebar di Mutt.
bind index,pager \CP sidebar-prev
bind index,pager \CN sidebar-next
bind index,pager \CO sidebar-open
macro index,pager B '<enter-command>toggle sidebar_visible<enter>'
color sidebar_new yellow default

mailcap

Creiamo il file mailcap nella directory .mutt:
touch ~/.mutt/mailcap
apriamolo con un editor:
nano ~/.mutt/mailcap
e decidiamo con quali programmi aprire i diversi file che potremo ricevere come allegati:

text/html; echo && /usr/bin/w3m %s; nametemplate=%s.html; copiousoutput
application/pdf; /usr/bin/xpdf %s
image/jpg; /usr/bin/display %s
image/gif; /usr/bin/display %s
image/jpeg; /usr/bin/display %s
image/png; /usr/bin/display %s
application/vnd.ms-powerpoint; libreoffice %s
application/x-mspowerpoint; libreoffice %s
application/ppt; libreoffice %s
application/excel; libreoffice %s
application/msexcel; libreoffice %s
application/vnd.ms-excel; libreoffice %s
application/x-excel; libreoffice %s
application/x-msexcel; libreoffice %s
application/ms-Excel; libreoffice %s
application/msword; libreoffice %s
application/vnd.msword; libreoffice %s

Questi sono quelli che mi vengono in mente, se pensate di ricevere altri allegati metteteli nell'elenco.

mail_aliases

Per non stare ogni volta a inserire l'indirizzo email completo del destinatario possiamo creare gli alias. Creiamo il file mail_aliases nella directory .mutt:
touch ~/.mutt/mail_aliases
apriamolo con un editor:
nano ~/.mutt/mail_aliases
e scriviamo gli alias con i quali richiamare in modo veloce gli indirizzi email che vogliamo con Mutt:

alias Tizio Tiberio Gracco <tiberiogracco@email.ext>
alias Caio Caio Gracco <fratellogracco@mail.ext>
alias Sempronio Sempronio Gracco <babbogracco@servermail.ext>
alias alex Alessandro Magno <alex@magno.ext>
alias botti Botti e Botti <venditoredibotti@bottiebotti.ext>

e cosi' via. Oltre a inserire direttamente gli alias nel file apposito, possiamo inserirli tramite Mutt, aprendo un'email speditaci da qualcuno che vogliamo mettere tra gli alias, premiamo il tasto a (poi parte una procedura automatica molto intuitiva).
In questo modo quando vorremo spedire un'email a qualcuno di cui abbiamo l'alias, nel campo To: anziche' inserire il suo indirizzo email potremo scrivere il suo alias (ad esempio alex e/o botti, ecc.) o premendo il tasto Tab ⇆ selezioniamo l'alias o gli alias dando ↵ Invio e premendo il tasto q per completare la procedura di immissione dei/del destinatari/o.

Tema

Se non vi dovesse piacere il colore di Mutt sul terminale, potete configurare il suo aspetto, mettendo i colori che volete o scaricarvi e copiare una configurazione grafica gia' pronta, aprite il file di configurazione di mutt:
nano ~/.muttrc

## Colori impostati per un background bianco


color normal            black           default

color hdrdefault        red             default
color signature         blue            default
color indicator         white           black
color error             brightred       default
color status            white           black
color tree              red             default
color tilde             magenta         default
color message           blue            default
color markers           cyan            default
color attachment        brightmagenta   default
color search            black           green
color quoted            blue            default
color quoted1           magenta         default
color quoted2           red             default
color quoted3           green           default
color quoted4           cyan            default
color quoted5           blue            default
color quoted6           magenta         default
color quoted7           red             default
color quoted8           green           default
color quoted9           cyan            default
color underline         brightgreen     default
color index             green           default ~F

color header            red             default ^(From|Subject):
# url
color body              black           default "((ftp|http|https)://|(file|news):|www\\.)[-a-z0-9_.:]*[a-z0-9](/[^][{} \t\n\r\"<>()]*[^][{} \t\n\r\"<>().,:!])?/?"
color body              cyan            default [-a-z_0-9.]+@[-a-z_0-9.]+    # e-mail addresses

# faccine
color body brightgreen default "<[Gg]>"
color body brightgreen default "<[Bb][Gg]>"
color body brightgreen default ">?[;:][-^]?[][)(><}{|/DP][)}]*"

# 
color body magenta default "\\* [^<]+ <[^>]+> \\[[^]]+\\]:"
color body magenta default "(^|[^[:alnum:]])on [a-z0-9 ,]+( at [a-z0-9:,. +-]+)? wrote:"

# URL
color body blue default "([a-z][a-z0-9+-]*://(((([a-z0-9_.!~*'();:&=+$,-]|%[0-9a-f][0-9a-f])*@)?((([a-z0-9]([a-z0-9-]*[a-z0-9])?)\\.)*([a-z]([a-z0-9-]*[a-z0-9])?)\\.?|[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+)(:[0-9]+)?)|([a-z0-9_.!~*'()$,;:@&=+-]|%[0-9a-f][0-9a-f])+)(/([a-z0-9_.!~*'():@&=+$,-]|%[0-9a-f][0-9a-f])*(;([a-z0-9_.!~*'():@&=+$,-]|%[0-9a-f][0-9a-f])*)*(/([a-z0-9_.!~*'():@&=+$,-]|%[0-9a-f][0-9a-f])*(;([a-z0-9_.!~*'():@&=+$,-]|%[0-9a-f][0-9a-f])*)*)*)?(\\?([a-z0-9_.!~*'();/?:@&=+$,-]|%[0-9a-f][0-9a-f])*)?(#([a-z0-9_.!~*'();/?:@&=+$,-]|%[0-9a-f][0-9a-f])*)?|(www|ftp)\\.(([a-z0-9]([a-z0-9-]*[a-z0-9])?)\\.)*([a-z]([a-z0-9-]*[a-z0-9])?)\\.?(:[0-9]+)?(/([-a-z0-9_.!~*'():@&=+$,]|%[0-9a-f][0-9a-f])*(;([-a-z0-9_.!~*'():@&=+$,]|%[0-9a-f][0-9a-f])*)*(/([-a-z0-9_.!~*'():@&=+$,]|%[0-9a-f][0-9a-f])*(;([-a-z0-9_.!~*'():@&=+$,]|%[0-9a-f][0-9a-f])*)*)*)?(\\?([-a-z0-9_.!~*'();/?:@&=+$,]|%[0-9a-f][0-9a-f])*)?(#([-a-z0-9_.!~*'();/?:@&=+$,]|%[0-9a-f][0-9a-f])*)?)[^].,:;!)? \t\r\n<>\"]"

# indirizzi email
color body brightmagenta default "((@(([0-9a-z-]+\\.)*[0-9a-z-]+\\.?|#[0-9]+|\\[[0-9]?[0-9]?[0-9]\\.[0-9]?[0-9]?[0-9]\\.[0-9]?[0-9]?[0-9]\\.[0-9]?[0-9]?[0-9]\\]),)*@(([0-9a-z-]+\\.)*[0-9a-z-]+\\.?|#[0-9]+|\\[[0-9]?[0-9]?[0-9]\\.[0-9]?[0-9]?[0-9]\\.[0-9]?[0-9]?[0-9]\\.[0-9]?[0-9]?[0-9]\\]):)?[0-9a-z_.+%$-]+@(([0-9a-z-]+\\.)*[0-9a-z-]+\\.?|#[0-9]+|\\[[0-2]?[0-9]?[0-9]\\.[0-2]?[0-9]?[0-9]\\.[0-2]?[0-9]?[0-9]\\.[0-2]?[0-9]?[0-9]\\])"

# Messaggi GPG
color  body            brightyellow    default "^gpg: Good signature .*"
color  body            white           default "^gpg: "
color  body            brightwhite     red     "^gpg: BAD signature from.*"
mono   body            bold                    "^gpg: Good signature"
mono   body            bold                    "^gpg: BAD signature from.*"


#  Con schermo mono

mono normal             none
mono indicator          reverse
mono tree               none
mono status             reverse
mono error              standout
mono message            none
mono quoted             bold
mono signature          none
mono attachment         underline
mono search             reverse
mono tilde              none
mono markers            bold
mono hdrdefault         none
mono bold               bold
mono underline          underline
mono header                     bold           "^(from|subject):"
mono body                       underline      "((ftp|http|https)://|(file|news):|www\\.)[-a-z0-9_.:]*[a-z0-9](/[^][{} \t\n\r\"<>()]*[^][{} \t\n\r\"<>().,:!])?/?"
mono body                       underline      "[-a-z_0-9.]+@[-a-z_0-9.]+"
mono body                       bold           "(^| )\\*[-a-z0-9äöüß*]+\\*[,.?]?[ \n]"
mono body                       underline      "(^| )_[-a-z0-9äöüß_]+_[,.?]?[ \n]"

Da cambiare a piacimento.

Utilizzare Mutt

Ora siamo pronti a mandare e leggere email con Mutt e ricevere email con Fetchmail, ma prima vediamo un'ultima cosa, GnuPG. Una volta settate le nostre chiavi GPG (vedi "GNU Privacy Guard"), se infatti le volessimo usare per firmare le nostre email, con Mutt lo possiamo fare. Se pero' abbiamo diverse chiavi private, GPG indichera' a Mutt di usare la prima della lista, che non e' detto sia quella corrispondente all'email che intendiamo usare.

La chiave GPG

Per indicare questa come chiave predefinita dobbiamo aprire il file gpg.conf contenuto nella nostra home all'interno della directory .gnupg, apriamo:
nano ~/.gnupg/gpg.conf
e cerchiamo queste righe:

# If you have more than 1 secret key in your keyring, you may want to
# uncomment the following option and set your preferred keyid.

#default-key 06FDA45D

decommentiamo (togliendo #) in modo da ottenere:

# If you have more than 1 secret key in your keyring, you may want to
# uncomment the following option and set your preferred keyid.

default-key 06FDA45D

Ovviamente al posto di 06FDA45D o quello che e' inserite l'ID della vostra chiave, per saperlo da terminale date il comando:
gpg --list-secret-keys
e cercate l'ID dell'email cinico@sito.ext.
o piu' direttamente: gpg --list-keys cinico
A questo punto possiamo passare a qualcosa di piu' complicato.

gpg.rc

Troviamo il file gpg.rc. Su Debian dovrebbe essere qui: /usr/share/doc/mutt/examples/gpg.rc. Copiamolo nella directory .mutt nella nostra home:
cp /usr/share/doc/mutt/examples/gpg.rc ~/.mutt/gpg.rc
o, nel caso non lo vogliate cercare:
cp `locate gpg.rc` ~/.mutt/gpg.rc
Indichiamo a Mutt dove andarsi a leggere il file di configurazione per criptare e firmare la posta aggiungendo nel suo file di configurazione (.muttrc questa riga:

source ~/.mutt/gpg.rc

Oppure dando da terminale questo comando:
echo "source ~/.mutt/gpg.rc" >> ~/.muttrc

Apriamo dunque con un editor di testo il file di configurazione di Mutt per GPG:
nano ~/.mutt/gpg.rc
Se abbiamo intensione di utilizzare solo una chiave, aggiungiamo o decommentiamo i seguenti comandi:

# Se abbiamo anche altri programmi di cifratura diversi da GnuPg,
# indichiamoli di usare gpg
set pgp_default_version=gpg
set pgp_use_gpg_agent = yes
# Indichiamo l'ID della nostra chiave al posto di 21371253
set pgp_sign_as = 21371253
# Cancella la passphrase dalla cache dopo 3600 secondi
set pgp_timeout = 3600
set crypt_autosign = yes
set crypt_replyencrypt = yes
# Verifica le firme senza chiedere
set pgp_verify_sig=yes

Controllate il manuale per altre impostazioni.

Assegnare la chiave

Avendo piu' account, ipotizziamo di avere una chiave gpg diversa per ciascuno. Dobbiamo dunque far capire a Mutt quale chiave usare a seconda dell'account con il quale spediamo la posta. Apriamo il file di configurazione di Mutt:
nano ~/.muttrc
e inseriamo queste righe (da modificare secondo i vostri dati):

# chiavi gpg a seconda del From
send-hook "~f pinco@pallino.it"  set pgp_sign_as=06FDA45D
# o del To
send-hook "~t cinico@sito.ext"   set pgp_sign_as=21371253
o ancora a seconda del folder:
folder-hook =Tulliouno/* set pgp_sign_as=06FDA45D
folder-hook =Canediunfilosofo/* set pgp_sign_as=21371253
folder-hook =Tulliogmail/* set pgp_sign_as=12345678

Per vedere questi ed altri hook leggete il manuale.

Altre configurazioni

Possiamo assegnare dei tasti per alcune azioni (presi da qui):

# key binds
bind compose p  pgp-menu
macro compose Y pfy "send mail without GPG"

Nell'header delle nostre email possiamo indicare dove chi le riceve puo' andarsi a prendere la nostra chiave pubblica. Prima di tutto esportiamo la nostra chiave pubblica:
gpg --output pubkey.asc --armor --export cinico@sito.ext
Mettiamola nel nostro sito (ad esempio qui: http://www.sito.ext/~cinico/pubkey.asc), apriamo il file di configurazione di Mutt:
nano ~/.muttrc
e inseriamo:

my_hdr="X-PGP-Key: http://www.sito.ext/~cinico/pubkey.asc"

Se non avessimo un sito, o non volessimo pubblicarla li, possiamo usare un keyserver:

my_hdr="X-PGP-Key: http://keys.gnupg.net/pks/lookup?op=vindex&search=cinico%40sito.ext"

Ovviamente se utilizziamo piu' account possiamo voler indicare un header diverso per ciascun account, basta inserirlo nel file di configurazione dell'account (~/.mutt/accounts/canediunfilosofo) anziche' in quello generale di Mutt (~/.muttrc)

Per verificare o decriptare un'email che abbiamo ricevuto dobbiamo scaricare la chiave pubblica del mittente:
gpg --recv-keys pinco@pallino.it
E' molto piu' comodo modificare il file di configurazione di GnuPG e dirgli di farlo in automatico. Per farlo, apriamo il file di configurazione:
nano ~/.gnupg/gpg.conf
e inseriamo queste righe:

keyserver INDIRIZZODELKEYSERVER
keyserver-options auto-key-retrieve

Al posto di INDIRIZZODELKEYSERVER inserite l'indirizzo di un keyserver, i piu' consigliati ci sono questi:

wwwkeys.pgp.net
search.keyserver.net
pgp.ai.mit.edu

Una lista la potete trovare qui.

Scaricare la posta

Adesso possiamo provare a ricevere le email, lo facciamo con Fetchmail:
fetchmail -v
Usiamo il metodo verbose per vedere se ci sono problemi e di che tipo si tratta. Nei successivi scaricamenti possiamo decidere ad esempio di scaricare anche i messaggi vecchi, quelli letti e quelli non letti (-a) lasciando pero' una copia delle email sul server (-k):
fetchmail -ak
Ci sono anche altre opzioni, date un'occhiata al manuale:
man fetchmail
un'opzione molto utile e' -l, indica i byte massimi che puo' avere un'email oltre i quali non verra' scaricata (ad esempio fetchmail -l 1000 evitera' di scaricare le email piu' grandi di 10000 bytes), utile (un tempo, ora meno con le connessioni veloci) per evitare di scaricare email con grossi allegati.
Un'altra opzione utile e' -d con la quale mandiamo fetchmail in background a scaricare la posta ogni tot secondi, ad esempio col comando:
fetchmail -d 1800
Fetchmail scarichera' la posta ogni 30 minuti. Se usiamo un lavoro di cron possiamo far scaricare la posta quando vogliamo (nei limiti delle possibilita' offerte da cron).

Leggere la posta

Ora apriamo finalmente Mutt e andiamo a leggere la posta arrivata (se ne e' arrivata) a rispondere e/o mandare email. Apriamo Mutt:
mutt
ma forse vi verra' piu' comodo usare questo comando se dovete leggere le email arrivate:
mutt -y
l'opzione -y dice a Mutt di aprirsi visualizzando subito l'elenco delle Mailbox.
Vi consiglio di leggere il manuale di Mutt per rendervi veramente conto di cio' che potete fare con il client di posta con meno bug in assoluto.

Ora che Mutt e' stato aperto possiamo leggere e rispondere alle email o scrivere un'email, il tutto utilizzando pochi tasti, cosi' da non rimpiangere l'assenza di bottoncini colorati da premere col puntatore del mouse.

Scrivere la posta

Per scrivere una nuova email premiamo il tasto m, in basso apparira' la scritta To:, scriviamo l'email del destinatario.
To: venditabotti@bottiebotti.ext
e premiamo ↵ Invio, ci chiedera' l'oggetto:

Subject: Richiesta invio nuova botte

e ripremiamo ↵ Invio. A questo punto si aprira' il nostro editor di default (ad esempio nano). Scriviamo il testo della nostra email, al termine salviamo con 【Ctrl o】 e chiudiamo nano 【Ctrl x】.
Controlliamo sia tutto giusto, nel caso apportiamo le correzioni o aggiunte necessarie, come ad esempio aggiungere un allegato (premete il tasto a), aggiungere uno o piu' destinatari in Cc (premendo il tasto c), o in Ccn, in inglese Bcc (premete il tasto b), salvare il messaggio per mandarlo in seguito (premendo il P). Oppure aprire le opzioni PGP (col tasto p) cosi' da criptare l'email (tasto e) o firmarla (tasto s). In questo caso meglio allegare la nostra chiave pubblica, lo facciamo tenendo premuto il tasto Esc e premendo il tasto k, inseriamo l'ID della nostra chiave ed ecco fatto.
Ora non ci resta che inviare l'email al destinatario (o ai destinatari) premendo il tasto y.

Rispondere alla posta

Se avessimo ricevuto un'email (per scaricarla usiamo Fetchmail (come abbiamo visto sopra), se non l'avete messo a lavorare in automatico con cron o con l'opzione demone) apriamo Mutt (con l'opzione -y che abbiamo visto sopra), spostiamoci con i tasti freccia nella Mailbox desiderata, premiamo ↵ Invio e leggiamo l'email. Ricordate che per leggere la pagina successiva dell'email, nel caso fosse lunga, dovete premere la barra spaziatrice, premete invece - (tasto meno) per salire di pagina.

From: "Alessandro Magno" <alex@magno.ext>
To: "Diogene di Sinope (il Cinico)" <cinico@sito.ext>

Chiedimi quel che vuoi.

Se non avete aperto mutt con l'opzione -y, spostarvi nelle Mailbox e' molto semplice, premete il tasto c, ora premete il tasto ? e scegliete la Mailbox che desiderate.
Una volta letta l'email, rispondiamo premendo il tasto r, decidiamo se includere o meno il messaggio nella risposta e scriviamo il nostro messaggio (con l'editor di default).

From: "Diogene di Sinope (il Cinico)" <cinico@sito.ext>
To: "Alessandro Magno" <alex@magno.ext>

Lasciami il mio sole

Infine premiamo il tasto y per inviare la risposta. A questo punto possiamo cancellare l'email di Alessandro (col tasto d) o spostarla in un'altra Mailbox, per farlo dobbiamo salvarla (s) scegliendo la Mailbox in cui metterla col tasto Tab ⇆. Poi usciamo (col tasto i e poi q.

Vediamo ora alcuni settaggi del file di configurazione di Mutt che possono rivelarsi utili, prima di tutto potremmo voler cambiare l'editor, per farlo inseriamo (o modifichiamo se c'e' gia') questa riga:

set editor="emacs -nw"

Cosi' l'editor sara' emacs nella sua versione senza interfaccia grafica. Se vogliamo possiamo anche usare emacs per controllare l'ortografia della nostra email, basta aprire il file di configurazione di emacs (posizionandoci come sempre nella nostra home):
nano .emacs
e inserire questo:

;; Dizionario italiano aspell-it
(setq ispell-dictionary "italiano")

Ovviamente dobbiamo aver installato aspell col suo pacchetto della lingua italiana aspell-it.
Se vogliamo mettere una "firma" (una frasetta di una o piu' righe) alla fine di ogni nostra email, creiamo il file apposito:
nano .signature.mutt
e scriviamoci quello che vogliamo, ad esempio:

Durante un banchetto
gli gettarono degli ossi,
come a un cane.
         Diogene, andandosene,
         pisciò loro addosso,
         come un cane.

mail to: cinico@sito.ext
website: http://www.sito.ext

Ora nel file di configurazione di Mutt inseriamo questa riga:

set signature="~/.signature.mutt"

Volendo possiamo usare il pacchetto fortune per mettere una firma alle nostre email, basta inserire questa riga al posto di quella vista in precedenza:

set signature="fortune |"

Oppure avere sia la vecchia firma sia le frasetta presa da fortune inserendo questa riga:

set signature="cat .signature.mutt; echo; fortune |"

Come vedete e' tutto molto semplice, nonostante l'assenza di una interfaccia grafica (o forse proprio per questo) vi accorgerete che leggere, scrivere e spedire email con Mutt e' un'esperienza pacifica e in grado di darvi una certa serenita' interiore. Inoltre Mutt usa i formati standard (mbox, maildir e mh) che rendono semplice esportare le email nei piu' gettonati programmi ad interfaccia grafica con tanti bug. Interfaccia grafica che costituisce solo un piacere fisico superfluo, se userete Mutt imparerete subito ad apprezzarne la semplicita'.

Dovrebbe essere tutto. A si, dimenticavo. Leggete i manuali:
man fetchmail
man procmail
man mutt
man offlineimap
man msmtp
è tutto.

 

Questo post non e' neppure lontanamente una guida, e' solo un piccolo appunto, ecco infatti un bell'elenco di ottime guide:

Buona lettura!


Commenti su Identi.ca.
Flattr this