werken met de shell - few.vu.nlabhulai/doc/werken met de shell.pdf · Een andere mogelijkheid is om...

Werken met de shell en shell-

commando’s

Inhoudsopgave Werken met de shell en shell-commando’s ------------------------------------------------------------------------ 1 1. Het practicum ---------------------------------------------------------------------------------------------------- 3

1.1. Doelstellingen ---------------------------------------------------------------------------------------------- 3 2. LINUX en DOS ------------------------------------------------------------------------------------------------- 4

2.1. Gebruik van handleidingen en help in LINUX -------------------------------------------------------- 4 3. Desktop-omgevingen onder LINUX -------------------------------------------------------------------------- 4

3.1. De werking van GNOME -------------------------------------------------------------------------------- 5 4. De (LINUX-) shell ---------------------------------------------------------------------------------------------- 7

4.1. Functies van de shell -------------------------------------------------------------------------------------- 7 4.2. De shell opstarten ----------------------------------------------------------------------------------------- 7

5. Enkele eenvoudige commando’s ------------------------------------------------------------------------------ 8 5.1. Passwd, Date, who, ls, lpr en man ---------------------------------------------------------------------- 8

5.1.1. date ---------------------------------------------------------------------------------------------------- 8 5.1.2. who ---------------------------------------------------------------------------------------------------- 8 5.1.3. ls ------------------------------------------------------------------------------------------------------- 9 5.1.4. lpr ------------------------------------------------------------------------------------------------------ 9 5.1.5. man ---------------------------------------------------------------------------------------------------- 9

5.2. Een commando afbreken -------------------------------------------------------------------------------- 10 6. Werken met directories ---------------------------------------------------------------------------------------- 10

6.1. Directories maken, de inhoud bekijken en veranderen van directory ----------------------------- 10 6.2. De weg kwijt?? ------------------------------------------------------------------------------------------- 12

7. Werken met files ----------------------------------------------------------------------------------------------- 14 8. Meer commando’s---------------------------------------------------------------------------------------------- 14

8.1. Commando’s combineren ------------------------------------------------------------------------------- 15 8.2. Speciale tekens-------------------------------------------------------------------------------------------- 15

8.2.1. ? ------------------------------------------------------------------------------------------------------- 15 8.2.2. * ------------------------------------------------------------------------------------------------------- 15

8.3. Redirectie van invoer en uitvoer ----------------------------------------------------------------------- 16 8.4. Pipes -------------------------------------------------------------------------------------------------------- 16 8.5. Grep -------------------------------------------------------------------------------------------------------- 17 8.6. Sorteren ---------------------------------------------------------------------------------------------------- 17 8.7. Met meer programma’s tegelijk werken -------------------------------------------------------------- 18

8.7.1. Processen op de achtergrond zetten -------------------------------------------------------------- 18 8.7.2. Processen beheren ---------------------------------------------------------------------------------- 18

8.8. Rijmwoordenboek ---------------------------------------------------------------------------------------- 19 9. Shell-scripts ----------------------------------------------------------------------------------------------------- 20

9.1. Een zeer eenvoudig shell-script ------------------------------------------------------------------------ 20 9.2. Shell-scripts met variabelen ----------------------------------------------------------------------------- 20 9.3. Een shell-script executable maken --------------------------------------------------------------------- 21 9.4. De plaats van shell-scripts ------------------------------------------------------------------------------ 21 9.5. Argumenten meegeven aan een shell-script ---------------------------------------------------------- 22 9.6. Keuzes maken--------------------------------------------------------------------------------------------- 23 9.7. Keuzes: de case-functie ---------------------------------------------------------------------------------- 23 9.8. Herhalen: de while-functie ------------------------------------------------------------------------------ 24 9.9. Meer mogelijkheden met shell-scripts ----------------------------------------------------------------- 25

10. Protectie en Permissie -------------------------------------------------------------------------------------- 25 10.1. Werkwijze 1 -------------------------------------------------------------------------------------------- 25

___________________________________________________________________________________ Werken met de shell en shell-commando’s 2

10.2. Werkwijze 2 -------------------------------------------------------------------------------------------- 26 10.3. Voor gevorderden: Bash ------------------------------------------------------------------------------ 27


1. Het practicum

1.1. Doelstellingen Aan het eind van het practicum:

ken je de basisprincipes van en kun je werken met LINUX besturingsystemen,

ken je de mogelijkheden van een shell,

ken je de opzet van het hiërarchische bestandsysteem binnen LINUX,

kun je werken met een groot aantal commando’s in LINUX, en

kun je enkele eenvoudige shell-scripts maken en gebruiken.


2. LINUX en DOS In tegenstelling tot bijvoorbeeld Microsoft Windows is LINUX van zichzelf geen grafische omgeving waarin je met behulp van de muis kunt manoeuvreren, maar wordt er gebruik gemaakt van commando’s.

Tijdens je studie zul je zeer veel commando’s leren gebruiken. Op het practicum zul je enkele (maar lang niet alle) zeer belangrijke commando’s leren.

Wanneer je wel eens met de Command prompt van Windows of Linux hebt gewerkt zul je merken dat er veel overeenkomsten zijn. Hieronder is een tabel opgenomen met enkele veelgebruikte commando’s in LINUX en de Command prompt van Windows. Tijdens het practicum zullen we met deze commando’s oefenen.

ACTIE LINUX Command prompt Windows

Maak een directory mkdir mkdir Verander van directory cd cd Geef de inhoud van een directory weer

ls dir

Verwijder een directory rmdir rmdir “Edit” een bestand emacs of vi edit Verwijder een bestand rm del Kopieer een bestand cp <oldfile> <newfile> copy <oldfile> <newfile>

Wijzig de naam van een bestand mv <oldfile> <newfile> rename <oldfile> <newfile>

Toon bestand more <filename> type <filename> | more

2.1. Gebruik van handleidingen en help in LINUX De informatie die in deze cursus wordt gepresenteerd is lang niet volledig, een voorzichtige schatting is dat maar 5% van de mogelijkheden van LINUX aan bod komt. Een handleiding over LINUX waarin alle mogelijkheden worden besproken is vele honderden pagina’s dik!

Toch zul je als je deze cursus hebt doorlopen redelijk met LINUX uit de voeten kunnen. Het is daarna belangrijk om regelmatig zelf op zoek te gaan naar de informatie die je nodig hebt. Je kunt dat doen door die dikke boeken te gaan lezen. Een andere mogelijkheid is om de manual-pages te raadplegen die al in LINUX zijn ingebouwd. Hoe je dat moet doen staat beschreven in hoofdstuk “


Enkele eenvoudige commando’s” van deze cursus.

Belangrijk is dat je je realiseert dat je met LINUX zeer veel kunt doen. Alleen door jezelf steeds vragen te blijven stellen en de antwoorden in de manuals op te zoeken leer je LINUX echt goed gebruiken.

Een goede houding is om er steeds vanuit te gaan dat binnen LINUX alles kan. Slechts zeer zelden zul je merken dat deze uitspraak toch niet helemaal waar is.

3. Desktop-omgevingen onder LINUX Wanneer je inlogt in LINUX verschijnt over het algemeen een scherm dat eruit kan zien als het onderstaande: het GNOME scherm. GNOME is op een soortgelijke manier opgebouwd als Windows. Op het bureaublad staan snelkoppelingen er is een menu van waaruit programma’s gestart kunnen worden en draaiende programma’s verschijnen als knoppen.

3.1. De werking van GNOME In deze sectie gaan we nader in op enkele onderdelen van deze omgeving.

Panelen

