<chapter id="configuration-chapter"><title>I Gotta Be Me!</title>

<blockquote><literallayout>
  If God had known we'd need foresight, she would have given it to us.
</literallayout></blockquote>

<sect1 id="config-bash"><title><application>Bash</application> aanpassen</title>
<para>
E&eacute;n van de dingen waarin de Unix filosofie zich onderscheidt, is dat de
systeemontwerpers geen poging ondernamen elke behoefte die gebruikers
zouden kunnen hebben voor te schrijven. In plaats daarvan probeerden ze 
het voor iedere individuele gebruiker makkelijk te maken om de omgeving 
aan hun eigen specifieke behoeften aan te passen. Dit wordt hoofdzakelijk 
bewerkstelligd via <emphasis>configuratiebestanden</emphasis><indexterm><primary>configuratiebestanden</primary></indexterm>. 
Deze staan ook bekend als "init files"<indexterm><primary>init files</primary></indexterm>,
"rc files"<indexterm><primary>rc files</primary></indexterm> (voor "run control"), of zelfs "dot
files", omdat de bestanden vaak met een punt "<filename>.</filename>" beginnen. 
Ter herinnering, bestandsnamen die met een "<filename>.</filename>" beginnen, worden
normaal gesproken niet door een <command>ls</command> weergegeven.
</para>

<para>
De belangrijkste configuratiebestanden zijn die door de shell worden
gebruikt. Linux's standaardshell is <application>bash</application>
en dat is
de shell die in dit hoofdstuk wordt behandeld. Voor we 
<application>bash</application> aan 
zullen gaan passen, moeten we weten naar welke bestanden 
<application>bash</application> zoekt.
</para>

<sect2 id="config-shellstart"><title>Shell opstart</title>
<para>
<application>Bash</application> kan op diverse manieren worden uitgevoerd.
Het kan als een <emphasis>loginshell</emphasis><indexterm><primary>login shell</primary></indexterm> worden
uitgevoerd, zo wordt het uitgevoerd wanneer je voor de eerste maal inlogt.
De loginshell is de eerste shell waar je mee te maken krijgt.
</para>

<para>
Een andere manier waarop <application>bash</application> kan worden uitgevoerd is als een
<emphasis>interactieve shell</emphasis><indexterm><primary>interactieve shell</primary></indexterm>. Dit is elke shell 
die een prompt presenteert aan een mens en wacht op invoer. Ook een 
loginshell is een interactieve shell. Een wijze waarop je een 
interactieve niet-login shell kunt krijgen is bijvoorbeeld met een 
shell binnen <application>xterm</application>
Elke shell die op enige andere wijze werd aangemaakt behalve voor het 
inloggen is geen login-shell.
</para>

<para>
Ten slotte zijn er nog <emphasis>niet interactieve shells</emphasis>
<indexterm><primary>niet-interactieve shells</primary></indexterm>
Deze shells worden gebruikt voor het uitvoeren van een bestand met
opdrachten, net als in MS-DOS<indexterm><primary>MS-DOS</primary>
</indexterm> batch files; de bestanden
die eindigen op <filename>.BAT</filename>. Deze <emphasis>shellscripts</emphasis><indexterm><primary>shellscripts</primary></indexterm> 
functioneren als mini-programma's. Terwijl ze gewoonlijk veel langzamer zijn
dan gecompileerde programma's is het vaak wel zo dat ze makkelijker zijn
te schrijven.
</para>

<para>
Afhankelijk van het type shell, zullen bij het opstarten van de shell
verschillende bestanden worden gebruikt:
</para>

<para>
<informaltable frame="all">
<tgroup cols="2"  align="left" colsep="1" rowsep="1">
<thead>
<row>
  <entry>Type Shell</entry>
  <entry>Actie</entry>
</row>
</thead>
<tbody>
<row>
  <entry>Interactieve login</entry>
  <entry>Het bestand <filename>.bash_profile</filename> wordt ingelezen en
uitgevoerd</entry>
</row>
<row>
<entry>Interactief</entry>
<entry>De bestanden <filename>.bashrc</filename> en <filename>.bashrc</filename>
worden ingelezen en uitgevoerd</entry>
</row>
<row>
<entry>Niet-interactief</entry>  
<entry>Het shellscript wordt ingelezen en uitgevoerd</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</para>
</sect2>

<sect2 id="config-startup"><title>Opstartbestanden</title>
<para>
Gezien de meeste gebruikers dezelfde omgeving willen, ongeacht voor 
welk type interactieve shell ze kiezen, of het een loginshell is of niet, 
zullen we onze configuratie starten met een zeer simpele opdracht in 
het bestand <filename>.bash_profile</filename>: 
"<command>source ~/.bashrc</command>". 
De <command>source</command><indexterm><primary>source</primary></indexterm>
opdracht vertelt de shell het argument 
als een shellscript te interpreteren. Wat dit voor ons betekent is dat 
elke keer wanneer <filename>.bash_profile</filename> wordt uitgevoerd, 
<emphasis>ook</emphasis> <filename>.bashrc</filename> wordt uitgevoerd.
</para>

<para>
We zullen nu gewoon wat opdrachten toe gaan voegen aan het bestand 
<filename>.bashrc</filename>. Wil je ooit dat je opdracht wordt uitgevoerd, wanneer je
inlogt, dan voeg je deze opdracht toe aan <filename>.bash_profile</filename>.
</para>
</sect2>

<sect2 id="aliasing-section"><title>Aliassen</title>
<para>
Wat is hetgeen je zou willen aanpassen?
Ik denk dat ongeveer 90% van de Bash gebruikers het volgende in 
<filename>.bashrc</filename> heeft geplaatst:
</para>

<para>
<screen>
alias ll="ls -l"
</screen>
</para>

<para>
Die opdracht definieerde een shell <emphasis>alias</emphasis>
<indexterm><primary>shell</primary><secondary>alias</secondary></indexterm>
genaamd <literal>ll</literal> welke "extraheert" tot de gewone shellopdracht 
"<command>ls -l</command>"
wanneer het wordt aangeroepen door de gebruiker.  Dus in de veronderstelling
dat Bash die opdracht uit <filename>.bashrc</filename> heeft gelezen, kun je 
gewoon <literal>ll</literal> typen om het effect van
"<command>ls -l</command>." te krijgen met slechts de helft van het aantal toetsaanslagen.
Wanneer je <literal>ll</literal> typt en de <keycap>Return</keycap>-toets 
indrukt, onderschept Bash het, omdat het uitkijkt naar aliassen, Bash vervangt 
het door "<command>ls -l</command>", en retourneert dat ervoor in de plaats. 
Op het systeem komt geen <literal>ll</literal> opdracht voor, maar de shell 
vertaalt de alias automatisch naar een geldig programma.

Een aantal aliassen staan in <xref linkend="sample-aliases"/>. 
Je zou ze in je eigen <filename>.bashrc</filename> kunnen plaatsen. Een 
vooral interessante alias is de eerste. Met die alias, wordt automatisch 
een <option>-F</option> vlag aangezet, wanneer iemand <command>ls</command> 
intikt. (De alias probeert zichzelf niet nogmaals
te extraheren.) Dit is een gebruikelijke manier
om opties toe te voegen die je elke keer gebruikt als je een programma
aanroept.

Let op het commentaar voorafgegaan door het <literal>#</literal> teken in
<xref linkend="sample-aliases"/>. Wanneer een <literal>#</literal>
verschijnt, negeert de shell de rest van de regel.
<indexterm><primary>shell</primary><secondary>commentaar</secondary></indexterm>
</para>

<para>
<example id="sample-aliases">
<title>Een aantal voorbeeldaliassen voor <application>bash</application></title>
<screen>
alias ls="ls -F"          # geef tekens aan het einde van de listing
alias ll="ls -l"          # speciale ls
alias la="ls -a"
alias ro="rm *~; rm .*~"  # backupbestanden aangemaakt door 
                          # Emacs verwijderen
