Linux voor beginners/De terminal

Uit Wikibooks
Ga naar: navigatie, zoek

Linux voor beginners

  1. Inleiding
  2. Welke versie kiezen?
  3. Installatie
  4. Eerste keer opstarten
  5. Software installeren
  6. Structuur van Linux
  7. De terminal

Appendix


In de meeste Linux systemen staat de terminal nog altijd centraal, in de andere distro's is de terminal nog duidelijk zichtbaar. De terminal is een tekst console waar je commando's in typt om zo opdrachten aan je besturingssysteem of aan een specifiek programma te geven, ook vaak aangeduid met de term commandline. Veel Linux gebruiker beweren dat "de muis gemakkelijke dingen gemakkelijk houdt en dat de commandline moeilijke dingen doenbaar houdt". Je zal dus niet constant met de terminal moeten werken en als je geen moeilijke taken wil doen, dan zal je er nooit mee moeten werken. Maar ik kan je verzekeren, als je kan met de commandline werken, dan zal je deze kennis goed kunnen gebruiken.

Zelf heb ik met de commandline leren werken door de site http://www.linuxcommand.org . Deze (engelstalige) site is nog altijd heel goed als je wat meer geavanceerde methodes wil leren om met de commandline te werken.

Op de volgende pagina's zullen we een kleine inleiding geven in het werken met de terminal. De terminal in Mint kan je onder de favorieten vinden in het Menu. De gebruikers van Mint vonden het plezant om altijd een kleine quote in ASCII-art te tonen. Als je dus de terminal opstart zal je iets dergelijks zien:

 
 ______________________________________
/ You will remember something that you \
\ should not have forgotten.           /
 --------------------------------------
       \   ,__,
        \  (oo)____
           (__)    )\
              ||--|| *
gebruiker@computer ~ $

Na het $-teken zie je een knipperende cursor, daar kan je commando's ingeven.

Navigatie[bewerken]

Het eerste commando dat je kan uitproberen is het commando ls (list). ls dient om de inhoud van de huidige map weer te geven. Als je het commando ls even ingeeft, dan moet je een resultaat verkrijgen zoals hier onder staat.

 
$ ls
Afbeeldingen
Bureaublad
Documenten
Downloads
...

We zullen niet meer alles voor het $-teken herhalen maar enkel het $-teken overschrijven als je zelf een commando wil ingeven. Alle code die dus met een $-teken begint moet je zelf ingeven, de rest is het resultaat van het commando dat je net ingegeven hebt.

Je merkt dus dat je momenteel in je persoonlijke map zit, de map waarin je documenten, afbeeldingen en dergelijke staan. Je kan ook altijd zien in welke map je zit als je kijkt naar wat net voor het $-teken staat. Een tilde (~) staat hier voor je persoonlijke map, andere mappen zullen altijd getoond worden door het pad weer te geven. Je kan ook de huidige map bekijken door het commando pwd (print working directory) te gebruiken. het resultaat ven het commando pwd is dan iets zoals

$ pwd
/home/gebruiker

Om van directory te veranderen kan je het commando cd (change directory) gebruiken. Bij het commando cd moet je wel een argument mee geven. Dit argument, de map waar je naartoe wil, moet je er gewoon na typen. Als je bijvoorbeeld naar de map "Documenten" wil gaan, dan kan je het volgende commando gebruiken:

$ cd Documenten

Opgelet want Linux is hoofdlettergevoelig. De directory "Documenten" is dus een andere directory dan "documenten".

Je kan ook meteen het volledige pad ingeven zoals hieronder getoond:

$ cd /home/gebruiker/Documenten

Let wel op dat je gebruiker vervangt door jouw gebruikersnaam.

Als je het volledige pad ingeeft moet dit beginnen met de rootdirectory /. Om een directory omhoog te gaan kan je .. gebruiken als argument. Als je nu in je map Documenten bent, dan zal het volgende commando je terug naar je persoonlijke directory brengen.

$ cd ..

Je kan zo ook drie mappen omhoog gaan met het argument ../../...

Hulpmiddelen[bewerken]

