Linux heeft een directory- en bestandsstructuur die erg veel lijkt op die van DOS/Win. Bestanden hebben namen die aan bepaalde regels moeten voldoen, worden opgeslagen in directory's, een aantal ervan zijn uitvoerbaar, en hiervan hebben de meeste commando-switches. Bovendien kun je gebruik maken van wildcard characters (jokertekens), redirection en piping (het omleiden/doorsturen van uitvoer). Er zijn slechts een paar kleine verschillen:
NOTENOUG.TXT
. Onder Linux kunnen we dat beter. Als je Linux
installeerde door gebruik te maken van een bestandssysteem als ext2 of
umsdos, kun je langere bestandsnamen gebruiken (tot aan 255 tekens), en met
meer dan één punt: bijvoorbeeld:
Dit_is.een.ZEER_lange.bestandsnaam
. Merk alsjeblieft op dat ik
zowel gebruik maakte van hoofdletters als kleine letters: 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 genaamd "Mijn oude bestanden"
$ mkdir "Mijn oude bestanden"
$ ls
Mijn oude bestanden bin tmp
Bovendien is het beter een aantal tekens niet te gebruiken: een aantal
daarvan zijn !*$&#
.*
' gemarkeerd wanneer je het commando
ls -F
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 uitvoerbare
bestanden, dat wil zeggen ``programma's''. Onder DOS eindigen backupbestanden
op .BAK, onder Linux eindigen ze op een tilde `~
'.
Een bestand waarvan de naam begint met een punt wordt als verborgen aangemerkt.
Voorbeeld: het bestand
.Ik.ben.een.verborgen.bestand
zal na het commando ls
niet
worden getoond;/switch
, Linux
switches met -switch
of --switch
. Voorbeeld: dir
/s<
tt> wordt ls -R
. Merk op dat veel DOS programma's, zoals
PKZIP
of ARJ
, switches in de stijl van UNIX gebruiken.Je kunt nu naar de sectie Commando's van DOS naar Linux vertalen gaan, maar als ik jou was zou ik verder lezen.
UNIX heeft een type bestand dat onder DOS niet voorkomt: de symbolische link.
Je kunt hierbij denken aan een verwijzer naar een bestand of directory,
en het kan in plaats van het bestand of directory waarnaar het verwijst
worden gebruikt; het is vergelijkbaar met de snelkoppelingen van Windows.
Voorbeelden van symbolische links zijn /usr/X11
, die naar
/usr/X11R6
verwijst; /dev/modem
, die naar
/dev/ttyS0
of /dev/ttyS1
verwijst.
Om een symbolische link aan te maken:
$ ln -s <bestand_of_dir> <linknaam>
Voorbeeld:
$ ln -s /usr/doc/g77/DOC g77manual.txt
Nu kun je naar g77manual.txt
verwijzen in plaats van
/usr/doc/g77/DOC
. Links verschijnen als volgt in directorylistings:
$ ls -F
g77manual.txt@
$ ls -l
(van alles en nog wat...) g77manual.txt -> /usr/doc/g77/DOC
DOS bestanden en directory's hebben de volgende kenmerken: A (archive = archief), H (hidden = verborgen), R (read-only = alleen lezen), en S (system = systeem). Alleen H en R hebben onder Linux een betekenis: verborgen bestanden beginnen met een punt, en wat betreft het kenmerk R, lees verder.
Onder UNIX heeft een bestand ``permissies'' en een eigenaar, die op zijn beurt weer aan een ``groep'' toebehoort. Kijk naar dit 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
, welke
aan root toebehoort, groep bin.
De resterende informatie latend voor wat het is, onthoud dat
-rwxr-xr-x
van links naar rechts betekent:
-
het bestandstype is (-
= gewoon bestand, d
=
directory, l
= link, enz.); rwx
zijn de permissies voor de
eigenaar van het bestand (read/lezen, write/schrijven, execute/uitvoeren); r-x
zijn de
permissies voor de groep van de eigenaar van het bestand
(read, execute); (Ik ga het niet hebben over het begrip groep, je kunt zolang
je beginner bent zonder ;-0
r-x
zijn de permissies voor alle andere gebruikers (read, execute).
De directory /bin
heeft ook permissies: zie sectie
Directory Permissies voor verdere details.
Daarom kun je het bestand /bin/ls
niet verwijderen tenzij je root bent:
je hebt geen permissie om dat te doen. Het commando voor het wijzigen van
de bestandspermissies is:
$ chmod <wieXperm> <file>
`wie' is u
(user, dat is de eigenaar), g
(group),
o
(other=anderen), X is of +
of -
, perm is r
(read), w
(write), of x
(execute). Algemene voorbeelden van
chmod
zijn:
$ chmod +x bestand
hiermee wordt de execute permissie voor het bestand ingesteld.
$ chmod go-rw bestand
hiermee wordt de read en write permissies voor iedereen behalve de eigenaar ingesteld.
$ chmod ugo+rwx bestand
dit geeft iedereen read, write en execute permissie.
# chmod +s bestand
hiermee wordt een zogenoemd ``setuid'' of ``suid'' bestand aangemaakt--- een bestand dat iedereen uit mag voeren met de privileges van de eigenaar. Je zal ongetwijfeld root suid bestanden tegenkomen; dit zijn vaak belangrijke systeembestanden, zoals de X-server.
Een beknoptere manier om naar permissies te refereren is met cijfers:
rwxr-xr-x
kan worden uitgedrukt als 755 (iedere letter correspondeert
met een bit: ---
is 0,
--x
is 1, -w-
is 2, -wx
is 3...). Het ziet er
moeilijk uit, maar met wat oefening zal je het concept begrijpen. root, als
superuser, kan de bestandspermissies van iedereen wijzigen.
LMP.
Links de DOS-commando's; rechts de Linux tegenhanger.
ATTRIB: chmod
COPY: cp
DEL: rm
MOVE: mv
REN: mv
TYPE: more, less, cat
Omleidings- en andere operatoren: < > >> |
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 slimmer onder Linux: *
komt overeen met
alle bestanden behalve de verborgen bestanden;
.*
komt overeen met alle verborgen bestanden (maar ook de huidige
directory `.
' en parent directory `..
': let op!);
*.*
komt alleen overeen met bestanden met een `.
' in het
midden of die op een punt eindigen; p*r
komt overeen met zowel
`peter' als `piper';
*c*
komt overeen met zowel `picked' als `peck';more
, op de <SPATIEBALK> om
door het bestand te bladeren, `q' om het te verlaten.
less
is intuïtiever en laat je de pijltjestoetsen gebruiken;UNDELETE
, dus bedenk je tweemaal
voordat je iets verwijdert;< > >>
van DOS, heeft Linux
2>
om foutmeldingen om te leiden (stderr); bovendien
wordt met 2>&1
stderr naar stdout omgeleid, en
1>&2
leidt stdout om naar stderr;[]
. Gebruik: [abc]*
komt overeen met bestanden die beginnen met een a, b, c; *[I-N1-3]
komt overeen met bestanden die eindigen op
I, J, K, L, M, N, 1, 2, 3;lpr
<bestand> drukt een bestand af in de achtergrond.
Gebruik lpq
voor het controleren van de status van de afdrukwachtrij;
gebruik lprm
voor het verwijderen van een bestand uit de afdrukwachtrij;RENAME
; dat wil zeggen dat
mv *.xxx *.yyy
niet zal werken. Een op REN lijkend commando is
te vinden op
ftp://metalab.unc.edu/pub/Linux/utils/file;cp -i
en mv -i
om te worden gewaarschuwd
wanneer een bestand zal worden overschreven.
Om een programma uit te voeren, typ je net als onder DOS de naam ervan in.
Als de directory (Sectie
Gebruik van directory's)
waarin het programma is opgeslagen in het PATH is opgenomen (Sectie
Systeem initialisatiebestanden), zal het programma
worden opgestart. Uitzondering: in tegenstelling tot DOS, zal een programma
in de huidige directory niet worden uitgevoerd, tenzij de directory in het
PATH is opgenomen. Je kunt hieraan ontsnappen: als prog
je programma
is, typ dan ./prog
.
Zo ziet een typische commandoregel eruit:
$ commando [-s1 [-s2] ... [-sn]] [par1 [par2] ... [parn]] [< invoer] [> uitvoer]
waar de -s1
, ..., -sn
staan voor programma-switches.
par1
, ..., parn
zijn de programma parameters. Je kunt
verscheidene commando's op de commandoregel aanroepen:
$ commando-1 ; commando-2 ; ... ; commando-n
Dat is alles over het draaien van programma's, maar het is eenvoudig een stap verder te gaan. Eén van de belangrijkste redenen om Linux te gebruiken is dat het een multitasking os is--- het kan verscheidene programma's tegelijkertijd draaien (van nu af aan, processen). Je kunt processen in de achtergrond opstarten en gewoon door blijven werken. Bovendien staat Linux toe dat je meerdere sessies hebt lopen: het is alsof je veel computers tegelijk aan het werk zet!
su - <loginnaam>
voor het starten van een
nieuwe sessie onder dezelfde v.c. zonder de huidige v.c. te verlaten.
Voorbeeld: su - root
. Dit komt bijvoorbeeld van pas als je een
taak uit moet voeren waarvoor alleen de root-gebruiker permissie heeft.exit
.
Als er gestopte jobs zijn (zie verderop), krijg je een waarschuwing.&
' aan het einde van de
commandoregel toe voor het in de achtergrond opstarten van een proces:
$ prognaam [-switches] [parameters] [< invoer] [> uitvoer] &
[1] 123
de shell identificeert het proces met een jobnummer (b.v. [1]
; zie
hieronder), en met een PID (Proces Identificatie Nummer; 123 in ons voorbeeld).ps ax
om te bekijken hoeveel processen er zijn.
Hiermee krijg je als uitvoer een lijst met de thans draaiende processen.kill <PID>
voor het killen (beëindigen)
van een proces. Wellicht dat je het eens nodig hebt als je niet weet hoe
je een proces op de juiste wijze moet laten eindigen...
Tenzij je root bent, kun je andermans processen niet killen.
Soms kan een proces alleen worden beëindigd met kill -SIGKILL
<PID>
.
Bovendien laat de shell je een proces stoppen of tijdelijk uitstellen,
een proces naar de achtergrond sturen, en een proces vanuit de achtergrond
naar de voorgrond brengen. In deze context, worden processen ``jobs'' genoemd.jobs
om te zien hoeveel jobs er zijn. Hier worden de
jobs geïndentificeerd door een jobnummer, niet via een PID.bg <%job>
voor een uitgesteld proces naar de
achtergrond te sturen (het wordt een job).fg <%job>
. Voor het naar de voorgrond brengen van de laatste
job die naar de achtergrond is gestuurd, typ je eenvoudigweg fg
.kill <%job>
waarbij <job> gelijk kan zijn aan 1, 2, 3,...Met deze commando's kun je tegelijkertijd een disk formatteren, een boel bestanden zippen, een programma compileren en een archief uitpakken en nog steeds de prompt tot je beschikking hebben. Probeer dit eens met Windows, enkel om het verschil in performance te zien (als het niet crasht, uiteraard).
Voor het uitvoeren van een programma op een remote computer met de naam
remote.machine.edu
:
$ telnet remote.machine.edu
Start na het inloggen je favoriete programma. Onnodig te zeggen dat je een shell-account op de remote computer nodig hebt.
Als je X11 hebt, kun je zelfs een X-applicatie op een remote computer
uitvoeren en het op je X scherm weergeven.
Stel dat remote.machine.edu
de remote X-computer is en
local.linux.box
je Linux-computer. Om een X-programma vanaf
local.linux.box
dat zich bevindt op
remote.machine.edu
uit te voeren, doe je het volgende:
xterm
of equivalente terminal emulator,
en typ dan:
$ xhost +remote.machine.edu
$ telnet remote.machine.edu
remote:$ DISPLAY=local.linux.box:0.0
remote:$ prognaam &
(in plaats van DISPLAY...
, moet je mogelijk opgeven: setenv DISPLAY
local.linux.box:0.0
. Dit is afhankelijk van de remote shell.)En ziedaar! Nu zal prognaam
op remote.machine.edu
worden
opgestart en op je computer worden weergegeven. Probeer dit echter niet via een
modem, aangezien dit zo langzaam is dat het niet meer werkbaar is.
Bovendien is dit een grove en onveilige methode:
lees alsjeblieft de ``Remote X Apps mini-HOWTO'' op
http://www.linuxdoc.org/HOWTO/mini/Remote-X-Apps.html.