alias rd="rmdir"          # bespaart tikken!
alias md="mkdir"
alias pu=pushd            # pushd, popd, en dirs werden niet behandeld 
alias po=popd             # in deze handleiding---je zou ze op 
alias ds=dirs             # kunnen zoeken in de manpage van bash 
# dit zijn allen slechts toetsenbordsnelkoppelingen
alias to="telnet cs.oberlin.edu"
alias ta="telnet altair.mcs.anl.gov"
alias tg="telnet wombat.gnu.ai.mit.edu"
alias tko="tpalk kold@cs.oberlin.edu"
alias tjo="talk jimb@cs.oberlin.edu"
alias mroe="more"         # spellingscorrectie!
alias moer="more"
alias email="emacs -f rmail" # mijn mail reader
alias ed2="emacs -d floss:0 -fg \"grey95\" -bg \"grey50\""
                          # een manier om emacs aan te roepen
</screen>
</example>
</para>

<para>
Je hebt wellicht wat vreemds ontdekt. Ten eerste liet ik in een paar
aliassen de aanhalingstekens achterwege, zoals in <literal>pu</literal>.
Strict genomen, zijn aanhalingstekens niet echt nodig wanneer aan de
rechterkant van het is gelijk teken slechts &eacute;&eacute;n woord staat.
</para>

<para>
Het kan echter geen kwaad wel aanhalingstekens te gebruiken, dus
laat me je geen slechte gewoonten aanleren. Je moet ze in ieder geval
gebruiken als je een alias maakt voor een opdracht met opties en/of 
argumenten:
</para>

<para>
<screen>
alias rf="refrobnicate -verbose -prolix -wordy -o foo.out"
</screen>
</para>

<para>
In de laatste alias tenslotte is het gebruik van aanhalingstekens
wat eigenaardig:
</para>

<para>
<screen>
alias ed2="emacs -d floss:0 -fg \"grey95\" -bg \"grey50\""
</screen>
</para>

<para>
Zoals je wellicht al raadde, wilde ik dubbele aanhalingstekens in de opties
zelf doorgeven, dus moest ik die laten voorafgaan door een backslash
om te voorkomen dat <application>bash</application> zou denken dat 
het 't einde van de alias was.
</para>

<para>
Als laatste heb ik twee gebruikelijke typfouten, nl "more" en 
"moer" in een alias geplaatst voor de opdracht die ik daarmee bedoel,
<command>more</command>. Argumenten die je aan een programma doorgeeft, 
verstoren aliassen niet. Het volgende werkt prima:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> mroe hurd.txt
</screen>
</para>

<para>
In feite beslaat, weten hoe je je eigen aliassen maakt, waarschijnlijk
minstens de helft van alle aanpassingen aan de shell. Experimenteer
er wat mee, zoek uit welke lange opdrachten je veel typt, en maak
hier aliassen voor aan. Je zult bemerken dat het 't werken achter de
shellprompt veel plezieriger maakt.
</para>
</sect2>

<sect2 id="section-env-variables"><title>Omgevingsvariabelen</title>
<para>
Iets anders van belang wat wordt ingesteld in <filename>.bashrc</filename> zijn
<emphasis>omgevingsvariabelen</emphasis><indexterm><primary>omgevingsvariabelen</primary></indexterm>.
En wat zijn omgevingsvariabelen?
Laten we het eens van een andere kant bekijken:
stel dat je de documentatie van het programma <command>fruggle</command>
aan het lezen bent en dat je deze zinnen tegenkomt:
</para>

<para>
Fruggle zoekt normaal gesproken in de homedirectory van de gebruiker
naar het configuratiebestand <filename>.frugglerc</filename>.
Als echter de omgevingsvariabele <varname>FRUGGLEPATH</varname> op een 
andere bestandsnaam is ingesteld, zal het in plaats daarvan daar zoeken.
</para>

<para>
Elk programma wordt uitgevoerd in een <emphasis>omgeving</emphasis><indexterm><primary>omgeving</primary></indexterm>, en die
omgeving wordt gedefinieerd door de shell die het programma aanriep
<footnote><para>Nu zie je waarom shellprogramma's zo belangrijk zijn.
Stel dat je met de hand een gehele omgeving moest doorgeven elke keer
dat je een programma aanriep!</para></footnote>. Van de omgeving kan worden 
gesteld dat ze zich "binnen" de shell bevindt.
Programmeurs gebruiken een speciale routine om de omgeving te
ondervragen en het <command>fruggle</command> programma maakt gebruik van deze routine.
Het controleert de waarde van de omgevingsvariabele 
<envar>FRUGGLEPATH</envar>.  Als
blijkt dat die variabele ongedefinieerd is, dan zal het gewoon het bestand
<filename>.frugglerc</filename> in je homedirectory gebruiken. Als het echter gedefinieerd 
is, zal <command>fruggle</command> de waarde van die variabele gebruiken (wat de naam
van een bestand moet zijn welke <command>fruggle</command> kan gebruiken in plaats
van het standaardbestand <filename>.frugglerc</filename>).
</para>

<para>
Zo kun je de omgeving onder <application>bash</application> wijzigen:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> export PGPPATH=/home/larry/secrets/pgp
</screen>
</para>

<para>
De opdracht <command>export</command> kun je zien met als betekenis "Exporteer
deze variabele naar de omgeving van waaruit ik programma's zal aanroepen,
zodat de waarde ervan zichtbaar is voor die programma's." 
De naam <command>export</command> is niet zonder reden, zoals je later zult zien.
</para>

<para>
Deze bepaalde variabele wordt gebruikt door 
Phil Zimmerman<indexterm><primary>Zimmerman, Paul</primary></indexterm>'s public-key encryptie programma, 
<application>pgp</application><indexterm><primary>pgp</primary></indexterm>.
Standaard maakt <application>pgp</application> gebruik van je homedirectory
als lokatie om naar bepaalde bestanden te zoeken die het nodig heeft
(met encryptiesleutels) en tevens een plaats voor het opslaan van tijdelijke
bestanden die het tijdens de uitvoering aanmaakt. Door de variabele
<varname>PGPPATH</varname> op deze waarde in te stellen, vertelde ik het 
in plaats daarvan de directory <filename>/home/larry/secrets/pgp</filename> 
te gebruiken. Ik moest de <application>pgp</application> handleiding lezen om achter de exacte naam van
de variabele te komen en wat deze doet, maar het is tamelijk standaard
de naam van het programma in hoofdletters te gebruiken, voorafgegaan door
het voorvoegsel "PATH".
</para>

<para>
Het is ook handig om de omgeving te kunnen ondervragen:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> echo $PGPPATH
/home/larry/.pgp
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Let op het teken "$"; je laat een omgevingsvariabele voorafgaan door
een dollar-teken om aan de waarde van de variabele te komen. Had je het
getypt zonder dit dollar-teken, dan zou <command>echo</command> simpelweg 
het opgegeven argument op het scherm hebben weerkaatst:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> echo PGPPATH
PGPPATH
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
De "$" wordt gebruikt om omgevingsvariabelen te 
<emphasis>evalueren</emphasis>, maar het doet dit alleen in de context 
van de shell; dat wil zeggen wanneer de shell interpreteert. Wanneer 
interpreteert de shell? Wanneer je opdrachten achter de prompt intikt 
of wanneer <application>bash</application> opdrachten inleest vanuit
een bestand zoals <filename>.bashrc</filename>, kan worden gesteld 
dat het de opdrachten "interpreteert".
</para>

<para>
Er is nog een andere handige opdracht voor het ondervragen van de
omgeving: <command>env</command>.<indexterm><primary>env</primary></indexterm>
<command>env</command> zal louter een opsomming
geven van de omgevingsvariabelen. Het is mogelijk dat de lijst van het
scherm afscrollt, vooral als je van X gebruik maakt. Als dit gebeurt,
sluis de uitvoer van <command>env</command> dan door naar 
<command>more</command>: <command>env|more</command>.
</para>