De terminal heeft ook een geschiedenis. Met het pijltje omhoog kan je het vorige commando opnieuw oproepen en eventueel wijzigen, met het pijltje naar beneden krijg je dan weer het volgende commando in de geschiedenis. Veel terminals hebben ook een autoaanvulfunctie, als je een deel van het commando hebt ingetypt, dan moet je enkel nog je tab-toets gebruiken om het commando automatisch aan te vullen. Stel dat je van je persoonlijke map naar de map "Documenten" wil navigeren, dan hoef je enkel het commando cd Doc intypen en daarna op de tab-toets. Je zal zien, als "Documenten" de enige map is die begint met "Doc", dat dan het commando automatisch aangevuld wordt tot cd Documenten/. Het kopiëren uit de terminal kan voor sommige mensen onhandig lijken tot je de gemakkelijkste manier weet. In alle Linux programma's kan je immers kopiëren door op een plaats tekst te selecteren, dan je cursor op een andere plaats te zetten en met de middelste muisknop te klikken. Voor muizen met een scroll wieltje is dat het scroll wieltje en voor mensen met een muis met twee knoppen of een touchpad kan je met de twee knoppen tegelijk klikken.

Argumenten en opties bij een commando[bewerken]

Argumenten[bewerken]

Je hebt al gezien dat je bij het commando cd een argument moet voegen. In het geval van het commando cd is dit de directory naar waar je wil navigeren. Er zijn echter ook commando's die niet altijd een argument nodig hebben maar er wel een mogen krijgen. Een voorbeeld van zo'n commando is het ls commando. Als je bij het ls commando geen argument heeft, dan toont het gewoon de inhoud van de huidige directory. Als je als argument een directory heeft, dan toont ls de inhoud van die directory. We geven een voorbeeld hieronder:

$ ls /bin
bash                  echo        more            sh.distrib
bunzip2               ed          mount           sleep
bzcat                 egrep       mountpoint      stty
bzcmp                 false       mt              su
bzdiff                fgconsole   mt-gnu          sync
bzegrep               fgrep       mv              tailf
bzexe                 fuser       nano            tar
...

Opties[bewerken]

De meeste commando's bieden de mogelijkheid om naast argumenten ook opties mee te geven. Het is algemeen afgesproken dat opties die bestaan uit één letter met een enkel streepje (-) vooraf gegaan worden en opties die bestaan uit een woord met een dubbel streepje (--) vooraf gegaan worden. Om te kijken welke opties er bestaan voor een commando bieden de meeste commando's de --help optie aan, sommige gebruiken ook -h. Om de help van het commando ls op te vragen doe je dus het volgende:

$ ls --help
Gebruik:  ls [OPTIE]... [BESTAND]...
Informatie tonen over de gegeven BESTANDen (standaard over de huidige map).
De items worden alfabetisch gesorteerd als geen van de opties '-cftuvSUX'
noch '--sort' gegeven is.

(Een verplicht argument bij een lange optie geldt ook voor de korte vorm.)
  -a, --all                  ook de namen tonen die beginnen met een '.'
  -A, --almost-all           als '-a', maar de items '.' en '..' weglaten
      --author               met '-l': de auteur van elk bestand tonen
  -b, --escape               van niet-grafische tekens de octale waarde tonen
      --block-size=GROOTTE   te gebruiken blokgrootte (in bytes; zie onder)
  -B, --ignore-backups       geen namen tonen die eindigen op '~'
  -c                         met '-lt': op 'ctime' sorteren en deze tonen (de
                               tijd van de laatste statusinformatiewijziging);
                               met '-l': op naam sorteren en 'ctime' tonen;
                               anders: op 'ctime' sorteren
  -C                         de items in kolommen presenteren (standaard)
      --color[=WANNEER]      bestandstypen met kleuren onderscheiden;
                               WANNEER is 'always' (altijd), 'never' (nooit),
                               of 'auto' (uitvoerapparaatafhankelijk)
  -d, --directory            de mappen zelf tonen in plaats van hun inhoud,
                               en symbolische koppelingen niet volgen
  -D, --dired                uitvoer produceren voor de 'dired'-modus van Emacs
  -f                         hetzelfde als '-a -U' zonder '-l -s --color'
  -F, --classify             achter elk item het type aanduiden (één van */=@|)
      --file-type            idem, maar '*' niet tonen
      --format=WOORD         te gebruiken opmaak; WOORD kan zijn 'commas' (-m),
                               'across' of 'horizontal' (-x), 'vertical' (-C),
                               'long' of 'verbose' (-l), 'single-column' (-1)
      --full-time            hetzelfde als '-l --time-style=full-iso'
  -g                         als '-l', maar geen eigenaar tonen
      --group-directories-first
                             mappen vóór bestanden groeperen; kan aangevuld
                               worden met een '--sort', maar gebruik van
                               '--sort=none' of '-U' deactiveert groepering
  -G, --no-group             bij een uitgebreide lijst geen groepsnaam tonen
  -h, --human-readable       groottes in leesbare vorm tonen (bijv. 15K, 234M)
      --si                   idem, maar machten van 1000 i.p.v. 1024 gebruiken
  -H, --dereference-command-line
