Källkod-configure


bild

Bilden visar en vanlig körning av kommandot "make"

Källkod


Vanlig källkod (./configure), vanligen packad med gunzip [programnamn.versionsnummer].tar.gz eller bzip2 [programnamn.versionsnummer].tar.bz2.

Beroenden

Beroenden för att kunna kompilera (bygga och installera) källkod: (GNU Compiler Collection, med C, C++ och ev java), d v s gcc, gcc-c++ inklusive libstdc++ libstdc++-devel, make samt tar för att kunna packa upp (rpmlib för tar och libbz2/bzip2 för bz2).
Vissa källkodsprogram -som t ex efax-gtk [Efax-GTK, en mjukvaru-fax] och rkhunter [Rootkit Hunter]- kan vid byggandet/kompileringen behöva stöd från/eller påverkar systemets kärna [kernel]: I de fallen behövs också kernel-source och kernel-headers för det egna systemet.
Vissa källkodspaket hämtas bäst från git- eller subversion-förråd/repositories. För att kunna hämta dessa: Installera även git samt svn/subversion.

[Dessutom kan man, om man vill försöka bygga ett distributionseget "paket" installera rpm-build eller checkinstall i SuSE/Fedora, checkinstall eller build-essential i Debian och dess derivat (t ex Ubuntu och LinuxMint) respektive checkinstall i Slackware. -Det bör nämnas att checkinstall inte uppdaterats sedan 2008 och därför inte längre är helt tillförlitligt. -rpm-build för SuSE/Fedora respektive build-essential för Debian och derivaten är tillförlitligare. I Slackware kan man som tillförlitligare alternativ installera src2pkg. Tillvägagångssättet vid pakettillverkningen är något annorlunda.]

Källkodsinstallation kan vara trickig eftersom man själv måste hålla reda på vilka beroenden det program man vill installera har. D v s ta reda på vilka extra program man behöver bygga och installera och installera dem i rätt ordning. Ju mer arbete man lägger på att undersöka detta innan man börjar, desto lättare brukar byggandet gå. -Det finns också poänger med källkod: Dels tillverkas det så det oftast passar den distribution man har, dels kan man numera lita på att det automatiskt byggs för den arkitektur man har, d v s 32-bitars- (X86) eller 64-bitars (X86_64)-arkitektur.

Hämta och packa upp källkoden

Om du nu tagit hem ett program i källkod (vanligen för att det inte funnits i din distributions repositorier) bör du lägga den i en särskild katalog, t ex src (för source) i din hemkatalog. Har du tagit hem det från sourceforge bör du kontrollera om det står något om beroenden (requires/requirements/dependencies) från platsen där du hämtade det. Du kan också kontrollera om programmet har en projektsida där det står något om beroenden. Hittar du inget där kan du göra en öppen sökning på internet och söka på programnamnet och dependencies eller requires et c. Hittar du fortfarande inget är det tyvärr bara att packa upp den komprimerade program-källkoden och undersöka filerna där.

Navigera till katalogen där du har din nedladdade [programnamn.versionsnummer].tar.gz

$ cd /***/**/[katalog där du lagt den komprimerade filen]


Packa upp källkoden:
Om packat med gunzip

$ tar -zxvf [programnamn.versionsnummer].tar.gz


Förklaring till "flaggorna":

-z : Uncompress the resulting archive with gzip command.
-x : Extract to disk from the archive.
-v : Produce verbose output i.e. show progress and file names while extracting files.
-f [programnamn.versionsnummer].tar.gz : Read the archive from the specified file called [programnamn.versionsnummer].tar.gz.


Om packat med bzip2

$ tar xvjf [programnamn.versionsnummer].tar.gz


Förklaring till "flaggorna":

x - extract
v - verbose output (lists all files as they are extracted)
j - deal with bzipped file
f - read from a file, rather than a tape device


I bägge fallen får du nu en ny katalog med namnet programnamn.versionsnummer/
Navigera till den med terminalen

$ cd programnamn.versionsnummer


Byggandet/Kompileringen

Studera noga filerna README och INSTALL och sök efter beroenden med samma beteckningar som ovan (requires et c).
Där kan också stå något om du behöver använda speciella flaggor när du kör configure: Notera dessa!
Det är inte helt fel att också läsa konfigurations-scriptet "configure": Där brukar i en separat del listas ytterligare flaggor (options) som kan användas vid byggandet. (-Som de står är de helt inaktiva!) Notera nu samtliga flaggor (options) du beslutat använda!

Har du på något sätt av de beskrivna nu hittat något om vilka beroenden ditt nya källkodsprogram ser du först till att ta hem och installera dem. Du kan ibland ha tur och hitta något av dem bland dina redan installerade, eller i din distributions repositorier. Om inte, får du ta hem, bygga och installera dem och se till att du göre det FÖRE du bygger ditt ursprungligen hemtagna program.
OBS! Har du något eller några av beroendena installerade från din distributions repositorier bör du också installera dessa beroendens -devel (utvecklings) komponenter! Dessa ingår normalt i en källkodsinstallation men separeras ofta ut till egna paket vid paketbygge (rpm, deb et c).OBS!

Har du inte hittat något om ditt nya källkods-programs beroenden återstår bara den plågsamma vägen: Att börja bygga det och stå ut med alla "Stopp" under bygget (f f a under "configure"), undersöka var configure stannar, se vilket program som saknas, installera det, pröva igen till nästa stopp, undersöka det nya stoppet, vad som saknas, installera det programmet..... o s v tills configure lyckas köra färdigt!