<para>
Een paar van deze variabelen kunnen nogal nuttig zijn, dus we zullen
ze behandelen. Kijk naar onderstaande tabel <xref linkend="env-variables"/>. 
Deze vier variabelen worden automatisch gedefinieerd wanneer je inlogt: 
je stelt ze niet in via <filename>.bashrc</filename> of 
<filename>.bash_login</filename>.
</para>

<para>
<anchor id="env-variables"/>
<table frame="all"><title>Een aantal belangrijke omgevingsvariabelen</title>
<tgroup cols="3" align="left" colsep="1" rowsep="1">
<thead>
<row>
  <entry>Variabelenaam</entry>
  <entry>Inhoud</entry>
  <entry>Voorbeeld</entry>
</row>
</thead>
<tbody>
<row>
  <entry><envar>HOME</envar></entry>
  <entry>homedirectory</entry>
  <entry>/home/larry</entry>   
</row>
<row>
  <entry><envar>TERM</envar></entry>
  <entry>type terminal</entry>
  <entry>xterm, vt100 of console</entry>
</row>
<row>
  <entry><envar>SHELL</envar></entry>   
  <entry>Pad naar je shell</entry>
  <entry>/bin/bash</entry>   
</row>
<row>
  <entry><envar>USER</envar></entry>
  <entry>Je loginnaam</entry>
  <entry>larry</entry>
</row>
<row>
  <entry><envar>PATH</envar></entry>
  <entry>Te doorzoeken lijst naar programma's</entry>
  <entry>/bin:/usr/bin:/usr/local/bin:/usr/bin/X11</entry>
</row>
</tbody>
</tgroup>
</table>
</para>

<para>
Laten we de variabele <envar>TERM</envar> eens nader bekijken. <indexterm><primary>terminals</primary></indexterm>
Om deze variabele te kunnen begrijpen, moeten we bekend zijn met de
historie van &unix;. Het besturingssysteem moet bepaalde feiten kennen
over je console, om basisfuncties zoals het schrijven van een teken
naar het scherm uit te voeren, de cursor naar de volgende regel te
verplaatsen, enz. In de begindagen van computers, voegden fabrikanten
constant nieuwe features toe aan hun terminals: eerst reverse-video, toen
wellicht Europeaanse tekensets, eventueel zelfs primitieve tekenfuncties
(denk er aan, dit was voordat er venstersystemen en muizen bestonden).
Echter al deze nieuwe functies bezorgden de programmeurs problemen:
hoe konden zij weten wat een terminal ondersteunde en wat niet? En hoe
konden ze nieuwe features ondersteunen zonder de oude terminals waardeloos
te maken?
</para>

<para>
Onder &unix;, was het antwoord op deze vragen 
<filename>/etc/termcap</filename>
<indexterm><primary>/etc/termcap</primary></indexterm>. <filename>/etc/termcap</filename> bestaat uit een
lijst met alle terminals die je systeem kent, en hoe ze de cursor besturen.
Als een systeembeheerder een nieuwe terminal aanschafte, hoefde hij slechts
de gegevens van die terminal aan <filename>/etc/termcap</filename> toe te voegen in plaats
dat hij &unix; geheel opnieuw moest samenstellen. Soms werkt het zelfs nog
eenvoudiger. Zo langzamerhand werd de vt100<indexterm><primary>vt100</primary></indexterm> terminal van
Digital Equipment Corporation<indexterm><primary>Digital Equipment Corporation</primary></indexterm> een
pseudo-standaard, en veel nieuwe terminals werden zo gebouwd dat ze
deze terminal konden emuleren of zodanig konden functioneren alsof het
een vt100 was.
</para>

<para>
Onder Linux, is de waarde van <envar>TERM</envar> soms <literal>console</literal>. 
Dit is een op vt100 lijkende terminal met een aantal extra features.
</para>

<para>
<indexterm><primary>shell</primary><secondary>zoekpad</secondary></indexterm>
Een andere variabele, <envar>PATH</envar>, is ook beslissend voor het 
juist functioneren van de shell. Hier is de mijne:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> env | grep ^PATH
PATH=/home/larry/bin:/bin:/usr/bin:/usr/local/bin:/usr/bin/X11:
/usr/TeX/bin 
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Je <envar>PATH</envar> bestaat uit een door dubbele punten gescheiden lijst met
die directory's die de shell doorzoekt op programma's, wanneer je de naam
van een uit te voeren programma intikt. Wanneer ik bijvoorbeeld <command>ls</command>
intik en op de <keycap>Return</keycap>-toets druk, dan zoekt Bash als eerste in
<filename>/home/larry/bin</filename>, een directory aangemaakt voor het opslaan 
van programma's die ik schreef. Ik schreef echter geen <command>ls</command>
(in feite denk ik dat het is geschreven nog voor ik werd geboren!).
Het niet kunnen vinden in <filename>/home/larry/bin</filename>, maakt dat Bash
vervolgens zoekt in <filename>/bin</filename>, en daar lukt het wel!
<command>/bin/ls</command> komt voor en het is uitvoerbaar, dus Bash stopt met
zoeken naar een programma met de naam <command>ls</command> en voert het uit.
Er had net zo goed nog een ander programma met de naam <command>ls</command>
in de directory <filename>/usr/bin</filename> voor kunnen komen, maar <application>bash</application> zou
het nooit uitvoeren tenzij hier expliciet om wordt gevraagd door een
absolute padnaam op te geven:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> /usr/bin/ls
</screen>
</para>

<para>
De variabele <envar>PATH</envar> is ervoor dat we geen volledige padnamen 
voor elke opdracht in hoeven tikken. Wanneer je een opdracht intikt, zoekt 
Bash naar deze opdracht in de volgorde opgegeven in <envar>PATH</envar>, en
voert deze uit als het de opdracht aantreft. Vind het de opdracht niet, 
dan krijg je een primitieve foutmelding:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> clubly
clubly: command not found
</screen>
</para>

<para>
In mijn <envar>PATH</envar> komt de directory "<filename>.</filename>" niet 
voor. Als dit wel zo was zou het er ongeveer zo hebben uitgezien:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt> echo $PATH
.:/home/larry/bin:/bin:/usr/bin:/usr/local/bin:
/usr/bin/X11:/usr/TeX/bin
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Dit heeft te maken met een of ander debat in Unix kringen (waar je nu
deel van uitmaakt, of je dat nu leuk vindt of niet). Het probeem bestaat
hieruit dat het plaatsen van de huidige directory in je PATH een 
beveiligingslek kan veroorzaken. Stel dat je met <command>cd</command>
naar een directory gaat waar iemand een "Trojan Horse" programma met de 
naam <command>ls</command> heeft achtergelaten, en je geeft de opdracht 
<command>ls</command> wat je al snel doet
als je eenmaal in een andere directory bent aangekomen. Gezien de 
huidige directory "<filename>.</filename>" als eerste in je <envar>PATH</envar> voorkomt, 
zou de shell deze versie van <command>ls</command> aantreffen en het uitvoeren.
Wat voor onheil wellicht in dat programma is geplaatst, heb je dan uitgevoerd.
De persoon die dit deed had hier geen rootprivileges voor nodig; er was
alleen schrijfpermissies nodig op de directory waar de "onechte" <command>ls</command>
werd gelokaliseerd. Het zou zijn homedirectory kunnen zijn geweest, 
als iemand zou weten dat je daar ooit rond zou neuzen.
</para>

<para>
Op je eigen systeem is het hoogstonwaarschijnlijk dat mensen een val voor
elkaar zetten.  Alle gebruikers zijn waarschijnlijk
vrienden of collega's. Op een groot multi-user systeem 
(zoals op vele universiteitscomputers), zouden er echter voldoende
onvriendelijke programmeurs kunnen zijn die je nog nooit hebt ontmoet.
Of je nu wel of niet het risico wilt lopen "<filename>.</filename>" in je
pad op te nemen, is afhankelijk van je situatie; Ik was niet van plan
om er op wat voor wijze dan ook autoritair in te zijn, ik wil gewoon
dat je bewust bent van de risico's<footnote><para>Denk eraan dat je altijd
programma's in de huidige directory uit kunt voeren door expliciet het
pad op te geven, d.w.z.: "<filename>./foo</filename>".</para></footnote>  
Multi-user systemen zijn in werkelijkheid gemeenschappen, waar mensen
elkaar op allerlei onvoorziene manieren iets aan kunnen doen.
</para>