...

We zullen hier onder enkele veelgebruikte opties van het commando ls bespreken als voorbeeld.

Veelgebruikte opties van het ls commando[bewerken]

Een eerste veelgebruikte optie van het ls commando is de -l optie. Deze optie zal een meer uitgebreide lijst geven van de bestanden in de huidige directory. Hieronder staat een mogelijk resultaat.

$ ls -l
-rw-------   1 gebruiker  groep       576 Apr 17  1998 tekstje.txt
drwxr-xr-x   6 gebruiker  groep      1024 Oct  9  1999 mijnWebSite
-rw-rw-r--   1 gebruiker  groep    276480 Feb 11 20:41 mijnWebSite.tar
-rw-------   1 gebruiker  groep      5743 Dec 16  1998 kaartje.txt

----------     ---------  -----  -------- ------------ ---------------
    |              |        |        |         |             |
    |              |        |        |         |       Bestandsnaam
    |              |        |        |         |
    |              |        |        |         +---    Datum laatste wijziging
    |              |        |        |
    |              |        |        +-------------    Grootte (in bytes)
    |              |        |
    |              |        +----------------------    Groep
    |              |
    |              +-------------------------------    Eigenaar van het bestand
    |
    +----------------------------------------------    Bestandsrechten

Bestandsnaam: De bestandsnaam is wat je met het ls commando te zien krijgt.

Datum laatste wijziging: De datum dat de laatste keer het bestand of de map bewerkt is.

Grootte: De grootte van het bestand in kwestie.

Groep: De gebruikersgroep die meer rechten over het bestand kan krijgen.

Eigenaar: De eigenaar van het bestand, de eigenaar heeft meer rechten over het bestand.

Rechten: De rechten van het bestand. Aan deze code kan je zien wie er lees-, schrijf- of uitvoerrechten heeft. Deze code wordt later uitgelegd in de sectie over rechten. Wat je wel al kan zien is dat de directories met een d beginnen.

Een ander veelgebruikte optie is de -a of --all optie. Met deze optie toont het ls commando alle bestanden, ook de verborgen bestanden. In Linux is het eenvoudig om een verborgen bestand te maken, het enige dat je moet doen is je bestandsnaam met een . (punt) beginnen. De verborgen bestanden kan je ook in nautilus (de filebrowser in de standaard Mint) tonen met de sneltoets ctrl+h. We vergelijken het resultaat van het ls en het ls -a commando:

$ ls
Bestand1.txt
Bestand2.txt

$ ls -a
.
..
.settings
Bestand1.txt
Bestand2.txt

$ ls --all
.
..
.settings
Bestand1.txt
Bestand2.txt

Als je opties gebruikt die maar uit één letter bestaan, dan kan je altijd opties samenvoegen. Het commando ls -l -a is het zelfde als het commando ls -la, dit is natuurlijk ook hetzelfde als ls -al.

Misschien heb je ook de puntjes opgemerkt als je ls -a opvraagt. Het enkel puntje wil de huidige map zeggen. In feite zou je bij een cd commando altijd dit puntje moeten gebruiken. Als je zou willen naar je Documenten gaan vanuit je persoonlijke map, dan zou je moeten cd ./Documenten/ typen. Het is immers meestal verondersteld dat je in de huidige map start en dus is cd Documenten/ genoeg en de laatste slash moet zelfs ook niet. De twee puntes duiden de map hier boven aan, dit hebben we al besproken bij het cd commando.

Argumenten en opties combineren[bewerken]

Als je alleen maar informatie over een bestand wil, dan kan je dat bestand als argument meegeven. Zo geeft ls -l textje.txt informatie over het bestand textje.txt. Het kan gemakkelijk zijn om deze vorm te gebruiken als de lijst van bestanden te lang is om gemakkelijk door te zoeken.

