Linux heeft een directory- en bestandsstructuur die erg veel op die van DOSWin lijkt. Bestanden hebben bestandsnamen, die aan speciale regels moeten voldoen, en in directory's worden bewaard, sommige daarvan zijn uitvoerbaar, en hiervan hebben de meeste commando switches. Bovendien kun je gebruik maken van jokertekens (wildcard characters), en het omleiden van uitvoer (redirection en piping). Er zijn slechts een paar kleine verschillen:
NOTENOUG.TXT
. Onder Linux kunnen we dat beter. Als je Linux hebt
geïnstalleerd en een bestandssysteem zoals ext2 of umsdos gebruikt,
kun je langere bestandsnamen (tot 255 tekens) en met meer
dan éen punt gebruiken:
bijvoorbeeld, Dit_is.een.ERG_lange.bestandsnaam
. Let
er alsjeblieft op dat ik zowel van hoofd- als kleine letters gebruik
maakte: in feite....FILENAME.tar.gz
en
filename.tar.gz
twee verschillende bestanden. ls
is een
commando, LS
is een fout;
$ # het volgende commando maakt een directory met de naam "Mijn oude bestanden"
aan:
$ mkdir "Mijn oude bestanden"
$ ls
Mijn oude bestanden bin tmp
Sommige tekens kun je beter niet gebruiken: enkele daarvan zijn
!*$&#
.*
' aan het einde van de bestandsnaam als je het
ls -F
commando geeft. Bijvoorbeeld:
$ ls -F
Ik_ben_een_dir/ cindy.jpg cjpg* brief_aan_Joe mijn_1e_script* oud~
De bestanden cjpg*
en mijn_1e_script*
zijn uitvoerbaar, dat
wil zeggen ``programma's''. Onder DOS eindigen backupbestanden met .BAK, terwijl
ze onder Linux met een tilde `~
' eindigen. Een bestand waarvan de
naam met een punt begint, wordt als een verborgen bestand aangemerkt.
Bijvoorbeeld: het bestand .Ik.ben.een.verborgen.bestand
zal na het
commando ls
niet worden getoond;/switch
, Linux
switches met -switch
of --switch
. Bijvoorbeeld:
dir /s
wordt ls -R
. Veel DOS programma's, zoals
PKZIP
of ARJ
, maken gebruik van switches in de UNIX
stijl.Je kunt nu verder gaan met paragraaf Commando's Vertalen Van DOS Naar Linux, maar als ik jou was, zou ik verder lezen.
UNIX heeft een type bestand dat onder DOS niet bestaat: de symbolische
link. Je kunt hierbij denken aan een verwijzer naar een bestand of een
directory, en deze kan worden gebruikt in plaats van het bestand of de
directory waarnaar ze verwijst; het is vergelijkbaar met de Windows
snelkoppelingen. Voorbeelden van symbolische links zijn /usr/X11
,
die verwijst naar /usr/X11R6
; /dev/modem
, die verwijst
naar /dev/ttyS0
of /dev/ttyS1
.
Een symbolische link aanmaken doe je zo:
$ ln -s <file_or_dir> <linkname>
Bijvoorbeeld:
$ ln -s /usr/doc/g77/DOC g77manual.txt
Nu kun je verwijzen naar g77manual.txt
in plaats van
/usr/doc/g77/DOC
.
Links kun je in een directory listing als volgt herkennen:
$ ls -F
g77manual.txt@
$ ls -l
(diverse zaken...) g77manual.txt -> /usr/doc/g77/DOC
DOS bestanden en directory's hebben de volgende kenmerken: A (archive), H (hidden), R (read-only), en S (system). Alleen H en R hebben een betekenis onder Linux: verborgen bestanden beginnen met een punt, lees verder voor het R kenmerk.
Onder UNIX heeft een bestand ``permissies'' en een eigenaar (owner), die op zijn/haar beurt weer tot een ``groep'' behoort. Bekijk het volgende voorbeeld:
$ ls -l /bin/ls
-rwxr-xr-x 1 root bin 27281 Aug 15 1995 /bin/ls*
In het eerste veld staan de permissies van het bestand /bin/ls
, dit
bestand behoort toe aan root, groep bin.
De overige informatie terzijde latend, onthoud dan dat -rwxr-xr-x
van links naar rechts betekent:
-
het bestandstype (- = gewoon bestand, d = directory, l = link,
enz);
rwx
zijn de permissies voor de eigenaar van het bestand
(read, write, execute);
r-x
zijn de permissies voor de groep waartoe de eigenaar van het
bestand behoort (read, execute); (Ik zal het begrip groep hier niet uitleggen,
zolang je een beginner bent, kun je zonder deze informatie ;-) r-x
zijn de permissies voor alle andere gebruikers (read, execute).
De directory /bin
heeft ook permissies: zie paragraaf
Directory Permissies voor
verdere details. Daarom kun je het bestand /bin/ls
niet verwijderen
tenzij je als root bent ingelogd: je hebt de permissie niet om dat te doen.
Je kunt de permissies van een bestand wijzigen met het volgende commando:
$ chmod <wieXperm> <file>
wie is u
(user, dat is de eigenaar), g
(groep),
o
(other=alle anderen), X is hetzij +
of -
, perm is
r
(read), w
(write), of x
(execute).
Algemene voorbeelden van het gebruik van chmod
:
$ chmod +x file
Hiermee stel je de execute permissie in voor het bestand:
$ chmod go-rw file
Hiermee verwijder je read en write permissies voor iedereen behalve de eigenaar:
$ chmod ugo+rwx file
Hiermee geef je iedereen read, write, en execute permissie:
# chmod +s file
Hiermee maak je een zogeheten ``setuid'' of ``suid'' bestand aan---een bestand dat iedereen kan uitvoeren met de rechten van de eigenaar van het bestand. Je zult in ieder geval root suid bestanden tegenkomen; dit zijn vaak belangrijke systeembestanden, zoals de X server.
Een kortere manier om naar permissies te verwijzen is met cijfers:
rwxr-xr-x
kan worden uitgedrukt als 755 (ieder cijfer correspondeert
met een bit: ---
is 0, --x
is 1, -w-
is 2, -wx
is 3...).
Het lijkt moeilijk, maar met een beetje oefening zul je het principe begrijpen.
root, de superuser, kan de bestandspermissies van iedereen wijzigen. LMP.
Links, de DOS commando's; rechts, het bijbehorende Linux commando.
ATTRIB: chmod
COPY: cp
DEL: rm
MOVE: mv
REN: mv
TYPE: more, less, cat
Redirection en de operators: < > >> |
Wildcards: * ?
nul: /dev/null
prn, lpt1: /dev/lp0 of /dev/lp1; lpr
DOS Linux
---------------------------------------------------------------------
C:\GUIDO>ATTRIB +R FILE.TXT $ chmod 400 file.txt
C:\GUIDO>COPY JOE.TXT JOE.DOC $ cp joe.txt joe.doc
C:\GUIDO>COPY *.* TOTAL $ cat * > total
C:\GUIDO>COPY FRACTALS.DOC PRN $ lpr fractals.doc
C:\GUIDO>DEL TEMP $ rm temp
C:\GUIDO>DEL *.BAK $ rm *~
C:\GUIDO>MOVE PAPER.TXT TMP\ $ mv paper.txt tmp/
C:\GUIDO>REN PAPER.TXT PAPER.ASC $ mv paper.txt paper.asc
C:\GUIDO>PRINT LETTER.TXT $ lpr letter.txt
C:\GUIDO>TYPE LETTER.TXT $ more letter.txt
C:\GUIDO>TYPE LETTER.TXT $ less letter.txt
C:\GUIDO>TYPE LETTER.TXT > NUL $ cat letter.txt > /dev/null
n/a $ more *.txt *.asc
n/a $ cat section*.txt | less
Opmerkingen:
*
is onder Linux slimmer: *
komt overeen met alle
bestanden behalve de verborgen bestanden; .*
komt overeen met alle
verborgen bestanden (maar ook de huidige directory `.
' en
parentdirectory `..
': let op!); *.*
komt slechts overeen met
die bestanden die een '.
' in het midden hebben of die met een punt
eindigen;
p*r
komt overeen met zowel `peter' en `piper'; *c*
komt overeen met zowel `picked' als `peck';more
gebruikt, druk dan op <SPACE> om het
volgende scherm met uitvoer te lezen en op 'q' om het te laten stoppen,
less
is intuïtief en laat je gebruik maken van de pijltjes
toetsen;UNDELETE
, dus bedenk je tweemaal voor je iets
verwijdert;< > >>
, heeft Linux 2>
om
foutmeldingen naar (stderr) om te leiden; meer dan dat, 2>&1
leidt
stderr om naar stdout, terwijl 1>&2
stdout omleidt naar stderr;[]
. Gebruik: [abc]*
dit
komt overeen met de bestanden die beginnen met a, b, c; *[I-N1-3]
dit
komt overeen met bestanden die eindigen op een I, J, K, L, M, N, 1, 2, 3;lpr
<file> drukt een bestand in de achtergrond af.
Om de status van de afdrukwachtrij te controleren, gebruik je
lpq
; om een bestand uit de afdrukwachtrij te verwijderen gebruik je
lprm
;RENAME
; dat wil zeggen,
mv
*.xxx *.yyy zal niet werken. Een op REN-gelijkend commando is
beschikbaar op
ftp://sunsite.unc.edu/pub/Linux/utils/file;cp -i
en mv -i
om een waarschuwing te krijgen
voordat een bestand zal worden overschreven.
Om een programma op te starten, typ je de naam van het programma in, net zoals je onder DOS zou doen. Als de directory, waar het programma zich in bevindt, in het PATH staat (paragraaf Directory's Gebruiken) (paragraaf Systeem Initialisatie Bestanden), wordt het programma opgestart.
Uitzondering:
In tegenstelling tot DOS zal een programma dat onder Linux in de huidige
directory staat niet starten, tenzij de directory in het PATH staat.
Mogelijke oplossing: ervan uitgaande dat het programma prog
,
het programma is, dat je op wilt starten, tik je ./prog
in.
Zo ziet een commandoregel er normaal gesproken ongeveer uit:
$ command [-s1 [-s2] ... [-sn]] [par1 [par2] ... [parn]] [< input] [> output]
Hier zijn -s1
, ..., -sn
de programma switches,
en par1
, ..., parn
de parameters van het programma. Je
kunt meerdere commando's op een commandoregel opgeven:
$ command1 ; command2 ; ... ; commandn
Dit is alles over het opstarten van programma's, maar het is gemakkelijk om nog een stap verder te gaan. Eén van de hoofdzaken voor het gebruiken van Linux is dat het een multitasking os is---het kan tegelijkertijd verschillende programma's uitvoeren (van nu af aan, processen). Je kunt processen in de achtergrond opstarten en toch door blijven werken. Zelfs meer dan dat, Linux staat meerdere sessies toe: het is alsof je meerdere computers tegelijkertijd aan het werk zet!
su - <loginname>
.
Bijvoorbeeld: su - root
. Dit kan nuttig zijn als je bijvoorbeeld een
taak wilt laten uitvoeren waarvoor alleen root permissies heeft.exit
in, om een sessie te beëindigen.
Als er jobs gestopt zijn (zie verderop), krijg je een waarschuwing.&
' toevoegen aan het einde van de commandoregel:
$ progname [-switches] [parameters] [< input] [> output] &
[1] 123
De shell identificeert het proces met een job nummer (d.i. [1]
; zie
hieronder), en met een PID (Process Identification Number; 123 in ons
voorbeeld).ps -ax
in. Dit zal als uitvoer een lijst geven met de huidig lopende processen.kill <PID>
om een proces te killen
(beëindigen). Het kan zijn dat je het commando kill toe moet passen op
een proces als je niet weet hoe je het op de juiste manier moet laten
stoppen. Tenzij je root bent, kun je de processen van anderen
niet 'killen'. Soms zal een proces alleen kunnen worden beëindigd als
je gebruik maakt van het commando kill -SIGKILL <PID>
.
In aanvulling hierop staat de shell toe, dat je je processen stop zet of
tijdelijk uitstelt, je een proces naar de achtergrond stuurt, en een
proces van de achtergrond naar de voorgrond stuurt.
In deze context worden processen ``jobs'' genoemd.jobs
in te tikken. Hier worden de jobs geïdentificeerd door middel van hun
job nummer, niet door hun PID.bg <job>
om een tijdelijk uitgesteld proces naar de
achtergrond te sturen
(het wordt een job).fg <job>
om een proces naar de voorgrond te brengen.
Om het laatste proces dat je in de achtergrond hebt geplaatst naar de
voorgrond te brengen, tik je fg
in.kill <%job>
in om een job te 'killen' <job>
kan worden vervangen door 1, 2, 3,...Door deze commando's te gebruiken kun je op hetzelfde tijdstip een disk formatteren, een aantal bestanden comprimeren, een programma compileren en een archief uitpakken en dan toch nog de prompt tot je beschikking hebben. Probeer dit eens met Windows, alleen al om het verschil in performance te kunnen zien (als je systeem niet vastloopt, natuurlijk).
Om een programma op een remote machine op te starten met IP adres
remote.machine.edu
, kun je het volgende doen:
$ telnet remote.machine.edu
Na het inloggen, start je je favoriete programma op. Je hebt wel een shell account nodig op de remote machine.
Als je X11 tot je beschikking hebt, kun je zelfs een X applicatie op de
remote computer opstarten en het op je eigen X scherm tonen.
Stel dat remote.machine.edu
je remote X computer is en stel dat
local.linux.box
je Linux machine is. Om vanaf
local.linux.box
een X programma op te starten dat op
remote.machine.edu
, verschijnt, doe je het volgende:
xterm
of vergelijkbare terminal
emulator, en typ dan:
$ xhost +remote.machine.edu
$ telnet remote.machine.edu
remote:$ DISPLAY=local.linux.box:0.0
remote:$ progname &
(in plaats van DISPLAY...
, kan het zijn dat je dit moet vervangen door:
setenv DISPLAY local.linux.box:0.0
. Dit is afhankelijk van de remote
shell).Nu zal progname
op de remote.machine.edu
starten en op je
machine worden getoond. Probeer dit echter niet over een modem want
daar is het te langzaam voor. Bovendien is dit een grove en onveilige
methode: lees alsjeblieft de ``Remote X Apps mini-HOWTO'' op
http://sunsite.unc.edu/LDP/HOWTO/mini/Remote-X-Apps.