<para>
De werkelijke wijze waarop ik mijn <envar>PATH</envar> instel, bestaat 
voornamelijk uit wat je tot dusverre hebt geleeerd over omgevingsvariabelen. 
Zo ziet mijn <filename>.bashrc</filename> eruit:
</para>

<para>
<screen>
export PATH=${PATH}:.:${HOME}/bin:/bin:/usr/bin:/usr/local/bin:
/usr/bin/X11:/usr/TeX/bin
</screen>
</para>

<para>
Hier maak ik gebruik van het feit dat de variabele <envar>HOME</envar> is
ingesteld voordat Bash mijn <filename>.bashrc</filename> inleest, door de waarde
ervan te gebruiken bij het instellen van mijn <envar>PATH</envar>.
De accolades ("{...}") dienen als een extra niveau
van quoting; ze bakenen in zekere mate af waartoe "$" zal evalueren,
zodat de shell niet in verwarring raakt door de tekst die er onmiddellijk 
opvolgt, (in dit geval "<filename>/bin</filename>"). Hier is nog een voorbeeld van
het effect van accolades:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt><userinput> echo ${HOME}foo</userinput>
<computeroutput>/home/larryfoo</computeroutput>
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Zonder de accolades zou ik niets krijgen, aangezien er geen 
omgevingsvariabele met de naam <envar>HOMEfoo</envar> bestaat.
</para>

<para>
<screen>
<prompt>/home/larry#</prompt><userinput>echo $HOMEfoo</userinput>

<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Laat me iets anders in dat pad verduidelijken: de betekenis van 
"${PATH}".  Het neemt de waarde van een <envar>PATH</envar> variabele op
in mijn nieuwe <envar>PATH</envar> die <emphasis>eerder</emphasis> werd ingesteld. Waar werd de
oude variabele ingesteld?  Het bestand <filename>/etc/profile</filename> dient als een soort
globaal <filename>.bash_profile</filename> dat voor alle gebruikers gelijk is.
Een dergelijk gecentraliseerd bestand maakt het makkelijker voor de
systeembeheerder om een nieuwe directory toe te voegen aan ieders
<envar>PATH</envar> of iets dergelijks, zonder ze allemaal individueel te hoeven
wijzigen. Als je het oude directorypad in je nieuwe directorypad opneemt,
dan raak je geen directory's kwijt die het systeem reeds voor je heeft
ingesteld.
</para>

<para>
Je kunt ook zelf bepalen hoe je prompt eruit komt te zien. 
Dit wordt bewerkstelligd
door het instellen van de waarde van de omgevingsvariabele <envar>PS1</envar>.  
Persoonlijk wil ik een prompt die me het directorypad van de huidige 
werkdirectory toont. Ik bewerkstellig dit als volgt in mijn <filename>.bashrc</filename>:
</para>

<para>
<screen>
export PS1='$PWD# '
</screen>
</para>
<para>
<indexterm><primary>shell</primary><secondary>quoting</secondary></indexterm>
Zoals je kunt zien, worden er hier in feite <emphasis>twee</emphasis> variabelen gebruikt.
Degene die wordt ingesteld is <envar>PS1</envar>, en het wordt ingesteld 
op de waarde van <envar>PWD</envar>, waaraan kan worden gedacht als de
"Print Werk Directory" of "DirectoryPad van WerkDirectory".  
Maar de evaluatie van <envar>PWD</envar> vindt plaats binnen enkele aanhalingstekens. 
De enkele aanhalingstekens dienen om de expressie daartussenin te evalueren,
welke zelf de variabele <envar>PWD</envar> evalueert. Als je de opdracht
<command>export PS1=$PWD</command> gaf, dan zou je in je prompt constant het pad
naar de huidige directory worden weergegeven <emphasis>op moment dat</emphasis>
<envar>PS1</envar> <emphasis>werd ingesteld</emphasis>, in plaats van dat 
het werd bijgewerkt zodra je van directory wijzigt. Dat schept wat verwarring, 
en echt belangrijk is het niet. Onthoud gewoon dat je de aanhalingstekens nodig 
hebt als je wilt dat de huidige directory wordt weergegeven in je prompt.
</para>

<para>
Misschien geef je de voorkeur aan <command>export PS1='$PWD>'</command>, of 
zelfs de systeemnaam: <command>export PS1=`hostname`'>'</command>. 
Laat me dat laatste voorbeeld wat verder uitdiepen.
</para>

<para>
In het laatste voorbeeld werd gebruik gemaakt van een <emphasis>nieuw</emphasis> type
quoting, de back quotes. Deze aanhalingstekens bieden nergens bescherming 
tegen. Je zult bemerken dat "hostname" nergens in de prompt verschijnt 
wanneer je dat uitvoert. Wat er in werkelijkheid gebeurt is dat de 
opdracht tussen de aanhalingstekens wordt ge&euml;valueerd, en de 
uitvoer in plaats van de aanhalingstekens en de opdrachtnaam wordt geplaatst.
</para>

<para>
Probeer <command>echo `ls`</command> of <command>wc `ls`</command>.
Als je wat meer ervaren bent in het gebruik van de shell, dan zal deze 
techniek steeds krachtiger worden.
</para>

<para>
Er valt heel wat meer te configureren aan <filename>.bashrc</filename>, 
maar daarvoor is hierin niet voldoende ruimte om het allemaal uit te leggen.
Voor meer informatie kun je de manpage van <application>bash</application> 
lezen of vragen stellen aan ervaren gebruikers van Bash. Hier is een 
volledig <filename>.bashrc</filename> bestand voor je om te bestuderen;
het is vrij standaard, alhoewel het zoekpad wat lang is.
</para>

<para>
<screen>
# wat willekeurige opdrachten:
ulimit -c unlimited
export history_control=ignoredups
export PS1='$PWD>'
umask 022

# toepassingsspecifieke paden:
export MANPATH=/usr/local/man:/usr/man
export INFOPATH=/usr/local/info
export PGPPATH=${HOME}/.pgp

# maak het PATH aan:
homepath=${HOME}:~/bin
stdpath=/bin:/usr/bin:/usr/local/bin:/usr/ucb/:/etc:/usr/etc:/usr/games
pubpath=/usr/public/bin:/usr/gnusoft/bin:/usr/local/contribs/bin
softpath=/usr/bin/X11:/usr/local/bin/X11:/usr/TeX/bin
export PATH=.:${homepath}:${stdpath}:${pubpath}:${softpath}
# Technisch gesproken, waren de accolades niet nodig, omdat de dubbele
# punten geldige scheidingstekens zijn; niettemin is het een goede 
# gewoonte gebruik te maken van accolades, en ze kunnen geen kwaad.

# aliassen
alias ls="ls -CF"
alias fg1="fg %1"
alias fg2="fg %2"
alias tba="talk sussman@tern.mcs.anl.gov"
alias tko="talk kold@cs.oberlin.edu"
alias tji="talk jimb@totoro.bio.indiana.edu"
alias mroe="more"
alias moer="more"
alias email="emacs -f vm"
alias pu=pushd
alias po=popd
alias b="~/.b"
alias ds=dirs
alias ro="rm *~; rm .*~"
alias rd="rmdir"
alias ll="ls -l"
alias la="ls -a"
alias rr="rm -r"
alias md="mkdir"
alias ed2="emacs -d floss:0 -fg \"grey95\" -bg \"grey50\""

function gco
{
  gcc -o $1 $1.c -g
}
</screen>
</para>
</sect2>
</sect1>