$ ls -l
-rw-------   1 gebruiker  groep       576 Apr 17  1998 tekstje.txt

Bestanden bewerken[bewerken]

Inhoud van bestanden bewerken[bewerken]

Met gedit[bewerken]

Gedit is een grafisch programma en kan je dus enkel gebruiken als er geen problemen zijn met je computer. Gedit ondersteunt syntax kleuring en is op zich redelijk geavanceerd. Om het bestand bestand.txt via de terminal met Gedit te openen gebruik je het commando

$ gedit bestand.txt

Met nano[bewerken]

Nano is een terminal programma en kan dus ook gebruikt worden als je in een systeem zonder grafische omgeving werkt. Om een bestand te openen gebruik je

$ nano bestand.txt

Onderaan je nano venster staan de sneltoetsen die je kan gebruiken, om af te sluiten gebruik je ctrl+x.

Bestanden manipuleren[bewerken]

In deze sectie hebben we het over kopiëren, knippen en plakken van bestanden en ook over het maken van directory's. Voor die taken gebruik je onderstaande commando's:

cp (copy) Kopieëer bestanden en directory's.
mv (move) Verplaats bestanden en directory's.
rm (remove) Verwijder bestanden en directory's.
mkdir (make directory) Maak een nieuwe directory aan.
rmdir (remove directory) Verwijder een lege directory.

Je denkt misschien dat je tot nu toe alles wat je geleerd hebt ook kan met de GUI. Nu komt er echter verandering in. Het is namelijk heel moeilijk om bestanden te selecteren die aan bepaalde criteria voldoen als je enkel wil klikken. Maar in de terminal is de keuzemogelijkheid heel groot. Voor we echt overgaan naar het gebruik van de genoemde commando's gaan we eerst wildcards bekijken.

Wildcards[bewerken]

Wildcards dienen om bestanden te selecteren zonder dat je de exacte naam opgeeft. Je selecteert dus bestanden die aan een bepaald patroon voldoen. We geven een samenvatting van de mogelijke wildcards:

* Om het even welk karakter en hoeveel.
? Eén willekeurig karakter.
[karakters] Eén karakter van de opgegeven karakter verzameling. Een verzameling kan je opgeven als [abc], dit is dan één enkele a, b of c. Je kan ook een voorgedefinieerde verzameling gebruiken.

[:alnum:]: Alfanumerieke karakters
[:alpha:]: Letters
[:digit:]: Cijfers
[:upper:]: Hoofdletters
[:lower:]: Kleine letters
Bij een voorgedefinieerde verzameling moet je wel extra haakjes gebruiken. De code [:upper:] stelt de verzameling {u,p,e,r,:} voor terwijl de code [[:upper:]] de verzameling van alle hoofdletters voorstelt.

! Een uitroep teken dient om de vorige verzameling om te keren. Zo is [!abc] één enkel teken dat geen a, b of c is en [![:upper]] om het even welk karakter dat geen hoofdletter is.

Voorbeelden:

Je kan de volgende voorbeelden gemakkelijk uitproberen met het ls commando. Als je je in een grote directory bevind, zoals de /usr/bin directory kan je ieder voorbeeld testen door ls voor het voorbeeld te typen.

* Alle bestanden.
a* Ieder bestand dat begint met een a.
*t*.sh Ieder bestand met een t in de naam dat eindigd op .sh.
tclsh??? Ieder bestand dat begint met tclsh en gevolgd wordt door exact drie tekens.
tclsh[[:digit:]].[[:digit]] Ieder bestand dat begint met tclsh, gevolgd wordt door exact een cijfer, een puntje en nog eens één cijfer. Dergelijke constructies kan je gebruiken om versie-onafhankelijke kopieën te maken.
*[![:lower:]] Ieder bestand dat niet eindigt op een kleine letter.

cp[bewerken]

Het cp commando wordt gebruikt om bestanden of directory's te kopiëren. De eenvoudigste vorm is één bestand naar een ander kopiëren. Dat wordt als volgt gedaan:

$ cp bestand1 bestand2

Je kan ook een bestand naar een directory kopiëren.

$ cp bestand directory

Deze procedure kan je zelfs met meerdere bestanden in één keer doen.

$ cp bestand1 bestand2 bestand3 directory

Kijk even naar de help van het commando:

