[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


250. Accorgimenti per una distribuzione Red Hat

Ogni distribuzione ha i suoi limiti, e a volte, dei piccoli accorgimenti possono risolvere problemi importanti.

250.1 Gestione dei pacchetti non ufficiali

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, e 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, e a volte necessario, 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, e se si mescolano i file, si rischia di avere due o tre versioni diverse di uno stesso pacchetto. Allora che fare? analizzare file per file e decidere quale cancellare? È decisamente una pessima idea.

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.

250.1.1 Composizione del nome dei pacchetti RPM

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, ed essere in grado di confrontarli. 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.

250.1.2 Programma per l'eliminazione dei file RPM doppi

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.

250.2 Personalizzazione e aggiornamento

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.

250.2.1 Installazione normale o attraverso il dischetto supplementare

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 filesystem 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.

250.2.2 Personalizzazione

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

  1. 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/

  2. In qualche modo si eliminano i pacchetti doppi più vecchi.

  3. 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.

250.3 Aggiornamento del kernel

Comunque si decida di aggiornare una distribuzione Red Hat, il kernel è un punto che crea solitamente dei problemi. Segue la descrizione del modo più corretto in generale, per aggiornarlo.

250.3.1 Installazione fisica

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

250.3.2 initrd

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

250.3.3 LILO

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.24-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

250.3.4 Dischetto di avvio di emergenza

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

250.4 Aggiornamento manuale di un'installazione

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.

Prima di proseguire è bene chiarire che il pacchetto `basesystem' non deve essere aggiornato e che i pacchetti RPM del kernel vanno aggiornati a parte secondo le modalità già descritte a questo proposito.

250.4.1 Estrazione dell'elenco dei pacchetti installati

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 e 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.

250.4.2 Aggiornare i pacchetti in base all'elenco

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...

250.4.3 Problemi

Questo tipo di procedimento lascia aperti una serie di problemi che si manifestano in modo non del tutto prevedibile.

250.5 Semplificazione della configurazione della rete

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.

250.5.1 Raggiro parziale del problema

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:

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.

250.5.2 Sostituzione del file /etc/rc.d/init.d/network

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.0
    /sbin/route add -net 127.0.0.0 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 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 eth0

    Instradamento predefinito
    /sbin/route del 0.0.0.0
    /sbin/route add -net default gw 196.195.194.1 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', e 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.

250.6 Riferimenti

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]