Veel handelingen kun je verrichten met behulp van de GNOME-panelen. Hiernaast zie je hoe een paneel eruit kan zien.

Als je wilt kun je een paneel verbergen door op een pijltje te klikken dat zich aan de uiteinden bevindt.

Er zijn meerdere soorten panelen: gewone panelen en een menu panel. Er is maar één menu-panel, die is niet verplaatsbaar en dit bevat onder andere het GNOME-hoofdmenu (met het voetje). Er zijn al een aantal nuttige programma’s in dit menu voor je ingesteld.

Veelgebruikte programma’s kun je toevoegen aan een paneel zodat je er snel bij kunt. Klik daarvoor met de rechtermuisknop op een leeg stukje van een paneel. In het contextmenu dat verschijnt staat (Panel ) Add to Panel Launcher from Menu Beweeg met je muispijl door de submenu’s heen om de launcher, oftewel de naam van het programma, die je wilt toevoegen te vinden. Een object op het paneel kan weer verwijderd worden door er met de rechtermuisknop op te klikken en Remove from panel te kiezen uit het contextmenu.


Vensterlijst

Helemaal rechtsboven in het scherm vind je een knop die met een pictogram aangeeft welk programma momenteel de aandacht (focus) heeft. Wanneer je op deze knop drukt zie je een lijst van alle programmavensters die op dat moment open zijn. Door op een item in de lijst te klikken ga je naar het corresponderende programma toe.

Werkbladwisselaar

Hiernaast zie je hoe de werkbladwisselaar (ook wel pager genoemd) eruit kan zien. Het idee is dat je meerdere “virtuele” werkbladen tot je beschikking hebt in plaats van slechts één. In situaties waar je veel vensters tegelijkertijd geopend hebt, zoals tijdens programmeerpractica, kan dit je helpen het overzicht te

bewaren. Op de eerste drie werkbladen staan vensters, op de vierde niet. Klik met de muis op een werkblad om ernaartoe te schakelen.


4. De (LINUX-) shell

4.1. Functies van de shell Shell is de naam van het programma dat de commando’s van je scherm leest of ontvangt en zorgt dat de commando’s worden uitgevoerd. Er zijn verschillende soorten shells en als je een loginnaam bij FEW krijgt toegewezen wordt daarmee een van die typen shells aan jou verstrekt. In principe werken we met de Bash-shell. De shell is niet alleen een programma dat je commando’s interpreteert, maar begrijpt ook een speciale shell-programmeertaal. Van de shell zijn verschillende versies in omloop. De originele versie, de zogenaamde Bourne shell, heet sh. Als student krijg je meestal de Bourne-again shell, ofwel ‘bash’1. Deze lijkt in heel veel aspecten op ‘sh’ maar kan ook een aantal handige dingen meer. Zo probeert bash als je tijdens het intikken van een commando op de TAB toets drukt zo goed mogelijk waar je mee bezig was voor je af te maken. Als je dus een file met een heel lange naam zou willen bewerken bv. ‘dit_is_een_file_met_een_hele_lange_naam’ kun je na het intikken van ‘dit’ (maar voordat je op return drukt) op TAB drukken waarna de shell de naam voor je afmaakt, vooropgesteld dat er in je directory geen andere file is die zo begint. Als die wel zou bestaan geeft bash de verschillende mogelijkheden en kun je wat karakters aan de filenaam toevoegen om de keuze duidelijk te maken.

Verder beschikt bash over een geheugen: er wordt onthouden welke commando’s je allemaal al hebt ingetikt. Met behulp van de pijltjestoetsen kun je door de lijst van opdrachten wandelen en het geschikte commando opnieuw laten uitvoeren. Dit kan je een hoop denkwerk schelen bij meer ingewikkelde commando’s.

Er zijn nog meer zaken waarop sh en bash verschillen, maar bovengenoemde mogelijkheden kunnen je al heel wat tikwerk besparen.

Gebruik nooit twee shells door elkaar, dit kan door de verschillen behoorlijk verwarrend zijn. Over het algemeen is het is beter eerst één shell heel goed te leren kennen en eventueel later over te stappen.

4.2. De shell opstarten

Een GNOME Terminalvenster kun je openen door op het hiernaast afgebeelde pictogram in het paneel/GNOME menu te klikken.

Er verschijnt nu een schermpje waarin je commando’s kan intikken.

1Uitgebreide documentatie voor bash is te vinden op http://www.gnu.org/software/bash/bash.html .


5. Enkele eenvoudige commando’s Voor het werken met de shell gebruiken we shell-commando’s. In dit hoofdstuk komen enkele eenvoudige, maar veelgebruikte commando’s aan de orde.

5.1. Passwd, Date, who, ls, lpr en man Commando’s zoals passwd, date, who, ls en man worden ook wel shell-commando’s genoemd. In de loop van deze cursus kom je nog een aantal andere shell-commando’s tegen.

Zorg ervoor dat je een window hebt waarin een shell draait (zie de vorige sectie). Plaats de muiswijzer binnen het window zodat je commando’s kunt invoeren.

Iedere opdracht die je aan de computer geeft moet altijd met de toets waar ENTER op staat afgesloten worden. Dat is het teken dat jij klaar bent met intikken en dat de computer nu aan het werk moet met jouw commando. Als je geen ENTER intikt gebeurt er dus niets. We zullen dat van nu af aan er niet meer bij vertellen. Als je je afvraagt of het klopt dat er niks gebeurt, geef dan nog een keer ENTER, misschien was je het vergeten (teveel keer kan nooit kwaad).

Linksboven in het window staat op de onderste niet-blanco regels de prompt (een $ of een %, afhankelijk van de instellingen van je shell) gevolgd door de cursor. De prompt geeft aan dat de computer klaar is met het verwerken van je vorige opdracht. Je zou het inloggen dus kunnen beschouwen als het eerste commando dat jij aan de computer gegeven hebt. Achter de prompt kun je opdrachten voor LINUX intikken.

druk op ENTER Als dat het enige is wat je doet, je hebt dus geen commando ingetikt, dan wordt dit verstaan als “Voer geen opdracht uit’’. Daar is het systeem (vrijwel) meteen mee klaar, en je wordt daarvan op de hoogte gesteld door de volgende prompt.

5.1.1. date

date

De computer geeft de datum en het tijdstip. Ten teken dat de opdracht uitgevoerd is verschijnt op de volgende regel dus weer een prompt.

5.1.2. who

who

Het resultaat is een lijst van personen die op dit moment op de computer zijn ingelogd. Ook is de tijd te zien waarop ze hebben ingelogd en hoe de terminal heet waarop ze werken. Wanneer je op een Windows-machine of een workstation bent ingelogd dan wordt na dit commando alleen je eigen naam genoemd. Dit komt omdat op een Windows-machine of een workstation maar één persoon tegelijkertijd kan inloggen, terwijl je via terminals met een aantal mensen op hetzelfde systeem werkt.

Wanneer de uitvoer meer dan een scherm beslaat kun je dat scherm voor scherm (of regel voor regel) bekijken, door de commando’s more of less aan het commando who mee te geven.

who | more

Het “|”-teken heet een pipe. Je vindt het meestal naast de BACKSPACE-toets op je toetsenbord (met SHIFT). Meer over pipes in sectie “Pipes”. Met more wordt zoveel van een file afgedrukt tot het scherm vol is. Door op ENTER te drukken worden nieuwe regels weergegeven, met de spatiebalk verschijnt een nieuwe pagina. Wanneer alle regels zijn afgedrukt keer je automatisch terug naar de prompt. Met q (quit) kun je tussendoor terugkeren naar de prompt.