$ cp --help
...
  -a, --archive             hetzelfde als -dR --preserve=all
      --backup[=METHODE]    van elk bestemmingsbestand een reservekopie maken
  -b                        zoals --backup, maar accepteert geen argument
      --copy-contents       de inhoud van speciale bestanden kopiëren als er
                              recursief gekopieerd wordt
  -d                        hetzelfde als '--no-dereference --preserve=links'
  -f, --force               als bestaand bestemmingsbestand niet geopend kan
                              worden, het verwijderen en het opnieuw proberen
                              (overbodig als de -n optie wordt gebruikt)
  -i, --interactive         voor overschrijven om toestemming vragen (gaat boven
                              een voorgaand gebruikte -n optie)
  -H                        gegeven symbolische koppelingen in BRON volgen
  -l, --link                harde koppelingen maken in plaats van kopieën
  -L, --dereference         symbolische koppelingen in BRON altijd volgen
  -n, --no-clobber          geen bestaand bestand overschrijven (gaat boven een
                              eerdere -i optie)
  -P, --no-dereference      geen symbolische koppelingen in BRON volgen
  -p                        hetzelfde als '--preserve=mode,ownership,timestamps'
      --preserve[=LIJST]    de genoemde attributen indien mogelijk behouden
                              (standaard zijn: mode,ownership,timestamps --
                              oftewel modus, eigenaarschap en tijdstempels);
                              verdere mogelijkheden: context, links, xattr,
                              all
      --no-preserve=LIJST   de genoemde attributen juist niet behouden
      --parents             volledige naam gebruiken van bronbestand onder MAP
  -R, -r, --recursive       mappen en hun inhoud recursief kopiëren
      --remove-destination  ieder bestaand bestemmingsbestand verwijderen
                              alvorens het te openen (anders dan '--force')
      --sparse=WANNEER      besturing van het aanmaken van bestanden met gaten
      --strip-trailing-slashes  schuine strepen achter elke BRON verwijderen
  -s, --symbolic-link           symbolische koppeling maken i.p.v. kopie
  -S, --suffix=SUFFIX           te gebruiken achtervoegsel voor reservekopieën
  -t, --target-directory=MAP    alle BRON-argumenten naar MAP kopiëren
  -T, --no-target-directory     BESTEMMING behandelen als een normaal bestand
  -u, --update              alleen kopiëren als BRON nieuwer is dan bestemming
                              of wanneer dit bestand niet bestaat
  -v, --verbose             tonen wat er gedaan wordt
  -x, --one-file-system     binnen dit bestandssysteem blijven
      --help      deze hulptekst tonen en stoppen
      --version  programmaversie tonen en stoppen
...

We kijken even naar interessante opties:

De -i, -n en -u optie dienen om te definiëren wanneer een bestand moet overschreven worden. Bij -i zal het gevraagd worden, bij -n zal het bestand niet overschreven worden en bij de optie -u zal de nieuwste versie van het bestand gebruikt worden. Dat deze opties aanwezig zijn betekend ook dat standaard een bestand altijd overschreven wordt. Let dus op bij het gebruik van dit commando, gelukkig kan je normaal gezien geen systeembestanden wissen, enkel persoonlijke data.

De -r optie kan je gebruiken om volledige directory's te kopiëren. Stel dat je een structuur hebt zoals hier onder:

  • /
    • Dir1
      • Bestand1
      • Bestand2
      • Subdir
        • Bestand1
    • Dir2
      • Bestand3

Als je dan het commando

$ cp -r /Dir1 /Dir2

uitvoert, dan zal in Dir2 een nieuwe directory met de naam Dir1 aangemaakt worden. De volledige structuur ziet er dan als volgt uit:

  • /
    • Dir1
      • Bestand1
      • Bestand2
      • Subdir
        • Bestand1
    • Dir2
      • Bestand3
      • Dir1
        • Bestand1
        • Bestand2
        • Subdir
          • Bestand1

Stel dat we nu zonder Dir2 gestart waren, dus met de volgende structuur:

  • /
    • Dir1
      • Bestand1
      • Bestand2
      • Subdir
        • Bestand1

Dan zou het commando

$ cp -r /Dir1 /Dir2

resulteren in de volgende structuur:

  • /
    • Dir1
      • Bestand1
      • Bestand2
      • Subdir
        • Bestand1
    • Dir2
      • Bestand1
      • Bestand2
      • Subdir
        • Bestand1

