[successivo]
[precedente]
[inizio]
[fine]
[indice generale]
[indice ridotto]
[translators]
[docinfo]
[indice analitico]
[volume]
[parte]
Capitolo 236. Servente HTTP: Mathopd
Mathopd (1) è un altro servente HTTP fatto per impegnare poche risorse, offrendo un insieme ragionevole di possibilità di configurazione.
|
Mathopd, da solo, non è in grado di mostrare il contenuto delle directory, in mancanza di un indice, inoltre produce un registro che non è conforme agli standard, che di solito è costituito dal formato CLF (Common log format) o da quello combinato (sezione 244.1), ma è possibile rimediare a queste carenze con degli script o dei piccoli programmi di contorno.
|
Mathopd si compone del programma eseguibile mathopd che richiede un file di configurazione, costituito normalmente dal file /etc/mathopd.conf. Il programma è fatto per funzionare da solo, fuori dal controllo del supervisore dei servizi di rete, senza bisogno di avviare altre copie di se stesso.
236.1
Utilizzo generale
Mathopd è un servente HTTP molto «particolare», a cominciare dalla sintassi per l'avvio del programma mathopd:
mathopd [opzioni] -f file_di_configurazione
|
Come si può osservare dal modello sintattico proposto, risulta obbligatorio indicare il file di configurazione con l'opzione -f, perché in mancanza di questa informazione, il programma si aspetta di ricevere la configurazione dallo standard input.
Attraverso le altre opzioni che si trovano descritte nella pagina di manuale mathopd(8) è possibile controllare il funzionamento del servente per obbligarlo a funzionare in primo piano o a fornire informazioni diagnostiche. Attraverso una serie di segnali, è possibile attivare e disattivare delle funzionalità diagnostiche o intervenire sugli accessi in corso. In particolare, se il programma servente riceve il segnale SIGHUP rilegge la configurazione, mentre con SIGTERM o SIGINT termina di funzionare. A questo proposito, in un sistema GNU/Linux il servizio potrebbe essere controllato con uno script simile all'esempio seguente:
#! /bin/sh
case "$1" in
start)
echo "Avvio del servizio HTTP."
/usr/sbin/mathopd -f /etc/mathopd.conf
;;
stop)
echo "Arresto del servizio HTTP."
killall -s SIGTERM mathopd
;;
reload)
echo "Rilettura della configurazione del servizio HTTP."
killall -s SIGHUP mathopd
;;
*)
echo "Utilizzo: /etc/init.d/mathopd {start|stop|reload}"
exit 1
esac
exit 0
|
|
Durante il suo funzionamento, Mathopd ha la necessità di scrivere su tre file, che in condizioni normali coincidono con l'elenco seguente; tuttavia, si può modificare la collocazione e il nome di questi file intervenendo nella configurazione:
/var/run/mathopd.pid | contiene il numero del processo elaborativo (PID); |
/var/mathopd/access.log | registro degli accessi; |
/var/mathopd/error.log | registro degli errori. |
|
A questo punto, sapendo che Mathopd annota il numero del processo elaborativo nel file /var/run/mathopd.pid, o in qualunque altro file specificato nella configurazione, si può migliorare lo script di controllo del servizio in questo modo, rendendolo adatto a un sistema GNU qualsiasi:
#! /bin/sh
case "$1" in
start)
echo "Avvio del servizio HTTP."
/usr/sbin/mathopd -f /etc/mathopd.conf
;;
stop)
echo "Arresto del servizio HTTP."
kill -s SIGTERM `cat /var/run/mathopd.pid`
;;
reload)
echo "Rilettura della configurazione del servizio HTTP."
kill -s SIGHUP `cat /var/run/mathopd.pid`
;;
*)
echo "Utilizzo: /etc/init.d/mathopd {start|stop|reload}"
exit 1
esac
exit 0
|
|
236.2
Configurazione
Come già spiegato, non esiste una posizione prestabilita del file di configurazione, che deve essere specificato obbligatoriamente attraverso la riga di comando. Tuttavia, una posizione abbastanza logica per collocare questa configurazione è costituita dal file /etc/mathopd.conf, a cui si fa riferimento in generale nel capitolo; inoltre la pagina di manuale che descrive la sintassi di questo file dovrebbe essere mathopd.conf(5).
Il file di configurazione è un file di testo in cui le righe bianche o vuote vengono ignorate, così come viene ignorato il testo di una riga che appare dopo il simbolo #. Le direttive possono essere «semplici», a indicare ognuna l'attribuzione di un valore a un certo parametro di funzionamento, oppure possono essere dei blocchi di direttive. Un blocco, a sua volta, può contenere sia direttive semplici, sia blocchi ulteriori:
Come si può intendere, il primo modello si riferisce a una direttiva semplice, mentre il secondo mostra la dichiarazione di un blocco. Naturalmente, le parentesi graffe del secondo modello sintattico servono a delimitare l'insieme di direttive contenute nel blocco, pertanto sono da intendersi in senso letterale.
Ci sono direttive semplici che possono stare da sole senza essere inserite in un blocco particolare, mentre nella maggior parte dei casi, queste direttive semplici hanno valore solo nel contesto di un blocco specifico. Tutto questo è comunque abbastanza intuitivo, pertanto si intende mostrare qui la configurazione solo attraverso degli esempi; per approfondire la questione si deve leggere la pagina di manuale mathopd.conf(5).
1 Umask 026
2
3 Tuning {
4 NumConnections 64
5 BufSize 12288
6 InputBufSize 2048
7 ScriptBufSize 4096
8 NumHeaders 100
9 Timeout 60
10 ScriptTimeout 60
11 }
12
13 User www-data
14 StayRoot Off
15
16 PIDFile /var/run/mathopd.pid
17 Log /var/log/mathopd/access.log
18 ErrorLog /var/log/mathopd/error.log
19
20 Control {
21 ScriptUser nobody
22 ChildLog /var/log/mathopd/child.log
23 Types {
24 text/html { html htm }
25 text/plain { txt }
26 image/gif { gif }
27 image/jpeg { jpg }
28 image/png { png }
29 text/css { css }
30 audio/midi { mid midi kar }
31 application/octet-stream { * }
32 }
33 External {
34 /usr/bin/php { php }
35 }
36 IndexNames { index.html index.htm }
37 }
38
39 Server {
40 Port 80
41 Address 0.0.0.0
42 Virtual {
43 AnyHost
44 Control {
45 Alias /
46 Location /var/www
47 Access {
48 Allow 0/0
49 }
50 }
51 Control {
52 Alias /cgi-bin
53 Location /usr/lib/cgi-bin
54 Specials {
55 CGI { * }
56 }
57 Access {
58 Allow 0/0
59 }
60 }
61 Control {
62 Alias /~
63 Location public_html
64 UserDirectory On
65 RunScriptsAsOwner On
66 Access {
67 Allow 0/0
68 }
69 }
70 Control {
71 Alias /~root
72 Location /nosuchdirectory
73 Access {
74 Deny 0/0
75 Allow 127.0.0.1/32
76 }
77 }
78 Control {
79 Alias /doc
80 Location /usr/share/doc
81 Access {
82 Deny 0/0
83 Allow 127.0.0.1/32
84 }
85 }
86 Control {
87 Alias /dwww
88 Location /var/lib/dwww/html
89 Access {
90 Deny 0/0
91 Allow 127.0.0.1/32
92 }
93 }
94 }
95 }
|
|
L'esempio appena mostrato riguarda una situazione abbastanza comune, dove si gestisce un solo dominio virtuale e il materiale pubblicato è generalmente disponibile a tutti. Per maggiore comodità, l'esempio viene sezionato durante la sua descrizione.
Questa direttiva iniziale, che non è racchiusa in alcun gruppo, dichiara la maschera dei permessi che si vuole sia usata per i file che Mathopd va a creare. In questo caso, viene tolto il permesso di scrittura al gruppo (28) e vengono tolti i permessi di lettura e scrittura agli utenti che non sono né il proprietario del file, né gli utenti del gruppo a cui questo è associato (68). In pratica, sapendo che non può entrare in gioco il permesso di esecuzione, il proprietario può leggere e modificare i file, mentre il gruppo può solo leggere.
3 Tuning {
4 NumConnections 64
5 BufSize 12288
6 InputBufSize 2048
7 ScriptBufSize 4096
8 NumHeaders 100
9 Timeout 60
10 ScriptTimeout 60
11 }
|
|
Il raggruppamento denominato Tuning consente di inserire alcune direttive che regolano il funzionamento generale. Il significato di queste può risultare abbastanza intuitivo; in particolare viene definito il numero massimo di connessioni simultanee (in questo caso sono 64) e la scadenza, sia per le connessioni, sia per l'esecuzione di un programma CGI (nell'esempio, per entrambe le situazioni viene assegnato un tempo di 60 s).
Quando Mathopd viene avviato con i privilegi dell'utente root, si deve utilizzare questa direttiva per fare in modo che, subito dopo l'avvio, il programma servente passi ai privilegi dell'utente indicato. In questo modo, tra le altre cose, i file che Mathopd utilizza devono essere accessibili a tale utente. Questo problema vale sia per i documenti da pubblicare, sia per i programmi da eseguire, sia per i file delle registrazioni. Il gruppo non viene specificato e questo dipende dal tipo di adattamento particolare di Mathopd (in un sistema GNU dovrebbe trattarsi del gruppo abbinato naturalmente all'utente indicato).
Questa direttiva, se attiva, fa sì che alcune funzioni di Mathopd vengano eseguite con i privilegi dell'utente root, nonostante sia usata la direttiva User. In certi casi, ciò può essere utile, ma in generale è meglio evitare questo.
16 PIDFile /var/run/mathopd.pid
17 Log /var/log/mathopd/access.log
18 ErrorLog /var/log/mathopd/error.log
|
|
Queste direttive permettono di stabilire la collocazione dei file usati per annotare il numero PID del programma servente e per i file delle registrazioni.
20 Control {
21 ScriptUser nobody
22 ChildLog /var/log/mathopd/child.log
|
|
Il gruppo Control serve a raggruppare delle direttive che controllano il comportamento del servente. Quando il gruppo si trova in un contesto generale (al di fuori di qualunque altro blocco), le direttive valgono per ogni situazione, salva la possibilità di ridefinire i parametri in contesti più specifici.
All'inizio del gruppo Control si vedono due direttive; la prima dichiara con quali privilegi debbano funzionare i programmi CGI, ma per funzionare è necessario che la direttiva StayRoot sia attiva; pertanto, in questo caso la richiesta di far funzionare i programmi CGI con i privilegi dell'utente nobody non può essere soddisfatta. La seconda direttiva che si vede dichiara un file nel quale annotare quanto emesso attraverso lo standard error dai programmi CGI. In mancanza di questa direttiva, tali messaggi vengono perduti (la parola child fa riferimento al fatto che i programmi CGI sono processi elaborativi discendenti da quello del servente).
23 Types {
24 text/html { html htm }
25 text/plain { txt }
26 image/gif { gif }
27 image/jpeg { jpg }
28 image/png { png }
29 text/css { css }
30 audio/midi { mid midi kar }
31 application/octet-stream { * }
32 }
|
|
Il gruppo Types è necessario per dichiarare i tipi di file in base all'estensione. Come si può vedere, i file HTML vengono riconosciuti in base all'estensione html o anche solo htm. L'ultima direttiva di questo gruppo deve indicare un tipo adatto a descrivere i file che hanno estensioni differenti da quelle previste espressamente (l'asterisco serve a indicare qualunque estensione). Purtroppo, questo è un limite importante di Mathopd, che non è in grado di individuare i file di testo senza estensione, a meno di usare tale dichiarazione per ultima. Per la precisione, l'estensione indicata non implica automaticamente la presenza di un punto, pertanto, può essere più corretto aggiungere questo punto nell'estensione stessa. A titolo di esempio, l'elenco dei tipi potrebbe essere esteso come nell'estratto seguente:
Types {
application/ogg { .ogg }
application/pdf { .pdf }
application/postscript { .ps .ai .eps }
application/rtf { .rtf }
application/xhtml+xml { .xht .xhtml }
application/zip { .zip }
application/x-cpio { .cpio }
application/x-debian-package { .deb }
application/x-dvi { .dvi }
application/x-gtar { .gtar .tgz .taz }
application/x-redhat-package-manager { .rpm }
application/x-tar { .tar }
audio/midi { .mid .midi .kar }
audio/mpeg { .mpga .mpega
.mp2 .mp3 .m4a }
audio/x-mpegurl { .m3u }
audio/x-wav { .wav }
image/gif { .gif }
image/jpeg { .jpeg .jpg .jpe }
image/pcx { .pcx }
image/png { .png }
image/tiff { .tiff .tif }
text/css { .css }
text/html { .htm .html .shtml }
text/plain { .asc .txt .text
.diff .pot
readme README
LEGGIMI
COPYRIGHT
COPYING }
text/rtf { .rtf }
text/xml { .xml .xsl }
video/fli { .fli }
video/mpeg { .mpeg .mpg .mpe .mp4 }
video/quicktime { .qt .mov }
video/x-ms-asf { .asf .asx }
video/x-msvideo { .avi }
application/octet-stream { * }
}
|
|
Evidentemente, date le caratteristiche di Mathopd, conviene estendere questo elenco solo quando si presenta la necessità, in base ai contenuti dei documenti pubblicati.
33 External {
34 /usr/bin/php { php }
35 }
|
|
Il gruppo External serve a delimitare delle direttive che dichiarano l'uso di un programma interprete per eseguire i file con le estensioni indicate. In questo caso, quando si incontra un file con estensione php, questo viene eseguito attraverso il programma /usr/bin/php. Come già per le direttive del gruppo Types, può essere più conveniente aggiungere il punto che precede l'estensione, come nell'esempio seguente dove però vengono aggiunte altre estensioni equivalenti:
External {
/usr/bin/php { .php .phtml .pht }
}
|
|
Si osservi che per quanto riguarda gli script che hanno i permessi per essere eseguibili, si attivano attraverso un'altra direttiva nel gruppo Specials, come nell'esempio successivo, che suppone si inserisca all'interno del gruppo Control principale:
Specials {
CGI { .cgi .sh .pl }
}
|
|
Come si può intuire, in questo esempio si intenderebbe dichiarare come programmi esterni i file che terminano per .cgi, .sh e .pl. Nell'esempio complessivo questo caso è stato escluso, per dichiarare piuttosto l'uso del gruppo Special nell'ambito di un percorso specifico.
36 IndexNames { index.html index.htm }
|
|
Questa direttiva dichiara quali file usare come indici delle directory.
39 Server {
40 Port 80
41 Address 0.0.0.0
|
|
Il gruppo Server contiene direttive riferite a un servente HTTP in ascolto in una certa porta, per tutti o solo per un certo indirizzo IP. Nell'esempio si attiva un servente in ascolto della porta 80, che accetta connessioni da qualunque indirizzo IPv4.
Il gruppo Virtual serve a delimitare un insieme di direttive relativo a un certo dominio virtuale. In questo caso, con la direttiva AnyHost si specifica che il gruppo riguarda qualunque dominio che non sia stato individuato in modo più dettagliato.
44 Control {
45 Alias /
46 Location /var/www
47 Access {
48 Allow 0/0
49 }
50 }
|
|
All'interno dei gruppi Virtual si indicano una serie di gruppi Control per individuare dei percorsi, a cui associare dei comportamenti. In questo caso, si dichiara il percorso iniziale del dominio, che corrisponde nel file system alla directory /var/www/. Come si può intuire, nel gruppo Access viene concesso espressamente l'accesso da qualunque indirizzo.
51 Control {
52 Alias /cgi-bin
53 Location /usr/lib/cgi-bin
54 Specials {
55 CGI { * }
56 }
57 Access {
58 Allow 0/0
59 }
60 }
|
|
Il gruppo Control successivo nell'esempio iniziale, ha lo scopo di dichiarare il percorso dominio/cgi-bin/ alla directory locale /usr/lib/cgi-bin/, specificando che ogni file contenuto al suo interno è da intendere un programma CGI. Anche in questo caso viene concesso l'accesso a chiunque.
61 Control {
62 Alias /~
63 Location public_html
64 UserDirectory On
65 RunScriptsAsOwner On
66 Access {
67 Allow 0/0
68 }
69 }
70 Control {
71 Alias /~root
72 Location /nosuchdirectory
73 Access {
74 Deny 0/0
75 Allow 127.0.0.1/32
76 }
77 }
|
|
Qui si dichiara l'accessibilità alla directory personale di ogni utente. Come si fa normalmente, gli accessi riguardano precisamente la directory ~/public_html/ e ciò che questa contiene. Teoricamente, in base alla direttiva RunScriptsAsOwner, che risulta attiva, i programmi CGI contenuti all'interno della gerarchia degli utenti, dovrebbero essere eseguiti con i privilegi degli utenti stessi. In pratica, dal momento che in precedenza il parametro associato alla direttiva StayRoot è stato disattivato, l'attivazione di RunScriptsAsOwner diventa priva di significato.
Per evitare di trattare nello stesso modo anche l'utente root, viene dichiarato un gruppo apposito, dove il percorso http://nodo/~root/ viene associato deliberatamente a una directory inesistente, per garantire che non vi si possa accedere. Sotto, con il gruppo Access viene escluso ogni accesso, salvo all'elaboratore locale, ma per il motivo appena descritto risulta ugualmente inaccessibile.
78 Control {
79 Alias /doc
80 Location /usr/share/doc
81 Access {
82 Deny 0/0
83 Allow 127.0.0.1/32
84 }
85 }
86 Control {
87 Alias /dwww
88 Location /var/lib/dwww/html
89 Access {
90 Deny 0/0
91 Allow 127.0.0.1/32
92 }
93 }
|
|
Infine, vengono previsti altri percorsi a directory contenenti della documentazione. A questi percorsi viene impedito l'accesso a tutti, escluso l'elaboratore locale.
Per dichiarare dei domini virtuali, si potrebbe continuare con altri gruppi Virtual che iniziano con una o più direttive Host, come nell'esempio seguente:
Virtual {
Host brot.dg
Host www.brot.dg
Control {
Alias /
Location /home/MIRROR/brot
}
Control {
Alias /cgi-bin
Location /nosuchdirectory
Access {
Deny 0/0
}
}
Control {
Alias /~
Location /nosuchdirectory
Access {
Deny 0/0
}
}
Control {
Alias /~root
Location /nosuchdirectory
Access {
Deny 0/0
}
}
}
|
|
236.3
Indici delle directory
Purtroppo, Mathopd non consente di visualizzare il contenuto di un percorso nel quale non è stato previsto un indice. Tuttavia, se si dispone di un programma CGI che genera l'indice, è possibile collocare tale programma in ogni directory priva di un altro indice e abilitarne l'uso nella configurazione:
Control {
ScriptUser nobody
ChildLog /var/log/mathopd/child.log
Types {
...
}
Specials {
CGI { dir_cgi }
}
IndexNames { index.html index.htm dir_cgi }
}
|
|
Come si vede, nel gruppo Control più esterno si può inserire un gruppo Specials allo scopo di dichiarare «l'estensione» dir_php come programma CGI, mettendo lo stesso nome nell'elenco dei file indice.
In pratica, non si tratta di un'estensione, ma del nome del file completo: se al posto del file index.html, o index.htm, c'è il programma dir_cgi, questo viene eseguito.
Il nome dir_cgi non è casuale, in quanto si tratta di un esempio diffuso dallo stesso autore di Mathopd (una copia di questo programma in forma sorgente, dovrebbe essere disponibile anche qui: <allegati/a2/dir_cgi.c>).
Un risultato simile si può ottenere con il programma seguente che è scritto in Perl ed è derivato da uno dei programmi di Alml (una copia di questo programma, dovrebbe essere disponibile anche qui: <allegati/a2/index-html.cgi>):
#!/usr/bin/perl
local ($index) = "";
local ($line) = "";
local ($type) = "";
local ($user) = "";
local ($group) = "";
local ($size) = "";
local ($day) = "";
local ($name) = "";
local ($true_name) = "";
open (DIRECTORY_LISTING, "export LC_ALL=C ; ls -l --full-time --si |");
$index = "<!DOCTYPE HTML PUBLIC \"ISO/IEC 15445:2000//DTD HTML//EN\">\
<HTML LANG=\"en\">\
<HEAD>\
<TITLE>directory listing</TITLE>\
</HEAD>\
<BODY>\
<TABLE SUMMARY=\"directory listing\">\
<TBODY>\
<TR><TD>previous</TD><TD><A HREF=\"..\">..</A></TD><TD></TD></TR>\
";
while ($line = <DIRECTORY_LISTING>)
{
if ($line =~ m/^(\S)\S+\s+\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+\S+\s+\S+\s+(.+)$/)
{
$type = $1;
$user = $2;
$group = $3;
$size = $4;
$day = $5;
$name = $6;
if ($type eq "d")
{
$index = $index . "<TR><TD>directory</TD>\
<TD><A HREF=\"$name\">$name/</A></TD><TD></TD></TR>\n";
}
elsif ($type eq "l")
{
$name =~ m/^(\S+)\s+\-\>\s+(\S+)$/;
$true_name = $2;
$index = $index . "<TR><TD>link</TD>\
<TD><A HREF=\"$true_name\">$name</A></TD><TD></TD></TR>\n";
}
else
{
$index = $index . "<TR><TD>file</TD>\
<TD><A HREF=\"$name\">$name</A></TD><TD>$size</TD></TR>\n";
}
}
}
$index = $index . "\
</TBODY>\
</TABLE>\
</BODY>\
</HTML>\
";
close (DIRECTORY_LISTING);
print ("Content-Type: text/html\n\n");
print ($index);
|
|
236.4
Registro degli accessi
Il formato usato da Mathopd per annotare gli accessi nel file /var/log/mathopd/access.log, o comunque nel file equivalente stabilito in base alla configurazione, non è standard. Nella configurazione si può intervenire con una serie di direttive racchiuse nel gruppo LogFormat:
LogFormat {
Ctime
RemoteUser
RemoteAddress
RemotePort
ServerName
Method
URI
Status
ContentLength
Referer
UserAgent
BytesRead
BytesWritten
}
|
|
Quello che si ottiene è un file di testo, contenente delle righe, una per ogni richiesta giunta al servente, in cui le varie informazioni sono separate da un carattere di tabulazione orizzontale (<HT>). L'esempio mostrato sopra nell'uso del gruppo LogFormat, rappresenta la sequenza dei campi predefiniti; tuttavia, anche cambiando la disposizione di questi campi, non si può ottenere il formato CLF (Common log format) e tanto meno quello combinato (sezione 244.1). Per disporre di un formato standard, è necessari rielaborare il file con un programma realizzato appositamente, pertanto è perfettamente inutile modificare la disposizione dei campi nella configurazione di Mathopd.
Nei punti di distribuzione di Mathopd potrebbero essere disponibili due script alternativi, che in qualche modo dovrebbero generare un formato combinato da un file di registrazione degli accessi predefinito. Il primo di questi è uno script AWK (una copia di questo script dovrebbe essere disponibile anche qui: <allegati/a2/mattoclf.awk>):
#!/usr/bin/awk -f
BEGIN {
FS="\t"
}
NF >= 11 && $5 ~ "^[-._[:alnum:]]+$" {
split($1, date, " ")
printf "%s - - [%02d/%s/%s:%s +0000] \"%s %s HTTP/1.0\" %d %d \"%s\" \"%s\"\n",
$3, date[3], date[2], date[5], date[4], $6, $7, $8, $9, $10, $11 > $5
}
|
|
Questo script attende dallo standard input il contenuto del registro degli accessi e genera tanti file quanti sono i domini virtuali. Ognuno di questi file, ha il nome del dominio virtuale relativo.
|
Questo programma sarebbe perfetto, se non fosse che, quando manca l'informazione del dominio virtuale (pertanto appare in quella posizione un trattino), si blocca, perché non può creare il file -.
|
Un altro script, questa volta in Perl, fa un lavoro simile, ma senza distinguere tra i domini virtuali (una copia di questo script dovrebbe essere disponibile anche qui: <allegati/a2/mattoclf.pl>):
#!/usr/bin/perl
while(<STDIN>) {
my(@x) = split(/\t/);
my $date = shift @x;
my @date = split(/\s+/, $date);
if ($x[8] eq '-') {
$x[8] = '';
}
printf "%s - - [%02d/%s/%s:%s +0000] \"%s %s HTTP/1.0\" %d %d \"%s\" \"%s\"\n",
$x[1], $date[2], $date[1], $date[4], $date[3], $x[4], $x[5], $x[6],
$x[7], $x[8], $x[9];
}
|
|
Data la mancanza di un programma soddisfacente nella distribuzione di Mathopd, viene proposto qui un programma Perl differente, più completo, che genera un risultato equivalente a quello del programma AWK già apparso sopra, ma senza incepparsi quando manca il nome del dominio virtuale (una copia di questo script dovrebbe essere disponibile anche qui: <allegati/a2/mathopd_to_clf>):
#!/usr/bin/perl
my ($line) = "";
my ($output) = "";
my ($previousServerName) = "";
while($line = <STDIN>)
{
my (@mathopd_log) = split(/\t/, $line);
my ($Ctime) = $mathopd_log[0];
my ($RemoteUser) = $mathopd_log[1];
my ($RemoteAddress) = $mathopd_log[2];
my ($RemotePort) = $mathopd_log[3];
my ($ServerName) = $mathopd_log[4];
my ($Method) = $mathopd_log[5];
my ($Uri) = $mathopd_log[6];
my ($Stats) = $mathopd_log[7];
my ($ContentLength) = $mathopd_log[8];
my ($Referer) = $mathopd_log[9];
my ($UserAgent) = $mathopd_log[10];
my ($BytesRead) = $mathopd_log[11];
my ($BytesWritten) = $mathopd_log[12];
#
if ($ServerName eq "-")
{
#
# Just ignore it.
#
next;
}
#
my (@date) = split(/\s+/, $Ctime);
#
if ($Referer eq '-')
{
$Referer = '';
}
#
$output = sprintf ("%s - - [%02d/%s/%s:%s +0000] \"%s %s HTTP/1.0\" %d %d \"%s\" \"%s\"",
$RemoteAddress,
$date[2], $date[1], $date[4], $date[3],
$Method,
$Uri,
$Stats,
$ContentLength,
$Referer,
$UserAgent);
if ($previousServerName eq "")
{
open (OUTPUT, ">>:utf8", $ServerName);
}
elsif ($previousServerName eq $ServerName)
{
#
# The output stream is already opened.
#
;
}
else
{
close (OUTPUT);
open (OUTPUT, ">>:utf8", $ServerName);
}
#
print OUTPUT ("$output\n");
}
close (OUTPUT);
|
|
236.5
Riferimenti
Appunti di informatica libera 2006.07.01 --- Copyright © 2000-2006 Daniele Giacomini -- <daniele (ad) swlibero·org>
1) Mathopd software libero con licenza speciale
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome servente_http_mathopd.htm
[successivo]
[precedente]
[inizio]
[fine]
[indice generale]
[indice ridotto]
[translators]
[docinfo]
[indice analitico]