5.1.3. ls

ls

Iedere gebruiker heeft een zogeheten home directory, een eigen map in het externe geheugen waar je automatisch terechtkomt als je inlogt. Die plaats wordt door systeembeheer ingesteld en aangemaakt. Het adres van je home directory is: /home/VUnetID , ook aan te duiden met ‘~’. Wanneer je het commando ls geeft en op Enter drukt, dan wordt de inhoud van je home directory getoond. Als dit de eerste keer is dat je inlogt, zullen er nog geen bestanden zichtbaar zijn.

Aan een commando kun je in het algemeen twee soorten argumenten toevoegen:

1. argumenten die bepalen op welke manier het commando wordt uitgevoerd (zgn. opties). Deze argumenten beginnen met een ‘-’, en heten ook wel ‘vlaggen’. Bijvoorbeeld:

ls -l (dit is geen één, maar een L)

Optie -l bepaalt dat niet alleen de namen van de files worden afgedrukt maar ook een aantal nadere gegevens, zoals de soort file, de grootte, de naam van de eigenaar, wat je er mee mag doen en het laatste moment van wijziging. Je hebt dus een commando en je kunt daarachter argumenten/vlaggen zetten (gescheiden door spaties) die meestal met ‘-’ beginnen, maar soms ook met ‘--’.

ls -a

Dit commando toont alle files in je huidige directory. Er zijn namelijk al een paar files voor je aangemaakt door het systeem. De namen daarvan beginnen met een punt. Je home-directory wordt aangegeven door een . (punt).

Wat ook werkt is dit:

ls -al

(een combinatie van ‘ls -a -l’). Welke mogelijkheden er allemaal zijn bij ‘ls’ kun je vinden in de handleiding van ls, zie sectie “man”.

2. argumenten die bepalen waarop het commando wordt uitgevoerd. Stel je even voor dat er zich in de directory waar je op dat moment bent een file bevindt met de naam fred.

ls –l fred

Je krijgt dan niet van alle files de bovengenoemde gegevens te zien, maar alleen die van de file fred. Omdat je nog geen file hebt met de naam fred wordt dit je keurig meegedeeld.

5.1.4. lpr

Het printen van files kan met het commando lpr gevolgd door de filenaam.

5.1.5. man

We hebben je er al gewezen dat het kunnen hanteren van de manuals van groot belang is voor het leren werken met LINUX. De manual roep je op door het commando man met als argument het onderwerp waarover je meer informatie wilt

man ls

Je komt nu in een aparte help-file terecht. Vaak past niet alle informatie op één scherm: met de pijltjestoetsen kun je door het document lopen. Met de spatiebalk spring je naar de volgende pagina. Met q (quit) verlaat je de manual en keer je terug naar de prompt van de shell.


5.2. Een commando afbreken Soms kan het voorkomen dat je een commando wilt afbreken voordat het volledig uitgevoerd is. Dat doe je door de control toets (meestal linksonder op het toetsenbord met afkorting CTRL) in te drukken, deze vast te houden en de c in te drukken.

who

Zodra de lijst met loginnamen begint:

druk je op CTRL-c

De computer breekt het commando dan af, en antwoordt weer met een prompt.

6. Werken met directories Directories zijn te vergelijken met grote multomappen waarin verschillende soorten documenten (files) zitten. Bijvoorbeeld notities, memo’s, schetsen en berekeningen. De vergelijking met een multomap gaat echter niet helemaal op, omdat een directory ook weer verschillende sub-directories kan bevatten. Dit is in het echt natuurlijk niet mogelijk.

Het LINUX-systeem heeft een hiërarchisch filesysteem, dit houdt in dat directories en files in relatie tot elkaar zijn georganiseerd.

6.1. Directories maken, de inhoud bekijken en veranderen van directory Als je steeds meer files maakt en geen verdere actie onderneemt zal je home-directory heel onoverzichtelijk worden. Zo’n handelwijze zou overeenkomen met het op één grote stapel leggen van alle papieren die je ontvangt zodat je tenslotte in die stapel niets meer kunt terugvinden. Als je dat beter wilt beheren doe je er verstandig aan om bij elkaar horende spullen ook bij elkaar te bewaren. In het LINUX filesysteem kan dat gelukkig ook. Je kunt nieuwe directories maken met het commando mkdir (make directory). Achter dit commando typ je de naam van de directory in die je wilt aanmaken.

Je kunt bijvoorbeeld een directory maken waarin je je files kunt zetten die je maakt bij het practicum van dit vak. De naam die je voor die directory zou kunnen gebruiken is intro.

mkdir intro

In je home-directory is nu een sub-directory met de naam intro gemaakt.

ls

Je ziet de directory intro die je net hebt aangemaakt staan.

mkdir probs

ls


Je hebt nu alvast een directory aangemaakt waarin je de bestanden van het vak Probleemoplossen, dat binnenkort start, kunt plaatsen. Met het commando ls zie je nu de twee subdirectories intro en probs staan. Schematisch kunnen je je dit zo voorstellen:

Dit proces van creëren van directories kun je verder doorzetten. Ook in de directory intro kun je weer directories maken enz. Je krijgt op deze manier een (omgekeerde!) boom van directories. Aan de uiteinden van de takken zitten de bladeren (de files) waarin gegevens staan. Het hele filesysteem van LINUX is dus in boomvorm georganiseerd. Uiteraard is jouw home directory niet de belangrijkste file in het hele systeem (behalve dan misschien vanuit jouw optiek). Ook boven jouw directory bevindt zich een hele boom van directories. Het startpunt van de hele boom is de zogenaamde ‘root’, die wordt aangeduid met het teken ‘/’. Deze wortel bevindt zich volgens het spraakgebruik van de informatica bovenaan de boom. Zoals je misschien al had gemerkt groeien in de informatica de bomen op hun kop!

Via het commando cd (change directory) kun je door een groot gedeelte van de boom wandelen. Sommige delen van de boom zijn echter niet voor iedereen toegankelijk, je kunt deze directories dan ook niet bekijken.

cd intro

Home directory: ~ je VUnetID

intro probs

/

cache ............ home tmp usr

home-directory: ~VUnetID

intro probs

etcetera etcetera

etcetera


Met het commando cd verplaats je dus je werkdirectory (de directory waarmee je aan het werk bent) naar die nieuwe directory. Je stapt als het ware de directory binnen en kunt daar vanaf nu subdirectories en files bekijken en maken.

ls

Via ls kun je weer bekijken welke documenten of sub-directories er aanwezig zijn in de directory intro. Hij is natuurlijk nog leeg.

Je kunt altijd direct terug naar je home directory met het commando cd ~ (~ is de naam van jouw home directory). De home directory van een andere gebruiker, bv. van piet wordt aangegeven door ~piet). Een andere mogelijkheid om naar je home directory te gaan is door het tikken van cd zonder argument.

Ga terug naar je home directory.

De directory ‘boven’ de directory waar je bent wordt de parent directory van die directory genoemd. Een parent directory wordt in LINUX aangegeven met ‘..’. Met ‘.’ wordt de directory aangegeven waar je op dat moment bent. Je kunt één stap teruggaan in de directory-boom door het commando cd .. te gebruiken.

Ga naar de parent directory van je home directory. Bekijk welke documenten en/of subdirectories in deze directory te vinden zijn.

Gebruik hiervoor het commando ls -l. Als het goed is zie je je eigen home-directory staan met al zijn eigenschappen. De home directories van je medestudenten zijn ook te zien.