<sect1 id="config-init-X"><title>De init-files van het X Window Systeem</title>
<para>
<informalfigure fload="0">
<graphic fileref="png-files/grote-X.png"></graphic>
</informalfigure>
De meeste mensen prefereren hun werk in een grafische omgeving
te doen, en voor &unix;-machines, betekent dat gewoonlijk het gebruik van X.
Als je gewend bent aan de Macintosh<indexterm><primary>Macintosh</primary></indexterm> of Microsoft
Windows<indexterm><primary>Microsoft Windows</primary></indexterm>, dan duurt het even eer je aan het
X Window Systeem gewend bent, vooral in hoe het wordt aangepast.
</para>

<para>
Bij de Macintosh of Microsoft Windows kun je de omgeving <emphasis>vanuit</emphasis> de omgeving aanpassen: als je bijvoorbeeld de omgeving wilt wijzigen, dan 
doe je dit door op de nieuwe kleur te klikken in een of ander
speciaal grafisch setupprogramma. Onder X, worden de standaardsysteemwaarden
bestuurd door tekstbestanden, die je op directe wijze bewerkt, m.a.w.
je typt de daadwerkelijke kleurnaam in een bestand om je achtergrond op 
die kleur in te stellen.
</para>

<para>
Er valt niet te ontkennen dat deze methode niet zo handig is als een aantal
commerci&euml;le venstersystemen.  Ik denk dat deze neiging om zelfs in
een grafische omgeving tekstge&ouml;ori&euml;nteerd te blijven, te maken heeft
met het feit dat X werd gecre&euml;erd door een boel programmeurs die simpelweg
niet trachtten software te schrijven die hun grootouders konden gebruiken.
Deze neiging kan in toekomstige versies van X veranderen (tenminste ik hoop
dat dit zo is), maar thans zul je moeten leren omgaan met nog meer
tekstbestanden. Het geeft je in ieder geval op z'n minst een zeer flexibele
en precieze controle over je configuratie.
</para>

<para>

Hier zijn de belangrijkste bestanden voor het configureren van X:

<informaltable frame="all">
<tgroup cols="2" align="left" colsep="1" rowsep="1">
<tbody>
<row>
  <entry>.xinitrc</entry>
  <entry>Een script dat door X wordt uitgevoerd wanneer het opstart</entry>
</row>
<row>
  <entry>.twmrc</entry>
  <entry>Wordt ingelezen door de X-Windowmanager <command>twm</command></entry>
</row>
<row>
  <entry>.fvwmrc</entry>
  <entry>Wordt ingelezen door de X-Windowmanager <command>fvwm</command>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</para>

<para>        
Deze bestanden zouden als ze al bestaan allemaal in je homedirectory
te vinden moeten zijn.

<filename>.xinitrc</filename> is een simpel shellscript dat wordt uitgevoerd wanneer
X wordt aangeroepen.  Het kan alles wat een ander shellscript kan, maar
natuurlijk is het zinvoller het te gebruiken voor het opstarten van diverse
X-programma's en het instellen van parameters voor het venstersysteem.
De laatste opdracht in <filename>.xinitrc</filename> bestaat gewoonlijk uit de naam van 
een uit te voeren window manager, zoals bijvoorbeeld 
<filename>/usr/bin/X11/twm</filename>.
</para>

<para>
Wat zou je willen plaatsen in het bestand <filename>.xinitrc</filename>?
Misschien wat aanroepen naar het programma <application>xsetroot</application>
om je rootvenster (de achtergrond) en muiscursor in te stellen op de wijze
waarop je wilt dat ze eruit zien. Aanroepen naar
<application>xmodmap</application>, die de server vertelt<footnote><para>De "server" betekent 
gewoon het hoofdproces X op je machine, degene met wie alle andere X-programma's
moeten communiceren om gebruik te kunnen maken van het display. Deze andere
programma's staan bekend als "clients" en het geheel wordt een
"client-server" systeem genoemd.</para></footnote> hoe de signalen van 
je toetsenbord
te interpreteren. Eventuele andere programma's die je elke keer dat je
X uitvoert opgestart wilt hebben (zoals bijvoorbeeld 
<application>xclock</application>).
</para>

<para>
Hier is een deel van mijn <filename>.xinitrc</filename>; die van jou ziet er ongetwijfeld
anders uit, dus dit is slechts bedoeld als een voorbeeld:
</para>

<para>
<screen>
#!/bin/sh
# Met de eerste regel wordt aan het besturingssysteem opgegeven welke
# shell moet worden gebruikt om dit script te interpreteren. Het script
# zelf wordt verondersteld te zijn gemarkeerd als uitvoerbaar;
# je kunt dit instellen met de opdracht "chmod +x ~/.xinitrc". 

# xmodmap is een programma waarmee je de X-server duidelijk kunt maken
# hoe de signalen van je toetsenbord moeten worden ge&iuml;nterpreteerd.
# Het is *beslist* de moeite waard hier iets over te leren. Je hebt
# "man xmodmap", "xmodmap -help", "xmodmap -grammar", en meer.
# Ik kan je niet garanderen dat onderstaande expressies op jouw systeem
# iets zullen betekenen (ik kan zelfs niet garanderen dat ze op mijn
# systeem van betekenis zijn):
xmodmap -e 'clear Lock'
xmodmap -e 'keycode 176 = Control_R'
xmodmap -e 'add control = Control_R'
xmodmap -e 'clear Mod2'
xmodmap -e 'add Mod1 = Alt_L Alt_R'

# xset is een programma voor het instellen van een aantal andere 
# parameters van de X-server:
xset m 3 2 &       # parameters voor de muis
xset s 600 5 &     # voorkeuren van de screensaver 
xset s noblank &   # ditto
xset fp+ /home/larry/x/fonts # voor cxterm
# Geef de opdracht "xset -help" voor meer informatie.

# Vertel de X server fish.cursor bovenop fish.mask te plaatsen en het
# resulterende patroon te gebruiken als mijn muiscursor:
xsetroot -cursor /home/lab/larry/x/fish.cursor /home/lab/larry/x/fish.mask &

# Een plezierig achtergrondpatroon en kleur:
xsetroot -bitmap /home/lab/larry/x/pyramid.xbm -bg tan

# te doen: xrdb hier?  Hoe zit het met het bestand .Xdefaults?

# Geef de opdracht "man xsetroot", of "xsetroot -help" voor meer 
# informatie over bovenstaand gebruikt programma.

# Een clientprogramma, de indrukwekkende ronde kleurenklok van 
# Jim Blandy:
/usr/local/bin/circles &

# Misschien dat je ten alle tijden een klok op je scherm wilt?
/usr/bin/X11/xclock -digital &

# Laat client X-programma's uitvoeren op occs.cs.oberlin.edu om ze daar
# weer te geven, doe hetzelfde voor juju.mcs.anl.gov:
xhost occs.cs.oberlin.edu
xhost juju.mcs.anl.gov

# Je kunt de X-server simpelweg laten weten clients op anders hosts 
# uit te laten voeren (een host als remote machine) om het daar
# weer te geven, maar dit is een beveiligingslek; die clients zouden
# door iemand anders uitgevoerd kunnen worden, en je toetsaanslagen 
# kunnen onderscheppen als je iets dergelijks als je wachtwoord 
# invoert! Als je het echter toch wilt, dan zou je een "+" kunnen 
# gebruiken, wat staat voor alle mogelijke hostnamen, in plaats 
# van gebruik te maken van specifieke hostnamen, zoals:
# xhost +

# En start als laatste de window manager:
/usr/bin/X11/twm
# Sommige mensen geven de voorkeur aan een andere window manager. Ik 
# gebruik twm, maar fvwm wordt ook vaak met Linux gedistribueerd:
# /usr/bin/X11/fvwm
</screen>
</para>

<para>
Een aantal opdrachten wordt in de achtergrond uitgevoerd (d.w.z.:
er staat een "&amp;" achter de opdracht), terwijl weer andere niet.
Het onderscheid is hier dat een aantal programma's zullen worden opgestart 
wanneer je X start en blijven draaien totdat je X weer verlaat, deze programma's
worden in de achtergrond geplaatst. Andere programma worden slechts
eenmaal uitgevoerd. <application>xsetroot</application> is hier een voorbeeld van; het
stelt slechts het rootvenster of de cursor of iets dergelijks in en
sluit dan weer af.
</para>

