Una lista di posta elettronica, o mailing-list, o più semplicemente lista, è un servizio attraverso cui un gruppo di persone può inviare dei messaggi di posta elettronica a tutti i partecipanti, creando in pratica un mezzo pratico per discutere di un certo argomento. Sotto questo aspetto, la mailing-list compie lo stesso servizio di un newsgroup, con la differenza che ci si deve iscrivere presso il server (o il «robot») che offre il servizio, e che i messaggi vengono inviati a tutti i partecipanti iscritti.
Dal momento che la lista di posta elettronica richiede questa forma di iscrizione, tende a escludere i visitatori occasionali (o casuali), ma permette ugualmente l'accesso a un numero di utenti più vasto: tutti quelli che hanno la possibilità di usare la posta elettronica. Infatti, per quanto riguarda i newsgroup, sono rari gli utenti di Internet che possono accedere a tutti i gruppi di discussione.
Il servizio di una lista di posta elettronica viene svolto normalmente da un programma che si occupa di ricevere la posta da un certo indirizzo e conseguentemente di rispedire i messaggi a tutti gli iscritti. Per iscriversi occorre inviare un messaggio speciale al programma che lo gestisce, contenente il nome della lista e l'indirizzo di posta elettronica di colui che si iscrive; in modo analogo si interviene per cancellare l'iscrizione.
Dal punto di vista amministrativo, si distinguono due tipi di liste: moderate e non moderate. Una lista moderata è quella in cui tutti i messaggi, prima di essere ritrasmessi agli iscritti, vengono controllati da uno o più moderatori; l'altro tipo di lista non viene controllata da alcuno.
|
In questo capitolo si fa riferimento implicitamente all'utilizzo di Sendmail. Tuttavia, le indicazioni date possono adattarsi a Exim, anche se non in modo identico. Quando necessario vengono aggiunte delle note riferite alle particolarità di Exim. |
Prima di vedere il funzionamento di un applicativo organizzato per la gestione di una lista, conviene apprenderne i rudimenti realizzandone una elementare attraverso la gestione degli alias.
Se l'obbiettivo che ci si prefigge è solo quello di definire un indirizzo di posta elettronica che serva come punto di riferimento per la prosecuzione (forward) dei messaggi a un elenco di persone, si può agire in due modi differenti: modificando il file /etc/aliases, oppure creando un utente fittizio che possieda nella sua directory personale il file ~/.forward.
Il secondo caso, quello dell'utente fittizio, è il più semplice da comprendere. Se si suppone di voler creare la lista prova, basterà registrare un utente con lo stesso nome nel sistema operativo, facendo opportunamente in modo che questo non abbia una password valida e nemmeno una shell funzionante. Nella sua directory personale verrà creato e gestito il file ~/.forward nel quale verranno inseriti gli indirizzi degli utenti iscritti alla lista prova.
È tutto qui; spetta all'amministratore del servizio l'aggiornamento manuale di questo file. Eventualmente, questo amministratore potrebbe essere un utente diverso dall'utente root, e in tal caso si potrebbe anche fare in modo che l'utenza prova possa funzionare regolarmente (con password e shell), lasciandola usare a questo amministratore.
Il limite principale di questo sistema sta nel fatto che il nome utilizzato per la lista deve rispettare i vincoli imposti dalla registrazione degli utenti nel sistema operativo.
Il metodo della creazione dell'alias è più efficace. Generalmente si crea un file contenente l'elenco degli indirizzi degli iscritti alla lista, e si fa in modo che un alias faccia riferimento a tutti questi indirizzi. Per esempio, se nel file /etc/aliases viene inserita la riga seguente,
prova: :include:/var/liste/prova/iscritti |
si fa in modo che tutti i messaggi diretti all'indirizzo prova siano poi rinviati a tutti gli indirizzi indicati nel file /var/liste/prova/iscritti. Dal momento che con questo sistema si hanno maggiori possibilità nella definizione dei nomi, si può aggiungere convenientemente un alias per l'amministratore del servizio, come nell'esempio seguente:
prova: :include:/var/liste/prova/iscritti prova-admin daniele |
Bisogna sempre ricordare, quando si interviene nel file /etc/aliases, che poi occorre rigenerare il file /etc/aliases.db attraverso il comando newaliases. Tuttavia, una volta creata la lista nel modo appena descritto, quando si interviene nel file degli iscritti non si deve più avviare newaliases, perché non c'è stato alcun intervento nel file /etc/aliases. Questo, tra le altre cose, garantisce che l'amministratore della lista possa essere una persona diversa dall'utente root, purché abbia i privilegi necessari per intervenire nella directory di appoggio della lista (/var/liste/prova/ in questo caso).
In entrambi i casi visti è possibile mantenere un archivio dei messaggi ricevuti dalla lista, con la semplice aggiunta di un indirizzo che faccia riferimento a un file su disco. Per esempio, il file ~prova/.forward potrebbe iniziare nel modo seguente:
"/home/prova/archivio" Tizio Tizi <tizio@dinkel.brot.dg> Caio Cai <caio@dinkel.brot.dg> ... |
Nello stesso modo, il file /var/liste/prova/iscritti potrebbe iniziare come segue:
"/var/liste/prova/archivio" Tizio Tizi <tizio@dinkel.brot.dg> Caio Cai <caio@dinkel.brot.dg> ... |
Bisogna fare attenzione ai permessi. È molto probabile che il file venga creato con i privilegi dell'utente mail. La prima volta conviene fare in modo che la directory che deve accogliere tale file abbia tutti i permessi necessari alla scrittura da parte di chiunque, in modo da vedere cosa viene creato effettivamente. Successivamente si possono regolare i permessi in modo più opportuno.
Gli esempi mostrati possono adattarsi anche all'uso di Exim, con qualche differenza.
Una volta modificato il file /etc/aliases non è necessario eseguire newaliases, perché ciò non avrebbe alcun significato.
Occorre verificare la proprietà e i permessi che utilizza Exim nella creazione di un file definito come alias all'interno di /etc/aliases. Potrebbe trattarsi di nobody.
SmartList è un applicativo in grado di gestire una lista di posta elettronica. Il principio di funzionamento è abbastanza semplice: attraverso una serie di alias del sistema di gestione dei messaggi di posta elettronica (Sendmail per intenderci), SmartList riceve i messaggi destinati all'indirizzo della lista e quindi li ritrasmette a tutti gli iscritti.
SmartList richiede la predisposizione di un utente e di un gruppo specifici per la gestione del servizio, e a seconda della distribuzione GNU/Linux può trattarsi di list o listserv o qualcosa di simile.
L'applicativo si distribuisce in una serie di directory il cui punto di origine comune è la directory personale dell'utente fittizio del servizio (directory home). Questa sua particolarità fa sì che SmartList non abbia una collocazione tradizionale nel filesystem di GNU/Linux. Alcune distribuzioni GNU/Linux possono collocare l'applicativo da qualche parte al di sotto della gerarchia /var/, ma forse la posizione più corretta è a partire da /home/.
Negli esempi che verranno proposti si suppone di avere installato SmartList in modo che l'utente fittizio corrispondente sia listserv e che la directory personale di tale utente (cioè l'inizio della gerarchia di SmartList) sia /home/listserv/.
Si è accennato al fatto che deve esistere un utente fittizio (e un gruppo corrispondente), e che la sua directory personale deve coincidere al punto di inizio della gerarchia di SmartList. Dal momento che la collocazione di questo applicativo non è scontata, può darsi che si debba ritoccare il file /etc/passwd. Di sicuro deve essere controllato, per verificare che la directory iniziale corrisponda a quanto esiste effettivamente.
listserv:!!:504:504::/home/listserv:/bin/bash |
L'utente abbinato a SmartList ha anche una shell, ma non può avere una password valida.
Dalla directory iniziale di SmartList si diramano alcune directory e file «nascosti», nel senso che iniziano con un punto.
listserv/
|-- .bin/
|-- .etc/
|-- .examples/
`-- .procmailrc
|
Questa impostazione conferma la sua natura di directory personale. La directory .bin/ contiene gli eseguibili e gli script che compongono l'applicativo; la directory .etc/ contiene file di configurazione; la directory .examples/ contiene solo esempi. Infine, il file .procmailrc è necessario a personalizzare il comportamento di procmail, utilizzato da SmartList per l'elaborazione dei messaggi.
Per poter intervenire su SmartList, per esempio per creare o eliminare una lista, occorre usare gli strumenti contenuti nella directory .bin/. Per questo, è opportuno che questa sia compresa tra i percorsi di ricerca degli eseguibili, ovvero nell'elenco contenuto nella variabile di ambiente PATH. Quando si interviene con questi programmi, occorre anche che la directory corrente sia la directory iniziale di SmartList.
Quando si genera una lista nuova, viene creata una directory con lo stesso nome, e al suo interno vengono collocati una serie di file di configurazione contenenti, tra le altre cose, i messaggi che vengono utilizzati automaticamente per guidare gli utenti che si iscrivono alla lista. SmartList genera tali file a partire da quanto già predisposto all'interno della directory .etc/: in alcuni casi vengono fatte delle copie, in altri dei collegamenti. Ciò permette di uniformare certi aspetti della gestione delle liste. Tuttavia, gli script utilizzati per ottenere questo sono predisposti per generare dei collegamenti fisici, mentre, forse, dei collegamenti simbolici sarebbero più pratici da gestire; soprattutto quando si vuole cambiare qualcosa in una lista in modo indipendente dalla configurazione generale, essendo i collegamenti simbolici più facili da individuare.
Se lo si desidera, si può modificare lo script responsabile della preparazione della directory di una lista in modo che invece dei collegamenti fisici si possano generare dei collegamenti simbolici. Si tratta di intervenire su .bin/createlist, e precisamente, basta modificare la riga
ln=ln # /bin/ln |
in modo che diventi come quella seguente:
ln="ln -s" # /bin/ln |
Per creare o eliminare una lista ci si deve posizionare nella directory iniziale di SmartList, e da lì utilizzare createlist o removelist. Ciò, tenendo presente che questi due script si trovano all'interno di .bin/, che deve essere raggiungibile attraverso i percorsi di ricerca per gli eseguibili.
La sintassi per creare una lista è la seguente:
createlist [
|
Se viene usata l'opzione -a
L'esempio seguente crea la lista prova amministrata da tizio@dinkel.brot.dg.
# cd ~listserv[Invio]
# createlist prova tizio@dinkel.brot.dg[Invio]
Installed the following files: root listserv 1024 Jun 3 prova root listserv 4 Jun 3 prova/accept -> dist root listserv 1024 Jun 3 prova/archive root listserv 19 Jun 3 prova/archive.txt -> ../.etc/archive.txt root listserv 1024 Jun 3 prova/archive/latest root listserv 62 Jun 3 prova/dist root listserv 16 Jun 3 prova/help.txt -> ../.etc/help.txt root listserv 4076 Jun 3 prova/rc.custom root listserv 15 Jun 3 prova/rc.init -> ../.etc/rc.init root listserv 18 Jun 3 prova/rc.request -> ../.etc/rc.request root listserv 17 Jun 3 prova/rc.submit -> ../.etc/rc.submit root listserv 14 Jun 3 prova/reject -> ../.etc/reject root listserv 21 Jun 3 prova/subscribe.txt -> ../.etc/subscribe.txt root listserv 23 Jun 3 prova/unsubscribe.txt -> ../.etc/unsubscribe.txt |
Lo script informa su quanto ha prodotto, e precisamente ha creato la directory prova/ e vi ha posto all'interno una serie di file. Se prima di utilizzare lo script, questo era stato modificato come suggerito in precedenza (in modo da generare dei collegamenti simbolici), questo è il risultato che si ottiene.
*1*
Subito dopo, createlist suggerisce anche le modifiche da apportare al file /etc/aliases.
Now make the following entries in your /etc/aliases file: ######################################################################## prova: "|exec /home/listserv/.bin/flist prova" prova-request: "|exec /home/listserv/.bin/flist prova-request" prova-dist: :include:/home/listserv/prova/dist ######################################################################## And make sure to run newaliases afterwards. |
Una volta inseriti questi alias, come suggerisce lo stesso createlist, si deve avviare newaliases.
# newaliases[Invio]
/etc/aliases: 18 aliases, longest 48 bytes, 313 bytes total |
A questo punto la lista prova è pronta e funzionante: l'indirizzo prova... serve per iscriversi, o ritirarsi, e per ottenere informazioni; l'indirizzo -request@prova@... è quello che viene usato per l'uso normale della lista.
Per eliminare una lista, si utilizza lo script removelist con la sintassi seguente:
remove <nome-lista> |
L'esempio seguente, elimina la lista prova.
# removelist prova[Invio]
Expunging /home/listserv/prova, countdown initiated:
3
2
1
zero
Don't forget to remove the corresponding entries from
the /etc/aliases file:
########################################################################
prova:
prova-request:
prova-dist:
########################################################################
|
L'effetto è abbastanza logico: viene eliminata la directory prova/ con tutto il suo contenuto di file, collegamenti e sottodirectory. Come si può intuire, per finire l'operazione occorre eliminare gli alias all'interno del file /etc/aliases.
Se l'MTA è Exim, le righe da includere nel file /etc/aliases devono essere un po' diverse, e precisamente quelle seguenti. In pratica, non si può usare il comando interno di shell exec.
prova: "| /home/listserv/.bin/flist prova" prova-request: "| /home/listserv/.bin/flist prova-request" prova-dist: :include:/home/listserv/prova/dist |
Inoltre, dal momento che si usano delle pipeline tra gli alias, è necessario che sia stato stabilito nella configurazione di Exim quale utente e gruppo usare come proprietari del processo relativo. Nella parte della configurazione riferita ai driver di direzione (director), dovrebbe apparire la definizione degli alias di sistema in un modo simile a quello seguente:
system_aliases: driver = aliasfile; file = /etc/aliases, search_type = lsearch user = exim group = mail |
Secondo questo esempio, le pipeline vengono avviate con i privilegi dell'utente exim e del gruppo mail.
È probabile che gli eseguibili di SmartList abbiano il bit SUID attivo, con la proprietà dell'utente root (SUID-root). In tal caso, non è importante quali siano i privilegi utilizzati per l'avvio della pipeline, perché tanto poi i programmi di SmartList acquistano automaticamente i privilegi dell'utente root.
SmartList è organizzato in modo che tutto quello che serve per l'amministrazione del servizio possa essere svolto da un utente che faccia parte anche del gruppo a cui appartiene l'utente fittizio della gestione di questo sistema (listserv o altro). Per evitare errori, la directory iniziale di SmartList deve avere il bit SGID attivo, e questo assicura che tutto ciò che discende da questa appartenga allo stesso gruppo della directory.
In questa situazione, il meccanismo può funzionare solo se, quando si interviene nei file delle liste, si utilizza una maschera dei permessi pari a 007. Questa consente di avere i permessi in scrittura anche per il gruppo, mentre toglie tutti i permessi per chi non abbia i privilegi dell'utente o del gruppo proprietari.
Dal momento che SmartList, per se stesso, richiede solo che il suo gruppo fittizio abbia tutti i permessi necessari a intervenire nei file (e nelle directory) delle liste, si può affidare l'amministrazione di liste differenti ad amministratori diversi, senza che questi abbiano i privilegi del gruppo di SmartList. Basta abbinare ai file delle liste rispettive la proprietà dell'utente amministratore. In pratica, si utilizza lo script donatelist secondo la sintassi seguente:
donatelist <utente> <nome-lista> |
L'esempio seguente, affida la lista prova all'utente tizio.
# donatelist tizio prova[Invio]
tizio listserv 1024 Jun 3 . listserv listserv 1024 Jun 3 .. tizio listserv 1024 Jun 3 prova root listserv 4 Jun 3 prova/accept -> dist tizio listserv 1024 Jun 3 prova/archive root listserv 19 Jun 3 prova/archive.txt -> ../.etc/archive.txt tizio listserv 1024 Jun 3 prova/archive/latest tizio listserv 62 Jun 3 prova/dist root listserv 16 Jun 3 prova/help.txt -> ../.etc/help.txt tizio listserv 4076 Jun 3 prova/rc.custom root listserv 15 Jun 3 prova/rc.init -> ../.etc/rc.init root listserv 18 Jun 3 prova/rc.request -> ../.etc/rc.request root listserv 17 Jun 3 prova/rc.submit -> ../.etc/rc.submit root listserv 14 Jun 3 prova/reject -> ../.etc/reject root listserv 21 Jun 3 prova/subscribe.txt -> ../.etc/subscribe.txt root listserv 23 Jun 3 prova/unsubscribe.txt -> ../.etc/unsubscribe.txt |
Anche in questo caso il listato che si ottiene rappresenta il contenuto della directory corrispondente alla lista, da cui si può osservare che è stata cambiata la proprietà dei soli file e directory, mentre i collegamenti sono rimasti correttamente inalterati.
Ormai dovrebbe essere chiara la logica attraverso cui si configura una lista. Se certe impostazioni globali, espresse attraverso i collegamenti, non vanno bene, basta elimiare i collegamenti desiderati e produrre delle varianti locali. Naturalmente, nello stesso modo in cui si hanno queste impostazioni globali, si possono definire gruppi di configurazioni, a cui puntare i collegamenti che si desiderano.
La configurazione di SmartList si divide in due parti: una globale, che riguarda potenzialmente tutte le liste gestite, e una particolare per ogni lista. La configurazione globale è contenuta nella directory .etc/, e viene usata per generare dei collegamenti nella directory di ogni lista, all'atto della creazione (come è stato mostrato). La configurazione particolare è costituita dai file che sono stati copiati nelle directory delle liste, la cui modifica, in tal modo, non può influenzare il comportamento delle altre liste.
È chiaro che se in una lista si desidera personalizzare qualche aspetto che riguarda file condivisi, basta cancellare il collegamento corrispondente e fare una copia locale di quel file.
I file più importanti da considerare sono rc.init, fornito generalmente alle directory delle liste in forma di collegamento, e rc.custom che viene copiato necessariamente perché non può essere condiviso in ogni caso.
Vanno verificati entrambi i file: il primo almeno una volta quando si attiva il servizio; il secondo alla creazione di ogni lista nuova. I file sono adeguatamente commentati, e questo dovrebbe bastare per capire il senso delle varie definizioni. In particolare, è importante verificare la definizione della variabile domain, all'inizio del file rc.init: deve contenere il dominio completo del nodo in cui si trovano a funzionare le liste. Eventualmente, se si vogliono gestire liste differenti su domini virtuali diversi, basta fare una copia del file rc.init nella directory di ogni lista, cambiando opportunamente la definizione di tali domini.
L'utente qualunque che desidera iscriversi alla lista, deve inviare un messaggio all'indirizzo <lista> (nel caso degli esempi proposti si tratta di -requestprova...), in cui, nell'oggetto o nel corpo del messaggio, appaia esclusivamente la parola -request@subscribe.
Nello stesso modo, l'utente che vuole eliminare la propria iscrizione alla lista, deve inviare un messaggio contenente esclusivamente la parola unsubscribe.
L'amministratore della lista, definito al momento della sua creazione, può utilizzare la posta elettronica per utilizzare alcuni comandi elementari. In pratica può aggiungere o eliminare degli iscritti. Per ottenere ciò deve inviare un messaggio all'indirizzo <lista> (nel caso degli esempi proposti si tratta di -requestprova...) in cui la voce -request@X deve essere usata per contenere il comando. Naturalmente, il risultato è un messaggio di risposta contenente l'esito del comando.
-Command
Si deve utilizzare la sintassi seguente:
<email-amministratore> <password> <comando> |
I comandi fondamentali sono:
subscribe <email-nuovo-iscritto> |
unsubscribe <email-vecchio-iscritto> |
help | info |
I primi due comandi servono per aggiungere o eliminare un iscritto alla lista; l'ultimo serve a ottenere un riepilogo dei comandi disponibili (ne esistono altri).
La password viene definita all'interno del file rc.custom (contenuto nella directory della lista), e assieme a questa si può modificare il nome dell'intestazione da usare per inviare i comandi di amministrazione. L'esempio seguente mostra una possibile modifica del file rc.custom per fare in modo di poter usare il campo del X al posto di -Admin:X.
-Command:
X_COMMAND = X-Admin X_COMMAND_PASSWORD = Marameo # put the password for # X-Command mails here |
In origine, nel file rc.custom, queste righe sono semplicemente commentate con il simbolo #. Bisogna togliere il commento e poi definire i valori da assegnare.
|
Si potrebbe essere tentati di utilizzare l'oggetto (il campo |
Naturalmente, l'amministratore, per poter utilizzare l'intestazione X deve configurare opportunamente il proprio programma MUA. Per esempio, nel caso di Pine, occorre intervenire nel campo -Command:customized (
93.7.2).
-hdrs
|
È bene considerare che, anche se non si vuole utilizzare questo meccanismo, esiste una password predefinita che potrebbe essere usata da qualcun altro. Pertanto, è almeno opportuno definire una password in ogni caso. |
L'amministratore della lista può intervenire ugualmente per cambiare l'elenco degli iscritti modificando direttamente il file che lo contiene. Si tratta di dist, composto semplicemente da una serie di righe, ognuna delle quali riporta esclusivamente l'indirizzo di posta elettronica di uno dei destinatari.
SmartList, come robot, deve inviare alcuni messaggi automatici a seguito dell'esecuzione di operazioni particolari, come l'iscrizione o la cancellazione in una lista. È evidente che sia opportuno tradurli e adattarli alle proprie esigenze particolari.
Il file help.txt contenuto nella directory della lista viene utilizzato come risposta a una richiesta help inviata all'indirizzo <lista> (come sempre si può usare l'oggetto o il corpo del messaggio per scrivere la parola -requesthelp).
Tale file dovrebbe contenere le informazioni generali per usare tutte le liste che si gestiscono, e in questo senso è generalmente un collegamento a un file uguale per tutte.
Volendo, si può aggiungere nella directory della lista un file di informazioni aggiuntivo e specifico. Deve trattarsi di info.txt e il suo contenuto viene accodato semplicemente a quello di help.txt.
General info ------------ Subcription/unsubscription/info requests should always be sent to the -request address of a mailinglist. If a mailinglist for example is called "thelist@some.domain", then the -request address can be inferred from this to be: "thelist-request@some.domain". To subscribe to a mailinglist, simply send a message with the word "subscribe" in the Subject: field to the -request address of that list. To unsubscribe from a mailinglist, simply send a message with the word (you guessed it :-) "unsubscribe" in the Subject: field to the -request address of that list. ... |
SmartList, come altri applicativi del genere, mantiene un archivio dei messaggi ricevuti, e questo può essere consultato (in modo piuttosto scomodo) attraverso alcuni comandi da inviare all'indirizzo <lista>. Il contenuto del file -requestarchive.txt serve a descrivere la procedura da utilizzare per questo scopo, e si ottiene quando all'indirizzo <lista> si invia un messaggio con il comando -requestarchive help nell'oggetto.
This archive server knows the following commands: get filename ... ls directory ... egrep case_insensitive_regular_expression filename ... maxfiles nnn version ... |
L'archivio dei messaggi si trova nella directory archive/latest/ discendente dalla directory della lista a cui si riferisce. Ogni messaggio viene memorizzato in un file differente.
La configurazione normale dell'archivio prevede che vengano conservati solo gli ultimi due messaggi; se si vuole amministrare un archivio, è evidente che tale numero deve essere aumentato. La modifica alla configurazione deve essere fatta nel file rc.custom, come nell'esempio seguente, in cui si stabilisce un massimo di 100 messaggi.
archive_hist = 100 # number of messages left archived |
Per consultare l'archivio si utilizzano una serie di comandi specifici, da inserire nel corpo di un messaggio di posta elettronica inviato all'indirizzo <lista>. Quello che conta è che nell'oggetto venga indicata la parola -requestarchive. I comandi possono essere più di uno in uno stesso messaggio, e seguono le regole descritte nella guida contenuta nel file archive.txt. Questa, come già accennato, si ottiene inviando la richiesta archive help.
Una lista di discussione è il destinatario ideale di messaggi pubblicitari di vario tipo, o più semplicemente di spam. Sotto questo aspetto, lo studio di un valido sistema di filtro contro gli utilizzi impropri è più che opportuno.
Per quanto riguarda il controllo dell'iscrizione alla lista, SmartList permette di intervenire nella directory della lista da controllare, in particolare nel modo seguente:
realizzando un file denominato reject, contenente un elenco di mittenti (identificati dai rispettivi indirizzi di posta elettronica) da cui rifiutare gli accessi;
creando un programma o uno script, denominato subscreen, che, ricevendo l'indirizzo del mittente come primo argomento, deve restituire il valore zero quando l'accesso viene consentito.
Anche l'invio dei messaggi alla lista può essere controllato, e questo attraverso il file accept. Generalmente questo è un collegamento al file dist, quello che contiene l'elenco degli iscritti a cui inviare copia di tutti i messaggi della lista. In tal modo, solo gli iscritti possono inviare messaggi alla lista.
Fino a questo punto è stato descritto come creare e gestire una lista non moderata. Per ottenere una lista moderata occorre indicare gli indirizzi di posta elettronica dei moderatori nel file moderators. La sola esistenza di questo file, nella directory della lista da moderare, fa sì che i messaggi vengano trasmessi solo ai moderatori, e uno di questi, dopo averli controllati ed eventualmente modificati, può ritrasmetterli aggiungendo la voce Approved, seguita dal suo indirizzo di posta elettronica. I messaggi «firmati» in questo modo vengono rispediti a tutti gli iscritti alla lista.
---------------------------
Appunti Linux 1999.09.21 --- Copyright © 1997-1999 Daniele Giacomini -- daniele @ pluto.linux.it
1.) Il listato che si ottiene è generato attraverso il comando ls . Nell'esempio si mostra un listato con meno colonne per non perdere le informazioni sulla parte destra, a causa del tipo di composizione tipografica adottato.-l