MAGRATHEA WORKS

Con questo tutorial impariamo ad installare i programmi in ambiente Linux.
la novità di questa guida è che cerca di compendiare una marea di nozioni raccolte in rete in un unico scritto.
I programmi di solito vengono distribuiti in quattro formati principali: in formato tar.gz, in formato RPM, in formato Deb e in tgz , vediamoli uno ad uno:

-Formato tar.gz
In formato tar.gz di solito vengono distribuiti i sorgenti. Prima di tutto è necessario scompattare il pacchetto con il comando:
-tar xzvf nomefile.tar.gz-
se i sorgenti li troviamo nel formato tar.bz2 per scompattarli usiamo
tar xvjf nomefile.bz2
Spieghiamo a che servono i parametri (per ulteriori informazioni sul comando tar digitate man tar): * -x estrae l'archivio;
* -z scompatta gli archivi .gz;
* -j scompatta gli archivi .bz2 (-I o -y dipende dalla versione di tar);
* -Z scompatta gli archivi .Z (file di compress)2;
* -v ci mostra la lista dei file presenti nell'archivio;
* -f usa il file da noi specificato.
Una volta scompattato viene creata una directory con lo stesso nome dell'archivio (naturalmente senza l'estensione).
Tale directory conterrà alcuni file e un file chiamato configure con i permessi di esecuzione.
A questo punto, entriamo nella cartella appena creata
-$cd nomepacchetto-
Ora, leggete attentamente i files di documentazione allegati al pacchetto, tipicamente c'è sempre almeno un file README ed un file INSTALL (scritto maiuscolo!) a volte più di uno. -Leggeteli!
Spesso così scoprirete quale è l'esatta procedura di installazione. Il novanta per cento dei pacchetti tar.gz o tar.bz2 si installa seguendo la procedura che vi spiegherò tra poco, ma ci sono delle eccezioni
e potrete scoprirlo solo leggendo la documentazione.-
Qui supponiamo che la procedura di installazione sia quella standard , allora

$./configure
Questo script controllerà se nel nostro sistema abbiamo tutto il necessario per il corretto funzionamento del
programma. Se tutto è presente non vedremo messaggi di errore e verrà creato un file chiamato Makefile. Questo file è il fulcro di tutto visto che permette la corretta compilazione del programma in base alla nostra configurazione.
L'unica opzione comune a tutti i pacchetti e spesso utile è-prefix, che vi permette di scegliere dove verranno installati i files
del programma quando lo avrete compilato.
./configure -prefix=/usr/local
ad esempio!

Adesso per finire lanciamo due comandi sulla stessa linea (da root ):
#make && make install
make compila il programma usando il file Makefile creato in precedenza, make install installa il programma nelle
directory di default (di solito /usr/local/bin). Il simbolo && esegue il secondo comando solo se il primo termina
senza
errori. Il procedimento è piuttosto lungo e dipende dalla vostra configurazione hardware (e ovviamente
dalle dimensioni del programma).