Ga naar je home directory. Met het commando ls -l intro krijg je informatie over wat er in de directory intro staat. Ga met behulp van de manual na welke optie je aan ls kunt meegeven zodat niet de inhoud maar de eigenschappen van de directory worden getoond.

6.2. De weg kwijt?? Wanneer je de weg kwijt bent en niet meer precies weet in welke directory je je bevindt dan kun je dat vragen aan LINUX met het commando pwd (Print Working Directory).

Ga terug naar je home directory

pwd

Wat wordt afgedrukt is de volledige padnaam (pathname) van de directory waar je op dat moment bent. De naam ontstaat door achter elkaar alle directories (gescheiden door het symbool ‘/’, de zogenaamde slash) op te schrijven die je vanaf de root moet doorlopen om bij de huidige directory te komen: dus via / kom je bij de sub-directory home en daarna bij je home directory. Oftewel: /home/VUnetID.

Wanneer een padnaam begint met een “/” wordt vanuit de root directory naar die file gezocht, we noemen dit de absolute padnaam. Wanneer een padnaam niet begint met een “/’’ wordt naar de file gezocht vanuit de directory waarin je je bevindt, dit is de relatieve padnaam. Relatieve en absolute namen onderscheiden zich dus doordat de absolute namen beginnen met een slash, en de relatieve juist niet.


Het kan natuurlijk voorkomen dat je een file zoekt die ergens op de schijf staat, maar waar? Het volgende commando begint te zoeken in de huidige directory (daar staat het puntje ‘.’ voor) en zal afdrukken waar de file met de naam ‘verhaaltje’ staat.

find . –name verhaaltje

Je kunt altijd teruggaan naar je home directory met het commando cd

Let op: in andere systemen (MS-DOS of Windows) wordt voor de slash ‘/’ het teken ‘\’ (backslash) gebruikt. Dit teken heeft binnen LINUX een andere betekenis.

Binnen LINUX mogen in een directory- of filenaam geen spaties voorkomen, behalve als je er quotes om plaatst (bijvoorbeeld: “a b”) of een backslash voor zet.


7. Werken met files Een file is een bestand ergens in het geheugen van de computer. Alle informatie in de computer en de daarbij behorende geheugensystemen is georganiseerd in de vorm van files. In feite kunnen ze niet alleen tekst bevatten maar ook computerprogramma’s in machinetaal.

Zorg ervoor dat je in je home-directory staat.

cp /usr/prac/ip/file intro/mijnfile

Let er op dat er een spatie is tussen cp en de eerste slash(/).

Met dit commando kopieer je het bestand met de naam file dat staat in de subdirectory ip van de subdirectory prac van de subdirectory usr van de root.

Met intro/mijnfile geef je aan waar je deze file precies wilt neerzetten (gerekend vanaf de directory waar je je op dat moment bevindt, in dit geval je home-directory) en hoe je hem noemt: je plaatst hem in de subdirectory intro en je geeft het oorspronkelijke bestand file nu de naam mijnfile.

cd intro

ls

De file mijnfile staat in de subdirectory intro

De inhoud van een file kun je bekijken met het commando cat.

cat mijnfile

LINUX antwoordt met de inhoud van de file. Deze bestaat uit drie regels tekst.

cp mijnfile file2

Nu heb je twee files met identieke inhoud. Je kunt dat controleren door met cat de beide files te bekijken.

diff mijnfile file2

De computer schrijft alle regels op het scherm die niet gelijk zijn in beide files (in dit geval nul regels).

Het is mogelijk files van naam te laten veranderen. Daarvoor is het commando mv (“move’’).

mv mijnfile rommel

Stel vast met het commando ls dat de file nu rommel heet.

Het verwijderen van een file gaat met het commando rm (“remove’’).

rm rommel

Ga na dat deze inderdaad verdwenen is. Kijk altijd uit met het gebruik van het remove-commando. Als je een file hebt weggegooid is deze onherroepelijk verdwenen. Er bestaat niet zoiets als een prullenbakje waaruit je nog wel weer je documenten kunt opvissen.

8. Meer commando’s In dit hoofdstuk laten we de werking zien van enkele veelgebruikte commando’s. We geven slechts een korte uitleg over deze commando’s. Wanneer je meer wilt weten over de mogelijkheden van een commando maak dan gebruik van de manual.


8.1. Commando’s combineren De shell kan nog veel meer dan regel voor regel commando’s uitvoeren. Zo kun je twee commando’s op een regel combineren door ze, gescheiden door een puntkomma achter elkaar te zetten

who;date Nu worden achtereenvolgens de personen die ingelogd zijn en de datum en tijd afgedrukt.

8.2. Speciale tekens Er zijn een paar karakters, die in de shell een speciale betekenis hebben. ? betekent ieder willekeurig karakter

* betekent nul of meer willekeurige karakters

Deze worden ook wel wildcards (jokers) genoemd.

8.2.1. ?

ls f?le2

Er wordt hier gezocht naar alle files in de directory waar deze beschrijving op past.

8.2.2. *

Het is niet altijd nodig om de volledige naam van een file als argument aan een commando mee te geven. Je kunt een soort kortschrift gebruiken waarbij het systeem zelf aanvult wat je niet hebt meegegeven. De aanduiding m* in een commando betekent: “alle files in de directory die beginnen met een m’’. Een enkele “*’’ is een kortere schrijfwijze voor “alle files in de directory”. Ze mogen ook in combinatie gebruikt worden.

Voorbeeld 1:

ls /u*/pr??/ip/?anton*

Er blijken twee files te zijn die aan deze beschrijving voldoen.

Voorbeeld 2:

Neem even aan dat je in je directory een aantal versies hebt staan van een bepaald programma dat je aan het schrijven bent, die je allemaal zou willen afdrukken (niet iets om in werkelijkheid aan te raden).

prog prog1.1 prog1.2 prog1.3 prog1.4 prog2

Je kunt dat doen door het commando lpr prog*. Alle files waarvan de naam begint met ‘prog’ worden dan naar de printer gestuurd. De * staat dus voor een willekeurig aantal tekens.

Die speciale betekenis van ? en * kun je weer omzeilen door de naam waar ze in voorkomen tussen enkele aanhalingstekens te zetten zoals bv. in ls ‘?’. Hiermee wordt alleen de file gemeld waarvan de naam ook werkelijk ? is.


8.3. Redirectie van invoer en uitvoer De meeste commando’s die we tot dusver hebben gezien produceren output op het beeldscherm. Sommige vragen ook om input vanuit het toetsenbord. Je kunt in LINUX de input of output ook altijd uit een file halen of naar een file wegschrijven.

Je kunt de output van ls bijvoorbeeld naar een file sturen in plaats van naar het scherm.

ls > naarfile

cat naarfile

De output van ls komt nu in de file naarfile terecht. Wanneer de file naarfile nog niet bestaat wordt die aangemaakt. Als de file al wel bestaat is de oude inhoud nu verdwenen!! Pas daarmee op! Als je wilt dat de output van het commando niet de gegevens in de file vervangt, maar ze er achter plakt dan kun je >> in plaats van > gebruiken.

date >> naarfile

cat naarfile

Op dezelfde manier kun je een programma dat invoer van het toetsenbord verwacht in plaats daarvan uit een file laten lezen door achter het commando een < teken en de naam van de file te zetten.

8.4. Pipes Het commando who vertelt wie er ingelogd zijn op de machine waarop jij op dat moment aan het werk bent. Veronderstel dat je die lijst zou willen bekijken met less; dat kan door de output van who eerst naar een file te sturen en daarna die file met less te bekijken:

who > temp

less temp

In LINUX bestaat de mogelijkheid om dit proces te stroomlijnen door middel van een zogenaamde pipeline of pipe: je geeft de output van het ene commando (who) mee als input voor het tweede commando (less) door ze achter elkaar te zetten met een ‘|’ (verticaal streepje) symbool ertussen.

who | less

Het resultaat is hetzelfde als hierboven, alleen wordt de file temp niet gecreëerd of gewijzigd. Het voorkomt dus dat je veel tijdelijke files moet aanmaken die je later weer moet weggooien. Less sluit je overigens af met de letter q.

Kijk erg goed uit bij het gebruik van * bij het weggooien van files. Of liever nog, gebruik het dan helemaal niet. Als je bedoelt rm *2 (gooi alle files weg die op 2 eindigen) maar je tikt per ongeluk rm * 2 (met een spatie tussen de * en de 2), betekent dat: gooi alle files weg, en bovendien de file 2. Het systeem klaagt dan dat de file 2 niet bestaat, nadat (zoals je zelf hebt opgegeven) al je files zijn weggegooid!


8.5. Grep Een heel handig commando is grep (afkorting van: Get Regular ExPression). Grep doorzoekt een file naar een woord of een combinatie van karakters dat je opgeeft en drukt de regels waarin dit woord voorkomt af.

grep drie file2

Het resultaat is dat de regel in de file file2 waarin het woord drie voorkomt wordt afgedrukt. Geef dus altijd eerst aan welk woord je zoekt en daarna in welke file.

Het kan zijn dat je in een file een bepaalde naam zoekt, maar dat je niet weet of die wel of niet met hoofdletters is geschreven. Je kunt dan aan grep een extra optie meegeven zodat naar beide mogelijkheden wordt gezocht. Ga met behulp van de manual na hoe je dit moet doen.

Vul in: De optie om zowel naar hoofd- als kleine letters te zoeken is: ___________

Ga na hoe je kunt zoeken naar regels waarin een woord NIET voorkomt. Druk hierbij ook de regelnummers af. Laat je methode controleren door de student-assistent.

8.6. Sorteren Sort is een commando dat de regels van een file (bv. een file met namen) alfabetisch lexicografisch sorteert en het resultaat afdrukt.

sort file2

Het resultaat van deze sorteeractie komt op je beeldscherm. Je kunt dit resultaat echter ook in een nieuwe file zetten:

sort file2 > alfa

Controleer dat er een file met de naam alfa is gemaakt. Bekijk de inhoud.

Ga met behulp van de manual na:

1) hoe je de file in omgekeerde volgorde kunt sorteren

2) hoe je de gegevens in de oorspronkelijke ongesorteerde file kunt vervangen door de gesorteerde gegevens met behulp van een hulpfile

Wanneer je geen tweede argument (in dit geval mijnfile) meegeeft aan grep dan wordt er gezocht in de inputfile, oftewel datgene wat jij op je terminal intikt. Er wordt net zolang gezocht totdat jij de inputfile sluit. Zolang je de file niet gesloten hebt blijft grep zoeken in de inputfile en is je terminal niet beschikbaar voor iets anders! Sluiten van de file gaat met CTRL-d.

Pas op met sort lijst > lijst. Als je dat doet wordt de inhoud van lijst eerst weggegooid (altijd bij redirectie) waarna er niets meer te sorteren is, en je al je gegevens kwijt bent. Experimenteer alleen met files waarbij het niet erg is als je de inhoud kwijt raakt!


De volgende moeilijke opgave is niet verplicht, maar wel een uitdaging!

3) Hoe kun je de gesorteerde gegevens zonder een hulpfile in de oorspronkelijk ongesorteerde file krijgen

Vul hier je antwoorden in laat deze controleren door de student-assistent:

1) ____________________________

2) ____________________________

3) ____________________________

8.7. Met meer programma’s tegelijk werken

8.7.1. Processen op de achtergrond zetten

Tegelijkertijd met verschillende programma’s werken heeft als voordeel dat je bijvoorbeeld ingewikkelde berekeningen die veel tijd kosten kunt uitvoeren terwijl je tegelijk je verslag aan het schrijven bent.

xcalc&

xedit&

xcalc is een rekenmachine. xedit is een simpel editor. Door achter de naam van het programma een & te zetten geef je aan dat je deze applicatie wilt starten terwijl je ook met de andere programma’s blijft werken. De programma’s worden ieder in een afzonderlijk window geopend. Door op de applicatie te klikken waarmee je wilt werken haal je deze naar de voorgrond en kun je gegevens invoeren.

Mocht je een programma gestart hebben zonder een ampersand (&) erachter, dan zit je terminal nog niet op slot. Gebruik CTRL+Z om je programma te pauzeren en je prompt terug te krijgen, en het commando bg (background) om het op de achtergrond verder te laten werken.

8.7.2. Processen beheren

De uitvoer van het jobs commando toont de processen die je al in de shell had opgestart, en hun status (gestopt, draaiende enzovoort).

jobs

Stel nu dat je het eerst opgestarte proces, xcalc, weer naar de voorgrond wilt halen. jobs geeft dit proces waarschijnlijk aan met een [1] ervoor. Je adresseert het xcalc-proces dan met %1 en geeft dat mee aan fg:

fg %1

LINUX geeft aan elke applicatie een process-id, waarmee de draaiende programma’s kunnen worden geïdentificeerd. Niet alleen de programma’s die je toevallig in de shell had gestart vallen hieronder, maar alle processen die op de computer actief zijn.

ps -a

Met het commando ps -a (Process Status) krijg je een overzicht van de processen die op de achtergrond draaien met hun process-id (PID).

Wanneer je een proces geforceerd wilt stoppen, bijvoorbeeld omdat deze niet meer normaal af te sluiten valt, gebruik je het commando kill -9 gevolgd door het PID.


Sluit een programma door eerst de lijst van processen op te vragen, en vervolgens het juiste proces te killen. Bijvoorbeeld:

kill –9 516

waarna het bijbehorende proces stopt. Kill begrijpt ook de %-notatie.

8.8. Rijmwoordenboek In dit onderdeel is het de bedoeling dat je zelf een rijmwoordenboek bouwt. We gaan er vanuit dat je je nog steeds in de shell bevindt.

/usr/dict/words is een file “words” dat staat in directory /usr/dict . We willen graag weten uit hoeveel losse woorden deze file bestaat. Het commando wc doet een word count.

Ga met behulp van de manual na wat volgens wc de definitie van een word is. Probeer het hieronder in je eigen woorden uit te leggen:

wc /usr/dict/words

Wat is de uitvoer van dit commando?

Bekijk met behulp van more eens de file ‘/usr/dict/words’

more /usr/dict/words

Wat is het verschil tussen hoe het more-commando hier wordt gebruikt en hoe het wordt gebruikt in sectie “who”?

De manual-page van het commando rev ziet er als volgt uit:

rev Command Purpose Reverse characters in each line of a file.

rev < /usr/dict/words > outfile

Wat doet dit commando? (Hint: zie sectie “Redirectie van invoer en uitvoer”).

Controleer of wat je hebt opgeschreven inderdaad klopt door de file outfile met more te bekijken.

Bedenk nu een samengesteld commando dat een file ‘rijmwoordenboek’ als uitvoer heeft, en de file ‘/usr/dict/words’ als invoer. De file ‘rijmwoordenboek’ moet alle woorden uit ‘/usr/dict/words’ bevatten en gesorteerd zijn op woorduitgang. Maak gebruik van een pipe.

Oplossing:


9. Shell-scripts Je hebt al kennis gemaakt met een groot aantal commando’s in LINUX. Vooral in het begin zul je met deze commando’s voldoende uit de voeten kunnen. Na verloop van tijd zul je echter merken dat je sommige handelingen te vaak moet uitvoeren of een aantal commando’s achter elkaar moet intypen. Dit wordt al snel vervelend. In deze gevallen is het handig om een shell-script te schrijven dat deze handelingen voor je kan uitvoeren.

Een shell-script wordt geschreven in de editor, waarna deze file door LINUX wordt aangeroepen en uitgevoerd. Net zoals je dat met een willekeurig commando als grep of sort kunt doen, kun je tegen de shell zeggen dat zijn invoer uit een file komt en niet van het toetsenbord.

Eigenlijk is een shell-script dus niets meer dan een file met tekst, maar deze tekst moet wel aan bepaalde regels voldoen: het moet een syntactische structuur bezitten, zodat het voor LINUX duidelijk is dat het om een script gaat. LINUX kan het shell-script dan lezen, de commando’s interpreteren en zorgen dat deze commando’s worden uitgevoerd. Op deze manier gebruik je de shell (zowel sh als bash) dus niet alleen als een programma dat je commando’s interpreteert, maar ook als programmeertaal. Op deze manier kun je lange, moeilijk te onthouden commando’s of een serie commando’s afkorten tot enkele letters.

9.1. Een zeer eenvoudig shell-script We hebben al eens de commando’s date en who gecombineerd (zie sectie “Commando’s combineren”). Wanneer je deze informatie wilt hebben, maar je hebt geen zin om de commando’s steeds in te tikken, dan kun je hiervan een shell-script maken.

Start twee keer de shell op

Typ in de tweede shell pico in om de editor pico op te starten en zorg ervoor dat de windows van de eerste shell en dat van pico tegelijk op je scherm leesbaar zijn. Pas hiervoor zonodig de grootte van vensters aan.

Typ in de editor onderstaande tekst letterlijk over en bewaar de file onder de naam whodate in de directory intro. Een script hoort standaard te beginnen met ‘#!/bin/sh’ - dit vertelt aan LINUX voor welk soort shell het script is geschreven, zodat het gegarandeerd goed wordt uitgevoerd.

#!/bin/sh who date

Ga naar de eerste shell. Zorg ervoor dat je in de directory intro staat.

sh whodate Met dit commando draai je het script in de shell. Met het commando sh roep je eerst de shell aan, die het shell-script whodate voor je uitvoert. De gevraagde gegevens worden op je scherm gezet. Op zich bespaart dit shell-script je niet heel veel tijd (je moet nu zelfs meer letters intypen!), maar het geeft wel in een notendop de werking van een shell-script weer.

9.2. Shell-scripts met variabelen In shell-scripts (en in computerprogramma’s in het algemeen) wordt veel met variabelen gewerkt. Een variabele is een plaats waar een waarde kan worden opgeslagen. Deze waarde kan van geval tot geval verschillen, afhankelijk van de keuze van de gebruiker. Een variabele begint altijd met een letter, gevolgd door een combinatie van letters, cijfers of andere tekens.

Binnen LINUX zijn al een groot aantal standaard variabelen in gebruik, deze worden in hoofdletters geschreven. Daarnaast kun je zelf in je shell-scripts variabelen definiëren, wanneer je kleine letters gebruikt ontstaan er geen problemen met de standaard gedefinieerde variabelen.


Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam welkom in de directory intro.

#!/bin/sh echo Wat is je naam? read antwoord echo Hallo $antwoord, welkom bij de Vrije Universiteit.

Run het shell-script welkom. Beantwoord de vraag die je gesteld wordt.

Dit shell-script maakt gebruik van de variabele antwoord.

$antwoord geeft aan dat de waarde moet worden genomen van de variabele antwoord.

Het commando echo drukt altijd het argument (datgene dat er achter staat) af.

Wanneer je een fout hebt gemaakt in het overtypen, dan verschijnt er een foutmelding op het scherm. Probeer de fout te herstellen en bewaar de file weer. Run het shell-script opnieuw. Wanneer je de foutmelding niet begrijpt of de oplossing niet weet vraag dan je practicumbegeleider of een medestudent om je even te helpen.

Probeer nu zelf het shell-script uit te breiden met de volgende vragen: hoe oud ben je, waar woon je en welke studierichting doe je? Verzin zelf leuke reacties op de antwoorden die je in moet voeren. Laat je script op correctheid controleren door de student-assistent. Bewaar en run het script.

9.3. Een shell-script executable maken Wanneer je een shell-script wilt uitvoeren typ je nu steeds sh gevolgd door de filenaam. Wanneer je de file executabel maakt hoef je alleen nog maar de filenaam in te typen. Het executabel maken van een file gaat door middel van het commando chmod 700 of chmod +x. Beide commando’s hebben dezelfde werking, namelijk ervoor zorgen dat de file nu door de shell uitvoerbaar (executabel) is. Een script werkt, als je het executabel hebt gemaakt, dus op dezelfde manier als een LINUX-commando.

chmod 700 welkom

Het intypen van de naam van de file is nu voldoende om het shell-script uit te voeren.

welkom

9.4. De plaats van shell-scripts De file welkom uit de vorige sectie moet voordat die kan worden uitgevoerd wel staan in de directory waar je op dat moment bent. Als je niet bent in de directory waar de file staat dan kan de shell je opdracht niet vinden en komt er een foutmelding:

Ga naar je home-directory.

welkom

Je kunt er echter voor zorgen dat je vanuit elke plaats een (zelfgemaakt) commando kunt uitvoeren door de file waarin het commando staat te verplaatsen naar de subdirectory met de naam bin in je home-directory. Als die directory er nog niet is moet je die eerst maken. De shell zoekt standaard op een aantal plaatsen waar commando’s zouden kunnen staan, en één daarvan is je bin (bin staat voor binary) directory.

Ga na of je in je home-directory een subdirectory hebt met de naam bin. Maak deze directory zonodig aan.


Verplaats het shell-script welkom naar de directory bin. Voer het shell-script (als je in de directory bin staat) een keer uit om te controleren of deze nog werkt.

Ga naar je home-directory.

welkom

Je merkt dat het shell-script nu wel werkt.

Als je wilt weten op welke plaatsen de shell zoekt kun je dat opvragen door te kijken naar de waarde van de variabele PATH.

echo $PATH

Je ziet dan, gescheiden door ‘:’ de locaties waarin de shell naar commando’s zoekt. Samen vormen ze de waarde van de variabele PATH.

Voor de duidelijkheid: onderstaand commando drukt alleen het woordje PATH af.

echo PATH

Je kunt de waarde van de PATH-variabele, en ook die van allerlei andere variabelen, zelf instellen.

Het meest gebruikelijk is dat te doen door allerlei waarden die bepalen hoe jij de shell wilt gebruiken in te stellen in de file .bashrc die zich in je home-directory bevindt. De punt aan het begin van de filenaam betekent dat het bestand hidden (verborgen) is en normaal gesproken niet wordt getoond na een ls-commando.

De commando’s die in die file staan worden uitgevoerd als je inlogt, en de dan ingestelde waarden gelden dan verder voor de duur van de sessie, tenzij je ze tussendoor weer verandert. Je kunt de file .bashrc op de gebruikelijke manier met de editor bewerken.

9.5. Argumenten meegeven aan een shell-script Je kunt, net als bij bestaande LINUX-commando’s, argumenten meegeven aan een shell-script. Wanneer het commando of shell-script wordt uitgevoerd wordt de waarde van de argumenten meegenomen bij het berekenen van het antwoord.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam showarg in de directory bin.