mv[bewerken]

Het mv commando dient om bestanden te verplaatsen, het werkt ongeveer hetzelfde als het cp commando maar verwijdert de originele bestanden. De enige optie die je niet kan gebruiken is de -r optie, deze is verondersteld als je twee directory's opgeeft.

rm[bewerken]

Het rm commando dient om bestanden te verwijderen. Ook dit commando werk ongeveer zoals de vorige. Bij de -i optie word je bij ieder bestand gevraagd of je het bestand wel degelijk wil verwijderen. Hier is de -r optie niet verondersteld als je ze niet typt, dit zou immers gevaarlijke situaties kunnen opleveren.

Let op: De bestanden die verwijderd worden komen niet terecht in de prullenbak, de enige manier om de verwijderde bestanden terug te krijgen is met geavanceerde software die je volledige harde schijf afzoekt naar achtergebleven resten van de verwijderde bestanden. Het is altijd aan te raden om eens te controleren met het ls -a commando welke bestanden je werkelijk zal verwijderen. Let ook op voor de speciale map "..". Als je het commando rm -r * uitvoert met de bedoeling om de huidige directory leeg te maken, dan zal je van een kale reis thuiskomen. De map .. zit immers ook tussen de verwijderde mappen en aangezien het recursief is zal alles in de bovenliggende map verwijderd worden, ook deze opdracht is nog eens recursief en zo zullen alle bestanden in je systeem verwijderd worden tot er een bestand gevonden wordt die niet kan verwijderd worden. Controleer dus zeer goed als de map .. niet tussen de namen zit die aan je te verwijderen directory's voldoet.

mkdir en rmdir[bewerken]

mkdir en rmdir zijn eenvoudige commando's die resp. een lege directory maken en een lege directory verwijderen. Met het gebruik van deze commando's kan je niet veel verkeerd doen.

Bestandsrechten[bewerken]

Zoals je wel weet is Windows een multitasking systeem, je moet niet wachten tot je antivirus zijn taak gedaan heeft om zelf te werken op de computer. De Unix systemen zijn echter meer dan multitasking, het is ook een multiuser systeem. Er kan met verschillende gebruikers om de beurt en zelfs samen op één enkele computer gewerkt worden. Nu vraag je je misschien af hoe het mogelijk is om verschillende gebruikers tegelijkertijd op een computer te laten werken. Dit betekent immers niet dat de gebruikers naast elkaar moeten zitten. Het is mogelijk om een computer op afstand te besturen. Denk bijvoorbeeld aan een webpagina. Als je een .php pagina opvraagt, dan moet die .php pagina verwerkt worden door de server. Op zich is dit een beperkte manier van die server besturen maar er zijn ook geavanceerdere manieren via ssh en dergelijke.

Bestanden[bewerken]

Om er voor te zorgen dat verschillende gebruikers niet in de bestanden van andere gebruikers gaan rommelen of zelfs in de systeembestanden gaan prutsen heeft iedere gebruiker per bestand rechten om dat bestand te bekijken, aan te passen of uit te voeren. Dit komt er op neer dat ieder bestand een eigenaar heeft, deze eigenaar heeft volledige controle over het bestand. Voor ieder bestand wordt er ook een groep bijgehouden. De gebruikers die in de groep van het bestand zitten hebben meer rechten om het te gebruiken.

Om te kijken wat de rechten van een bepaald bestand zijn gebruik je het commando ls -l. We geven een voorbeeld:

$ ls -l Bestand1
-rw-r----- 1 ik mijnGroep 9 2010-02-02 10:18 Bestand1
^^^^^^^^^^
||||||||||
|||||||\\\----------- andere gebruikers
|||||||
||||\\\-------------- groep
||||
|\\\----------------- eigenaar
|
\-------------------- bestand = "-" (mogelijk: -, d, l, b, c, q)

Je ziet dus wie er eigenaar is, in dit geval de gebruiker met de naam ik. En de groep mijnGroep is de groep die het bestand kan controleren. Om te zien wie welke rechten heeft kijk je naar de eerste code:

  • Als er een - als eerste teken staat, dan is het een gewoon bestand. Voor directory's wordt een d gebruikt en voor links een l. Er zijn ook nog meer exotische letters.
  • Na de eerste letter volgen drie blokjes met elk drie tekens. Het eerste blokje, rw- in ons geval, zijn de rechten die aan de eigenaar gegeven worden. Het tweede blokje, r-- in ons geval, zijn de rechten die aan de controlerende groep gegeven worden en het laatste blokje --- zijn de rechten voor iedere gebruiker.

