En hoe moet ik nou naar een directory die niet in de hogere directory staat? Of wat moet ik doen als ik "verdwaald" raak en mijn weg naar mijn "home" directory niet meer kan vinden?
In de meeste gevallen maakt het niet uit wat u gebruikt. Een kennelijke uitzondering is als het argument zelf aanhalingstekens bevat. Als we de volgende regel zouden invoeren, zou er een probleem ontstaan:
$ grep 'Croc's stuff' bookmarks.html
Het probleem is hier dat het commando grep (waarover later meer) zal proberen om Croc te gebruiken als argument in plaats van Croc's stuff . In dit geval gebruikt u dus dubbelel aanhalingstekens:
$ grep "Croc's stuff" bookmarks.html
Er zijn gevallen waarin de Linux Shell (de Command-Line Interpreter) speciale betekenis hecht aan bepaalde tekens, zoals het dollarteken $. In dat soort gevallen worden enkele aanhalingstekens aanbevolen.
In het algemeen kunt u de volgende regels gebruiken:
Laten we aannemen dat er enkele bestanden in uw directory staan, hoewel u die niet zelf hebt aangemaakt. Naar alle waarschijnlijkheid staan er ook een stel verborgen bestanden in. We gebruiken het ls commando:
$ls
eenfile prog.c index.html volgende $De echte uitvoer van de lijst kan verschillen, maar in essentie zal het hier op lijken. Dat is prima, maar het geeft niet veel info over de bestanden. Ook kunnen we op deze manier niet weten of "eenfile" en "volgende" bestanden zijn of directories. De meeste namen met een suffix (zoals "prog.c" en "index.html") zullen wel bestanden zijn. De simpelste manier om dat uit te vinden is de optie -l te gebruiken.
$ ls -l
-rw------- 1 jacco student 2379 Jun 20 13:14 eenfile -rw------- 1 jacco student 2382 Jun 20 13:14 prog.c -rw----r-- 1 jacco student 1262 Jun 25 11:27 index.html drwx------ 4 jacco student 512 Jun 24 13:52 volgende $Hier staat meer bruikbare info in. Over de "bevoegdheden" lijst hebben we het later (het -rw------- stukje), maar merk hier alvast op dat een directory een "d" als eerste teken heeft in plaats van een "-". We kunnen hier ook zien wie de eigenaar is van deze bestanden (een zekere jacco in dit geval, hoewel u dat normaliter zelf zult zijn), alsmede de namen en de omvang ervan en de datum waarop de bestanden voor het laatst werden gewijzigd.
Er is nog een (misschien duidelijker) manier om directories te onderkennen. U kunt ook de optie -F gebruiken bij het commando ls, waarna alle directories zullen verschijnen gevolgd door een "/". Bijvoorbeeld:
$ ls -F
eenfile prog.c index.html volgende/ $Maar we hebben nog steeds geen verborgen bestanden gezien, dus hoe laten we die tevoorschijn komen? Simpel door het gebruik van de -a optie. U kunt opties combineren en hier is dat aangewezen. De optie -a alleen helpt niet veel, maar in combinatie met -l krijgt u een mooi overzicht.
$ ls -al
drwx--x--x 22 jacco student 2048 Jun 25 11:57 . drwxr-xr-x 163 root staf 4096 Jun 22 09:19 .. -rw------- 1 jacco student 27630 Feb 4 14:01 .hithere -rw------- 1 jacco student 2379 Jun 20 13:14 somefile -rw------- 1 jacco student 2382 Jun 20 13:14 prog.c -rw----r-- 1 jacco student 1262 Jun 25 11:27 index.html drwx------ 4 jacco student 512 Jun 24 13:52 next $We hebben ze zichtbaar gemaakt! Maar wat zijn de verborgen directories "." en ".."? En wie is die "root"?
$ mkdir vanalles nieuw
$
Hierboven werden er zelfs twee directories aangemaakt. U kunt namelijk net zoveel directories in een keer aanmaken als u wilt. Met het commando ls kunt u beide directories te zien krijgen. Maar hoe kunnen we er in komen? Heel simpel. Middels het commando:
$ cd vanalles
$
Het commando cd (change directory) maakt "vanalles" tot de actieve directory. Opeens herinnert u zich, dat u eigenlijk naar de directory "nieuw" wilde gaan. Hoe komt u terug? Er zijn twee manieren. U kunt eerst terug naar de "aanpalende" directory ('. .') en daarna met cd naar de directory "nieuw".
$ cd ..
$ cd nieuw
$
Maar u kunt ook een relatieve padnaam invoeren om direct naar "nieuw" te gaan.
$ cd ../nieuw
$
Beetje uitgebreid weergegeven betekent het bovenstaande: 'ga naar de
hogere directory en daarna naar de "nieuw" directory'.
En hoe moet ik nou naar een directory die niet in de hogere directory
staat? Of wat moet ik doen als ik "verdwaald" raak en mijn weg naar mijn
"home" directory niet meer kan vinden?
Twee goede vragen.
Ik beantwoord de tweede eerst, omdat dat het gemakkelijkst is. Als
u ooit de weg kwijt bent op de computer, of gewoon terug wilt naar uw home
directory, voert u gewoon cd in zonder verder iets.
Voor een antwoord op de eerste vraag moeten we een paar dingen veronderstellen.
Laten we aannemen, dat u twee directories hebt buiten uw home directory
(vanalles en nieuw b.v.). Als u nu in een directory bent binnen de "vanalles"
directory is de vraag hoe u naar de "nieuw" directory komt. U zou dan twee
keer naar de aanpalende directory kunnen gaan met "cd .." en daarna naar
de "nieuw" directory. Maar er is ook een simpeler manier. U kunt ook het
"~"(tilde) teken gebruiken. Dat teken wordt gebruikt als een voorvoegsel
aan iemands gebruikersnaam, en wordt dan vertaald als (het pad naar) de
home directory van die gebruiker.
$ cd ~/nieuw
$
Dit is dus een korte schrijfwijze voor het complete pad naar uw home directory. En het staat dus b.v. voor:
$ cd /users/cs/student1/gebruikersnaam/nieuw
$
Bovendien: als u ooit het spoor kwijtraakt naar waar u precies bent, kunt u altijd middels het commando pwd de huidige actieve directory opvragen.
U wilt er nog meer van weten? Neem een kijkje bij het bestandssysteem.
In Linux (net als in UNIX) zijn er twee soorten editor, regel- en schermeditors. De verwerkingseenheid van een regeleditor is (zoals het woord zegt) een regel (= een string tekens afgesloten door een RETURN-teken). De populariteit van dit soort editors is miniem vergeleken bij de schermeditors. In dat soort editors kun je de cursor over het hele scherm bewegen en bewerkingen en/of aanpassingen maken waar je maar wilt.
Twee van de meest gebruikte editors in Linux zijn vi en pico. Ik ga hier niet op hun respectieve werking in. Voor beginners beveel ik pico aan. Hij is eenvoudig te gebruiken, maar kan nog niet de helft van wat vi kan. Daar tegenover is vi zeer cryptisch en heeft het zoveel mogelijkheden, dat er geen mens is die ze allemaal uit zijn hoofd weet. Bovendien is vi niet erg gebruikersvriendelijk en rekent op vi-vriendelijke gebruikers. Als u iets fout doet wordt er alleen een boos piepje geproduceerd. En als u de gebruiksaanwijzing niet kent, zullen er heel wat van dat soort piepjes klinken!! Maar het gebruik ervan kan natuurlijk geleerd worden.
Voor het moment kunt u het beste volstaan met
$ pico filename
$
en gebruik maken van de ingebouwde uitleg om enkele bestanden aan te
maken.
Het eerste commando waarmee u de inhoud van een bestand kunt bekijken is cat. Dit commando heet zo, omdat het (bij toevoeging van meer bestandsnamen) de inhoud van bestanden aan elkaar kan koppelen (concateneren). Het is een simpel commando.
$cat somefile
Ik heb hierbij de uitvoer weggelaten, omdat die eenvoudig bestaat uit de inhoud van het bestand. De meeste bestanden bevatten meer tekst dan op 1 scherm weggezet kan worden. Vandaar dat cat soms tamelijk onoverzichtelijk kan werken. Hoewel je met Ctrl-S en Ctrl-Q de uitvoer kunt stilzetten en door laten gaan, gaat het meestal zo snel over het scherm, dat je alleen het eind van het bestand te zien krijgt. In dat geval kun je dus beter een editor gebruiken om het bestand te bekijken.
Oorspronkelijk is cat ontworpen om bestanden aan elkaar te koppelen. Meestal wilt u dan de gezamenlijke inhoud bewaren in een nieuw bestand. Dat gaat als volgt:
$cat file1 file2 > output
waarbij output het bestand is waarin de gekoppelde bestanden file1 en file2 worden bewaard. De volgorde waarin u de invoer bestanden neerzet zal de volgorde van verschijning bepalen in het uitvoerbestand. In dit geval zal file1 eerst verschijnen en daarna file2.
Een ander commando voor het bekijken van bestanden is tail. Daarmee kunt u de laatste paar regels van een bestand bekijken. Standaard zal tail de laatste 10 regels laten zien. U kunt dat echter aanpassen middels de opties "-" en "+".
$tail -3 somefile
laat dus de laatste drie regels zien van somefile, terwijl
$tail +6 somefile
alle regels laat zien vanaf regel 6 tot het eind.
Als u cat en tail tegelijk gebruikt, kunt u een foutmelding krijgen van het onderstaande type
tail: Can't open somefile
Als dat gebeurt, zorg dan dat u de bestandsnaam correct hebt gespeld en dat u in de juiste directory staat. Mogelijk ook hebt u helemaal geen bevoegdheid om het bestand te lezen.
$cp hier daar
staat voor "copieer de inhoud van "hier" naar "daar".
De meeste bewerkingen die gelden voor cd kunt u ook gebruiken bij cp (en bij mv en rm). Om een bestand te copieren naar de hogere directory, gebruikt u het commando:
$cp somefile ..
In dit geval zal het aangemaakte bestand ook somefile heten. Normaliter geeft u de naam van het nieuwe bestand apart aan (zoals in het eerste voorbeeld van cp). Op die manier kan cp ook worden gebruikt om bestanden te hernoemen, waarbij u een copie van het oorspronkelijke bestand onder de oude naam bewaart. Kijk daarvoor nog even naar het eerste voorbeeld. Bestaat het bestand daar al voor we het cp commando gebruiken? Als dat zo is, bent u de oorspronkelijke inhoud ervan dus wel kwijt! Het commando cp overschrijft dat namelijk zonder verder vragen! Controleer de zaak dus eerst b.v. met het commando ls!
Nog een laatste opmerking. U kunt met cp meerdere bestanden tegelijk copieren. Echter kunt u de bestanden alleen copieren naar een reeds bestaande directory en kunt u ze onderweg ook niet hernoemen! Probeer het volgende maar eens:
$cp file1 file2 dir1(dit zou moeten werken)
of
$cp file1 file2 file3(dit zou een foutmelding moeten veroorzaken)
Het commando mv (move) lijkt heel erg op cp, behalve dat u het bestand zelf verplaatst zonder daarvan copieen te maken. Er zijn twee gevallen waarin mv gebruikt kan worden: om bestanden te hernoemen of om ze naar een andere locatie te brengen. Als u een bestand start hebt, dat u wilt hernoemen tot finish, kunt u het volgende intypen:
$mv start finish
Merk op dat na het succesvol draaien van dit commando er geen bestand met de naam start meer is. De inhoud ervan staat nu in het nieuw aangemaakte bestand finish.
Om een bestand te transporteren tussen directories doet u iets dergelijks. B.v. als u het bestand finish wilt verplaatsen naar de directory next, geeft u het volgende commando:
$mv finish next
Klaar. Als u nu een cd doet naar de next directory, zou u daar finish moeten kunnen vinden.
En dan nu het misschien gevaarlijkste commando tot dusver: rm (remove = verwijderen). Zoals de naam al aangeeft staat rm u toe bestanden en directories te wissen. Wees erg voorzichtig met rm, omdat het erg moeilijk is (en soms zelfs onmogelijk!) om verwijderde bestanden terug te halen. Er zijn echter een aantal opties om rm zo veilig mogelijk te maken. Ik zou ze gebruiken als ik u was.
Maar laten we eerst eens zonder opties een bestand verwijderen.
$rm finish
Weg. Compleet verdwenen. Gaat u maar kijken met ls. Het bestand is naar never-never-land!
Maar waar zijn al die opties dan, vraagt u? Laten we er een stel opvoeren. De eerste is de "-i" (= interactief) optie. Als u die gebruikt, zal rm eerst controleren of u het bestand echt wilt verwijderen. Dat is een erg verstandige voorzorg tegen het per ongeluk wissen van een bestand, dat u eigenlijk had willen houden. Een voorbeeld:
$rm -i file1 file2
rm: remove file1?n
rm: remove file2?y
$
Als u de y-toets aanraakt, zal rm dat opvatten als een bevestiging dat het bestand gewist kan worden. Typt u enige andere toets, dan zal rm het bestand niet verwijderen. In ons voorbeeld is file2 dus verwijderd, maar file1 niet.
Een andere optie is het omgekeerde van "-i", namelijk "-f" (staat voor 'force'). Met deze optie zal rm bestanden verwijderen zonder verder ook maar iets te vragen, zelfs als ze schrijfbescherming hebben (daarover hebben we het trouwens straks in het stukje over bestandsbevoegdheden, maar schrijfbescherming houdt in, dat u geen toestemming hebt om een bestand te veranderen).
Probeert u ook maar eens een directory te wissen middels rm. Dat werkt dus niet. Waarschijnlijk kreeg u een foutmelding als:
$rm volgende
rm: volgende is a directory
$
Om directories te verwijderen kunt u het rmdir commando gebruiken. Dat heeft als nadeel dat de directory eerst leeg moet zijn. Gelukkig kunnen we bij rm ook een andere optie gebruiken, die directories wel verwijdert. Zelfs inclusief de eventuele bestanden erin!
Wanneer u rm gebruikt met de optie "-r" (staat voor recursive) zal rm
de directory-boom langsgaan en alle subdirectories en bestanden daarin
wissen. Denk er goed om waar en wanneer u dit commando gebruikt. Als u
het als 'root' gebruikt, kunt u er een compleet Linux-systeem in 1 keer
mee wissen. En dan bent u dus echt alles kwijt!! ;-(
Ons eerste wild-card (of meta-teken) is het vraagteken "?". Dat kan staan voor elk enkel teken.
$ls c?
Met dit commando vindt u alle betanden die namen hebben bestaande uit de letter "c" gevolgd door een enkel ander teken. U kunt ook meerdere vraagtekens gebruiken:
$ls c??
wat de namen laat zien van bestanden met een "c" gevolgd door twee andere tekens.
Het teken "*" (de asterisk) kan overeenkomen met een willekeurige serie tekens, inclusief een serie met de lengte 0 (een zogenaamde nul-string):
$ls c*
Hiermee vindt u alle bestandsnamen met een "c", ongeacht hoe lang de bestandsnaam is.
Een serie tekens ingesloten in teksthaken ("[" en "]") staat bekend als een "character-class". De betekenis daarvan is "kies elk enkele teken dat binnen de teksthaken staat". Bijvoorbeeld:
$ls c[12684xyz]
Dit commando toont alle bestandsnamen die beginnen met "c" en gevolgd worden door "1" of "2" of "6" of "8" of "4" of "x" of "y" of "z".
Alle wild-cards kunnen ook gecombineerd worden om samen nieuwe argumenten
te vormen. Ook gebruikte ik in de voorbeelden alleen ls. Maar u kunt natuurlijk
ook elk ander commando gebruiken. Weest u daar echter voorzichtig mee.
In het bijzonder met rm!!
Voor elk bestand en elke directory zijn er drie klassen van gebruikers,
waarmee rekening gehouden moet worden:
Owner De Owner (eigenaar) is de gebruiker die het bestand aanmaakte. Group Een aantal gebruikers kan gecombineerd worden in een groep. Zo is er ook een groepseigendom gekoppeld aan elk bestand en elke directory. Public Alle andere gebruikers van de Linux machine. Dat wil zeggen: iedereen die op de Linux computer een geldige gebruikersnaam en wachtwoord heeft.Elk bestand en elke directory heeft bovendien drie typen van toegankelijkheid, die aangeven wat er met directory of bestand gedaan kan worden. Omdat directories en bestanden van elkaar verschillen, verschilt ook de interpretatie van de bevoegdheden van elkaar. De geldende bevoegdheden zijn:
Read Leesbevoegdheid. Wie leesbevoegdheid heeft kan de inhoud van het bestand bekijken. Als het over een directory gaat, kan betrokken gebruiker zien welke bestanden er in de directory staan. Write Schrijfbevoegdheid. Wie dat heeft kan de inhoud van het bestand veranderen. Als het om een directory gaat, kan de gebruiker de inhoud van de directory veranderen: nieuwe bestanden aanmaken en oude verwijderen. Execute Uitvoeringsbevoegdheid. Wie dat heeft kan het betreffende programma op de Linux machine uitvoeren. Als het over een directory gaat kan de gebruiker naar die directory toegaan en daar vandaan copieren, als hij tenminste ook leesbevoegdheid heeft voor die directory.Door de drie typen bevoegdheden te combineren en de drie typen van gebruikers, kunnen we komen tot een totaal van 9 combinaties van bevoegdheden:
read leesbevoegdheid voor de eigenaar (user) write schrijfbevoegdheid voor de eigenaar (user) execute uitvoeringsbevoegdheid voor de eigenaar (user) read leesbevoegdheid voor de groep write schrijfbevoegdheid voor de groep execute uitvoeringsbevoegdheid voor de groep read leesbevoegdheid voor het publiek (others) write schrijfbevoegdheid voor het publiek (others) execute uitvoeringsbevoegdheid voor het publiek (others)Normaliter worden deze negen bevoegdheden als volgt weergegeven:
rwxrwxrwx
Een ontbrekende bevoegdheid wordt aangegeven met een "-" en heet een
"bescherming". Deze negen bevoegdheden, of beschermingen, staan tesamen
bekend als de "modus" van een bestand of directory.
Het commando chmod kan op een aantal manieren gebruikt worden. We kijken naar twee ervan, te beginnen met "numerieke specificatie". Deze manier combineert elke bevoegdheid met een 1 en elke bescherming met een 0 (binair systeem dus). Anders gezegd: "rw-r--r--" wordt op die manier "110100100". Lastig? Ik geef toe, dat binaire notatie enige gewenning vraagt. Maar het echt lastige is, dat de binaire notatie niet wordt gebruikt, maar in plaats daarvan de octale notatie. Dan wordt "110100100" vertaalt in "644".
Octale notatie?
Een klein stukje geschiedenis. Computers slaan informatie op in bits. Een bit kan twee waardes hebben: aan of uit, oftewel 0 of 1. Elke keer dat je een nieuwe bit toevoegt, heeft hij weer twee mogelijke waardes, zodat het aantal mogelijke waardes verdubbelt. Twee bits hebben 4 mogelijke waardes. Drie bits hebben 8 mogelijke waardes. Vier bits hebben er 16. Enzovoorts. Een lange reeks nullen en enen is lastig om te lezen. Simpeler is het om de serie te groeperen tot pakketjes die eenvoudiger te behandelen zijn. De eerste generatie computers in de vroege 60er jaren had geen speciale geheugen architectuur en het was gewoon om de bits te clusteren in groepjes van drie. Daardoor konden de mogelijke waardes (zie hierboven) worden weergegeven met de getallenset 0,1,2,3,4,5,6,7 (oftewel"octale notatie").
Kunt u het volgen? Zal wel niet. ;-) Ok ... u zou natuurlijk een boek kunnen gaan lezen over octale (en hexadecimale) notatie. Maar waarschijnlijk werkt het beter als u de conversiekaart hieronder gebruikt om uit te vinden welke octale notatie hoort bij welke modus.
Om de modus te veranderen in een getal telt u gewoon de cijfers op die horen bij de bevoegdheden die u wenst. Als u dus wilt dat het bestand lees- en schrijfbaar is door de eigenaar (uzelf dus), leesbaar voor de groep en leesbaar voor alle anderen, dan komt u tot de optelsom:
400 200 40 4 --- 644Derhalve zal uw chmod commando er als volgt uitzien:
$chmod 644 ditbestand datbestand nogeenbestand
$
Nogmaals: u kunt de modus van vele bestanden in een keer veranderen (zoals hierboven) of elk bestand telkens apart.
Het gebruik van octale getallen om de modus aan te geven kan eerst wat ingewikkeld lijken, maar u gaat weldra de getallen kennen die horen bij de meest gebruikelijke bevoegdheden voor bestanden. Hier zijn een paar van de meest voorkomende:
644 is rw-r--r-- de eigenaar kan lezen en schrijven, de rest alleen lezen. 755 is rwxr-xr-x de eigenaar kan lezen, schrijven en uitvoeren de rest alleen lezen en uitvoeren. Voor een directory, is deze modus gelijk aan 644 711 is rwx--x--x eigenaar kan lezen, schrijven en uitvoeren, alle anderen alleen uitvoeren. 444 is r--r--r-- deze waarde betekent alleen lezen voor iedereenDe tweede manier van het aangeven van de modi is de "symbolische manier" en die is een beetje ingewikkelder. U hebt daarbij de keus te zeggen welke modus u wilt hebben, of aan te geven hoe u wilt dat de bestaande bevoegdheden worden veranderd. Hiervoor worden de volgende afkortingen gebruikt:
De typen bevoegdheden zijn zoals gewoonlijk r, w en x.u user (eigenaar) bevoegdheden g group bevoegdheden o others (public) bevoegdheden a all, dus user, group en others bevoegdheden = kent een bevoegdheid absoluut toe + voeg een bevoegdheid toe - haal een bevoegdheid weg
Een van de redenen dat de symbolische manier complex kan zijn is, dat hij u vele manieren verschaft om een en hetzelfde te doen. Bijvoorbeeld als we een lees/schrijf bevoegdheid willen toekennen aan de gebruiker, leesbevoegdheid voor de groep en idem voor alle anderen kan dat als volgt:
$chmod a=r,u+w somefile
$
of
$chmod u=rw,go=r somefile
$
Kijkt u maar eens rustig en probeer uit te vinden wat elke symbolische aanduiding doet. Merk daarbij op, dat "a=r" leesbevoegdheid verleent aan iedereen en dat "u+w" daar voor de gebruiker dus schrijfbevoegdheid aan toevoegt.
De nieuwe modus die u wenst moet voor chmod als enkel argument verschijnen. Dat wil zeggen dat er geen enkele spatie in mag zitten. Als er dus meer dan een verandering wordt aangegeven, worden die gescheiden door komma's en niet door spaties, hoewel dat in Linux (UNIX) niet echt gebruikelijk is.
Hieronder is een voorbeeld van het veranderen van de huidige modus in plaats van het opgeven van een compleet nieuwe modus.Als de directory een aantal bestanden bevat die alreeds lees-, schrijf- en uitvoerbaar zijn voor iedereen:
$ls -l
-rwxrwxrwx 1 jacco student 1045 Mar 18 13:35 ditbestand -rwxrwxrwx 1 jacco student 11925 Mar 6 16:33 datbestand -rwxrwxrwx 1 jacco student 1458 Jun 17 13:07 nogeenbestand $en we willen weer lees/schrijfbevoegdheid voor de gebruiker, leesbevoegdheid voor de groep en idem voor alle anderen, kunnen we simpel de schrijfbevoegdheid voor group en others verwijderen:
$chmod go-w ditbestand datbestand nogeenbestand
$ls -l
-rwxr-xr-x 1 jacco student 1045 Mar 18 13:35 ditbestand -rwxr-xr-x 1 jacco student 11925 Mar 6 16:33 datbestand -rwxr-xr-x 1 jacco student 1458 Jun 17 13:07 nogeenbestand $Nog een voorbeeld: als u wilt dat een bestand uitvoerbaar is voor iedereen, maar u wilt verder de lees/schrijfbevoegdheden laten als ze zijn:
$chmod a+x file
$
Als u geen gebruiker, groep of anderen aangeven, wordt aangenomen dat
u iedereen bedoelt. Dus:
$chmod +x file
$
doet precies hetzelfde als het vorige voorbeeld.
Het veranderen van modi kan lastig zijn, en bovendien weinig vruchtbaar. De meest belangrijke uitzondering zou zijn als u begint met het maken van homepages. Dan is het nodig de modi voor bepaalde directories en bestanden te veranderen zodat ze leesbaar zijn door iedereen (waaronder natuurlijk de webbrowser).
Tenslotte: als u om welke reden ook ooit de aanmaakdata van bepaalde bestanden wilt veranderen in de huidige datum/tijd, dan kunt u dat doen met het touch commando. Het is ook mogelijk de tijd op te geven. Zie daarvoor de uitleg bij touch, middels het commando man touch.
Koppelingen geven u de mogelijkheid een enkel bestand meerdere namen te geven. Bestanden wordt in het bestandssysteem eigenlijk onderscheiden aan de hand van hun inode nummer. Dat is een uniek identificatiemiddel voor elk bestand. Een directory is daarbij eigenlijk een lijst van inode nummers met de bijbehorende bestandsnamen. Elke bestandsnaam in een directory is een koppeling naar een enkele inode. Het commando ln wordt gebruikt om meer dan een koppeling te maken voor een enkel bestand. Laten we zeggen dan u het bestand onzin in een directory hebt staan. Middels het commando ls -i kunnen we het inode nummer voor dat bestand zichtbaar maken.
$ ls -i onzin
22192 onzin
$
Hier heeft het bestand onzin een inode nummer van 22192 in het bestandssysteem. We kunnen een extra koppeling maken naar onzin, namelijk larie:
$ ln onzin larie
Met ls -i kunnen we zien dat de twee bestanden hetzelfde inode nummer hebben.
$ ls -i onzin larie
22192 larie 22192 onzin
$
Met andere woorden: middels hetzij onzin, hetzij larie benaderen we hetzelfde bestand. Als u veranderingen maakt in onzin, zullen die veranderingen ook in larie gemaakt worden. Bij alle bewerkingen slaan onzin en larie op hetzelfde bestand.
Deze koppelingen worden aangeduid als harde (of echte) koppelingen omdat ze een directe koppeling maken naar een inode. Merk op dat u alleen dergelijke koppelingen kunt maken in hetzelfde bestandssysteem. Symbolische koppelingen (zie hieronder) hebben die beperking niet.
Als u een bestand verwijdert met het commando rm, verwijdert u feitelijk alleen een koppeling naar dat bestand. Als u het commando gebruikt:
$ rm onzin
wordt alleen de koppeling met de naam onzin verwijderd. De koppeling larie zal nog steeds bestaan. Een bestand is ook alleen echt van de computer verwijderd als er geen koppelingen naar dat bestand meer bestaan. Normaliter heeft een bestand slechts een koppeling. Het commando rm zal het bestand derhalve geheel verwijderen. Als een bestand echter meerdere koppelingen heeft, zal rm telkens slechts een koppeling verwijderen. Teneinde het bestand helemaal te verwijderen, dient u alle koppelingen naar het bestand te wissen.
Het commando ls -l zal het aantal koppelingen naar een bestand (naast andere informatie) laten zien.
$ ls -l onzin larie
-rw-r--r-- 2 root root 12 Aug 5 16:51 larie
-rw-r--r-- 2 root root 12 Aug 5 16:50 onzin
$
De tweede kolom in de lijst, "2", geeft het aantal koppelingen naar het bestand aan.
Zoals gezegd is een directory feitelijk alleen een bestand met informatie over de koppelingen naar inodes. Bovendien heeft elke directory twee harde (echte) koppelingen, namelijk "." (een koppeling naar zichzelf) en ".." (een koppeling naar de hogere directory). In de root directory (/) verwijst echter de koppeling ".." alleen naar de directory zelf ('/'). Er is immers geen hogere directory dan de root directory.
Symbolische koppelingen zijn een ander soort koppelingen, enigszins anders dan de harde (echte) koppelingen. Een symbolische koppelingen geeft u de mogelijkheid een bestand een andere naam te geven, maar koppelt het bestand niet via een en dezelfde inode.
Het commando ln -s zal een symbolische koppeling maken naar een bestand. Gebruiken we bijvoorbeeld het commando
$ ln -s onzin larie
dan maken we de symbolische koppeling larie die wijst naar het bestand onzin. Als we het commando ls -i gebruiken, zien we dat de twee bestanden feitelijk verschillende inodes hebben.
$ ls -i onzin larie
22195 larie 22192 onzin
$
Gebruiken we echter het commando ls -l, dan zien we dat het bestand larie een symbolische koppeling is, wijzend naar onzin.
$ ls -l onzin larie
lrwxrwxrwx 1 root root 3 Aug 5 16:51 larie -> onzin
-rw-r--r-- 1 root root 12 Aug 5 16:50 onzin
$
De bevoegdheden bits voor een symbolische koppeling worden niet gebruikt (ze verschijnen dus altijd als rwxrwxrwx). In plaats daarvan worden de bevoegdheden bepaald door die van het doel van de symbolische koppeling. In ons voorbeeld dus door de bevoegdheden van onzin.
Functioneel zijn echte en symbolische koppelingen gelijk. Feitelijk zijn er een paar verschillen. Om te beginnen: je kunt een symbolische koppeling maken naar een bestand dat niet bestaat. Datzelfde kan nooit bij een echte koppeling. Bovendien worden symbolische koppelingen door de kernel anders behandeld dan echte koppelingen. Dat is natuurlijk alleen een technisch verschil, maar het is wel belangrijk! Symbolische koppelingen zijn makkelijk omdat ze aangeven naar welk bestand ze wijzen. Met echte koppelingen is het niet makkelijk uit te maken welke filenamen allemaal wijzen naar dezelfde inode.
Koppelingen worden op vele plekken in het Linux systeem gebruikt. Symbolische koppelingen zijn vooral belangrijk bij de gedeelde library images in /lib. Zie Verkenning van het bestandssysteem voor meer informatie over /lib.
Het format van het commando is
tar {opties} file1 file2 ... fileN
waarbij {opties} slaat op de lijst commando's en opties voor tar, en file1 tot en met fileN slaat op de lijst van bestanden die in- of uitgepakt moet worden.
Het commando
$ tar cvf backup.tar next
bijvoorbeeld pakt alle bestanden in next in het tar archief backup.tar. Het eerste argument voor tar (``cvf'') is het tar ``commando''. ``c'' zegt tar om een nieuw archief bestand aan te maken. De ``v'' optie dwingt tar om te werken in de "verbose mode" (veel uitleg over wat tar doet), waarbij elke bestandsnaam wordt geschreven terwijl hij wordt gearchiveerd. De ``f'' optie maakt tar duidelijk dat het volgende argument (backup.tar) de naam is van het aan te maken archief. De rest van de argumenten voor tar zijn de bestands en directory namen die aan het archief moeten worden toegevoegd.
Het commando
$ tar xvf backup.tar
zal het tar bestand backup.tar uitpakken in de huidige directory. Dit kan soms gevaarlijk zijn. Als u bestanden uit een tar bestand uitpakt, kunnen oude bestanden overschreven worden.
Verder is het van belang voordat u tar bestanden uitpakt, om te weten waar de bestanden zullen komen staan. Bijvoorbeeld: laten we zeggen dat u de volgende bestanden heeft gearchiveerd: next/index.html, next/prog.c, en next/assign.dvi. Als u nu het commando gebruikt
$ tar cvf backup.tar next/index.html next/prog.c next/assign.dvi
wordt de directory naam next/ toegevoegd aan het begin van elke bestandsnaam. Om de betanden op de juiste plaats uitgepakt te krijgen dient u de volgende commando's in te voeren:
$ cd /
$ tar xvf backup.tar
omdat de bestanden worden uitgepakt met de padnaam in het archiefbestand opgeslagen.
Als u echter de bestanden hebt gearchiveerd met het commando
$ cd next
$ tar cvf index.html prog.c assign.dvi
is de directory naam niet bewaard in het archief. Daarom zou u ``cd next'' moeten invoeren voor u de bestanden uitpakt. Zoals u ziet maakt het groot verschil hoe u het archiefbestand hebt ingepakt. Het commando
$ tar tvf backup.tar
Kan worden gebruikt om een "index" te vertonen van het tar bestand voor u het uitpakt. Op die manier kunt u zien welke directory er mogelijk met de bestanden is meegekomen, zodat u de zaak op de goede manier kunt uitpakken.
Anders dan archiveringsprogramma's voor DOS comprimeert tar de bestanden niet automatisch bij het archiveren. Als u dus twee bestanden van 1 Mb elk archiveert, zal het tar bestand 2 Mb in omvang zijn. Het gzip commando kan worden gebruikt om een bestand te comprimeren. Het commando
$ gzip -9 backup.tar
zal backup.tar comprimeren en u het bestand backup.tar.gz opleveren: de gecomprimeerde versie van het bestand. De optie -9 maakt aan gzip duidelijk dat de hoogste compressiefactor moet worden gebruikt.
Het gunzip commando kan worden gebruikt om een gzipped bestand uit te pakken. U kunt ook gebruik maken van ``gzip -d''.
gzip is een relatief nieuw programma in de Linux/UNIX wereld. Gedurende vele jaren werd het compress commando gebruikt. Vanwege verschillende redenen wordt dit programma nu uitgefaseerd.
Gecomprimeerde bestanden hebben .Z als extensie. Zo is bijvoorbeeld backup.tar.Z de gecomprimeerde versie van backup.tar, terwijl backup.tar.gz de gezippede versie is. Het uncompress commando werd gebruikt om gecomprimeerde bestanden uit te pakken. gunzip weet daar ook mee om te gaan.
Derhalve: om een groep bestanden te archiveren en het resultaat te comprimeren kunt u de volgende commando's gebruiken:
$ tar cvf backup.tar next
$ gzip -9 backup.tar
Het resultaat zal het bestand backup.tar.gz zijn. Om dit bestand uit te pakken gebruikt u de omgekeerde volgorde:
$ gunzip backup.tar.gz
$ tar xvf backup.tar
Natuurlijk moet u er wel zeker van zijn dat u in de juiste directory bent voor u een tar bestand uit pakt.
U kunt ook wat UNIX trucjes gebruiken om dit allemaal op een commando regel te doen, zoals hieronder:
$ tar cvf - next | gzip -9c > backup.tar.gz
Hier sturen we het tar bestand naar "-" wat staat voor tar's standaard uitvoer. Dit wordt gepiped naar gzip, die het binnenkomende tar bestand comprimeert en het resultaat wegzet in backup.tar.gz. De -c optie voor gzip maakt gzip duidelijk om zijn uitvoer naar stdout te sturen, wat wordt omgeleid naar backup.tar.gz.
Een enkel commando om dit archief uit te pakken zou er zo uit zien:
$ gunzip -c backup.tar.gz | tar xvf -
Nogmaals: gunzip pakt de inhoud van backup.tar.gz uit en stuurt het resulterende tar bestand naar stdout. Dit wordt weer doorgevoerd naar tar, die ``-'' inleest, deze keer verwijzend naar tar's standaard invoer.
Gelukkig sluit het tar commando de z optie automatisch in, zodat bestanden onmiddellijk worden gecomprimeerd of uitgepakt, met gebruikmaking van het gzip compressie algoritme.
Bijvoorbeeld: het commando
$ tar cvfz backup.tar.gz next
is equivalent aan
$ tar cvf backup.tar next
$ gzip backup.tar
Net als het commando
$ tar xvfz backup.tar.Z
gebruikt kan worden in plaats van
$ uncompress backup.tar.Z
$ tar xvf backup.tar
Lees de man pagina's van tar en gzip voor meer informatie.