#!/bin/sh echo Het aantal argumenten is $# echo Het eerste argument is $1 echo Het tweede argument is $2 echo Het derde argument is $3

sh showarg jan piet (wanneer je het shell-script eerst executabel hebt gemaakt typ dan showarg jan piet)

Je voert hier het commando showarg uit met twee argumenten: argument jan en argument piet.

De waarden van deze argumenten worden opgeslagen in de parameters $1 en $2. Bij dit commando is er geen derde argument, deze krijgt dan ook geen waarde. Het totale aantal argumenten wordt geteld en bevindt zich in $#.

sh showarg jan piet klaas

Als je de waarde van een variabele wilt gebruiken moet je dus de naam van de variabele vooraf laten gaan door een $-teken.


Nu is er ook een derde argument. De waarde wordt opgeslagen in parameter $3.

9.6. Keuzes maken Met behulp van de variabelen en/of parameters kun je in het shell-script keuzes maken.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de

naam moeilijk in de directory bin.

echo Vind je shell-scripts schrijven moeilijk? Typ ja of nee. read antwoord if test $antwoord = ja then echo Je hebt $antwoord ingetikt. Je vindt het moeilijk else echo Je hebt $antwoord ingetikt. Je vindt het niet moeilijk fi

Run shell-script moeilijk. Beantwoord de vraag eerst met ja. Run het script daarna nog een keer met het antwoord nee.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam verwijder in de directory bin.

echo Wil je echt $1 verwijderen? read antwoord if test $antwoord = ja then echo $1 is verwijderd! rm $1 else echo dan verwijder ik niets fi

sh verwijder moeilijk

Wanneer je ‘ja’ invoert wordt het shell-script moeilijk verwijderd.

De variabele test is hier het hulpmiddel dat een berekening uitvoert over wat er achter staat, d.w.z. kijkt of dat waar of niet waar is. Op grond van de berekende waarheidswaarde kiest het script de actie die tussen then en else staat (in het geval van true) of de actie die tussen else en fi staat, in het geval van false.

test kan ook voor je kijken of een file, waarvan je de naam als argument meegeeft, wel of niet bestaat. Ga na hoe je dat moet doen en laat je oplossing controleren door de student-assistent.

9.7. Keuzes: de case-functie Een andere mogelijkheid om keuzes te maken is de case functie. Daarbij wordt datgene wat na het commando case staat vergeleken met elk van de patronen in de rij die volgt op het woordje in.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam stoplight in de directory bin. Test of het shell-script naar behoren werkt.

echo Geef een kleur read stoplicht case $stoplicht in rood) echo STOP ;; oranje) echo Stoppen als het kan, anders doorrijden ;; groen) echo Doorrijden ;; blauw|bruin|paars) echo Dit zijn geen stoplichtkleuren! ;; esac

sh showarg


Het script showarg dat je eerder hebt gemaakt werkt niet helemaal naar behoren. Als je geen argumenten meegeeft wordt toch drie keer een regel begonnen over de waarde van een argument, zonder dat het script er iets achter kan invullen. Kun je met behulp van case het script showarg zo veranderen, dat het eerst meldt hoeveel argumenten er zijn, en daarna: - bij 0 argumenten klaar is

- bij 1 argument meldt: “het enige argument is ....”

- bij 2 argumenten: “het eerste argument is ......”

“het tweede argument is ...”

- bij 3 of 4 argumenten: “meer dan twee argumenten mag niet”

9.8. Herhalen: de while-functie Door middel van het commando while kun je de shell één of meer opdrachten laten herhalen, zolang aan een bepaalde voorwaarde is voldaan.

Typ in de editor onderstaande shell-script letterlijk over en bewaar de file onder de naam herhalen in de directory bin.

#!/bin/sh antwoord=“ja” while test $antwoord = “ja” do echo “OK, nog een keer” echo “Moet ik nog steeds doorgaan?” read antwoord done

Deze shell-script voert de regels tussen do en done uit zolang de gebruiker als antwoord ja intikt.

In plaats van de regel

while test $antwoord = “ja” mag je ook schrijven:

while [ $antwoord = “ja” ]

Zowel de functie test als de vierkante haken zorgen ervoor dat de uitdrukking $antwoord = “ja” wordt geëvalueerd. Op grond van de uitkomst (true of false) wordt besloten of er nog moet worden doorgegaan met herhalen.

Schrijf nu zelf een script dat de gebruiker steeds om twee dingen vraagt: een zoekterm en de naam van een file. Als de laatste de naam is van een bestaande file uit de huidige directory, zoekt je script op in hoeveel regels van de file de zoekterm voorkomt en drukt dat aantal af. Dit proces wordt steeds herhaald totdat de gebruiker de naam van een niet-bestaande file opgeeft. Het script geeft dan een melding en stopt.

Commando’s als if en case dien je altijd op een goede manier af te sluiten, zodat de computer weet dat hij niet verder hoeft te zoeken naar meer keuzemogelijkheden. Het einde van een if-statement wordt aangegeven met fi, het einde van een case-statement met esac. (de commando’s achterstevoren gelezen).


HINT: je kunt van een regel een aantal karakters afhakken met behulp van het ‘cut’ commando. Kijk in de manual hoe dat precies moet.

9.9. Meer mogelijkheden met shell-scripts Met shell scripts kan nog veel meer. Het is zelfs mogelijk om complete programma’s te schrijven met specifieke shell commando’s samen met gewone LINUX commando’s. Het voert echter te ver om hier dieper op in te gaan; zie voor meer informatie de manual of een andere uitgebreide handleiding over LINUX.

10. Protectie en Permissie Niet iedereen mag zomaar alles doen met elke file. Als je een file creëert ben je eigenaar en kan je zelf bepalen wie er wat mee mag doen. Voor dat doel is de LINUX-wereld verdeeld in drie categorieën:

4) de eigenaar van de file

5) de mensen die in zijn “groep” zitten

6) overige personen.

Voor elk van deze categorieën kun je apart opgeven wat ze wel of niet met jouw files mogen doen. Er zijn twee werkwijzen om de protectiemode van je directories en files in te stellen, ze komen hier beide aan de orde. Kies voor het instellen van de protectiemodes de werkwijze die jij het prettigst vindt. Raadpleeg ook eens de manual page over dit onderwerp (man chmod)!

10.1. Werkwijze 1

ga binnen je home directory naar de directory intro

ls -al

Je krijgt nu een overzicht van de bestanden met veel informatie.

Voor iedere file staat een aanduiding in de vorm “-rw-r--r--’’. Deze aanduiding geeft aan welke gebruikers wat mogen doen met de file. Hierbij staat r voor read (lezen), w voor write (schrijven) en x voor execute (uitvoeren). Deze regel van 10 karakters heeft een eerste karakter die aangeeft of het een directory (d) is of niet (-), De volgende negen karakters wordt onderverdeeld in 3 stukjes van 3 karakters:

De meest linkse drie posities (rw-) geven aan wat de user (dat ben jij) mag doen met de file.

De volgende drie posities (r--) geven aan wat mensen uit jouw group (alle medestudenten van jouw jaar) met de file mogen doen.

De meest rechtse drie posities (r--) geven aan wat alle andere gebruikers met de file mogen doen. In dit voorbeeld (-rw-r--r--) mag dus iedereen de file lezen, maar alleen jij mag de file ook veranderen.