Zo'n blokje rechten heeft iedere keer een gelijkaardige structuur. Er worden drie letters gebruikt: de r staat voor leesrecht, de w staat voor schrijfrecht en de x staat voor het recht om het bestand uit te voeren. Als de gebruiker waarvoor het blokje telt de letter heeft, dan heeft hij dat recht op het bestand. Als de gebruiker waarvoor het blokje telt die letter niet heeft maar een - heeft in plaats van die letter, dan heeft de gebruiker dat recht niet.

Bij het voorbeeld zien we dus dat ik het bestand mag bewerken en bekijken (rw-). De gebruikers die in de groep mijnGroep zitten mogen het bestand bekijken (r--) en andere gebruikers mogen niets (---).

Laten we als tweede voorbeeld eens het bash bestand nemen uit de buik van het systeem:

$ ls -l /bin/bash
-rwxr-xr-x 1 root root 875596 2009-09-14 07:09 /bin/bash
^^^^^^^^^^
||||||||||
|||||||\\\----------- andere gebruikers
|||||||
||||\\\-------------- groep
||||
|\\\----------------- eigenaar
|
\-------------------- bestand = "-" (mogelijk: -, d, l, b, c, q)

Je ziet dus dat de eigenaar root is en de controlerende groep ook root. root heeft alle rechten op het bestand: lezen, schrijven en uitvoeren (rwx), iedereen anders, ook degene die in de groep root zitten hebben enkel lees- en uitvoerrechten (r-x).

Info: root is de naam van de superuser. In literatuur wordt meestal superuser geschreven terwijl de systemen aan die gebruiker de naam root geven.

Rechten wijzigen[bewerken]

Een eerste manier[bewerken]

Rechten van een bestand of directory kan je wijzigen met het chmod (change modifiers) commando. Het eerste wat je moet weten is hoe Linux deze rechten onthoudt. Een blokje van drie tekens die de rechten voor een gebruiker voorstellen, wordt onthouden door een binair getal op de volgende manier:

"rwx" = 111
"r-x" = 101

Natuurlijk kunnen we die binaire getallen omzetten in decimale getallen|:

"rwx" = 111 = 7
"rw-" = 110 = 6
"r-x" = 101 = 5
"r--" = 100 = 4
"---" = 000 = 0

Wat je vervolgens doet is gewoon de cijfers aan elkaar "plakken". Als je dus een bestand de rechten rwx r-x r-x (voor iedereen leesbaar en uitvoerbaar en voor de eigenaar wijzigbaar) wil geven, dan gebruik je de code 755. Die code gebruik je met het chmod commando als volgt:

$ chmod 755 bestand1

We geven een tabel met veelgebruikte codes:

777 rwxrwxrwx Iedereen heeft alle rechten op het bestand, normaal is dit niet zo'n goede keuze.
755 rwxr-xr-x De eigenaar mag alles met het bestand, iedereen anders mag het bestand bekijken of uitvoeren. Dit is veel gebruikt voor algemene applicaties (zie het bash voorbeeld).
700 rwx------ De eigenaar heeft alle rechten, iedereen anders heeft geen rechten. Een goede instelling voor een applicatie die alleen door de eigenaar gebruikt kan/mag worden.
666 rw-rw-rw- Iedereen heeft alle rechten maar het bestand kan niet uitgevoerd worden.
644 rw-r--r-- De eigenaar kan het bestand lezen en schrijven, iedereen anders kan het bestand enkel lezen. Deze instelling is standaard gebruikt als je een nieuw bestand maakt.
600 rw------- De eigenaar kan het bestand lezen en schrijven, iedereen anders heeft geen rechten.

Een tweede manier[bewerken]

Naast rechtstreeks de code ingeven kan je ook vragen om de leesbaarheid, schrijfbaarheid of uitvoerbaarheid te wijzigen voor iedereen. Als je bijvoorbeeld een bestand wil uitvoerbaar maken voor iedereen zonder je zorgen te moeten maken wie het bestand kan wijzigen, dan gebruik je de code

