Werken met de shell en shellcommando s

Werken met de shell en shellcommando 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

10.2. Werkwijze 2 -------------------------------------------------------------------------------------------- 26 10.3. Voor gevorderden: Bash ------------------------------------------------------------------------------ 27 Werken met de shell en shell-commando s 2

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. Werken met de shell en shell-commando s 3

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 ls dir directory weer 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 manualpages te raadplegen die al in LINUX zijn ingebouwd. Hoe je dat moet doen staat beschreven in hoofdstuk Werken met de shell en shell-commando s 4

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 GNOMEhoofdmenu (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. Werken met de shell en shell-commando s 5

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. Werken met de shell en shell-commando s 6

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. 1 Uitgebreide documentatie voor bash is te vinden op http://www.gnu.org/software/bash/bash.html. Werken met de shell en shell-commando s 7

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. Werken met de shell en shell-commando s 8

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. Werken met de shell en shell-commando s 9

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 Werken met de shell en shell-commando s 10

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: Home directory: ~ je VUnetID intro probs 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! / cache... home tmp usr etcetera home-directory: ~VUnetID etcetera intro probs etcetera 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 Werken met de shell en shell-commando s 11

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. Werken met de shell en shell-commando s 12

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. Werken met de shell en shell-commando s 13

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 removecommando. 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. Werken met de shell en shell-commando s 14

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. Werken met de shell en shell-commando s 15

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.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. Werken met de shell en shell-commando s 16

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. 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. 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. 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! 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 Werken met de shell en shell-commando s 17

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. Werken met de shell en shell-commando s 18

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: Werken met de shell en shell-commando s 19

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 shellscript 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. Werken met de shell en shell-commando s 20

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. Werken met de shell en shell-commando s 21

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. Als je de waarde van een variabele wilt gebruiken moet je dus de naam van de variabele vooraf laten gaan door een $-teken. 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 Werken met de shell en shell-commando s 22

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 Werken met de shell en shell-commando s 23

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). 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 nietbestaande file opgeeft. Het script geeft dan een melding en stopt. Werken met de shell en shell-commando s 24