Met het commando chmod kun je deze bescherming veranderen. chmod who=permission filenaam verandert de protection mode van de file genaamd filenaam. Hierbij is who u (voor user), g (voor group), o (voor others) en a (voor all).

Bijvoorbeeld:

u=rw : maak lees en schrijfbaar voor jezelf.

g=rx : maak lees en uitvoerbaar voor iedereen in jouw groep.

ug= : jij en iedereen in je groep kunnen de file niet lezen, schrijven en uitvoeren

(gevaarlijk!).

ugo=rwx: maak leesbaar, schrijfbaar en uitvoerbaar voor iedereen (gevaarlijk!).

a=r : maak leesbaar voor iedereen


Kopieer de file herhalen en hernoem deze naar permissies

chmod u= permissies

chmod g=rw permissies

chmod o=r permissies

ls -l

Nu blijkt de file leesbaar te zijn voor derden, lees- en beschrijfbaar voor groepsleden maar niet lees- of beschrijfbaar voor jezelf!

pico permissies Je krijgt nu de mededeling dat de file wel bestaat, maar dat je hem niet mag lezen.

Uiteraard mag je alleen de mode veranderen van files waarvan je zelf eigenaar bent. Het is verstandig om files alleen voor jezelf lees- en beschrijfbaar te houden, zodat anderen niet je files kunnen verpesten. Daarom veranderen we de protection mode weer:

chmod ugo= permissies

chmod u=rw permissies

Controleer dat je de file permissies weer kunt lezen en veranderingen kunt aanbrengen.

10.2. Werkwijze 2 Bij methode twee maken we gebruik van de binaire notatie van de protectiemodes. Voor elk van de hierboven aangegeven categorieën eigenaren kunt je de protectiemode instellen door middel van een getal van 0 tot 7.

Het handigste is om je dat getal voor te stellen in binaire notatie (zo wordt het natuurlijk ook opgeslagen); dan gaat het dus om getallen tussen 000 en 111. Stel dat voor een bepaalde categorie het meest rechtse binaire cijfer een 1 (dat staat voor het voorkomen van 1 in de binaire ontwikkeling) is, dan mogen de personen uit die categorie de file gebruiken (= execute) en als het cijfer een 0 is dan mag dat niet.

Als het middelste binaire cijfer een 1 is (dat staat dus voor het voorkomen van 2 in de binaire ontwikkeling) mag je in de file schrijven (= write). Met 0 mag je weer niet schrijven.

Het meest linkse cijfer (dat staat voor het voorkomen van 4 in de binaire ontwikkeling) bepaalt op dezelfde manier of je in de file mag lezen (= read) of niet: 1 is wel lezen, 0 is niet lezen.

Als het binaire getal dus 101 is mag de betreffende categorie de file gebruiken en er in lezen, maar er niet in schrijven.

Voor elk van de drie categorieën gebruikers ontstaat er zo dus een binair getal. Deze drie binaire getallen worden weer vertaald naar de decimale notatie: de 101 wordt dan een 5. Omdat voor alle drie de categorieën zo’n getal wordt bepaald krijgen we dus een rijtje van drie octale cijfers, waarvan het eerste gaat over de mogelijkheden van de eigenaar, de tweede over die van de andere leden van zijn groep, en het derde over alle andere personen. Deze drie octale cijfers vormen samen de protectiemode.


Onderstaand ter verduidelijking een tabel met enkele codes in de binaire en octale notatie en de protectie-mode.

Binaire notatie Octaal getal Protectiemode Betekenis

000 000 000 000 --------- Niemand mag lezen, schrijven of uitvoeren GEVAARLIJK.

100 100 100 444 r--r--r-- Iedereen mag lezen, maar niemand mag schrijven of uitvoeren.

110 100 100 644 rw-r—r-- Eigenaar mag lezen en schrijven, anderen alleen lezen.

111 100 100 744 rwxr—r-- Eigenaar mag lezen, schrijven en uitvoeren, anderen alleen lezen.

110 110 100 664 rw-rw-r-- Eigenaar en groep mogen lezen en schrijven, rest alleen lezen.

111 111 111 777 Rwxrwxrwx Iedereen mag lezen, schrijven en uitvoeren. GEVAARLIJK!!

Je kunt als eigenaar de protectiemode weer zelf instellen door middel van het commando chmod.

chmod 444 permissies

Verander de protectiemode van de file permissies zodanig dat de eigenaar mag lezen en schrijven en de andere categorieën alleen mogen lezen.

10.3. Voor gevorderden: Bash Op de VU wordt standaard gebruik gemaakt van de bash-shell. Informatie over wat bash precies is, is te vinden op de website: http://www.gnu.org/software/bash/ Bash heeft een aantal configuratiebestanden, waaronder het bestand genaamd '.bashrc'. Deze is te vinden in de home directory van de gebruiker. In dit bestand staat een aantal commando's dat bash uitvoert zodra het gestart wordt. Een voorbeeld hiervan zou kunnen zijn: echo "hallo $USER" Dit commando drukt de tekst “hallo <de gebruikersnaam>” af. Het is mogelijk ieder willekeurig commando/programma te laten starten als je je bash opstart. Zo is het ook mogelijk om gelijk het mailprogramma pine te starten, simpelweg door dit in de .bashrc te zetten. Zoals te zien is in het voorbeeld kun je met $USER je gebruikersnaam afdrukken. Dit komt omdat bash een aantal variabelen van tevoren heeft aangemaakt. Met het commando 'set' kan je zien welke variabelen dat allemaal zijn. Je kunt ook zelf variabelen toevoegen met het commando: $ variabele1="waarde" Als je je variabele wilt bewaren buiten alleen de huidige terminal, typ dan:

export variabele1="waarde"


Een speciale variabele is PROMPT_COMMAND. Dit is een variabele waarvan de inhoud elke keer dat je de prompt te voorschijn komt uitgevoerd wordt. Een van de variabelen is de tekenreeks genaamd de prompt (standaard een '$' teken). Dit is wat je dus standaard ziet voor elk commando dat je intypt. Deze variabele heet PS1. Deze is ook te zien als je het commando 'set' uitvoert en is ook op te vragen met

echo $PS1 Bash is (ook) een programmeertaal. Er kunnen functies gemaakt worden is bash, en dat is ook wat je nodig hebt voor deze opdracht. Jouw opdracht is om te zorgen dat de promt (de PS1 variabele) verandert in een iets meerzeggend geheel. Oftewel: Zorg dat de prompt verandert in de huidige werkmap (op te vragen met het commando 'pwd', gevolgd door een linebreak waarna alsnog de $ staat. Je prompt ziet er dan zo uit: /home/<user> $ En na het uitvoeren van het commando 'cd bin', zo: /home/<username>/bin $ Je moet je prompt variabele laten bepalen door een functie aan te roepen die je zelf schrijft. Een voorbeeld van een zelfgeschreven functie opgeslagen in een variabele: VARIABELE="functie" functie() {

echo "Hallo, dit is een functie waar je alles in kan zetten" banner hoi

} Om deze functie uit te voeren typ je

$VARIABELE Dit is hetzelfde wat bash doet voor elke prompt; hij voert het commando uit dat in de variabele PROMPT_COMMAND is opgeslagen. Voor meer informatie kan je het beste kijken in de manual pages van bash en echo. Deze kan je openen met de LINUX commando’s ‘man bash’ en ‘man echo’.

werken met de shell - few.vu.nlabhulai/doc/werken met de shell.pdf · Een andere mogelijkheid is om...

Documents

Transcript of werken met de shell - few.vu.nlabhulai/doc/werken met de shell.pdf · Een andere mogelijkheid is om...