<para>
Zodra de window manager is opgestart, zal het zijn eigen init
file inlezen, welke bestuurt hoe zaken zoals je menu's zijn ingesteld,
op welke posities vensters naar voren komen, de besturing over ikonen,
en andere belangrijke zaken. Maak je gebruik van 
<application>twm</application>, dan is dit
het bestand <filename>.twmrc</filename> in je homedirectory. 
Gebruik je <application>fvwm</application> dan is het <filename>.fvwmrc</filename>, enz. Ik heb alleen maar iets met deze twee
bestanden te maken, aangezien dat de window managers zijn die je naar
alle waarschijnlijkheid aantreft onder Linux.
</para>

<sect2 id="twm-config-section"><title>Twm configuratie</title>
<para>
<indexterm><primary>twm</primary></indexterm>
Het bestand <filename>.twmrc</filename> is geen shellscript. Het is in 
wezen geschreven in een taal die speciaal voor <application>twm</application>
is ontworpen, geloof
het of niet!<footnote><para>Dit is &eacute;&eacute;n van de hardvochtige 
feiten over init files: ze hebben gewoonlijk elk hun eigen karakteristieke 
opdrachttaal. Dit betekent dat gebruikers zeer snel erg goed worden in het 
leren van opdrachttalen. Ik veronderstel dat het aardig zou zijn geweest 
als eerdere Unix programmeurs een of ander standaardformaat voor init files 
overeen waren gekomen, zodat we niet elke keer weer een nieuwe syntax 
hoefden te leren, maar om eerlijk te zijn, is het moeilijk te voorspellen 
wat voor soort informatie programma's nodig zullen hebben.</para></footnote>
Het belangrijkste waarmee
mensen graag experimenteren in hun <filename>.twmrc</filename> is de stijl 
van de vensters (zoals kleuren en dergelijke) en het maken van gave menu's,
dus hier een voorbeeld van een <filename>.twmrc</filename> waarin dat is gedaan:
</para>

<para>
<screen>
# Stel kleuren in voor de diverse vensteronderdelen. Dit heeft 
# een enorme impact op de "feel" van je omgeving.
Color
{
    BorderColor "OrangeRed"
    BorderTileForeground "Black"
    BorderTileBackground "Black"
    TitleForeground "black"
    TitleBackground "gold"
    MenuForeground "black"
    MenuBackground "LightGrey"
    MenuTitleForeground "LightGrey"
    MenuTitleBackground "LightSlateGrey"
    MenuShadowColor "black"
    IconForeground "DimGray"
    IconBackground "Gold"
    IconBorderColor "OrangeRed"
    IconManagerForeground "black"
    IconManagerBackground "honeydew"
}

# Ik hoop dat je geen monochroom systeem hebt, maar 
# mocht dit wel zo zijn...
Monochrome
{
    BorderColor "black"
    BorderTileForeground "black"
    BorderTileBackground "white"
    TitleForeground "black"
    TitleBackground "white"
}

# Ik maakte beifang.bmp aan met het programma "bitmap".  
# Hier geef ik twm op het te gebruiken als het standaard 
# highlight patroon op titelbalken van vensters:
Pixmaps
{
    TitleHighlight "/home/larry/x/beifang.bmp"
}

# Maak je hier niet druk om, is slechts voor vergevorderden :-)
BorderWidth     2
TitleFont       "-adobe-new century schoolbook-bold-r-normal--14-140-75-75-p-87-iso8859-1"
MenuFont        "6x13"
IconFont        "lucidasans-italic-14"
ResizeFont      "fixed"
Zoom 50
RandomPlacement

# Deze programma's krijgen standaard geen venstertitelbalk:
NoTitle
{
  "stamp"
  "xload"
  "xclock"
  "xlogo"
  "xbiff"
  "xeyes"
  "oclock"
  "xoid"
}

# "AutoRaise" betekent dat een venster naar voren wordt gebracht 
# wanneer de muisaanwijzer binnen dit venster komt. Ik vind dit 
# hinderlijk, dus heb ik het uitgezet. Zoals je kunt zien, nam 
# ik mijn .twmrc over van mensen die autoraise ook maar niks vonden.
AutoRaise 
{
  "nothing"     # Ik houd niet van auto-raise  
                # Geldt ook voor mij  
                # en mij
}

# Hier worden de muisknopfuncties gedefineerd. Let op het patroon:
# een muisknop ingedrukt op het rootvenster, zonder ingedrukte 
# modifier toets, geeft altijd een menu. Andere lokaties resulteren 
# gewoonlijk in een of andere vorm van venstermanipulatie, en modifier
# toetsen worden in combinatie met de muisknoppen gebruikt om bij de 
# geavanceerdere venstermanipulaties te komen.
#
# Je hoeft dit patroon niet te volgen in je eigen .twmrc -- het is
# geheel aan jou hoe je je omgeving regelt.

# Button = KEYS : CONTEXT : FUNCTION
# ----------------------------------
Button1 =      : root    : f.menu "main"
Button1 =      : title   : f.raise
Button1 =      : frame   : f.raise
Button1 =      : icon    : f.iconify
Button1 = m    : window  : f.iconify

Button2 =      : root    : f.menu "stuff"
Button2 =      : icon    : f.move
Button2 = m    : window  : f.move
Button2 =      : title   : f.move
Button2 =      : frame   : f.move
Button2 = s    : frame   : f.zoom
Button2 = s    : window  : f.zoom

Button3 =      : root    : f.menu "x"
Button3 =      : title   : f.lower
Button3 =      : frame   : f.lower
Button3 =      : icon    : f.raiselower

# Je kunt eigen functies schrijven; deze wordt gebruikt in het menu
# "windowops" vrijwel aan het einde van dit bestand:
Function "raise-n-focus"
{
    f.raise
    f.focus
}

# Ok, hieronder staan de feitelijke menu's waarnaar wordt gerefereerd
# in het deel over de muisknoppen.  Veel van deze menu-ingangen roepen
# submenu's aan. Je kunt gebruik maken van zoveel niveaus in het menu
# als je wilt, maar wees je ervan bewust dat recursieve menu's niet 
# werken. Ik heb het geprobeerd.

menu "main"
{
"Vanilla"       f.title
"Emacs"         f.menu "emacs"
"Logins"        f.menu "logins"
"Xlock"         f.menu "xlock"
"Misc"          f.menu "misc"
}

# Hiermee kan ik emacs op verschillende machines aanroepen. Zie het deel
# over .rhosts bestanden voor meer informatie hoe dit werkt:
menu "emacs"
{
"Emacs"      f.title
"here"       !"/usr/bin/emacs &"
""           f.nop
"phylo"      !"rsh phylo \"emacs -d floss:0\" &"
"geta"       !"rsh geta \"emacs -d floss:0\" &"
"darwin"     !"rsh darwin \"emacs -d floss:0\" &"
"ninja"      !"rsh ninja \"emacs -d floss:0\" &"
"indy"       !"rsh indy \"emacs -d floss:0\" &"
"oberlin"    !"rsh cs.oberlin.edu \"emacs -d floss.life.uiuc.edu:0\" &"
"gnu"        !"rsh gate-1.gnu.ai.mit.edu \"emacs -d floss.life.uiuc.edu:0\" &"
}

# Hiermee kan ik xterms op verschillende machines aanroepen. Zie het 
# deel over .rhosts bestanden voor meer bestanden over hoe dit werkt:
menu "logins"
{
"Logins"     f.title
"here"       !"/usr/bin/X11/xterm -ls -T `hostname` -n `hostname` &"
"phylo"      !"rsh phylo \"xterm -ls -display floss:0 -T phylo\" &"
"geta"       !"rsh geta \"xterm -ls -display floss:0 -T geta\" &"
"darwin"     !"rsh darwin \"xterm -ls -display floss:0 -T darwin\" &"
"ninja"      !"rsh ninja \"xterm -ls -display floss:0 -T ninja\" &"
"indy"       !"rsh indy \"xterm -ls -display floss:0 -T indy\" &"
}

