Inizio Capitolo

Introduzione


Anche l'analfabetismo altrui rende difficile lo scrivere. [Stanislaw Jerzy Lec]

Scrivere e inviare una mail


I passi essenziali

Mutt consente di inviare una mail con pochi passaggi. Vediamoli.

1. Premiamo m (mail to:) per iniziare la composizione di un nuovo messaggio.

2. Mutt ci chiede in successione e noi inseriamo:
	l'indirizzo del destinatario (dopodichè premiamo invio),
	il soggetto del messaggio (poi invio).
		
3. Nell'editor aperto da Mutt scriviamo il testo del messaggio.

4. Usciamo dall'editor (salvando).

Mutt ci porta al compose menu.

5. Premiamo y per spedire il messaggio.

Semplice e veloce!

Oltre che creare e inviare un messaggio ex novo, possiamo selezionare un messaggio ricevuto e:

premendo r (reply)		rispondere al mittente

premendo g (group-reply)	rispondere al mittente e agli altri destinatari

premendo f (forward)		inoltrare il messaggio ad altri destinatari

premendo b (bounce)		rimbalzarlo, così come arrivato, ad altri destinatari

La differenza tra forward e bouncing di un messaggio è semplice:

Con reply o group-reply, Mutt utilizza come primo destinatario (per capirsi, quello dell'header To:) l'indirizzo contenuto nell'header From: del messaggio risposto.

Tuttavia, qualora il messaggio risposto abbia un header Reply-To: valorizzato, Mutt ci chiede, di default, quale indirizzo vogliamo utilizzare tra quello contenuto nell'header Reply-To: e quello dell'header From:. Va detto che gran parte dei client di posta adotta automaticamente come primo destinatario l'indirizzo contenuto nel Reply-To:, senza lasciare possibilità di scelta.

Per questo dobbiamo settare la variabile reply_to.

# chiede se si vuole usare l'header 'Reply-To:' del messaggio originale
# quando si replica ad un messaggio (ask-yes, ask-no, yes, no)
# rispondendo no Mutt utilizza l'indirizzo dell'header From:
# valore di default = ask-yes

set reply_to = ask-yes

Anche noi possiamo fare in modo che i nostri messaggi, quando spediti, contengano l'header Reply-To:. Di norma è utile valorizzarlo quando il mittente vuole suggerire al rispondente un diverso indirizzo dove gradisce ricevere risposta. Più avanti in questo capitolo, vedremo diversi modi per editare gli header e per impostarli automaticamente.


TIP: Come specificare anche destinatari in Cc e Bcc (copia conoscenza e copia conoscenza nascosta).

Abbiamo 3 modi (melius abundare quam deficere).

La prima modalità, a mio avviso la più semplice, è fare in modo che Mutt ce lo chieda!
Per questo dobbiamo settare le variabili askcc e askbcc, come dall'esempio tratto dal mio .muttrc:

# se settato a yes Mutt chiede se si vuole inserire un destinatario Cc
# valore di default: no

set askcc = yes

# se settato a yes Mutt chiede se si vuole inserire un destinatario Bcc
# valore di default: no

set askbcc = yes

La seconda modalità è di rendere editabili gli header del messaggio all'interno dell'editor con cui componiamo il testo.
Per questo dobbiamo impostare la variabile edit_headers, come possiamo vedere dall'esempio:

# se settato a yes, Mutt consente di editare gli header
# del messaggio in spedizione (oltre al body)
# valore di default: no

set edit_headers = yes

La terza modalità è di specificare (o correggere, se già inseriti) i destinatari Cc e Bcc quando siamo nel compose menu.

Nel compose menu possiamo infatti editare diversi campi dell'header:
il campo Cc:		premendo c

il campo Bcc:		premendo b

Inoltre:
il campo To: premendo t il campo From: premendo Esc f il campo Reply-To: premendo r il campo Subject: premendo s

Le tre modalità non sono alternative!


TIP: Come specificare l'editor da utilizzare per la composizione.

Mutt ci lascia liberi di utilizzare l'editor preferito per scrivere i nostri messaggi.
Per questo dobbiamo settare la variabile editor, così come possiamo vedere dall'estratto del mio .muttrc:

# Ponendo set editor=$EDITOR l'editor sarebbe preso da .bash_profile,
# altri esempi:
# setup per vim: set editor = "vim -c 'set nobackup' -c '/^$/+1'"
# setup per joe: set editor = "jstar '+14'"
# set editor = "xjed %s -g14"
# set editor = "jed %s -g 14" all'apertura il cursore va a riga 14
# set editor = "jed %s -f eob" all'apertura il cursore va a fine buffer
# set editor = "jed %s -s -- " all'apertura il cursore si posiziona su "-- "
# apre jed in mail_mode e posiziona il cursore sulla prima stringa "-- " trovata
# set editor = "jed %s -tmp -f mail_mode -s -- "
# valore di default: ""

set editor = "jed %s -tmp -f mail_mode"

Come si può notare, il mio editor of choice è Jed, scritto da John E. Davis, autore anche del newsreader Slrn.
Una buona guida a Jed è stata redatta da Guido "goccia" Gonzato.


TIP: Come rimandare l'invio di un messaggio appena scritto.

Usciti dall'editor e arrivati al compose menu, invece di premere y:
  1. Premiamo q (quit = abbandona).
  2. Rispondiamo si alla domanda "rimando a dopo questo messaggio?".

Per rispondere "si" ci basterà premere Invio, perchè il valore di default della variabile che controlla questa fase del comportamento di Mutt è ask-yes. Se preferiamo che Mutt non ci chieda conferma, dobbiamo settare la variabile postpone.
Un esempio dal mio .muttrc:

# con yes Mutt non chiede conferma dopo che abbiamo chiesto di
# salvare (nella mailbox fissata con la variabile postponed) un
# messaggio che non si vuole inviare subito
# valore di default: ask-yes

set postpone = yes

Personalmente trovo adeguato il valore di default della variabile (ask-yes). Un utilizzo "estremista" potrebbe essere quello di disabilitare completamentela la funzione dei messaggi postposti, settando a "no" il valore della variabile postpone.


Quando chiederemo a Mutt di comporre un nuovo messaggio, qualora ci siano messaggi la cui spedizione è stata rimandata, Mutt ci chiederà se vogliamo riprendere il messaggio rimandato (rispondendo si, nel caso ce ne siano più d'uno, verrà aperto il postponed menu per scegliere quale inviare).

Personalmente trovo comodo personalizzare il comportamento di Mutt e fare in modo che la risposta di default, data premendo Invio, non sia "si apri", ma sia invece "no non aprire". A tal fine, dobbiamo utilizzare la variabile recall.
Un esempio dal mio .muttrc:

# con ask-no Mutt chiede conferma che non deve richiamare un messaggio
# posposto quando se ne crea uno
# valore di default: ask-yes

set recall = ask-no

Non mi sembra utile settare invece a yes la variabile recall, perchè Mutt aprirebbe il messaggio posposto senza chiedere (questo, ovviamente, dopo che abbiamo richiesto, con m, la creazione di un nuovo messaggio).

Precisiamo che Mutt riapre sempre in editing il messaggio postposto, consentendoci di apportare ulteriori modifiche prima della spedizione.


TIP: Come tornare ad editare un messaggio appena scritto.

Usciti dall'editor e arrivati al compose menu, invece di premere y:
  1. Premiamo E (comando edit-headers).
  2. Mutt riapre l'editor consentendoci di modificare il testo del messaggio e gli headers.

Questa funzione è utile quando il messaggio va spedito subito e la correzione deve essere immediata (altrimenti potremmo usare la funzione di postponimento del messaggio).


TIP: Come visualizzare il testo di un messaggio appena scritto.

Usciti dall'editor e arrivati al compose menu, invece di premere y:
  1. Premiamo h (comando display-toggle-weed)
  2. Mutt visualizza il testo del messaggio.
  3. Premiamo i per tornare al compose menu.

Se vogliamo dare un'ultima controllatina al testo prima della spedizione, questa è la funzione che serve.


TIP: Come avviare la composizione del messaggio dal browser menu.

Di default il processo descritto ad inizio capitolo può essere avviato una volta entrati all'interno di una mailbox (il cosiddetto index menu, ove Mutt ci mostra i messaggi presenti), oppure quando stiamo visualizzando il testo di un messaggio (il cosiddetto pager).

Se vogliamo avviare la composizione anche dalla finestra che ci elenca le mailbox disponibili (il cosiddetto browser menu), possiamo ricorrere ad una semplice macro, inserita nel file di configurazione di Mutt (.muttrc).

Di seguito la macro estratta dal mio .muttrc

# macro per poter avviare la composione di una
# mail direttamente dal browser menu
# (senza dover entrare in una mailbox)

macro browser m "<return><mail>" "avvia composizione nuovo messaggio"



^top

Settare le informazioni personali

Come vogliamo che ci riconosca chi riceve il nostro messaggio email? Ovvero, quale mittente deve comparire nel campo from:? Per impostare il nostro nome e indirizzo email, settiamo la variabile from

# indica a Mutt il from da impostare nei messaggi scritti
# (viene sovrascritto da eventuali settaggi delle variabili
# my_hdr, reverse_name)
# valore di default: ""

set from = "Francesco Ciattaglia <[email protected]>"

Visto che stiamo impostando alcune variabili relative ad informazioni personali, vediamo anche come far riconoscere a Mutt che un certo messaggio è indirizzato a (o proviene da) un nostro indirizzo email (nel capitolo precedente ricordiamo che abbiamo illustrato il flag associato ad ogni messaggio che ci consente di vedere a chi è stato indirizzato). Per questo impostiamo la variabile alternates.

# indica a Mutt i propri indirizzi così da fargli gestire correttamente
# i flag assegnati ai messaggi (attraverso la funzione to_chars).
# (puo' essere un espressione regolare)
# valore di default: ""

alternates [email protected] [email protected] [email protected]
oppure (utilizzando una regexp)
alternates ^francesco\\.[email protected]\\.it$ [email protected]\\.com$ ^f\\.[email protected]\\.it$

Se usiamo Mutt in una piccola rete locale, può essere comodo inviare un messaggio di posta locale ad un utente, scrivendo nel campo To: solo il nome utente. Per fare in modo che Mutt componga l'indirizzo completo dal solo nome utente (accodandogli la chiocciola e il nome del dominio locale), possiamo settare la variabile hostname.

# dominio da accodare dopo la "@" agli indirizzi locali
# indirizzo locale = indirizzo senza la parte @dominio
# valore di default: ""

set hostname = "Ciatty.debian.home"

Mutt non spedisce direttamente la posta al server di posta del nostro provider, ma la passa al server di posta che gira sulla nostra macchina. Quest'ultimo si fa carico della effettiva spedizione del messaggio. Per indicare a Mutt il Mail Transfer Agent (di default si aspetta di interagire con sendmail) dobbiamo settare la variabile sendmail.

# path e argomenti per il programma di spedizione della posta inviata
# da Mutt. L'opzione "f" indica a sendmail/postfix di usare
# forzatamente l'indirizzo "vero" e non quello locale nella
# negoziazione della spedizione con il server di posta del provider
# (utile quando il provider consente il "transito" solo a messaggi
# il cui mittente è suo cliente, ovvero ha una mail appartenente al
# suo dominio).
# valore di default: "/usr/sbin/sendmail -oem -oi"

set sendmail = "/usr/sbin/sendmail -oi -oem [email protected]"

Dall'esempio sul settaggio della variabile sendmail, abbiamo visto che è possibile indicare al MTA, tramite il flag f, l'indirizzo email da utilizzare per negoziare la richiesta di relay del messaggio con il server del provider. Una alternativa (mutuamente esclusiva) è di non utilizzare il flag f, ma di settare a yes la variabile envelope_from. Ad esempio:

# Settando la variabile, Mutt deriva dall'header "From:" il mittente
# della "busta" contenente il messaggio da passare al MTA
# (Il mittente viene specificato da Mutt al MTA tramite il flag f)
# valore di default: "no"

set envelope_from = yes



^top

Settare gli header del messaggio

Quando spediamo un nostro messaggio potremmo voler personalizzare anche gli headers del messaggio.

Gli header sono componenti fondamentali del messaggio, alcuni creati dal programma che ha generato il messaggio, altri inseriti dai server di posta che hanno gestito, grazie agli header stessi, la sua spedizione fino al destinatario.

Gli header intestano il messaggio e forniscono molte informazioni su di esso. Approfondire un argomento come questo esula dallo scopo di questa guida, benchè sia certamente basilare per la posta elettronica. Volendo saperne di più possiamo leggere RFC822: Standard for ARPA Internet Text Messages e, tra i tanti, Reading Email Headers e How To read Email Headers.

Per definire i nostri header abbiamo a disposizione il comando my_hdr.

## H E A D E R S
#----------------------------------------------------------------------

# indicano a Mutt gli header personali da inserire nel messaggio
# creato e da spedire (quelli che personalizziamo con i send-hook
# possono essere commentati)

my_hdr From: Francesco Ciattaglia <[email protected]>
my_hdr Reply-To: Francesco Ciattaglia <[email protected]>

my_hdr X-Operating-System: "`uname -sr` - powered by Debian Sid"
my_hdr X-Uptime: `uptime`

my_hdr X-Disclaimer: Linux: dovevo conoscerti prima... AMORE !
my_hdr X-Mailer: Mutt http://www.mutt.org
my_hdr X-Editor: Jed http://space.mit.edu/%7Edavis/jed/

my_hdr X-GPG-Keyserver: http://www.keyserver.net:11371/search?q=0xC9B94521
my_hdr X-GPG-Keynumber: C9B94521
my_hdr X-GPG-Fingerprint: F820 7823 4EC6 CBF4 A971 0F8C 1D0F 3EB1 C9B9 4521

my_hdr X-URL: http://ataualpa.altervista.org
my_hdr X-Registered-Linux-User: 249410
my_hdr X-Face: `cat $HOME/.mutt.xface`



TIP: Come creare una X-Face da inserire poi tra gli headers.

A volte, "nascosta" in mezzo agli header del messaggio viaggia una piccola immagine chiamata X-Face.
Una X-Face è una icona di 48x48 pixel in bianco e nero, che può essere inserita, previa opportuna codifica, in uno speciale header del messaggio di posta (o di uno usenet post) e visualizzata da chi lo legge.
L'X-Face tipicamente (ma non necessariamente) contiene una foto di chi ha spedito il messaggio.

Nonostante sia una amenità, a me questa cosa è sempre piaciuta (anche perchè appesantisce il post o la email di soli 100-200 bytes). Se tutti inserissero una X-Face con il proprio viso ritratto e se tutti i programmi per la posta e usenet sapessero gestirla, si potrebbe "vedere in faccia" l'autore di ciò che leggiamo :-)

Spieghiamo quindi come fare per creare la nostra X-Face e inserirla in un file che poi (vedi sopra) facciamo caricare da my-hdr per valorizzare l'header X-Face:

Il metodo più rapido può essere il seguente:
Con GIMP (o programma di photo editing equivalente) riduciamo la foto
scelta come X-Face ad una dimensione di 48x48 pixel.

Convertiamo l'immagine in bianco e nero.

Salviamo l'immagine come GIF, PNG, JPEG/JPG or TIFF.

Utilizziamo l'Online X-Face Converter per creare il codice
dell'X-Face partendo dal file creato con Gimp.
Lo troviamo all'indirizzo
http://www.dairiki.org/xface/

Nel capitolo successivo, vedremo come visualizzare una X-Face contenuta in un messaggio ricevuto.



^top

Ricercare e inserire un indirizzo email contenuto nella rubrica

Domanda: dov'è la rubrica? (non posso ricordare tutti gli indirizzi a memoria!)

Mutt non ha una vera e propria rubrica, ma offre comunque un primo supporto attraverso gli alias.

Se abbiamo bisogno di associare ad un contatto altre informazioni oltre all'indirizzo email, possiamo interfacciarci con un programma esterno, come l'ottimo abook.

Vediamo entrambe le possibilità

  1. Utilizziamo gli alias come rubrica
  2. Mediante gli alias Mutt consente di associare un nick, facile da ricordare, ad un indirizzo email (o ad un gruppo di indirizzi).

    Utilizzare gli alias è immediato.
    1. Se ricordiamo il nick, lo scriviamo nei campi opportuni (To: Cc: e Bcc:)

    2. Se non lo ricordiamo, possiamo utilizzare la funzione di tab completion, che Mutt ci mette a disposizione quando siamo in un qualsiasi campo di input:
     1.	Premiamo il tasto Tab mentre siamo sui campi To:, Cc:, o Bcc:
    2. Mutt legge il file degli alias e ci mostra i nick con relativo indirizzo email associato
    3. Selezioniamo i destinatari che ci interessano, scorrendo la lista con i tasti freccia e poi confermando con Invio. Per inserire più indirizzi, selezioniamo quelli desiderati premendo t (li tagghiamo) e confermiamo sempre con Invio. (Per deselezionare un indirizzo di nuovo t!)

    Per usare gli alias dobbiamo prima averli, ovvero disporre di un file degli alias.
    Creare un file di alias è semplice. E' un file di testo che per ogni riga presenta:

    alias (spazio) il nick (spazio) il nome della persona (spazio) <l'indirizzo email>
    ad es.: alias mamma Paola Verdi <[email protected]>

    Il file degli alias può essere utilizzato anche per creare delle mailing list.
    In tal caso, la struttura della riga (attenzione sempre un alias per riga) sarà la seguente:

    alias il nick <indirizzo email>, <indirizzo email>, ...., <indirizzo email>
    ad es.: alias amici <[email protected]>, [email protected]>, [email protected]>

    Nel file di configurazione .muttcr, dobbiamo indicare a Mutt qual'è il file degli alias ed eventuali criteri di gestione diversi da quelli di default.

    Di seguito possiamo vedere un estratto del mio .muttrc relativo proprio alla gestione degli alias, con il settaggio delle variabili alias_file, reverse_alias, sort_alias.

    # A L I A S
    #-------------


    # Indica a Mutt il path del file contenente gli
    # alias a cui appendere nuovi alias creati
    # attraverso la funzione $create-alias (tasto "a")
    # valore di default: "~/.muttrc"

    set alias_file = $HOME/Posta/.Mutt/mutt_aliases

    # Indica a Mutt di caricare all'avvio il file
    # degli alias

    source $HOME/Posta/.Mutt/mutt_aliases

    # Se settato a yes, Mutt visualizza nel menu
    # dei messaggi (l'index menu) il nome
    # personale dell'autore dell'email preso dai propri
    # alias, invece dell'address. Utile per quegli
    # indirizzi e-mail non parlanti che provocherebbero
    # difficoltà a capire chi è il proprietario.
    # valore di default: no

    set reverse_alias = yes

    # Indica a Mutt come ordinare gli alias
    # visualizzati nell'alias-menu
    # valori validi:
    # address [per e-mail],
    # alias [alfabetico],
    # unsorted [ordine specificato in .muttrc]
    # valore di default: alias

    set sort_alias = alias

    TIP: Come inserire negli alias l'indirizzo di chi ci ha scritto un messaggio

    Una volta selezionato il messaggio,

     1.	Premiamo a (alias)
      
     2.	Inseriamo nell'input line le informazioni relative all'alias
     	(nick, indirizzo email, nome-cognome della persona)

    Il nuovo alias viene aggiunto da Mutt al file specificato settando la variabile $alias_file, descritta in precedenza.


    TIP: Come editare il file degli alias mentre siamo in Mutt

    Possiamo utilizzare questa semplice macro

    # Macro per editare il file degli alias e
    # ricaricarlo senza dover uscire da Mutt.
    # La macro è descritta al capitolo 7.3 del
    # Mutt-GnuPG-PGP-HOWTO e viene lanciata con esc a

    macro generic \ea "!xjed ~/Posta/.Mutt/mutt_aliases\n:source =.Mutt/mutt_aliases\n"
    macro index \ea "!xjed ~/Posta/.Mutt/mutt_aliases\n:source =.Mutt/mutt_aliases\n"
    macro pager \ea "!xjed ~/Posta/.Mutt/mutt_aliases\n:source =.Mutt/mutt_aliases\n"

  3. Utilizziamo abook come rubrica esterna
  4. Con abook possiamo disporre di un programma che ci consente di gestire le tipiche informazioni di una rubrica e non solo l'indirizzo email:

    1. fino a 4 email per ogni persona
    2. indirizzo
    3. 4 numeri telefonici (casa, ufficio, cellulare, fax)
    4. il nickname, l'indirizzo del sito personale, un campo note
    5. 5 ulteriori campi custom

    Come Mutt, abook è un programma testuale, utilizzabile pertanto anche su linux box che non utilizzano il server grafico.

    Non illustreremo in dettaglio le funzionalità di abook, che possiamo leggere sul sito del programma, concentrandoci su quando e come interrogarlo da Mutt:

    1. In composizione messaggio
    Premiamo Ctrl t quando Mutt ci presenta i campi per indicare i destinatari (To:, Cc:, Bcc:).
    (Per la selezione degli indirizzi vale quanto scritto sopra per gli alias)

    2. All'interno della finestra che elenca i messaggi (index menu)
    Premiamo Shift q (query command) e nel campo Cerca: proposto da Mutt
    scriviamo il nome (o parte di esso) di cui vogliamo l'indirizzo.
    Se vogliamo vedere tutti gli indirizzi, scriviamo solo un punto (.)

    Mutt cerca sulla rubrica di abook solo se lo abbiamo istruito a dovere.

    Dobbiamo settare adeguatamente nel .muttrc la variabile query_command, così come mostrato dall'estratto del mio file di configurazione:

    # ADDRESS BOOK
    #-----------------------


    # Mediante il comando Q dall'index menu si chiede
    # a Mutt di lanciare abook e cercare nel suo address
    # book la stringa indicata.
    # La ricerca può essere effettuata anche quando si è
    # nel campo "To:" mediante Ctrl+t.
    # valore di default: ""

    set query_command = "abook --mutt-query '%s'"

    TIP: Come lanciare abook mentre siamo in Mutt.

    Possiamo utilizzare una macro. Di seguito, sempre dal mio .muttrc, vediamo come possiamo fare.

    # questa macro consente di lanciare abook
    # premendo Ctrl+a

    macro generic \ca "!abook\n" "lancia abook"
    macro index \ca "!abook\n" "lancia abook"
    macro pager \ca "!abook\n" "lancia abook"

    Per spedire una mail ad un indirizzo selezionato, in questo caso, premiamo m.

    TIP: Come inserire nella rubrica di abook l'indirizzo di chi ci ha scritto un messaggio.

    Anche qui ci viene in aiuto una semplice macro, con l'esempio dal mio .muttrc:

    # questa macro consente di aggiungere il mittente
    # del messaggio alla rubrica di abook premendo Shift a

    macro index A "|abook --add-email\n" "aggiunge il mittente ad abook"
    macro pager A "|abook --add-email\n" "aggiunge il mittente ad abook"



^top

Inserire un allegato alla mail in partenza

L'inserimento di un file allegato può essere effettuato dal compose menu, ovvero la schermata che ci si presenta una volta usciti dall'editor con cui abbiamo composto il testo del messaggio.

1.	Premiamo a (attach).
	Mutt ci chiede la directory che contiene il file da allegare
	[Allega un file ('?' per la lista):].
	
2.	Premiamo Tab per navigare nell'hard disk e poter
	selezionare la directory. Mutt ci presenta il contenuto della
	nostra home directory.
	
3.	Arriviamo nella directory che ci interessa usando i tasti pagina
	sù/giù, e/o i tasti freccia e premendo invio per entrare nelle
	directory.
	
4.	Portiamo il cursore sul file da mettere in attach e premiamo
	invio per allegarlo al messaggio.
	
5.	Per selezionare più di un file li tagghiamo premendo t
	su ogni file da allegare (nuovamente t per deselezionare un file)
	
6.	Per trovare ciò che ci interessa in una directory piena di file,
	possiamo sempre usare la funzione di ricerca premendo / (slash).
	Nella funzione di ricerca possiamo usare una espressione regolare (regexp).
	
7.	Per deselezionare un allegato una volta ritornati nel compose menu
	possiamo utilizzare la funzione detach premendo D.

Per allegare un messaggio contenuto in una delle nostre mailbox il percorso è analogo, solo che come primo passo dobbiamo premere A invece di a.
Mutt entra nel cosiddetto attach-message mode, evidenziato mediante l'indicatore A nella status line (vedremo il settaggio di tali indicatori nel Capitolo dedicato al Look n' Feel di Mutt ed in particolare qui).

Una volta entrati in una mailbox, qualora se ne debba uscire senza aver selezionato un messaggio come allegato, possiamo premere c e poi Tab.


Inviare mediante forward un messaggio ed i suoi allegati

Frequentemente si legge di utenti di Mutt che chiedono perchè, forwardando un messaggio con allegati, questi ultimi non vengano spediti. Vediamo allora le variabili che Mutt ci mette a disposizione per personalizzare il suo comportamento in caso di forward.

Nel suo comportamento di default, Mutt quando forwarda un messaggio cerca di inserirlo come plain text nel corpo del nuovo messaggio (inline).

Se desideriamo invece che il messaggio originale venga allegato come componente MIME (message/rfc822), dobbiamo settare nel .muttrc la variabile mime_forward.

Personalmente preferisco settare la variabile con ask-no, in modo da mantenere il controllo sul modus forwardandi:

# se settato a yes indica a Mutt che il messaggio che si forwarda
# deve essere allegato come componente MIME, così chi lo riceve
# lo vede come noi lo abbiamo ricevuto.
# Utile per forwardare messaggi MIME (es testo più allegati)
# Valore di default: no

set mime_forward = ask-no

Ciascuno dei due tipi di forward può ulteriormente essere personalizzato, utilizzando altre due variabili che consentono di decidere se Mutt deve o meno tentare, analizzando gli eventuali allegati MIME, di inserirli inline dopo averli convertiti in plain text.

Vediamo le possibili casistiche.

Primo caso: sto effettuando un normal forward e voglio che Mutt tenti di inserire nel corpo del messaggio, convertendoli a plain text, anche eventuali allegati MIME al messaggio originale.

A tale scopo, possiamo utilizzare la variabile forward_decode. Nel suo valore di default il settaggio è già adeguato allo scopo:

# (questa variabile viene presa in considerazione se è stata
# settata a NO la variabile mime_forward; altrimenti viene
# analizzato ed applicato il settaggio di mime_forward_decode).
# Settando a yes questa variabile Mutt inserisce nel corpo del messaggio
# quelle componenti MIME del messaggio originale che riesce a
# decodificare come plain text
# Valore di default: yes

set forward_decode = yes

Se settiamo a no la variabile forward_decode, invece, qualora il messaggio originale che viene forwardato abbia allegati, nessuno di essi verrà spedito.

Secondo caso: sto effettuando un MIME forward e voglio che Mutt tenti di inserire nel corpo del messaggio gli eventuali allegati MIME al messaggio originale che è in grado di convertire a plain text.

In questo caso debbo utilizzare, modificandone il settaggio di default, la variabile mime_forward_decode.

# (questa variabile viene considerata nel caso in cui sia settata
# a YES la variabile mime_forward; altrimenti viene
# analizzato ed applicato il settaggio di forward_decode).
# Settando a yes questa variabile Mutt inserisce nel corpo del messaggio
# quelle componenti MIME del messaggio originale che riesce a
# decodificare come plain text
# Valore di default: no

set mime_forward_decode = yes
E' opportuno sottolineare che, settando mime_forward_decode a yes: Pertanto, se vogliamo che tutti gli allegati del messaggio originale vengano inviati as-is, dobbiamo impostare a no la variabile mime_forward_decode.

TIP: Come forwardare un messaggio e solo uno (o alcuni) dei suoi allegati.

1.	Entriamo in lettura del messaggio che ha l'allegato(/i) da forwardare.

2.	Premiamo v per entrare nel menu degli allegati.

3.	Premiamo t per taggare l'allegato (o gli allegati).

4.	Premiamo ; e poi f (per il forward).

5.	Proseguiamo come sappiamo.

Nota: del messaggio che contiene l'allegato, vengono forwardati gli header, ma non il testo. Se vogliamo forwardare anche il testo dobbiamo selezionare anche il primo allegato (è il corpo del messaggio).


A questo forward "mirato" si può applicare un settaggio particolare mediante la variabile mime_forward_rest.

In pratica con mime_forward_rest possiamo chiedere a Mutt di tentare di convertire in plain text, inserendoli inline nel corpo del nuovo messaggio, gli allegati che stiamo forwardando.

# (questa variabile viene considerata se è stata settata
# a NO la variabile mime_forward).
# Settando a yes questa variabile, se si sta forwardando
# dal menu attachment una serie di allegati che sono parte
# di un messaggio MIME, Mutt cerca di inserire inline nel
# corpo del nuovo messaggio quelli decodificabili, mentre
# quelli non decodificabili come plain text vengono allegati
# Valore di default: yes

set mime_forward_rest = ask-no

Penso che una schematizzazione grafica seguente possa chiarire molto meglio queste possibili configurazioni:


forward_decrypt e forward_quote sono altre variabili settabili per customizzare il comportamento di Mutt. Illustriamole rapidamente tramite l'esempio dal .muttrc:

# Se settato a yes, quando si forwarda un messaggio criptato, Mutt
# elimina la criptazione.
# Il settaggio viene considerato da Mutt solo se la variabile
# mime_forward è settata e se la variabile mime_forward_decode NON
# è invece settata.
# Valore di default: yes

set forward_decrypt = yes

# Se settato a yes indica a Mutt di quotare il testo del
# messaggio forwardato (nel caso sia incluso nel corpo del
# messaggio che si spedisce, ovvero nel caso in cui sia
# settata a no la variabile mime_forward).
# Per quotare Mutt utilizza la stringa definita mediante la
# variabile indent_string
# Valore di default: no

set forward_quote = yes


^top

Effettuare il controllo ortografico sul testo della mail in partenza

Una volta scritto il testo della mail possiamo anche effettuare un controllo ortografico. Sempre dal compose menu:

1.	Premiamo i per lanciare il programma di controllo ortografico.

2.	Sostituiamo con la parola corretta proposta dal programma ciascuna
	parola evidenziata come errata (con aspell si preme semplicemente il
	numero corrispondente alla parola corretta tra le varie proposte).

Per indicare a Mutt quale programma di correzione ortografica utilizzare, dobbiamo intervenire nel file di configurazione, settando la variabile ispell così come possiamo vedere dall'estratto del mio .muttrc:

# path programma e parametri per il correttore ortografico
# valore di default: ispell

set ispell = "/usr/bin/aspell --mode=email check --lang=it_IT"

Aspell è da preferire a Ispell (il programma altrimenti utilizzato di default da Mutt) per una migliore interpretazione di ciò che va sottoposto a spelling (non è opportuno che venga effettuato controllo ortografico sugli header, sul testo quotato se si sta rispondendo ad un messaggio, sulla signature del messaggio).

Se vogliamo avere a disposizione anche la verifica ortografica in una lingua diversa dalla nostra (ad esempio perchè a volte scriviamo messaggi in inglese), possiamo impostare una macro che cambia il settaggio al volo.

Di seguito un esempio tratto dal mio .muttrc.

# questa macro consente di usare il programma aspell per effettuare
# dal menu compose lo spell checking di testo inglese
# viene eseguita premendo "control i"

macro compose \ci '<enter-command>set ispell="/usr/bin/aspell -c\
--mode=email --lang=en_GB"<enter><ispell><enter-command>\
set ispell="/usr/bin/aspell -c --mode=email --lang=it_IT"<enter>

In alternativa, possiamo incaricare l'editor di eseguire la correzione ortografica.
Jed, ad esempio, effettua lo spelling mediante Ispell.

^top

Inserire una signature casuale alla mail

Per inserire automaticamente in coda ad ogni messaggio una signature casuale abbiamo bisogno di un programma e di un archivio da cui attingere (contenente citazioni, aforismi, barzellette, ...).

Va bene il classico programma fortune, installato di default in qualsiasi distribuzione Gnu/Linux, unitamente agli archivi di aforismi (i fortunes, appunto).

Se non sono stati già installati, sono disponibili anche fortunes in italiano. Per Debian, sono i pacchetti:


Sgrotum - The Signature Rotumbulator

Oltre a fortune, il primo programma che suggerisco è Sgrotum - the signature rotumbulator.

Sgrotum costruisce il file di signature scegliendo a caso uno dei template da noi predefiniti e inserendovi, sempre casualmente, una frase attinta dall'archivio messogli a disposizione.

L'archivio possiamo crearcelo da soli, oppure cercare qualche anima pia che ci omaggi del suo, da utilizzare perlomeno come base di partenza. Io, anima pia, metto a disposizione il mio, sia in formato sgrotum, sia in formato fortune.

Nel file di configurazione di Mutt vanno settate le variabili sig_dashes e signature:

# se settato a yes Mutt inserisce una linea contenente '-- '
# prima della firma (variabile $signature)
# valore di default: yes

set sig_dashes = yes

# path e file contenente la firma aggiunta da Mutt alla fine dei
# messaggi in spedizione. Se il nome del file termina con una pipe (|)
# Mutt assume che sia un comando e che l'input debba essere letto dal
# suo standard output.
# valore di default: "~/.signature"

set signature = "sgrotum ~/.sgrotum/config.file.cfg; cat ~/.signature |"

Se preferiamo una signature statica possiamo scriverla nel file .signature e poi settare come di seguito il .muttrc:

set signature = "~/.signature"

Htag - Huggie Tag

Il secondo programma che consiglio di utilizzare è Htag.

Htag, precedentemente conosciuto come Huggietag, è uno script perl, pacchettizzato e disponibile nei repo Debian e quindi installabile senza difficoltà.

Abbiamo visto che sgrotum genera in output un file di testo contenente la signature, che poi Mutt recupera e appende al messaggio di posta da aprire nell'editor.

Htag, invece, prende in pasto direttamente il messaggio dal client prima che venga aperto dall'editor e produce direttamente su di questo le proprie elaborazioni.

La differenza non è da poco, perchè Htag è in grado di personalizzare il messaggio di posta non solo relativamente alla signature, ma anche a tutte le altre parti del messaggio, prima di trasferirlo per la nostra composizione all'editor di testo.

Inoltre, Htag può farsi carico di differenziare il proprio comportamento, analizzando gli header del messaggio che gli è stato trasferito dal client. In pratica, ad esempio, è possibile gestire attraverso Htag la diversificazione della signature in base al destinatario.

Essendo infine Htag uno script perl, risulta relativamente semplice intervenire per modificarlo, ampliandone le funzionalità.

Evento raro per programmi di questo tipo, Htag dispone anche di una buona documentazione che illustra il suo funzionamento e come configurarlo.

La configurazione di Htag è relativamente semplice e può essere sintetizzata nelle seguenti attività:

  1. personalizzazione del file di configurazione, chiamato .htrc;
  2. creazione di template, definiti signature file, costituenti la parte fissa della firma e loro inserimento in una directory che viene anche specificata in .htrc;
  3. creazione di un archivio di aforismi, citazioni e quant'altro volete che, attinto casualmente da Htag, finisca unito alla firma (signature) dei vostri messaggi. Htag definisce questa parte della firma la tagline, rimandando ai tempi delle gloriose bbs. Anche la collocazione di questo file è indicata in .htrc;
  4. creazione di uno script bash per far eseguire in successione Htag e poi l'apertura dell'editor per la composizione del messaggio;
  5. chiamata dello script da parte del client di posta (Mutt nel nostro caso).

Per il primo passo, la personalizzazione di .htrc, si può fare riferimento al SampleHtagRC.
Inoltre si può guardare la mia versione di .htrc, con i commenti tradotti.

La creazione di template, il secondo passo, è lasciata alla fantasia di ciascuno. Di seguito alcuni miei signature file, da cui partire per costruire propri template:

La creazione dell'archivio di taglines, il terzo passo, va fatta sottolineando che il formato è analogo a quello richiesto da sgrotum, ovvero una frase per riga.
Questo significa che si può utilizzare come base di partenza anche il mio Ataualpa fortunes.

Lo script bash, il quarto passo, è a dir poco essenziale e può essere creato prendendo spunto dal mio, chiamato htagrun, che riporto di seguito:

#!/bin/sh

# $HOME/htagrun - Edit a mail or news message
# Mementote: rendete eseguibile il file
# Copyright 2004 Ben Finney
# Customizzato da Francesco Ciattaglia, 2007 31 Agosto
# Chi usa vim, commenti jed e scommenti vim
# Free software, licensed under the GNU GPL v2

# Costanti che definiscono l'editor
HTAG="/usr/bin/htag"
JED="/usr/bin/xjed"
# VIM="/usr/bin/vim -X" HTAG_DIR="$HOME/.htag"

# Verifica il file in input
MSGFILE=$1
if [ ! -f $MSGFILE ] ; then
echo "$0: il seguente message file non esiste: $MSGFILE"
exit 2
fi

# Imposta le opzioni di esecuzione di Htag
HTAG_OPTS="-m $MSGFILE"

# Esegue Htag
# La parte commentata serve per il debugging
$HTAG $HTAG_OPTS # 2<&1 | tee ~/.htag/htaglog

# Apre l'editor con il messaggio di posta da scrivere
$JED $MSGFILE -tmp -f mail_mode
#$VIM -c "+/^s*$" $MSGFILE

# Fine script

Rimane, infine, l'intervento su .muttrc per far eseguire da Mutt la chiamata di Htag. In pratica si deve:

  1. settare su /dev/null il signature file; Questo perchè, come detto, Htag lavora direttamente sul messaggio di posta prima che sia passato all'edit buffer;
  2. indicare a Mutt di inserire nel messaggio di posta gli header, in modo che siano possibili eventuali personalizzazioni della signature da parte di Htag, in base a verifiche operate sul contenuto degli header;
  3. indicare che il segno di inizio signature ("-- ") non deve essere inserito da Mutt, poichè vi provvede Htag;
  4. eseguire lo script sopra descritto;

Vediamo come operare questi settaggi:

# Indica a Mutt il signature file da utilizzare.
# Utilizzando Htag, non ne deve usare.
# valore di default: "~/.signature"
set signature = "/dev/null"

# se settato a yes, Mutt consente di editare gli header del
# messaggio in spedizione (oltre al body), passandoli all'edit buffer
# valore di default: no
set edit_headers = yes

# se settato a yes Mutt inserisce una linea contenente '-- ' prima
# della firma (variabile $signature)
# settato a no, perchè è Htag che provvede ad inserirlo
# valore di default: yes
set sig_dashes = no

# viene lanciato lo script che prima di aprire l'editor esegue Htag
set editor = "/home/ataualpa/htagrun"

Vi lascio alla lettura del file .htrc, per scoprire le numerose funzionalità disponibili con Htag.


Come nota didascalica appare opportuno precisare* che la signature, in base alle regole della netiquette, deve essere:

* smentendo in parte l'impegno (a non farlo), espresso in introduzione a proposito delle limitazioni della guida.



^top

Approfondimenti ulteriori sulla scrittura messaggi


Rispondere a più messaggi contemporaneamente.

Per fare questo, nell'index menu:
1.	Tagghiamo, premendo t, i messaggi che ci interessano,

2.	Premiamo ; (punto e virgola) e poi r (reply).

3.	Proseguiamo come nella normale composizione di un messaggio

Nota: i destinatari vengono attinti da tutti i mittenti dei messaggi a cui stiamo rispondendo (ma possiamo modificarli se non vanno bene).


Forwardare più messaggi in un colpo solo.

La strada è analoga alla precedente, visto che basta sostituire r con f (forward).


Velocizzare la digitazione di un comando su più messaggi taggati.

Abbiamo visto che, per eseguire un comando su una pluralità di messaggi precedentemente marcati, dobbiamo anteporre ; (punto e virgola).
Per risparmiarci questa "fatica", possiamo settare a yes la variabile auto_tag, come dall'esempio seguente del mio .muttrc.

# se settato a yes evita di dover premere ";" prima di applicare un
# comando a una serie di messaggi gia' marcati.
# Se sono marcati in piu' di uno, applica a tutti.
# valore di default: no

set auto_tag = yes

Comporre una mail partendo da un messaggio esistente.

Se dobbiamo inviare messaggi con testo standard possiamo utilizzare la funzione resend-message, attraverso cui un messaggio che abbiamo selezionato viene usato come template per la creazione di un nuovo messaggio.

Dall'index menu:
1.	Selezioniamo con il cursore il messaggio che vogliamo utilizzare
	(se ci siamo costruiti i messaggi-template scrivendoli e poi non
	spedendoli, usando cioè la funzione di invio rimandato, possiamo
	attivare la finestra con la lista dei template disponibili
	premendo R, usando cioè la funzione di recall dei
	messaggi postposti).

2.	Premiamo ESC e.

3.	Procediamo come sappiamo...

Nota: viene proposto il mittente della mail utilizzata come template (e il resto degli headers). Se usiamo un messaggio che avevamo scritto noi nessun problema, altrimenti per cambiare il from dal menu compose premiamo ESC f (oppure lo modifichiamo direttamente quando scriviamo la mail nell'editor, se abbiamo configurato con yes in .muttrc la funzione edit_headers, come visto in precedenza).


Inserire il testo di un messaggio mentre ne stiamo componendo uno nuovo.

Questa è un'operazione che non viene assistita direttamente da Mutt (siamo già nell'editor, che è un programma a parte!). Pertanto dobbiamo arrangiarci.

Proviamo a vedere come fare, anche se non credo che sia un'esigenza da soddisfare frequentemente (utilizzeremo più spesso il reply ad un messaggio, oppure comporremo un messaggio allegandone un altro - comando A nel compose menu, ricordate? -).

1.	Usciamo dal messaggio che stiamo scrivendo e postponiamolo.

2.	Selezioniamo l'altro messaggio di cui vogliamo includere del testo
	e copiamolo in un file (es: ~/buttavia).

3.	Ritorniamo in editing del messaggio postposto.

4.	Apriamo anche il messaggio copiato e andiamo di copia e incolla.

Possiamo evitarci il postponimento se possiamo aprire un'altra istanza di Mutt per effettuare la copia del messaggio che ci interessa. Oppure se apriamo con l'editor tutta la mailbox che contiene il messaggio (la mailbox è pur sempre un file di testo!), cerchiamo la porzione di testo che ci interessa e andiamo di copia e incolla.



^top

Conclusione

In questo secondo capitolo abbiamo imparato come:

  1. Scrivere, rispondere, forwardare o rimbalzare un messaggio.
  2. Definire l'editor con cui comporre i messaggi.
  3. Rimandare l'invio di un messaggio scritto, posponendolo.
  4. Impostare le informazioni personali che corredano i nostri messaggi.
  5. Impostare gli header del messaggio.
  6. Creare una X-Face da inserire tra gli header del messaggio.
  7. Utilizzare gli alias come rubrica di base.
  8. Utilizzare una rubrica esterna come abook.
  9. Allegare un file al messaggio.
  10. Effettuare il controllo ortografico sul testo del messaggio.
  11. Inserire una signature (firma) casuale o statica al messaggio.
  12. Effettuare operazioni su più messaggi.
  13. Scrivere un messaggio partendo da un template.
  14. Inserire del testo nel messaggio in scrittura da un altro messaggio.


<< Capitolo Precedente Prossimo Capitolo >>