[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]
Ogni distribuzione ha i suoi limiti; a volte dei piccoli accorgimenti possono risolvere problemi importanti.
La Red Hat, come azienda, produce una distribuzione GNU/Linux limitata a un certo numero di applicativi, quelli che è in grado di seguire e garantire in base al personale a sua disposizione. Naturalmente, questo è il limite comune delle distribuzioni GNU/Linux commerciali.
Tutti i pacchetti assemblati all'esterno dell'azienda, vengono «relegati» all'area dei contributi (contrib/) e, spesso, di questi programmi non si può fare a meno.
Se non si ha un accesso permanente a Internet, diventa utile conservare da qualche parte questi programmi che non fanno parte della distribuzione standard. Si pone però un problema nel momento in cui si viene in possesso di un CD-ROM contenente parte di questi contributi, che si ritiene essere aggiornato. Infatti, tale CD-ROM non li può contenere tutti e se si eliminano quelli conservati precedentemente si rischia di perdere qualcosa che serve; inoltre, se si mescolano i file, si rischia di avere due o tre versioni diverse di uno stesso pacchetto.
Con un po' di abilità si può realizzare un programmino che analizza una directory, cerca di identificare i pacchetti uguali ed elimina quelli delle versioni più vecchie.
Il nome dei pacchetti RPM è organizzato secondo la struttura seguente:
nome_dell'applicativo-versione-rilascio.architettura.rpm
In pratica, dopo il nome dell'applicativo segue un trattino e quindi l'indicazione della versione, quindi ancora un trattino e poi il rilascio, ovvero la versione riferita alla trasformazione in un pacchetto RPM. Nella parte finale, dopo un punto di separazione, appare la sigla dell'architettura e l'estensione .rpm. L'esempio seguente mostra il nome del pacchetto contenente il kernel generico e i moduli precompilati per la versione 2.0.34, rilascio 1, per l'architettura i386.
kernel-2.0.34-1.i386.rpm
Volendo confrontare i nomi di file di versioni differenti, occorre estrapolare la versione e il rilascio. Nella migliore delle ipotesi, la versione è composta da una serie di numeri separati da un punto, dove il primo numero è quello più significativo; nello stesso modo può essere organizzato il rilascio. Il problema si pone quando la versione o il rilascio contengono dei dati alfabetici: diventa impossibile determinare a priori il modo corretto di confronto.
Quello che segue è uno script scritto in Perl per la scansione di una directory, quella corrente nel momento in cui si avvia, allo scopo di eliminare i file corrispondenti a pacchetti già esistenti in versioni più recenti.
#!/usr/bin/perl
#======================================================================
# rpmdoppi
#
# Interviene nella directory *corrente* eliminando i file doppi,
# più vecchi.
#======================================================================
$file0 = "";
$file1 = "";
$nome0 = "";
$nome1 = "";
$versione0 = "";
$versione1 = "";
$rilascio0 = "";
$rilascio1 = "";
$architettura0 = "";
$architettura1 = "";
$verA0 = "";
$verA1 = "";
$verB0 = "";
$verB1 = "";
$verC0 = "";
$verC1 = "";
$verD0 = "";
$verD1 = "";
$verE0 = "";
$verE1 = "";
$verF0 = "";
$verF1 = "";
#----------------------------------------------------------------------
# Carica l'elenco dei file dalla directory corrente.
#----------------------------------------------------------------------
open ( ELENCO, "ls *.rpm | sort |" );
#----------------------------------------------------------------------
# Scandisce nome per nome.
#----------------------------------------------------------------------
while ( $file1 = <ELENCO> ) {
#------------------------------------------------------------------
# Estrae gli elementi che compongono il nome del file.
#------------------------------------------------------------------
$file1 =~ m{^(.*)-([^-]*)-([^-]*)\.([^._-]*)\.rpm};
#------------------------------------------------------------------
# Distribuisce i vari pezzi a variabili più comprensibili.
#------------------------------------------------------------------
$nome1 = $1;
$versione1 = $2;
$rilascio1 = $3;
$architettura1 = $4;
#------------------------------------------------------------------
# Verifica se i nomi sono comparabili.
#------------------------------------------------------------------
if ( $nome1 eq $nome0 ) {
if ( $architettura1 eq $architettura0 ) {
#----------------------------------------------------------
# Ok, i nomi sono comparabili.
#----------------------------------------------------------
;
} else {
#----------------------------------------------------------
# Le architetture sono differenti.
#----------------------------------------------------------
print "Attenzione all'architettura:\n";
print " $file0";
print " $file1";
#----------------------------------------------------------
# Riprende il ciclo.
#----------------------------------------------------------
next;
}
} else {
#--------------------------------------------------------------
# I nomi sono differenti, quindi ripete il ciclo.
#--------------------------------------------------------------
next;
}
#------------------------------------------------------------------
# Qui i nomi e le architetture sono uguali.
#------------------------------------------------------------------
#------------------------------------------------------------------
# Se l'ultima cifra della versione è alfabetica e la penultima
# è numerica, quella alfabetica viene
# trasformata in numerica per facilitare il confronto.
#------------------------------------------------------------------
if ( $versione1 =~ m{^.*\d[A-Za-z]$}
&& $versione0 =~ m{^.*\d[A-Za-z]$} ) {
#--------------------------------------------------------------
# L'ultimo elemento della versione è una lettera alfabetica.
# Converte la lettera in numero.
#--------------------------------------------------------------
$versione1 =~ m{^(.*)([A-Za-z])$};
$versione1 = $1 . ord $2;
$versione0 =~ m{^(.*)([A-Za-z])$};
$versione0 = $1 . ord $2;
}
#------------------------------------------------------------------
# Si verifica che la versione sia numerica.
#------------------------------------------------------------------
if ( $versione1 =~ m{^[0-9.]*$} && $versione0 =~ m{^[0-9.]*$} ) {
#--------------------------------------------------------------
# La versione è correttamente numerica.
# Si procede a estrarre i vari valori separati da punti
# (al massimo sei).
#--------------------------------------------------------------
$versione1 =~ m{^(\d*)\.*(\d*)\.*(\d*)\.*(\d*)\.*(\d*)\.*(\d*)$};
$verA1 = $1;
$verB1 = $2;
$verC1 = $3;
$verD1 = $4;
$verE1 = $5;
$verF1 = $6;
$versione0 =~ m{^(\d*)\.*(\d*)\.*(\d*)\.*(\d*)\.*(\d*)\.*(\d*)$};
$verA0 = $1;
$verB0 = $2;
$verC0 = $3;
$verD0 = $4;
$verE0 = $5;
$verF0 = $6;
#--------------------------------------------------------------
# Si procede al confronto tra le versioni.
#--------------------------------------------------------------
if ( $verA1 > $verA0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verA1 < $verA0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verB1 > $verB0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verB1 < $verB0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verC1 > $verC0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verC1 < $verC0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verD1 > $verD0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verD1 < $verD0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verE1 > $verE0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verE1 < $verE0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verF1 > $verF0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verF1 < $verF0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
}
} elsif ( $versione1 =~ m{^$versione0$} ) {
#--------------------------------------------------------------
# Le versioni sono uguali; più avanti si verifica il numero
# di rilascio.
#--------------------------------------------------------------
;
} else {
#--------------------------------------------------------------
# La versione contiene simboli non numerici.
#--------------------------------------------------------------
print "Attenzione ai file seguenti (versione non numerica)\n";
print " $file0";
print " $file1";
next;
}
#------------------------------------------------------------------
# Qui le versioni sono uguali.
#------------------------------------------------------------------
#------------------------------------------------------------------
# Si verifica che il rilascio sia numerico.
#------------------------------------------------------------------
if ( $rilascio1 =~ m{^[0-9.]*$} && $rilascio0 =~ m{^[0-9.]*$} ) {
#--------------------------------------------------------------
# Il rilascio è correttamente numerico.
# Si procede a estrarre i vari valori separati da punti
# (al massimo 3).
#--------------------------------------------------------------
$rilascio1 =~ m{^(\d*)\.*(\d*)\.*(\d*)$};
$verA1 = $1;
$verB1 = $2;
$verC1 = $3;
$rilascio0 =~ m{^(\d*)\.*(\d*)\.*(\d*)$};
$verA0 = $1;
$verB0 = $2;
$verC0 = $3;
#--------------------------------------------------------------
# Si procede al confronto tra i rilasci.
#--------------------------------------------------------------
if ( $verA1 > $verA0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verA1 < $verA0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verB1 > $verB0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verB1 < $verB0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} elsif ( $verC1 > $verC0 ) {
print "Eliminazione del file $file0";
system( "rm $file0" );
next;
} elsif ( $verC1 < $verC0 ) {
print "Eliminazione del file $file1";
system( "rm $file1" );
next;
} else {
print "I file seguenti sembrano identici\n";
print " $file0";
print " $file1";
next;
}
} else {
#--------------------------------------------------------------
# Il rilascio contiene simboli non numerici.
#--------------------------------------------------------------
print "Attenzione ai file seguenti (rilascio non numerico)\n";
print " $file0";
print " $file1";
next;
}
} continue {
#------------------------------------------------------------------
# Accantona i dati per il confronto.
#------------------------------------------------------------------
$file0 = $file1;
$nome0 = $nome1;
$versione0 = $versione1;
$rilascio0 = $rilascio1;
$architettura0 = $architettura1;
}
#----------------------------------------------------------------------
# Il lavoro è terminato; viene chiuso l'elenco dei file.
#----------------------------------------------------------------------
close ( ELENCO );
#======================================================================
Come si può intuire, questo programma potrebbe anche fallire nel suo intento. In ogni caso, bisogna analizzare i messaggi per intervenire manualmente sui file che non possono essere trattati automaticamente.
Una delle cose più fastidiose della distribuzione GNU/Linux Red Hat sono gli aggiornamenti numerosi, già dopo pochi giorni che una nuova versione viene pubblicata. Se si scarica la distribuzione dalla rete, o se la si acquista attraverso uno dei tanti distributori non ufficiali, si ottiene sempre solo una versione «originale», con tutti i difetti che potrebbe avere, dove gli aggiornamenti vanno fatti dopo l'installazione, in modo manuale.
Quando si installa GNU/Linux in modo sistematico su un gran numero di elaboratori, questo problema diventa delicato, perché il lavoro di aggiornamento deve essere moltiplicato su tutte le macchine, mentre sarebbe utile la possibilità di ottenere una distribuzione personalizzata e aggiornata come si vuole.
Allo stato attuale, i dischetti per l'installazione sono due. Il primo è sufficiente per le forme di installazione più comuni, come quella da un CD-ROM o da un file system di rete NFS, mentre il secondo deve essere usato in tutti gli altri casi.
Il programma di installazione aggiuntivo, collocato nel dischetto supplementare è più tollerante e in molti casi è in grado di installare una distribuzione contenente file di versioni differenti rispetto a quelle previste nell'edizione standard. Al contrario, il programma del primo dischetto richiede un'esatta corrispondenza tra i nomi dei file.
Per la precisione, le forme di installazione che fanno uso del solo dischetto di avvio, richiedono la presenza del file RedHat/base/hdlist, che contiene l'elenco e le descrizioni dei pacchetti RPM disponibili.
Come accennato, per poter personalizzare una distribuzione Red Hat con i pacchetti aggiornati, occorre rigenerare il file RedHat/base/hdlist. Questo si ottiene con il programma misc/src/install/genhdlist.
Supponendo di disporre di una distribuzione Red Hat per la piattaforma i386, a partire dalla directory /MIO_RHL/, strutturata come si vede dallo schema seguente (che è comunque semplificato rispetto alla realtà), si devono compiere i passi elencati successivamente.
/MIO_RHL |-- RedHat/ | |-- RPMS/ | |-- base/ | |-- instimage/ | | `... | | | `-- i386 | |-- doc/ | |-- dosutils/ | `... | |-- images/ | |-- misc/ | |-- boot/ | `-- src/ | |-- install/ | `... | |-- updates/ | |-- COPYING |-- README `-- RPM-PGP-KEY
Si copiano i file dei pacchetti aggiornati nella directory RPMS/ della versione personalizzata che si sta predisponendo.
# cp /MIO_RHL/updates/* /MIO_RHL/RedHat/RPMS/
In qualche modo si eliminano i pacchetti doppi più vecchi.
Si rigenera il file RedHat/base/hdlist, ma prima si sistemano i permessi, nel caso serva.
# chmod u+x /MIO_RHL/misc/src/install/genhdlist
# chmod 644 /MIO_RHL/RedHat/base/hdlist
# /MIO_RHL/misc/src/install/genhdlist /MIO_RHL/
Come si può intuire, l'eliminazione dei pacchetti doppi più vecchi può essere fatta con l'aiuto dello script rpmdoppi già descritto in questo capitolo.
Comunque si decida di aggiornare una distribuzione Red Hat, il kernel è un punto che crea solitamente dei problemi. Segue la descrizione del modo più conveniente per aggiornarlo.
Per prima cosa, con il sistema già funzionante, si procede all'aggiornamento simultaneo di tutti i pacchetti del kernel, saltando solo quelli che non vengono già utilizzati nel sistema. L'aggiornamento simultaneo è necessario per evitare problemi di conflitti.
Il modo più semplice è quello di collocare i file dei pacchetti desiderati in una directory temporanea e da lì installarli contemporaneamente.
# rpm -Uv /tmp/updates/*.rpm
Se il sistema utilizza unità SCSI, dal momento che i kernel modulari predisposti dalle distribuzioni Red Hat non includono nel blocco principale la gestione di questi dispositivi, occorre aggiornare anche l'immagine initrd. Questa infatti deve contenere i moduli necessari per il riconoscimento delle unità SCSI esistenti e, avendo aggiornato il kernel, occorre ricostruire anche questo file.
Se la gestione dei moduli è configurata correttamente, dovrebbe bastare il comando seguente, dove la versione e il rilascio vanno sostituiti con quelli del kernel aggiornato.
mkinitrd /boot/initrd-versione-rilascio versione-rilascio
In pratica, immaginando che si tratti della versione 2.0.34 rilascio 1, si dovrebbe procedere nel modo seguente:
# mkinitrd /boot/initrd-2.0.34-1 2.0.34-1
Una volta che i file del kernel e l'immagine initrd sono al loro posto, ci si deve prendere cura del sistema di avvio, di solito con LILO. Evidentemente, occorre ritoccare il file /etc/lilo.conf in modo che venga avviato il file corretto del kernel e venga utilizzato eventualmente la nuova immagine initrd.
L'esempio seguente riguarda il caso di un kernel 2.0.34-1.
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz-2.0.34-1
label=linux
root=/dev/hda3
initrd=/boot/initrd-2.0.34-1
read-only
Naturalmente, alla fine, occorre avviare lilo per sistemare il settore di avvio.
# lilo
Anche il dischetto di avvio di emergenza può essere ricostruito facilmente. Basta utilizzare il comando seguente, che si rifà al solito caso del kernel 2.0.34-1.
# mkbootdisk --device /dev/fd0 2.0.34-1
Un altro difetto importante della distribuzione Red Hat è che l'aggiornamento di un'edizione precedente funziona di rado: quasi sempre il programma di installazione si interrompe a metà. Esistendo questo rischio, è decisamente sconsigliabile di tentare un'operazione del genere: o si reinstalla da zero, o è meglio aggiornare pacchetto per pacchetto, al momento della necessità.
Chi ha già una buona pratica con il programma rpm ed è in grado di superare i problemi comuni dovuti alle dipendenze, potrebbe cimentarsi in una sorta di aggiornamento semiautomatico che viene descritto qui. Si tratta comunque di un'operazione delicata da fare con prudenza e che potrebbe anche fallire.
Il programma rpm non prevede un modo per aggiornare solo i pacchetti già esistenti nel sistema. Per arrivare a questo occorre un po' di lavoro e per prima cosa è necessario ottenere un elenco dei nomi dei pacchetti (vecchi) già installati che si presume di volere aggiornare.
# rpm --queryformat '%{NAME}\n' -qa | sort
Il comando mostrato genera un elenco ordinato dei nomi dei pacchetti installati. La cosa importante è che i nomi sono senza l'indicazione della versione.
L'idea è che con l'elenco che si ottiene, dopo aver tolto basesystem e i pacchetti del kernel, si potrebbe alimentare un comando di aggiornamento (rpm -U). Si può modificare il comando che genera l'elenco nel modo seguente, per i motivi che si chiariranno in seguito.
# rpm --queryformat '%{NAME}-\[0-9\]\*.rpm\n' -qa | sort
Si ottiene qualcosa di molto simile all'elenco seguente:
AfterStep-APPS-[0-9]*.rpm AfterStep-[0-9]*.rpm AnotherLevel-[0-9]*.rpm ElectricFence-[0-9]*.rpm ImageMagick-[0-9]*.rpm MAKEDEV-[0-9]*.rpm SysVinit-[0-9]*.rpm ...
Come si può intuire, l'intenzione è quella di ottenere un elenco di modelli (glob) che corrispondano ai rispettivi file dei pacchetti aggiornati, di cui non si conosce a priori il numero della versione. Da come sono stati scritti, si presume che dopo il nome di un pacchetto ci sia un trattino (-), seguito da una cifra numerica, da una stringa indefinita e infine dall'estensione .rpm. Ciò non può essere sempre vero, però funziona nella maggior parte dei casi.
L'elenco descritto nella sezione precedente, quello contenente i modelli di shell (o modelli glob), va controllato e da lì si devono eliminare i pacchetti che non si possono o non si vogliono aggiornare. È già stato ripetuto che non si deve aggiornare basesystem e che i pacchetti del kernel vanno aggiornati a parte.
Una volta che l'elenco è corretto, ci si può posizionare nella directory che contiene i file RPM aggiornati e si può lanciare il comando di aggiornamento.
# cd /mnt/cdrom/RedHat/RPMS
# rpm -Uv `cat /tmp/elenco` 2>&1 | tee /tmp/risultato
Dall'esempio si intende che i pacchetti si trovano nella directory /mnt/cdrom/RedHat/RPMS/, che l'elenco dei modelli da aggiornare si trova nel file /tmp/elenco e che si vuole conservare una copia dei messaggi nel file /tmp/risultato.
Purtroppo, di solito non funziona...
Questo tipo di procedimento lascia aperti una serie di problemi che si manifestano in modo non del tutto prevedibile.
Alcune dipendenze potrebbero risultare non soddisfatte.
Se per qualunque motivo non dovessero essere soddisfatte tutte le dipendenze, si può tentare di isolare i pacchetti che creano questo problema, togliendo le voci relative dal file di elenco, installandoli successivamente a mano, cercando di risolvere le dipendenze.
Di solito può trattarsi di librerie nuove o di parti che sono state scorporate in pacchetti separati. Eventualmente si può tentare di installare tali pacchetti prima di iniziare con l'aggiornamento generale.
Alcuni pacchetti potrebbero avere cambiato nome.
Se un pacchetto nella versione nuova della distribuzione ha cambiato nome, non si ottiene il suo aggiornamento, perché il modello che si utilizza per indicarlo non coincide. Se si tratta di un pacchetto indispensabile ad altri, si otterrà la segnalazione di errori dovuti alle dipendenze.
Alcuni pacchetti potrebbero essere stati scissi in diversi pacchetti più specifici.
Se un pacchetto è stato scisso, può darsi che il nome vecchio sia stato mantenuto per la parte principale di questo, così non si ottiene l'installazione della parte aggiuntiva.
Questo fatto può portare comunque a problemi di dipendenza.
A un certo punto dell'aggiornamento si potrebbe arrivare a uno scarico della memoria (core dump).
Se l'aggiornamento si interrompe, è possibile modificare il file contenente l'elenco dei modelli in modo da eliminare le voci corrispondenti ai pacchetti già esaminati e aggiornati; quindi si può ripetere il comando di aggiornamento.
La configurazione della rete secondo l'impostazione della Red Hat, in presenza di situazioni particolari potrebbe tradursi in un labirinto troppo complicato. Anche l'uso degli strumenti previsti, come netcfg o linuxconf, potrebbe essere insufficiente per le proprie esigenze.
Si potrebbe decidere di saltare questo sistema, inserendo i comandi necessari all'attivazione delle interfacce di rete e alla definizione degli instradamenti nel file /etc/rc.d/rc.local. In tal caso conviene:
predisporre il file /etc/sysconfig/network, avendo cura di attivare la rete (NETWORKING=yes);
predisporre il file /etc/sysconfig/network-scripts/ifcfg-lo in modo che sia definita l'interfaccia di loopback;
eliminare ogni altro file /etc/sysconfig/network-scripts/ifcfg-* in modo che non venga definita alcuna interfaccia reale;
aggiungere in coda al file /etc/rc.d/rc.local i comandi necessari ad attivare le interfacce di rete e a definire gli instradamenti.
In alternativa si potrebbe eliminare completamente la directory /etc/sysconfig/network-scripts/. In tal caso, nel file /etc/rc.d/rc.local andrebbero aggiunti anche i comandi necessari a configurare e instradare l'interfaccia di loopback.
Questo tipo di approccio ha anche altre conseguenze, per esempio l'impossibilità di attivare un'interfaccia PPP attraverso gli strumenti della distribuzione. Anche per queste cose occorre creare degli script appositi.
L'effetto peggiore di questo metodo sta nel fatto che lo script /etc/rc.d/rc.local viene avviato per ultimo, nella sequenza della procedura di inizializzazione del sistema, per cui alcuni servizi che fanno affidamento sull'attivazione precedente della rete potrebbero non essere in grado di avviarsi correttamente.
Nella procedura di inizializzazione del sistema utilizzato da Red Hat, lo script /etc/rc.d/init.d/network è quello che si utilizza per attivare le interfacce di rete nel momento giusto. La sostituzione del contenuto di questo script con un altro che sia indipendente dai meccanismi che compongono la directory /etc/sysconfig/network-scripts/, potrebbe essere una soluzione migliore, anche se non perfetta.
Quello che segue è un esempio più o meno complesso di quello che potrebbe contenere questo script: si utilizza una porta parallela PLIP con il mascheramento IP e una scheda Ethernet connessa a Internet.
#!/bin/sh
#
# network Attiva/disattiva la rete
#
# chkconfig: 345 10 97
# description: Attiva/Disattiva la rete.
# Riutilizza le variabili definite nel file di configurazione
# della rete della Red Hat.
. /etc/sysconfig/network
RiattivazioneRete() {
# Si prende cura della configurazione dell'inoltro IPv4 secondo
# Red Hat.
if [ "$FORWARD_IPV4" = "no" -o "$FORWARD_IPV4" = "false" ]
then
echo "0" > /proc/sys/net/ipv4/ip_forward
echo "L'inoltro IPv4 è disabilitato."
else
echo "1" > /proc/sys/net/ipv4/ip_forward
echo "L'inoltro IPv4 è abilitato."
fi
# loopback
/sbin/ifconfig lo down
/sbin/ifconfig lo 127.0.0.1 netmask 255.0.0.0
/sbin/route del 127.0.0.1
/sbin/route del 127.0.0.0
# /sbin/route add -net 127.0.0.0 netmask 255.0.0.0 dev lo
/sbin/route add -host 127.0.0.1 dev lo
# plip
/sbin/modprobe plip
/sbin/ifconfig plip0 down
/sbin/ifconfig plip0 192.168.254.254 pointopoint 0.0.0.0
/sbin/route del 192.168.254.0
/sbin/route add -net 192.168.254.0 dev plip0
# firewall
/sbin/ipchains -F forward
/sbin/ipchains -P forward ACCEPT
/sbin/ipchains -A forward -s 192.168.0.0/16 -d 0/0 -j MASQ
/sbin/ipchains -L forward -n
# eth0
/sbin/modprobe eth0
/sbin/ifconfig eth0 down
/sbin/ifconfig eth0 196.195.194.7 netmask 255.255.255.0
/sbin/route del 196.195.194.0
/sbin/route add -net 196.195.194.0 netmask 255.255.255.0 dev eth0
Instradamento predefinito
/sbin/route del 0.0.0.0
/sbin/route add -net default gw 196.195.194.1 dev eth0
}
# Verifica del modo in cui è stato chiamato lo script.
case "$1" in
start | restart | reload)
RiattivazioneRete
touch /var/lock/subsys/network
;;
stop)
/sbin/ifconfig eth0 down
/sbin/ifconfig eth1 down
/sbin/ifconfig eth2 down
/sbin/ifconfig plip0 down
/sbin/ifconfig plip1 down
/sbin/ifconfig plip2 down
echo "0" > /proc/sys/net/ipv4/ip_forward
echo "L'inoltro IPv4 è disabilitato."
rm -f /var/lock/subsys/network
;;
status)
/sbin/ifconfig
/sbin/route -n
/sbin/ipchains -L -n
;;
probe)
exit 0
;;
*)
echo "Utilizzo: network {start|stop|restart|reload|status}"
exit 1
esac
exit 0
Questa alternativa consente l'eliminazione di tutta la directory /etc/sysconfig/network-scripts/ e del file /etc/sysconfig/static-routes; inoltre risolve il problema legato al momento in cui si attiva o disattiva la rete.
È evidente che anche in questo caso non è più possibile configurare la rete attraverso gli strumenti consueti e l'attivazione di una possibile connessione PPP deve essere fatta in modo personalizzato, eventualmente attraverso degli script.
Morten Kjeldgaard, Peter von der Ahé, Burning a Red Hat CD mini-HOWTO
<http://www.linux.org/docs/ldp/howto/HOWTO-INDEX/howtos.html>
daniele @ swlibero.orgDovrebbe essere possibile fare riferimento a questa pagina anche con il nome accorgimenti_per_una_distribuzione_red_nbsp_hat.html
[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]