# De schermbeveiliging xlock, aangeroepen met diverse opties 
# (waarvan elk zorgt voor een ander aardig plaatje):
menu "xlock"
{
"Hop"   !"xlock -mode hop &"
"Qix"   !"xlock -mode qix &"
"Flame" !"xlock -mode flame &"
"Worm" !"xlock -mode worm &"
"Swarm" !"xlock -mode swarm &"
"Hop NL"   !"xlock -mode hop -nolock &"
"Qix NL"   !"xlock -mode qix -nolock &"
"Flame NL" !"xlock -mode flame -nolock &"
"Worm NL" !"xlock -mode worm -nolock &"
"Swarm NL" !"xlock -mode swarm -nolock &"
}

# Diverse programma's die ik zo nu en dan uitvoer:
menu "misc"
{
"Xload"         !"/usr/bin/X11/xload &"
"XV"            !"/usr/bin/X11/xv &"
"Bitmap"        !"/usr/bin/X11/bitmap &"
"Tetris"        !"/usr/bin/X11/xtetris &"
"Hextris"       !"/usr/bin/X11/xhextris &"
"XRoach"        !"/usr/bin/X11/xroach &"
"Analog Clock"  !"/usr/bin/X11/xclock -analog &"
"Digital Clock" !"/usr/bin/X11/xclock -digital &"
}

# Dit heb ik gekoppeld aan de middelste muisknop:
menu "stuff"
{
"Chores"       f.title
"Sync"         !"/bin/sync"
"Who"          !"who | xmessage -file - -columns 80 -lines 24 &"
"Xhost +"      !"/usr/bin/X11/xhost + &"
"Rootclear"    !"/home/larry/bin/rootclear &"
}

# X functies die weleens van nut kunnen zijn:
menu "x"
{
"X Stuff"               f.title
"Xhost +"               !"xhost + &"
"Refresh"               f.refresh
"Source .twmrc"         f.twmrc
"(De)Iconify"           f.iconify
"Move Window"           f.move
"Resize Window"         f.resize
"Destroy Window"        f.destroy
"Window Ops"            f.menu "windowops"
""                      f.nop
"Kill twm"              f.quit
}

# Submenu van het bovenstaande:
menu "windowops"
{
"Window Ops"            f.title
"Show Icon Mgr"         f.showiconmgr
"Hide Icon Mgr"         f.hideiconmgr
"Refresh"               f.refresh
"Refresh Window"        f.winrefresh
"twm version"           f.version
"Focus on Root"         f.unfocus
"Source .twmrc"         f.twmrc
"Cut File"              f.cutfile
"(De)Iconify"           f.iconify
"DeIconify"             f.deiconify
"Move Window"           f.move
"ForceMove Window"      f.forcemove
"Resize Window"         f.resize
"Raise Window"          f.raise
"Lower Window"          f.lower
"Raise or Lower"        f.raiselower
"Focus on Window"       f.focus
"Raise-n-Focus"         f.function "raise-n-focus"
"Destroy Window"        f.destroy
"Kill twm"              f.quit
}
</screen>
</para>

<para>
Wauw!  Geloof me, dat is zelfs nog niet eens de meest ingewikkelde
<filename>.twmrc</filename> die ik ooit heb gezien. Het is heel goed 
mogelijk dat er een aantal
fraaie voorbeeldbestanden van <filename>.twmrc</filename> bij je X pakket 
werden geleverd. Kijk eens in de directory <filename>/usr/lib/X11/twm/</filename> of <filename>/usr/X11/lib/X11/twm</filename> om erachter te komen wat 
daar staat.
</para>

<para>
Een fout waar je bij <filename>.twmrc</filename> voor uit moeten kijken is het vergeten de
&amp; achter een menuopdracht te plaatsen.
Als je bemerkt dat X bij het uitvoeren van bepaalde opdrachten gewoon
vastloopt, dan kan het zijn dat dit de oorzaak is.
Ga met <keycap>Ctrl-Alt-Backspace</keycap> uit X, bewerk <filename>.twmrc</filename>, 
en probeer het nogeens.
</para>
</sect2>

<sect2 id="fvwm-config-section"><title>Fvwm configuratie</title>
<para>
<indexterm><primary>fvwm</primary></indexterm>
Als je gebruik maakt van <application>fvwm</application> dan zijn tevens in de directory
<filename>/usr/lib/X11/fvwm/</filename> 
(of <filename>/usr/X11/lib/X11/fvwm/</filename>) een aantal goede
voorbeelden van configuratiebestanden te vinden.
</para>
</sect2>
</sect1>

<sect1 id="config-other-init"><title>Andere initbestanden</title>
<para>
Een aantal andere initialisatiebestanden zijn:
</para>

<para>
<informaltable frame="all">
<tgroup cols="2" align="left" colsep="1" rowsep="1">
<tbody>
<row>
  <entry><filename>.emacs</filename></entry>
<entry>Wordt ingelezen door de teksteditor Emacs zodra het wordt opgestart
</entry>
</row>
<row>
<entry><filename>.netrc</filename></entry>
<entry>Geeft standaardloginnamen en wachtwoorden voor ftp</entry>
</row>
<row>
<entry><filename>.rhosts</filename></entry>
<entry>Maakt je account remote toegankelijk</entry>
</row>
<row>
<entry><filename>.forward</filename></entry>
<entry>Voor het automatisch doorsturen van mail</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</para>

<sect2 id="config-init-emacs"><title>Het initbestand van emacs</title>
<para>
Gebruik je <application>emacs</application> als je primaire editor, dan is het bestand
<filename>.emacs</filename> van groot belang. Het wordt uitgebreid behandeld in
<xref linkend="emacs-chapter"/>.
</para>
</sect2>

<sect2 id="config-ftp"><title>FTP standaards</title>
<para>
In het bestand <filename>.netrc</filename> kun je bepaalde standaardwaarden
voor <application>ftp</application> instellen voordat je <application>ftp</application> opstart. Hier is een beknopt voorbeeld
van <filename>.netrc</filename>:
</para>

<para>
<screen>
machine floss.life.uiuc.edu login larry password fishSticks
machine darwin.life.uiuc.edu login larry password fishSticks
machine geta.life.uiuc.edu login larry password fishSticks
machine phylo.life.uiuc.edu login larry password fishSticks
machine ninja.life.uiuc.edu login larry password fishSticks
machine indy.life.uiuc.edu login larry password fishSticks

machine clone.mcs.anl.gov login fogel password doorm@
machine osprey.mcs.anl.gov login fogel password doorm@
machine tern.mcs.anl.gov login fogel password doorm@
machine altair.mcs.anl.gov login fogel password doorm@
machine dalek.mcs.anl.gov login fogel password doorm@
machine juju.mcs.anl.gov login fogel password doorm@

machine sunsite.unc.edu login anonymous password larry@cs.oberlin.edu
</screen>
</para>

<para>
Op elke regel van <filename>.netrc</filename> staat de naam van een machine, 
een standaard te gebruiken loginnaam voor die machine en een wachtwoord.
Dit is erg handig als je veel gebruik maakt van <application>ftp</application> en het moe
bent constant je gebruikersnaam en wachtwoord van de diverse sites
in te moeten tikken.
Het <application>ftp</application> programma zal proberen je automatisch in te loggen met de 
informatie die het aantreft in het bestand <filename>.netrc</filename>, 
als je middels <application>ftp</application> met &eacute;&eacute;n van 
de machines vermeld in dit bestand verbinding maakt.
</para>

<para>
Je kunt <application>ftp</application> opgeven het bestand .netrc te negeren en geen automatische
login trachten uit te voeren door het aan te roepen met de optie
<option>-n</option>: "<command>ftp -n</command>".
</para>