Om det ändå kanske inte är så besvärligt som jag beskriver närmast ovan, de flesta beroenden kanske redan är installerade, är tillvägagångssättet för att bygga och installera källkods-programmet inte så svårt.

Du "står" alltså med terminalen i den uppackade källkodskatalogen /programnamn.versionsnummer/
Kör configure

$ ./configure

Har man i det ovanstående bestämt sig för att lägga till några flaggor (options) läggs dessa, separerade med mellanslag, till kommandot ./configure vid körningen. Exempel:

$ /.configure --enable-[option1] --enable-[option4] --disable-[option7]


I bästa fall går det lättare än jag målade på väggen ovan, till slut blir det klart i alla fall ;-)!
Kör make

$ make


Nu har du tillverkat en "i princip" installerbar version av programmet! Allt du tillverkat hittills har inte berört rootfilsystemet, allt tillverkat och byggt ligger kvar i din ursprungliga uppackade katalog: /programnamn.versionsnummer/ Nu har du också ett antal val och minst ett övervägande att göra!

Avinstallation?

Du bör kontrollera om det finns installations- och avinstallationsscript i filen Makefile (eller ev i separata script med namnet "install"/uninstall")?
Öppna den/dem och läs: Sök efter "install" respektive "uninstall".
Finns det bör du spara byggkatalogen inkl filen Makefile för att kunna avinstallera programmet om du i framtiden skulle vilja det.
Finns det INTE bör du ändå spara filen Makefile: Scriptet "install" innehåller en detaljerad beskrivning av var programmets filer läggs. Vid en manuell avinstallation är det den beskrivningen du får följa för att manuellt kunna radera programmets filer och se till att du raderar RÄTT filer.

Bygga distributionseget paket?

OBS! Bortsett från Slackware-beskrivningen för paket nedan är detta något som i realiteten visat sig ha mycket små förutsättningar att lyckas i Debian/Fedora/OpenSUSE! OBS! Det kräver ett helt annat förfarande vid konfigurationen.
Allmänt: Se t ex: http://www.linuxuser.co.uk/tutorials/make-your-own-deb-and-rpm-packages
För Debian: https://www.debian.org/doc/manuals/maint-guide/first.en.html
För Fedora: https://fedoraproject.org/wiki/How_to_create_an_RPM_package
För OpenSUSE: https://en.opensuse.org/openSUSE:Packaging_guidelines

Vill du ändå försöka bygga ett programpaket som är anpassat för din distribution (*.rpm, *.deb eller *.tgz/*.txz) kan det ha vissa fördelar framför att köra en direkt installation:
Du kan hantera programmet med distributionens egen pakethanterare och du kan enkelt vid behov avinstallera det med denna.
Har du installerat checkinstall:
I Debian/Fedora/OpenSUSE/Slackware kan du då i stället för

# make install


som användare (fortfarande) köra

$ checkinstall


och därefter (som root/sudo) installera paketet med din distributions pakethanterare.

Har du i stället installerat (i Fedora/OpenSUSE) rpm-build/ (i Debian) build-essential
kör du i stället

$ make package


och därefter (som root/sudo) installera paketet med din distributions pakethanterare.

I Slackware finns en alternativ metod, "src2pkg", som bortsett från kontrollen av beroendena, gör källkodshanteringen annorlunda och något enklare:
Har du, så långt möjligt kontrollerat och installerat ditt nya källkodsprograms beroenden kan du redan när du tagit hem den packade källkoden [programnamn.versionsnummer].tar.gz använda programmet src2pkg.
-Du tar hem och installerar det från: http://www.src2pkg.net/ -> http://distro.ibiblio.org/amigolinux/download/src2pkg/
Efter installationen tar programmet dig genom en guidad konfiguration, default-värdena är vanligen tillräckligt bra.

Ställ dig i den katalog dit du tog hem din oupppackade källkod [programnamn.versionsnummer].tar.gz
"Bli" root:

$ su
lösenord: ******
# src2pkg [programnamn.versionsnummer].tar.gz


(i själva verket kör scriptet src2pkg ./configure make i /tmp/programnamn.versionsnummer]-src-1/build. Är inte alla beroenden uppfyllda får du också under configure samma plågsamma sökande var det stannar, och beroendelösande som jag beskrev ovan.)
Det färdiga *.tgz/*.txz-paketet ligger /tmp och kan installeras eller hämtas därifrån för senare installation.

Direkt installation?

Vill du, i stället för omvägen via "paket", installera programmet du byggt direkt, måste du få administratörs/root-behörighet:

$ su
lösenord: *******
# make install
#


eller

$ sudo make install
lösenord: *********
$


OBS! Spara här terminalloggen för # make install! OBS! Underlättar vid ev avinstallation.

Källkodsprogram installeras vanligen i /usr/local/bin /usr/local/lib och /usr/local/share (om du inte ändrat detta med någon flagga i configure). Vill du avinstallera det direktinstallerade programmet och har ett uninstallscript i Makefile, navigerar du åter till din uppackade källkodskatalog

$ cd /programnamn.versionsnummer/


och som root/sudo kör

# make uninstall


Har du inget avinstallationsscript, men har sparat terminal-loggen för # make install, kan du enkelt följa den, se var ditt programs filer ligger installerade och radera dem där.
Har du ingendera men har kvar Makefile får du läsa den (under "install") och se vart filerna installerades.


valid-xhtml10 Strict valid-css