Se il programma installato non è di vostro gradimento basta digitare:
#make uninstall (o make deinstall)
per disinstallarlo automaticamente (naturalmente il file Makefile deve essere presente, quindi se avete cancellato
i sorgenti scompattate l'archivio e rieseguite lo script configure). Alcuni software non hanno questa funzione quindi
non ci resta che cancellare a mano i file del programma. Per il formato tar.gz abbiamo finito .

NB-E' ovviamente possibile avere degli errori di compilazione, spesso dovuti ad una errata versione di qualche libreria,
o del compilatore stesso. In questo caso provate ad aggiornare le librerie richieste dal programma o a debuggarvi il codice!

-Formato RPM
Installare un RPM è facile , ma funziona alla perfezione solo nelle distribuzioni dove l'installazione viene eseguita
esclusivamente tramite archivi RPM (Fedora, Mandriva, SuSE, ecc..) e se un RPM è stato creato per una distribuzione
probabilmente non funzionerà sulle altre (anche se compatibili). Infatti i programmi distribuiti nel formato RPM sono
già compilati per una configurazione standard e quindi hanno delle dipendenze .
Molti pacchetti software vengono distribuiti "pacchettizzati" in formato rpm (formato ideato dalla software house
Redhat®). Alcune distribuzioni, Redhat e Mandriva in testa, sono interamente basate su questo sistema di
"pacchettizzazione". Le principali GUI disponibili per linux, KDE e GNOME in primis, dispongono di tool grafici per la
gestione dei pacchetti rpm quali kpackage per kde e gnorpm per gnome. Questi tool consentono di visualizzare
informazioni sui pacchetti quali l'autore e i files contenuti con il relativo percorso di installazione, nonchè
l'installazione e la disinstallazione dei pacchetti, non consentono però la risoluzione automatica delle
dipendenze. Per questo scopo, alcune software house tipo Mandriva® e Suse® redhat-fedora hanno ideato per le
loro distribuzioni dei tool che consentono di risolvere questo problema. Nel caso della Mandrake il tool è denominato
urpmi con un front-end grafico denominato rpmdrake per fedora-redhat c'è yum ,per suse yast(Zypper).

per un approfondimento su URPMI
http://www.mandrakeitalia.org

per un approfondimento su YUM
http://www.fedoraitalia.org

per un approfondimento su ZYPPER
http://en.opensuse.org
http://www.suseitalia.org

In questa guida viene trattato l'uso di Rpm dalla console e precisamente vedremo come:

a. Installare un pacchetto
#rpm -ivh nomepacchetto.rpm
questo comando installa il contenuto del pacchetto indicato mostrando una barra di progressione orizzontale ma non le sue dipendenze.

b. Aggiornare un pacchetto
#rpm -Uvh nomepacchetto.rpm
come il comando precedente, l'unica differenza è che in questo caso viene effettuato l'aggiornamento dei files di un pacchetto già installato con i files del pacchetto indicato.
In entrambi i casi bisogna indicare il nome completo del pacchetto ad esempio: gimp-1.2.3-17mdk.i586.rpm

c. Rimuovere un pacchetto
#rpm -e nomepacchetto
questo comando rimuove dal sistema il pacchetto e tutti i files che lo compongono.
In questo caso bisogna indicare solo il nome indicativo del pacchetto, ad esempio : rpm -e gimp rimuove il pacchetto contenente il programma di grafica Gimp che nel caso di una mdk9 sarà contenuto nel pacchetto
gimp-1.2.3-17mdk.i586.rpm

d. Ottenere Informazioni sui pacchetti installati
#rpm -qi nomepacchetto
comando ritorna informazioni sul pacchetto indicato che riguardano la versione, la data di installazione, la categoria di appartenenza, il tipo di licenza, l'impacchettatore ed una descrizione del programma o dei programmi in esso contenuti. Anche in questo caso deve essere digitato solo il nome indicativo del pacchetto.
#rpm -ql nomepacchetto
questo comando ritorna l'elenco dei files contenuti nel pacchetto indicato con il relativo percorso di installazione.
Occorre precisare che è possibile anche abbinare le richieste. Ad esempio digitando rpm -qli gimp si avranno informazioni sulla lista dei files installati e quelle relative alla descrizione del paccchetto con relativa data di installazione, impacchettatore, etc...

e.Ottenere Informazioni sui pacchetti non installati
Si possono avere informazioni anche sui pacchetti non installati . Prendendo a riferimento i comandi precedentemente descritti, basta aggiungere nella richiesta di informazioni la lettera "p". Bisogna precisare che in questo caso è necessario indicare, il nome completo del pacchetto.
#rpm -qpi nomepacchetto.rpm

il campo "install date" indica "not installed", non potrebbe indicare altrimenti, poichè il pacchetto non è installato.
Anche in questo caso è possibile abbinare nella formulazione delle richieste diverse opzioni. Ad esempio digitando rpm -qlpi wvdial-1.42-4mdk.i586.rpm, si avranno informazioni sui files contenuti nel pacchetto con il relativo percorso di installazione, la versione del programma, il gruppo di appartenenza, l'occupazione di spazio disco se installato, la data di creazione del pacchetto, l'impacchettatore, etc...

Attenzione : con yum o urpmi si possono installare anche i singoli pkg che risiedono in locale come???
# cd /"directory contenente l'rpm"
# yum localinstall prova.rpm
A questo punto dovresti aver installato il pacchetto prova sfruttandone la disponibilità da sorgente, averlo compilato , e averlo installato sfruttando la potenza di yum che tra l'altro gestisce le dipendenze per quel pacchetto- questo è il vantaggio!!.
Inoltre se vuoi disinstallare prova basta dare il classico
# yum remove pippo

-Formato Tgz
Slackware utilizza un proprio sistema di pacchettizzazione il tgz. A differenza dei tar.gz non contiene sorgenti ma binari (non sempre ovviamente). Le utility fornite da Slackware sono 3:
*installpkg: utilizzato per installare i pacchetti;
*upgradepkg: utilizzato per aggiornare pacchetti già installati;
* removepkg: Utilizzato per rimuovere i pacchetti;
* pkgtool: frontend3 testuale per i precedenti.
L'uso dei comandi è semplice:
#installpkg nome_pacchetto.tgz
#upgradepkg nome_pacchetto.tgz
#removepkg nome_pacchetto
#upgradepkg --install-new nome_pacchetto.tgz
Nella directory /var/log/packages troviamo la lista di tutti i pacchetti installati.

Swaret di Slackware
Swaret è un programma, non ancora incluso nella versione ufficiale di Slackware, che permette di aggiornare uno o più pacchetti utilizzando un reposity (niente di più di un server ftp contente alcuni file oltre ai pacchetti). Il file di configurazione (/etc/swaret.conf) contiene la lista dei reposity (basta togliere il # per utilizzarne uno) e la versione della vostra Slack.
quindi si scarica swaret-1.6.3-noarch-1.tgz -l'ultima versione stabile -
lo installo con
root@slackware:/home/kio# installpkg swaret-1.6.3-noarch-2.tgz
scaricandolo dal sito http://swaret.sf.net/
Installing package swaret-1.6.3-noarch-2...
Executing install script for swaret-1.6.3-noarch-2...
For new installs, rename /etc/swaret.conf.new to /etc/swaret.conf
Type 'man swaret.conf' to see a list of settings
eseguo editando il file /etc/swaret.conf.new rinominandolo
/etc/swaret.conf.
Innanzitutto si devono inserire i repository che ci interessano, se vogliamo
aggiungerne a quelli già presenti di default, con la seguente sintassi:
REPOS_ROOT=Slacky%http://www.slacky.eu/repository/slackware-11.0
Dobbiamo quindi controllare con un editor che almeno le seguenti righe, le più
importanti fra quelle che definiscono le varie opzioni, risultino come descritto qui
sotto:
VERSION=current: serve a stabilire la versione a cui aggiornare i pacchetti .........
Se volete, potete dire a swaret di aggiornare anche il kernel se vengono
rilevati aggiornamenti: commentate la linea:
EXCLUDE=kernel
anteponendo il carattere `#' cosi':
#EXCLUDE=kernel
Salvate, uscite da swaret
Vediamo come utilizzare swaret:
#swaret –update
#swaret --search nome_pacchetto
#swaret --install nome_pacchetto
#swaret --upgrade nome_pacchetto
Il primo comando “scanna” il reposity alla ricerca di nuovi pacchetti (e aggiornamenti). Se non passiamo come argomento dei pacchetti a --upgrade vengono aggiornati tutti i pacchetti installati (utile se abbiamo settato current come versione della distribuzione poiché aggiorna tutti i pacchetti seguendo il changelog slackware

-Formato Deb
Apt-get, sviluppato e utilizzato da debian (e ovviamente dalle derivate Ubuntu/Kubuntu, ecc),uno dei migliori sistemi di pacchettizzazione esistente, e ovviamente il più copiato (swaret, yum, urpmi, ecc sono apt like).
Vedremo come utilizzarlo, senza addentrarci nei meandri nelle versioni di debian. Ricordate come sempre che tutti i comandi sono da eseguire da root.
Repository
Un repository è nient'altro che un contenitore di pacchetti (contenente ovviamente anche la lista dei pacchetti ed altre informazioni). Per aggiungere un repository si edita il file source.list (di solito in /etc/apt). La sintassi è questa:
deb url nome_versione_distro tipo_repository
un esempio (per ubuntu) è:
deb http://it.archive.ubuntu.com/ubuntu breezy universe multiverse
(di solito, almeno su ubuntu, il source.list contiene i repository predefiniti, per upgrade e co, basta quindi eliminare il # all'inizio della riga)
Usiamo Apt
Prima di tutto (anche ogni volta che aggiungiamo un repository) dobbiamo aggiornare il db locale (ebbene si il database dei pacchetti rimane in locale in modo da poterlo consultare quando si vuole) con:
#apt-get update
Adesso possiamo cercare un pacchetto (nel db locale):
#apt-cache search nome_pacchetto
e installarlo:
#apt-get install nome_pacchetto
(apt cercherà le dipendenze del pacchetto e installerà anche quelle). Per aggiornare i pacchetti installati:
#apt-get upgrade
(per aggiornare un solo pacchetto si usa apt-get install nome).
Per passare da una versione all'altra della distribuzione (per quanto riguarda ubuntu al momento la versione stabile si chiama breezy e la versione unstable si chiama dapper, per informazioni sulle versioni di debian visitate
http://www.debian.it) dopo aver cambiato il nome distro all'interno del source.list e aggiornato il database locale serve un semplice:
#apt-get dist-upgrade
upgrade si limita ad aggiornare i pacchetti installati, mentre dist-upgrade installa anche nuovi pacchetti (vedi versioni aggiornate del kernel) inseriti all'interno della distribuzione e elimina software sostituiti e/o eliminati.
Per vedere quali pacchetti sono installati si usa l'utility a basso livello (molto potente) dpkg:
#dpkg --list
e per rimuovere:
#dpkg -r nome_pacchetto
e per installare
#dpkg -i nome_pacchetto
Per un approfondimento su Apt
http://www.debian.org

NOTA:Può capitare di imbattersi in file .bin a differenza dei soliti .deb o .tar o .rpm , l’installazione è molto semplice:
1. ci si posizione nella cartella che contiene il file
2. settiamo i permessi dando: #chmod +x nome_file.bin
3. installiamo il file digitando: ./nome_file.bin ovvero sh nome_file.bin
A questo punto si avvierà l’installazione del programma che dovremmo seguire fino alla fine.

E se ci trovassimo in Ambiente GENTOO(ad esempio su sabajon)
be allora leggiamoci :
http://www.gentoo.org

- Ma noi vorremmo essere dei geek ed abbiamo sentito dire che essi usano ARCH
http://wiki.archlinux.org

-Utility varie
Come si convertono i pacchetti?

-Vediamo il programma Alien che serve a convertire da un formato di un pacchetto ad un altro. Ecco un esempio di utilizzo di Alien per convertire un pacchetto RPM in .deb:
# alien --to-deb pacchetto.rpm
Eccone un altro che mostra invece come convertire un pacchetto .deb in formato RPM: # alien --to-rpm pacchetto .deb
Eccone un altro che mostra invece come convertire un pacchetto .tgz in formato RPM
In questo caso l'utilizzo di Alien sarà simile al seguente:
# alien --to-tgz pacchetto .rpm

-Conversione di RPM in tgz
Tramite l'utility rpm2tgz è possibile trasformare un pacchetto RPM nel formato gestito dal Package Management di Slackware
Uno dei formati più popolari tra i sistemi di packaging è RPM di Red Hat, ed è quindi probabile trovare spesso software in questo formato. A volte è possibile che il pacchetto ricercato sia disponibile solamente in questo formato. In questo caso è possibile trovare una soluzione (anche se non in tutti i casi), per l'installazione in una distribuzione Slackware, grazie all'utility rpm2tgz.
Il programma rpm2tgz crea un pacchetto con estensione .tgz partendo da un pacchetto RPM, la sua sintassi è:
rpm2tgz
Un esempio di utilizzo:
#ls
nmap-3.00-1.i386.rpm
Il file di partenza è un pacchetto di tipo RPM
#rpm2tgz nmap-3.00-1.i386.rpm
#ls
nmap-3.00-1.i386.rpm nmap-3.00-1.i386.tgz
Una volta lanciata l'esecuzione del programma si ottiene un pacchetto di tipo tgz gestibile dalle utility di Slackware come pkgtool, installpkg, removepkg o upgpackage

-Adesso vogliamo creare pacchetti per la nostra distribuzione
Installare da sorgenti è molto performante ma installare da binari precompilati è molto comodo: che ne dite di unire le due cose? Per fare ciò possiamo usare il comodo checkinstall, che crea pacchetti rpm, tgz e deb dai sorgenti. Vediamo come fare:
1-installare checkinstall o dai sorgenti o tramite pkg precompilati per la propria distro poi
Una volta scompattato il sorgente del programma , come visto sopra, viene creata una directory con lo stesso nome dell'archivio (naturalmente senza l'estensione). Tale directory conterrà alcuni file .c e un file chiamato configure con i permessi di esecuzione.
A questo punto, entriamo nella cartella appena creata e diamo
#./configure && make && checkinstall -S
con l'argomento -S creiamo pacchetti Slackware, con -R creiamo degli RPM e con -D dei pacchetti deb, il tutto ottimizzato per la nostra Linux Box

warning:
-si è creata una incompatibilità tra checkinstall e la nuova release di slackware la 12.0
intanto checkinstall va installato dai sorgenti .il .tgz non si trova
Per chi (come me) non può (o non vuole) proprio fare a meno di checkinstall su Slackware-12 , questa è la soluzione :
An incompatibility with the newest coreutils seems to have bitten a bunch of people, specially users of the recently released Slackware 12.
A new checkinstall version will be released soon which will address this issue. In the meantime, as a workaround you can use the "--fstrans=no" command line flag when invoking checkinstall. Read the details here.
ovvero vediamo l'esempio di nano
scarichiamo i sorgenti e li scompattiamo
#tar xvzf nano-2.0.6.tar.gz
#cd /home/kio/nano-2.0.6
# sh configure && make && checkinstall --fstrans=no
poi #installpkg nano-2.0.6-i386-1.tgz
e buonanotte ai suonatori !!!!!

-si è creata una incompatibilità anche tra checkinstall e la nuova release di Mandriva la 2008.0
la soluzione tampone consiste nella modifica di
/usr/bin/checkinstall sostituedo gli statement da
$RPMBUILD -bb {RPM_TARGET_FLAG}${ARCHITECTURE} "$SPEC_PATH" &>
${TMP_DIR}/rpmbuild.log
a
$RPMBUILD -bb ${RPM_TARGET_FLAG}${ARCHITECTURE} --buildroot $BROOTPATH "$SPEC_PATH" &>
${TMP_DIR}/rpmbuild.log

Quindi checkinstall è vivo e lotta insieme a noi!!!!!
ps vogliamo il pkg x l'architettura i686???
modifichiamo il file
/usr/lib/checkinstall/checkinstallrc
cambiando
# Default architecture type (Leave it empty to allow auto-guessing)
ARCHITECTURE=""
CON
ARCHITECTURE="i686"

APPENDICE-1
Creare un pkg RPM partendo dai sorgenti forniti in formato RPM stesso
es. devo installare freepops-vado sul sul sito http://www.freepops.org/it/download-linux.shtml scarico un RPM generico che dovrebbe essere installabile sulla maggior parte delle distro basate su RPM, così almeno ci dicono.
[root@Fedora kio]# rpm -ivh freepops-0.0.29-1.i386.rpm
error: Failed dependencies:
libcrypto.so.0.9.7 is needed by freepops-0.0.29-1.i386
libssl.so.0.9.7 is needed by freepops-0.0.29-1.i386
linux-gate.so.1 is needed by freepops-0.0.29-1.i386
: visto che non trovo le librerie per fedora http://rpmfind.net/linux/RPM/ allora scarico il sorgente
freepops-0.0.29-1.src.rpm e mi compilo da solo il binario , come loro stessi suggericono in caso di
problemi, ma come si fa?
seguo la ottima guida di lukylinux su fedoraitalia
*************
fase 1: acquisizione
scaricare il pacchetto *.src.rpm in home/~/directoryavostrascelta/
fase 2: installazione del sorgente
diventare superutente (su - root)
entrare in home/~/directoryavostrascelta/
installare il pacchetto con
rpm -ivh *pacchetto*.src.rpm
........ l'installazione produrrà un file *pacchetto*.spec su misura per il vostro sistema indicandovi alla fine anche la directory dove viene creato, solitamente /usr/src/redhat/SPECS
fase3: costruzione del binario .rpm
entrate nella directory indicata da rpm:
cd /usr/src/redhat/SPECS
costruire l'rpm definitivo con
rpmbuild -bb *.spec
le opzioni -bb:
b: build, costruisce;
b: binary, pacchetto binario (rpm);
rpmbuild costruisce un pacchetto o più (devel, doc, e simili) .rpm su misura, solitamente con estensione *.rpm e vi indica dove trovarlo, di solito /usr/src/redhat/RPMS/i386/
-se rpmbuild è un comando sconosciuto allora installare il pkg rpm-build
fase 4: installazione del programma
entrate nella directory indicata da rpmbuild:
cd /usr/src/redhat/RPMS/i386/
e installate finalmente il programma:
rpm -ivh *pacchetto*.root.rpm
o aggiornate finalmente il programma:
rpm -Uvh *pacchetto*.root.rpm
*************
seguo fedelmente la guida ma quando dopo
#cd/home/kio
#rpm -ivh *pacchetto*.src.rpm
#cd /usr/src/redhat/SPECS
do
#rpmbuild -bb *.spec
mi compare l'errore
License field must be present in package
apro il file .spec e modifico la riga 6 da copyright GPL a License: GPL!
riprovo e trovo nella dir rpm da me compilato
# cd /usr/src/redhat/RPMS/i386
[root@Fedora i386]# ls
freepops-0.0.29-1.i386.rpm freepops-debuginfo-0.0.29-1.i386.rpm
procedo con l'installazione
# rpm -ivh freepops-0.0.29-1.i386.rpm
Preparing... ###########################################
[100%]
1:freepops ###########################################
[100%]
[root@Fedora i386]#
e bingoooooooooooooo!

vediamo la stessa operazione su mandriva 2007.1 spring
mi procuro il sorgente aggiornato es. di freepops
#rpm -ivh freepops-0.2.2-1ddz2007.1.src.rpm
#cd /usr/src/rpm/SPECS
#rpmbuild -bb *.spec
#cd /usr/src/rpm/RPMS/i586
#ls
freepops-0.2.2-1ddz2007.1.i586.rpm

APPENDICE-2 creare un pkg tgz con lo slackbuild
**************
Lo SlackBuild è semplicemente uno script contenente una lista di comandi stutturati in modo tale da generare un pacchetto Slackware base, installabile semplicemente con i tool pkgtool, installpkg o upgradepkg.
Lo script lavora sulla base di programmi standard come make, gcc etc etc. Normalmente viene accompagnato dai sorgenti originali del programma da lavorare da un file chiamato slack-desck, che contiene la descrizione del pacchetto e dal file doinst.sh usato per impartire comandi esterni di modifica o altro a files esterni.
Ricordiamo che la Slackware utilizza i pacchetti .tgz che sono dei precompilati achiviati con tar e compressi con gzip.
da http://www.slacky.eu/wikislack
*****************
L'uso di questi script è molto utile in caso di ricompilazioni sicure oppure se volete una versione nuova di un pacchetto non ancora disponibile nel ramo current potrete, editando a dovere lo SlackBuild compilare in modo automatico e sicuro i nuovi sorgenti. Ottimizzare alcune applicazioni e molto altro..
nel mio esempio ci costruiremo un tgz con la nuova versione di ntfs-3g la -1.417 del 6 aprile mentre sul slacky.it per la stable/current è disponibile la versione Ntfs-3g 20070204 del 4 febbraio 2007 anche se su
http://www.linuxpackages.net è già presente la nuova versione , procediamo :
1)scarichiamo i sorgenti dal sito http://www.ntfs-3g.org/
2)scarichiamo lo slackbuild -lo slack-required e lo slack-desk da
http://www.slacky.eu/repository/slackware-11
e li inseriamo nella stessa dir
3)modifico lo slack build del pacchettizzatore da così
#!/bin/sh
# Heavily based on the Slackware 11.0 SlackBuild
# http://www.ntfs-3g.org
# Packager Andrea Sciucca ( gohanz at infinito.it)
# http://www.slacky.it
# Required: FUSE.
CWD=`pwd`
TMP=${TMP:-/tmp/tgz}
PKG=$TMP/package/ntfs-3g
NAME=ntfs-3g
VERSION=`date +%Y%m%d`
CHOST=i486
ARCH=${ARCH:-i486}
BUILD=1as
if [ "$ARCH" = "i486" ]; then
SLKCFLAGS="-O2 -march=i486 -mtune=i686"
elif [ "$ARCH" = "i686" ]; then
SLKCFLAGS="-O3 -march=i686 -pipe -fomit-frame-pointer"
elif [ "$ARCH" = "athlon64" ]; then
SLKCFLAGS="-O2 -march=athlon64 -pipe"
elif [ "$ARCH" = "athlonxp" ]; then
SLKCFLAGS="-O3 -march=athlon-xp -pipe -fomit-frame-pointer"
elif [ "$ARCH" = "x86_64" ]; then
SLKCFLAGS="-O2"
elif [ "$ARCH" = "s390" ]; then
SLKCFLAGS="-O2"
fi
......................
a così
#!/bin/sh
# Heavily based on the Slackware 11.0 SlackBuild
# http://www.ntfs-3g.org
# Packager Andrea Sciucca ( gohanz at infinito.it) rivisto by Kio
# Required: FUSE.
CWD=`pwd`
TMP=${TMP:-/tmp/tgz}
PKG=$TMP/package/ntfs-3g
NAME=ntfs-3g
VERSION=1.417
CHOST=i686
ARCH=${ARCH:-i686}
BUILD=1as
if [ "$ARCH" = "i486" ]; then
SLKCFLAGS="-O2 -march=i486 -mtune=i686"
elif [ "$ARCH" = "i686" ]; then
SLKCFLAGS="-O3 -march=i686 -pipe -fomit-frame-pointer"
elif [ "$ARCH" = "athlon64" ]; then
SLKCFLAGS="-O2 -march=athlon64 -pipe"
elif [ "$ARCH" = "athlonxp" ]; then
SLKCFLAGS="-O3 -march=athlon-xp -pipe -fomit-frame-pointer"
elif [ "$ARCH" = "x86_64" ]; then
SLKCFLAGS="-O2"
elif [ "$ARCH" = "s390" ]; then
+ SLKCFLAGS="-O2"
fi
questo perchè Attualmente i pacchetti ufficiale di Slackware sono costruiti per i486,
per cui avremo i seguenti due valori: -march=i486 e -mcpu=i686.
Pacchetti costruiti per uso personale possono anche avere ottimizzazioni più spinte ottimizzati per 686, ad esempio i FLAGS -O3 e -march=i686 (che non funzioneranno dunque su un i486)!!!
a quel punto
#cd /home/kio/ntfs-3g
#./ntfs-3g.SlackBuild --cleanup che mi produce il mio pkg ntfs-3g-1.417-i686-1as.tgz che installo con successo sulla 11.0 e sulla current
per approfondire
http://www.slacky.eu/wikislack
e www.slacky.eu/wikislack