<para>
Je moet ervoor zorgen dat het bestand <filename>.netrc</filename> 
<emphasis>alleen</emphasis> leesbaar is door jouzelf. Gebruik het programma 
<application>chmod</application> om de leespermissies van het bestand in te stellen. Als andere 
mensen het kunnen lezen, betekent dit dat ze achter je wachtwoord kunnen
komen van de diverse sites. Een groter beveiligingslek kan men
niet hebben; om je aan te moedigen dat je zorgvuldig te werk
gaat, zullen <application>ftp</application> en andere programma's die op 
zoek gaan naar het bestand <filename>.netrc</filename> weigeren te werken 
als de leespermissies van het bestand niet goed zijn ingesteld.
</para>

<para>
Er is meer te vertellen over het bestand <filename>.netrc</filename> dan 
wat ik zojuist heb aangegeven; geef de opdracht 
"<command>man .netrc</command>" of "<command>man ftp</command>"
als je daartoe even de kans ziet.
</para>
</sect2>

<sect2 id="config-remote-access"><title>Eenvoudig remote toegang tot je account toestaan</title>
<para>
Als in je homedirectory een bestand met de naam <filename>.rhosts</filename>
voorkomt, dan kun je op deze machine programma's remote uitvoeren.
Dat wil zeggen dat je op de machine <literal>cs.oberlin.edu</literal> zou 
kunnen zijn ingelogd, maar dat je met een correct geconfigureerd 
<filename>.rhosts</filename> bestand op <literal>floss.life.uiuc.edu</literal>,
een programma zou kunnen draaien op <literal>floss.life.uiuc.edu</literal> 
en de uitvoer naar <literal>cs.oberlin.edu</literal> zou kunnen
laten gaan zonder ooit in te hoeven loggen of een wachtwoord te hoeven 
intikken.
</para>

<para>
Een <filename>.rhosts</filename> kan er bijvoorbeeld zo uitzien:
</para>

<para>
<screen>
frobnozz.cs.knowledge.edu jsmith
aphrodite.classics.hahvaahd.edu wphilps
frobbo.hoola.com trixie
</screen>
</para>

<para>
Het formaat is tamelijk recht-toe-recht-aan: een machinenaam, gevolgd door
een gebruikersnaam. Stel bijvoorbeeld dat dit voorbeeld mijn 
<filename>.rhosts</filename>
bestand is op <literal>floss.life.uiuc.edu</literal>. Dat zou betekenen 
dat ik programma's op floss zou kunnen uitvoeren, de uitvoer naar een van de
opgesomde machines zou gaan, zolang ik ook zou zijn ingelogd als de
corresponderende gebruiker opgegeven voor die machines wanneer
ik dat probeerde.
</para>

<para>
Men voert gewoonlijk een remote programma uit via het programma
<application>rsh</application>. Het staat voor "remote shell". Het
start een shell op een remote machine en voert de opgegeven opdracht uit.
Bijvoorbeeld:
</para>

<para>
<screen>
<prompt>frobbo$ </prompt><userinput>whoami</userinput>
<computeroutput>trixie</computeroutput>
<prompt>frobbo$ </prompt><userinput>rsh floss.life.uiuc.edu "ls ~"</userinput>
<computeroutput>foo.txt    mbox   url.ps    snax.txt</computeroutput>
<prompt>frobbo$ </prompt><userinput>rsh floss.life.uiuc.edu "more ~/snax.txt"</userinput>
[snax.txt komt hier per scherm]
</screen>
</para>

<para>
Gebruiker trixie op floss.life.uiuc.edu, die het eerder getoonde 
voorbeeldbestand van <filename>.rhosts</filename> had, staat trixie op
frobbo.hoola.com expliciet toe programma's als trixie vanaf floss uit
te voeren.
</para>

<para>
Je hoeft op alle machines niet dezelfde gebruikersnaam te gebruiken wil
een <filename>.rhosts</filename> goed functioneren. Gebruik de optie 
"<option>-l</option>" van <application>rsh</application>, om de remote 
machine op te geven welke gebruikersnaam je graag wilt
gebruiken om in te loggen. Als die gebruikersnaam op de remote machine 
voorkomt en daarop een <filename>.rhosts</filename> bestand voorkomt met 
daarin je huidige (d.w.z.: local) machine en gebruikersnaam, dan lukt de 
<application>rsh</application>.
</para>

<para>
<screen>
<prompt>frobbo$ </prompt><userinput>whoami</userinput>
<computeroutput>trixie</computeroutput>
<prompt>frobbo$ </prompt><userinput>rsh -l larry floss.life.uiuc.edu "ls ~"</userinput>
[Voeg hier een listing in van mijn directory op floss]
</screen>
</para>

<para>
Dit werkt als gebruiker <literal>larry</literal> op 
<literal>floss.life.uiuc.edu</literal> een <filename>.rhosts</filename>
bestand heeft die <literal>trixie</literal> van 
<literal>frobbo.hoopla.com</literal> toestaat programma's in zijn account 
uit te voeren. Of het hier wel of niet om dezelfde persoon gaat is irrelevant: 
het enige wat belangrijk is, is de gebruikersnaam, de naam van de
machine en de regel in larry's <filename>.rhosts</filename> bestand op floss.  
</para>

<para>
Er zijn nog andere combinaties mogelijk die in een <filename>.rhosts</filename> bestand
kunnen worden geplaatst. Je kunt bijvoorbeeld de gebruikersnaam volgend op
een remote machinenaam achterwege laten waarmee je elke gebruiker van die
machine toestaat in jouw naam programma's uit te voeren op de lokale
machine! Dit is natuurlijk een beveiligingsrisico:
iemand zou op afstand een programma kunnen uitvoeren waarmee je bestanden
worden verwijderd, gewoon door een account op een bepaalde machine.
Als je iets doet als het achterwege laten van de gebruikersnaam,
dan moet je ervoor zorgen dat het <filename>.rhosts</filename> bestand alleen door
jou en niemand anders leesbaar is.
</para>
</sect2>

<sect2 id="config-mailforwarding"><title>Mail Forwarding</title>
<para>
Je kunt ook een <filename>.forward</filename> bestand hebben, wat strict genomen geen
"init bestand" is. Als hierin een e-mailadres staat, dan zal alle
mail bestemd voor jou in plaats daarvan worden doorgestuurd naar dat adres.
Dit is handig als je op meerdere systemen accounts hebt, en alleen
mail op &eacute;&eacute;n lokatie wilt lezen.
</para>

<para>
Er bestaan nog een boel andere mogelijke initialisatiebestanden.  Het
exacte aantal zal van systeem tot systeem varieren, en het is
afhankelijk van de software die op je systeem is ge&iuml;nstalleerd.
Een manier er meer over te leren is de bestanden in je homedirectory
te bekijken die met een "<literal>.</literal>" beginnen. Je hebt geen 
garantie dat deze bestanden allen init bestanden zijn, maar het is een goede
gok dat de meesten dit wel zijn.
</para>
</sect2>
</sect1>

<sect1 id="config-examples"><title>Een aantal voorbeelden bekijken</title>
<para>
Het laatste voorbeeld dat ik je kan geven is een draaiend Linux
systeem. Dus als je toegang hebt tot Internet, telnet dan gerust naar
<literal>floss.life.uiuc.edu</literal>. Log in als "guest", password "explorer",
en dool eens rond.  De meeste voorbeeldbestanden die hier zijn gegeven, zijn
te vinden in <filename>/home/kfogel</filename>, maar er zijn ook nog andere 
directory's. Je mag gerust alles kopi&euml;ren wat je kunt lezen. Wees 
alsjeblieft voorzichtig: floss is niet zo'n veilige box, en je kunt vrijwel 
zeker roottoegang verkrijgen als je het hard genoeg probeert. Ik geef de 
voorkeur aan vertrouwen in plaats van constante waakzaamheid om de beveiliging
te onderhouden.
</para>
</sect1>
</chapter><!--
% Local Variables: 
% mode: latex
% TeX-master: "guide"
% End: -->