$ chmod +x bestand

De +x staat dus voor bij iedere gebruiker een x toe te voegen. Het tegenovergestelde is dan -x. Je kan hetzelfde doen met w en r. Het gebruik van de tweede manier kan ook handig zijn als je een hoop bestanden wil uitvoerbaar maken met wildcards en geen andere rechten aan die bestanden wil wijzigen. Via deze optie kan je ook recursief werken met de -R optie. Let op, hier is het een hoofdletter R omdat de kleine -r al gebruikt is om leesrecht te ontnemen. Voor je recursief werkt is het echter beter om eerst het deel over rechten van directory's te lezen.

Rechten van directory's[bewerken]

Het noteren van rechten van directory's is ongeveer hetzelfde als bij bestanden. w staat voor het recht om bestanden te maken en te verwijderen (een bestand aanpassen mag dus wel zonder het w recht). r staat voor het bekijken van de inhoud van de directory*. Het enige rare recht is de x. Een directory kan je immers nooit uitvoeren maar je hebt het x recht nodig om bepaalde dingen te doen in die directory, daaronder valt ook het opsommen van alle bestanden*. Het is dus het best om voor directory's altijd aan iedereen het x recht te geven als die iets met de directory moet kunnen doen.

  • Hoe verschilt x van r op de directory als beide toelaten om de inhoud van de directory te tonen?

Superuser worden[bewerken]

Je hebt misschien al gemerkt, als je geen eigenaar van een bestand bent, dan kan je ook de rechten niet wijzigen. Dit is logisch want anders zouden rechten geen nut hebben. Er is echter één gebruiker die altijd alle rechten heeft en ook altijd de rechten van bestanden mag wijzigen en zelfs de eigenaar en groep mag wijzigen. Dit is de superuser of root. In veel linuxdistributies moet je apart inloggen maar in Ubuntu en dus ook in Mint heb je geen aparte gebruiker. In Ubuntu heb je systeembeheerders (administrators), een systeembeheerder is een account die tijdelijk superuser kan worden. Als je zelf Linux geïnstalleerd hebt, dan is je account standaard een systeembeheerder.

Om voor even root te worden moet je je commando beginnen met sudo (switchuser do). Daarna zal je je eigen wachtwoord moeten typen. We gaan het sudo commando even proberen:

Kijk eens welke rechten er zijn bij het bash bestand:

$ ls -l /bin/bash
-rwxr-xr-x 1 root root 875596 2009-09-14 07:09 bash

Probeer nu eens de rechten te wijzigen naar 777:

$ chmod 777 /bin/bash
chmod: veranderen van toegangsrechten van `/bin/bash’: Bewerking niet toegestaan

$ sudo chmod 777 /bin/bash
[sudo] password for gebruiker: 

$ ls -l /bin/bash
-rwxrwxrwx 1 root root 875596 2009-09-14 07:09 bash

Het is nu het best om die rechten weer normaal te zetten:

$ sudo chmod 755 /bin/bash

Als je ooit een script maakt waarvoor je even root wil worden is het nogal omslachtig als je dat script altijd in een terminal moet uitvoeren als de enige reden daarvoor is dat je je wachtwoord moet ingeven. Om dit op te lossen is er ook gksudo, gksudo werkt op dezelfde manier als sudo maar gksudo tovert het bekende kadertje tevoorschijn dat je ontmoet als je programma's wil installeren of updaten.

Wijzigen van eigenaar en groep van een bestand[bewerken]

Het spreekt voor zich dat je root moet zijn als je de eigenaar van een bestand wil wijzigen. De eigenaar van een bestand kan je wijzigen met het commando chown. Je gebruikt het commando als volgt:

$ sudo chown mijnNaam bestand1

Waarbij mijnNaam de gebruikersnaam is die je kan zien voor @ in het terminal venster.

Je kan ook de groep en eigenaar in een keer wijzigen. Dit doe je als volgt:

$ sudo chown mijnNaam:mijnGroep bestand1

Om te zien welke gebruikers er zijn en in welke groepen die ingedeeld zijn kan je even naar je configuratiescherm gaan en het onderdeel gebruikers en groepen bekijken.

Om enkel de groep te wijzigen heb je het chgrp commando. Maar als je het chown commando onthoudt is dat voldoende.

Informatie afkomstig van http://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.