Over dit artikel:

Het onderstaande verhaal is de vertaling van een interessant stuk van de hand van Rusty Russell. Deze man heeft nogal een reputatie op het Linux vlak en diverse Linux HOWTO's op zijn naam. Wegens mijn gebrek aan kennis over netwerken, communicatiemethoden en firewalls heb ik besloten een aantal van zijn documenten die geen HOWTO's zijn geworden in het Nederlands te vertalen. Een dubbele drijfveer dus, ik word er wijzer van en voor de lezer is het een interessant document. Veel leesplezier gewenst!

Wat is een computer netwerk?

Een computernetwerk is gewoon een aantal dingen die 'knopen' gebruiken om met elkaar te communiceren (met 'knopen' bedoel ik bv. computers, printers, frisdrankmachines en vul maar in). Het maakt eigenlijk niet uit hoe ze met elkaar verbonden zijn; met kabels of desnoods postduiven. Uiteraard is de ene optie beter dan de andere (zeker als je een kat hebt).

Normaliter worden twee computers bij elkaar geen netwerk genoemd; daar heb je er drie of meer voor nodig. Ook kunnen netwerken weer samengesteld zijn uit een aantal kleinere netwerken.

De daadwerkelijke verbinding tussen twee computers wordt vaak een 'netwerk verbinding' genoemd. Als er bij jouw machine een kabel uit de PC naar de andere PC's loopt is dat jouw 'netwerk verbinding'.

Er zijn vier dingen waar we bij het praten over een computernetwerk belang aan hechten:

Grootte

Als je thuis eenvoudig vier computers aan elkaar wilt schakelen praat je over een LAN (Local Area Network). Als je alle PC's lopend kunt bereiken praat je normaliter over een LAN, ongeacht de hoeveelheid machines die aangesloten zijn en ongeacht de samenstelling van het netwerk.

Aan de andere kant heb je een WAN (Wide Area Network). Als je een PC in Parijs, Rome en Londen hebt staan en je krijgt het voor elkaar om de computers met elkaar te verbinden dan spreek je over een WAN.

Topologie: De vorm

Teken een kaart van het netwerk: lijnen zijn netwerk verbindingen, en elke knoop is een punt. Misschien krijg je een vorm waarbij alle lijnen naar een centraal punt lopen, hetgeen inhoudt dat iedereen via een punt communiceert. Dat wordt ook wel een 'ster-topologie' genoemd.

			    o   o   o
			     \_ | _/
			       \|/
			  o-----o-----o
			      _/|\_
			     /  |  \
			    o   o   o
			

Misschien communiceert iedereen over een lijn als volgt:

			    o------o------o-------o--------o
			    |                              |
			    |                              |
			    |                              o
			    |                              |
			    o                              |
			                                   o
			

Of misschien zijn er drie subnetwerken onderling gekoppeld via één knoop:

			                o
			    o           |  o--o--o
			    |           |  |
			    o--o--o--o--o  o
			           \       |
			            o------o
			           /       |
			    o--o--o--o--o  o
			    |           |  |
			    o           |  o--o
			                o
			

In de praktijk zijn er nog veel meer en veel ingewikkeldere vormen.

Fysisch: Waar is het van gemaakt

Een tweede punt om je mee bezig te houden is waar het netwerk uit bestaat. De goedkoopste oplossing is een paar gympie-netwerk, waar slecht geklede mensen floppies van de ene naar de ander computer verplaatsen. Dit is vrijwel altijd een LAN. Floppies zijn erg goedkoop en een paar gympies koop je ook voor 20 euro.

Het meest gebruikte systeem om thuiscomputers met een veel groter netwerk te verbinden is de modem (MODulator/DEModulator). De modem verandert een telefoon verbinding in een netwerkverbinding. Het zet de computergegevens om in geluid en luistert naar geluiden die van de andere kant van de lijn komen om die weer in computergegevens om te zetten. Je kunt je voorstellen dat dit niet erg efficiënt is en telefoonlijnen zijn hier ook eigenlijk niet voor bedoeld. Het is echter zo populair omdat vrijwel iedereen een telefoonlijn heeft en omdat het realtief goedkoop is. Je koopt een modem voor rond de 50 euro en de telefoonverbinding kosten je een paar hondererd euro's per jaar.

De meeste gebruikte manier om machines aan een LAN te koppelen is het gebruik van Ethernet. Ethernet kent deze veel voorkomende vormen (oud naar nieuw): Thinwire/Coax/10base2, UTP (Unshielded Twisted Pair)/10baseT en UTP/100baseT. Gigabit ethernet (om de naam 1000baseT te voorkomen) begint ook zijn toepassingen te kennen. 10base2 kabel bestaat normaliter uit zwarte coaxkabel met T stukken om connecties te maken. Iedereen komt aan een grote lijn met speciale `terminator' stukken aan de beide uiteinden. UTP bestaat normaal uit een blauwe draad, met 'click-in' telefoonachtige connectors die in sockets worden gestoken om een verbinding te maken: Elke kabel verbindt een knoop met een centrale `hub'. De kabel kost een paar euro's per meter en de 10baseT/10base2 kaarten zijn moeilijk nieuw te krijgen. 100baseT cards, die ook met 10baseT kun communiceren zijn tien maal sneller en kosten ca 45 euro.

Een veel duurdere oplosssing is het gebruik van glasfiber. Een doorgaande kleine glasdraad omwikkeld door een beschermende coating die gebruikt kan worden om machines tussen continenten te verbinden. In het algemeen kost dit duizenden euro's.

Normaliter noemen we elke verbinding naar een knoop een 'netwerk interface' of kortweg 'interface'. Linux benoemd deze als `eth0' voor de eerste ethernet interface, en `fddi0' voor de eerste fiberglas interface. Het commando `/sbin/ifconfig' geeft hiervan een overzicht.

Protocol: Wat wordt er gesproken

Het laatste waar we ons mee bezig moeten houden is hoe er tussen twee machines gesproken wordt. Als twee modems met elkaar over de telefoonlijn communiceren moeten ze het er over eens zijn welk geluid wat betekent anders heeft het gewoon geen nut. Die afspraak heet het `protocol'. In de loop der tijd zijn er manieren uitgevonden om de berichten van de computer in kleinere geluiden op te slaan en werden en nieuwere protocollen ontwikkeld; er zijn er minstens een dozijn en de meeste modems proberen daar een aantal van tot ze begrijpen wat de andere kant van de lijn bedoeld.

Een ander voorbeeld is het voornoemde 100baseT netwerk. Dit gebruikt dezelfde fysische network verbindingen (UTP) maar praat tien maal zo snel. Deze twee protocollen worden 'link-level' protocollen genoemd; hoe zaken overgedragen worden op individuele netwerkverbindingen of 'een hop'. Het woord `protocol' refereert ook naar andere conventies die gevolgd worden. Dat zullen we weldra zien.

Wat is 'Internet'

Internet is een WAN die over de hele aarde loopt; het is het grootste computer netwerk dat er bestaat. Met de term `internetworking' wordt het aansluiten van verschillende netwerken tot een groter netwerk bedoeld. 'Internet' is een verzameling van een heleboel subnetwerken.

Nu gaan we de bovenstaande lijst af en we vragen ons af wat de grootte van Internet is, wat de fysische details en de protocollen zijn.

De grootte hebben we al bepaald; het zit over de hele wereld.

De fysische details variëren echter; elk klein subnetwerk is anders aangesloten met een verschillende layout en een verschillende fysische opbouw. Pogingen om het op een praktische manier uit te tekenen monden op niets uit.

De protocollen die door iedere aansluiting gesproken worden zijn vaak ook verschillend; alle 'link-level protocollen' die eerder opgesomd zijn worden gebruikt en meer.

Hoe werkt het Internet?

De volgende vraag borrelt nu op; hoe kan elke knoop op het Internet met de ander praten als er verschillende 'link-level protocollen' voor communicatie gebruikt worden?

Het antwoord is eigenlijk vrij eenvoudig; we hebben een overkoepelend protocol nodig dat regelt hoe de zaken over het netwerk rondgaan. Het 'link-level protocol' beschrijft hoe je van de ene knoop naar de andere knoop komt als ze direct aangesloten zijn. Het `netwerk protocol' beschrijft hoe we van het ene naar het andere punt in het netwerk komen, indien nodig via andere verbindingen.

Voor het Internet is het netwerkprotocol het Internet Protocol (versie 4) ook wel `IP' genoemd. Het is niet het enige protocol (Apple's AppleTalk, Novell's IPX, Digital's DECNet en Microsoft's NetBEUI zijn andere) maar IP is de meest toegepaste / geaccepteerde. Er is een nieuwere versie van IP, IPv6 genaamd maar dit is nog geen gemeengoed.

Om een bericht van de ene naar de andere kant op de aarde te sturen schrijft de computer een stukje Internet Protocol, stuurt dit naar je modem, deze gebruikt een modem 'link-level protocol' om het naar de modem waarmee het verbonden is te sturen, die op zijn beurt vaak onderdeel is van een terminal server (een soort grote kast vol modems), die het weer naar een knoop in het ISP's netwerk stuurt, die het weer naar een grotere knoop stuurt, die het weer naar een volgende knoop stuurt etc, etc. Een knoop die twee of meer netwerken verbindt noem je een `router'; deze heeft een interface voor elk netwerk.

We noemen deze verzameling van protocollen een `protocol stack', meestel getekend als volgt:

			 [ Applicatie: Verwerkt data ]           [ Applicatie laag: Levert data ]
			              |                                          ^
			              v                                          |
			 [ TCP: Verwerkt 'retransmission' ]       [ TCP: Verwerkt 'retransmission' ]
			              |                                          ^
			              v                                          |
			    [ IP: Zorgt voor routing ]              [ IP: Zorgt voor routing ]
			              |                                          ^
			              v                                          |
			[ Link: Werkt als een enkele hop ]      [ Link: Werkt als een enkele hop ]
			              |                                          |
			              +------------------------------------------+
			

In het diagram zien we bv. Netscape (de applicatie linksboven) die een webpagina van een webserver (de applicatie rechtsboven) ontvangt. Om dit voor elkaar te krijgen gebruiken we het `Transmission Control Protocol' of `TCP'; meer dan 90% van het huidige Internet verkeer is TCP, zoals het gebruikt wordt voor Email en het Web.

Netscape doet een verzoek om een TCP connectie naar een remote web server; dit wordt doorgegeven aan de TCP laag, die het doorgeeft aan de IP laag, die de richting die we moeten gaan bepaald, geeft dit door aan de geschikte verbindingslaag, die het vervolgens doorstuurt naar de andere kant van de verbinding.

Aan de andere kant geeft de verbindingslaag het door aan de IP laag, die bekijkt of het bericht voor deze 'host' bedoeld is (zo niet dan kan het weer doorgegeven worden naar een andere verbindingslaag die het weer doorstuurt naar de volgende knoop), geeft het weer door aan de TCP laag, die het weer aan de server doorgeeft.

We kunnen het dus als volgt uit elkaar trekken:

1. De applicatie (Netscape, of de web server aan de andere kant) bepaalt met wie het wil praten en wat het wil versturen.

2. De TCP laag stuurt een speciaal pakketje om de communicatie met de andere kant op gang te brengen en pakt daarna de data in een TCP-pakket; een pakket is een term voor een stuk data dat door het netwerk getransporteerd wordt. De TCP laag geeft dit pakket door aan de IP laag; het blijft dit pakket sturen tot de TCP laag aan de andere kant een bericht geeft dat het pakket ontvangen is. Dit wordt `retransmission' genoemd en bevat een hele berg complexe regels die bepalen wanneer er opnieuw verzonden (retransmit) moet worden, hoe lang er gewacht moet worden, etc. Het geeft ook elk pakket een aantal nummers zodat de andere kant de pakket in de juiste volgorde kan plaatsen.

3. De IP laag kijkt naar de bestemming van het pakket en bepaald naar welke volgende knoop het pakket gestuurd moet worden. Dit simpele proces wordt `routing' genoemd en kan erg simpel zijn (indien je slechts een modem hebt en geen andere netwerk interfaces gaan alle pakketen naar buiten via die interface) maar ook extreem complex (als je bv. 15 grote netwerken gekoppeld hebt).

Het IP gebeuren

De rol van de IP laag is dus om uit te vinden hoe de pakketen 'gerouted' moeten worden naar het uiteindelijke doel. Om dit mogelijk te maken heeft elke interface in het netwerk een 'IP adres'. Een IP adres bestaat uit vier getallen gescheiden door punten bv `167.216.245.249'. Elk nummer ligt tussen de 0 en de 255.

Interfaces in het zelfde netwerk hebben de neiging om naastliggende IP adressen te hebben. Bijvoorbeeld, `167.216.245.250' staat rechts naast de machine met IP adres `167.216.245.249'. Onthoud ook dat een router een knoop is met interfaces op meer dan een netwerk zodat de router voor elke interface een IP adres heeft.

De Linux kernel's IP laag houdt een tabel bij met verschillende routes die een beschrijving omvatten hoe je naar de verschillende IP adressen komt. De meest simpele van deze wordt de standaard route (`default route') genoemd; als de IP laag niks beters weet is dit de plek waar het pakket heengaat. Je kunt de lijst met routes zien met `/sbin/route'.

Routes kunnen naar een knoop wijzen of een specifieke knoop die aan een ander netwerk gekoppeld is. Bijvoorbeeld, als je naar de ISP belt zal je standaard route naar het modem wijzen omdat daar de hele wereld bereikbaar is.

			  Rusty's              ISP's  ~~~~~~~~~~~~ 
			   Modem               Modem {            }
			       o------------------o { Het Internet }
			                             {            }
			                              ~~~~~~~~~~~~  
			

Maar als je een permanente machine in je netwerk hebt die met de buitenwereld in contact staat wordt het wat ingewikkelder. In het onderstaande figuur kan mijn machine direct met de machine van Piet en Paul praten en met de firewall maar het moet ook weten dat pakketen die voor de rest van de wereld bedoeld zijn naar de firewall moeten gaan die deze weer door zal sturen. Dit houdt in dat er twee routes zijn; één die zegt 'indien het op mijn netwerk is, stuur het dan direct daar naar toe' en één standaard route die zegt 'zo niet, stuur het naar de firewall'.

			                         o  Piets
			                         |    Werk Machine      ~~~~~~~~~~~~
			  Rusty's                |                     {            } 
			   Werk Machine o--------+-----------------o--{ Het Internet }
			                         |            Firewall {            } 
			                         |                      ~~~~~~~~~~~~
			                         o  Pauls
			                              Werk Machine
			

Groepen van IP adressen; Network Masks

Er is nog een laatste detail: Er is een standaard notatie voor een groep van IP adressen ook wel netwerk adressen genaamd. Net zoals een telefoonnummer in een kengetal en de rest opgesplitst kan worden, kunnen we een IP adres in een network code en de rest opsplitsen.

Vroeger praatte men over 'het 1.2.3 netwerk', waarmee alle 256 adressen van 1.2.3.0 tot 1.2.3.255 bedoeld werden. Als dat niet groot genoeg was werd er over het `1.2 netwerk' gesproken waarmee alle adressen van 1.2.0.0 tot 1.2.255.255 bedoeld werden.

We schrijven normaal niet `1.2.0.0 - 1.2.255.255'. We korten het daarentegen af naar `1.2.0.0/16'. Deze rare `/16' notatie (ook wel `netmask' genaamd) vraagt om wat uitleg.

Elk nummer tussen de punten in een IP adres is in feite 8 binaire digits (00000000 tot 11111111): We schrijven ze echter in decimale vorm om ze voor ons leesbaarder te maken. De `/16' betekent dat de eerste 16 binaire digits het netwerk adres is, met andere woorden, het `1.2.' deel is het netwerk (onthoud: elke digit staat voor 8 binaire digits). Dit betekent dat elk IP adres dat met `1.2.' begint deel uitmaakt van het netwerk dus bv `1.2.3.4' en `1.2.3.50' wel, en `1.3.1.1' niet.

Om het ons gemakkelijker te maken eindigen we netwerken vaak met `/8', `/16' en `/24'. Bijvoorbeeld, `10.0.0.0/8' is een groot netwerk die de adressenvan 10.0.0.0 tot 10.255.255.255 bevat (meer dan 16 miljoen adressen!). 10.0.0.0/16 is kleiner en bevat enkel de IP adressen van 10.0.0.0 tot 10.0.255.255. 10.0.0.0/24 is nog kleiner en bevat de adressen 10.0.0.0 to 10.0.0.255.

Om het weer wat ingewikkelder te maken is er een andere manier om netmasks te noteren. We kunnen ze als IP adressen noteren:

			10.0.0.0/255.0.0.0
			

Uiteindelijk is het ook van belang om te vermelden dat het allerhoogste IP adres in elk netwerk gereserveerd is als zendadres (`broadcast adres'), dat gebruikt kan worden om iedereen tegelijkertijd een bericht te kunnen sturen.

Hier is een tabel met netwerk masks:

			Korte   Volledige               Maximum         Commentaar
			  Vorm    Vorm                    #Machines
			
			/8      /255.0.0.0              16,777,215      Werd `A-class' genoemd
			/16     /255.255.0.0            65,535          Werd `B-class' genoemd
			/17     /255.255.128.0          32,767
			/18     /255.255.192.0          16,383
			/19     /255.255.224.0          8,191
			/20     /255.255.240.0          4,095
			/21     /255.255.248.0          2,047
			/22     /255.255.252.0          1,023
			/23     /255.255.254.0          511
			/24     /255.255.255.0          255             Werd `C-class' genoemd
			/25     /255.255.255.128        127
			/26     /255.255.255.192        63
			/27     /255.255.255.224        31
			/28     /255.255.255.240        15
			/29     /255.255.255.248        7
			/30     /255.255.255.252        3
			

Machinenamen en IP Adressen

Elke interface op elke knoop heeft dus een IP adres. Men besefte zich natuurlijk snel dat mensen niet zo goed zijn in het onthouden van nummers en er werd besloten om (net als wel met telefoonnumers gebeurd) een lijst met namen in te voeren. Maar als we nu toch computers gebruiken is het nog handiger als deze de namen automatisch voor ons opzoekt.

Daarmee werd de Domain Name System (DNS) geïntroduceerd. Er zijn knopen met goed bekende IP adressen waarbij programma's namen op kunnen geven en de IP adressen terug krijgen. Vrijwel elke programma is hiertoe in staat waardoor je bv. in Netscape `www.linuxcare.com' in kan tikken in plaats van `167.216.245.249'.

Je hebt uiteraard ten minste een IP adres van een `naam server' nodig; deze staat normaal in het `/etc/resolv.conf' bestand.

Omdat DNS verzoeken en antwoorden relatief erg klein zijn (1 pakket per stuk) wordt er normaal geen TCP protocol toegepast; dat zorgt weliswaar voor automatische 'retransmission', sortereert zelf en is goed te vertrouwen maar wel ten koste van extra pakketen die over het netwerk gaan. We gebruiken voor DNS het simpele `User Datagram Protocol', dat geen van de opties van TCP biedt die we niet nodig hebben.

Verschillende diensten: Email, Web, FTP, Name Serving

In het voorgaande voorbeeld toonden we Netscape dat een TCP verzoek aan een webserver op een andere knoop deed. Maar stel je voor dat deze knoop ook Email, FTP en name server diensten levert; hoe weet de knoop voor welke service het TCP verzoek bedoeld is?

Hiertoe gebruiken TCP en UDP het `poorten' concept. Elk pakket heeft ruimte voor een `destination port', dat aangeeft voor welke service het pakket is. Bijvoorbeeld; TCP poort 25 is de mail server, en poort 80 is de webserver (hoewel je ook op andere poorten webservers kunt vinden). Een lijst van poorten kun je vinden in `/etc/services'.

Een ander probleem; als twee Netscape vensters beide verschillende delen van dezelfde website bezoeken, hoe weet de Linux machine waar Netscape op draait welke TCP pakketen van de webserver voor welk venster bedoeld is?

Hier is de `source poort' voor bedoeld; elke nieuwe TCP verbinding heeft een verschillende source poort, dus kunnen ze van elkaar gescheiden blijven zelfs als ze naar hetzelfde IP adres en hetzelfde poortnummer gaan. Standaard is het eerste source poort nummer 1024, om vervolgens op te lopen.

Opbel interfaces: PPP

Als je met je modem op een ISP inbelt en je modem zich met de modem op de ISP verbonden heeft, begint de kernel niet direct IP pakketen door de lijn te duwen. Er is een protocol genaamd `Point-to-Point Protocol', of `PPP', dat met de andere kant overlegt voordat er pakketverkeer toegestaan wordt. Dit wordt gebruikt door de ISP om te achterhalen wie er gebeld heeft; op je Linux machine wordt dit door het programma `PPP daemon' geregeld.

Omdat er zoveel verschillende mensen zijn die inbellen hebben ze normaal geen eigen IP adres; de meeste IPS's geven je bij het inbellen een tijdelijke adres te leen (waar de PPP daemon voor verantwoordelijk is). Dit wordt een `dynamisch IP adres' genoemd, in tegenstelling tot een `statisch IP adres' dat je krijgt als je een permanent adres hebt. De adressen worden meestal door de modem uitgegeven; de volgende keer dat je inbelt krijg je waarschijnlijk een ander modem en dus een ander IP adres.

Hoe pakketen er uitzien

Voor de extreem nieuwsgierigen onder jullie is hier een beschrijving van hoe een pakket er daadwerkelijk uitziet. Er zijn verschillende tools die pakketverkeer in en uit je Linux machine gadeslaan; de meest bekende is `tcpdump' (die tegenwoordig meer dan TCP begrijpt), maar een fijnere is `ethereal'. Zulke programma's staan bekend als `packet sniffers'.

De start van elk pakket geeft aan waar het heen gaat en waar het vandaan komt en andere administratieve details. Dit deel wordt de `packet header' genoemd. De rest van het pakket dat de daadwerkelijke data bevat wordt meestal de `packet body' genoemd.

Elk IP pakket begint dus met een `IP header'; minstens 20 bytes lang. Het ziet er als volgt uit (dit diagram is zonder schaamte gepikt van RFC 791):

			  .-------+-------+---------------+-------------------------------.
			  |Versie |  IHL  |Service type   |          Totale lengte        |
			  |-------+-------+---------------+-------------------------------|
			  |         Identificatie         |Flags|      Fragment Offset    |
			  |---------------+---------------+-------------------------------|
			  |  Time to Live |    Protocol   |         Header Checksum       |
			  |---------------+---------------+-------------------------------|
			  |                       Source Address                          |
			  |---------------------------------------------------------------|
			  |                    Destination Address                        |
			  `---------------------------------------------------------------'
			

De belangrijke velden zijn het Protocol dat aangeeft of dit een TCP pakket (nummer 6), een UDP pakket (nummer 17) of iets anders is, het Source IP Adres, en het Destination IP Adres.

Als het protocolveld aangeeft dat dit een TCP pakket is volgt er direct een IP header met een lengte van eveneens minstens 20 bytes:

			  .-------------------------------+-------------------------------.
			  |          Source Port          |       Destination Port        |
			  |-------------------------------+-------------------------------|
			  |                        Sequence Number                        |
			  |---------------------------------------------------------------|
			  |                    Acknowledgment Number                      |
			  |-------------------+-+-+-+-+-+-+-------------------------------|
			  |  Data |           |U|A|P|R|S|F|                               |
			  | Offset| Reserved  |R|C|S|S|Y|I|            Window             |
			  |       |           |G|K|H|T|N|N|                               |
			  |-------+-----------+-+-+-+-+-+-+-------------------------------|
			  |           Checksum            |         Urgent Pointer        |
			  `---------------------------------------------------------------'
			

De belangrijkste velden hier zijn de source port en de destination port, die aangeven naar welke service het pakket toegaat (of in geval van antwoordende pakketen; van welke service het komt). De volgorde en acceptatie nummers (Acknowledgment Number) worden gebruikt om de pakketen op volgorde te houden en vertellen de andere kant welke pakketen er reeds ontvangen zijn. De ACK, SYN, RST en FIN vlaggen (van boven naar beneden genoteerd) zijn enkele bits die het openen (SYN) en sluiten (RST of FIN) van de verbindingen regelen.

Na deze header komt het daadwerkelijke bericht dat de applicatie heeft verzonden (de packet body). Een normaal pakket neemt circa 1500 bytes in beslag: dit betekent dat de meeste ruimte voor data 1460 bytes is (20 bytes voor de IP header, en 20 voor de TCP header); meer dan 97%.

Samenvatting

Het moderne Internet gebruikt dus IP pakketen om te communiceren en de meeste van deze IP pakketen gebruiken intern TCP. Speciale knopen 'routers' genaamd verbinden al deze kleine netwerken samen tot een groter netwerk en brengen deze pakketen naar hun bestemming. De meeste gangbare machines zijn enkel met één netwerk verbonden ( met andere woorden; hebben slechts een interface) en zijn dus geen routers.

Elke interface heeft een uniek IP adres dat er uit ziet als `1.2.3.4'; interfaces in hetzelfde netwerk hebben gerelateerde IP adressen met dezelfde start (net als de kengetallen bij de telefoonnummers) en dezelfde prefix. Deze netwerk adressen zien er uit als IP adressen met een `/' om aan te geven hoeveel de prefix in beslag neemt bv. `1.2.0.0/16' dat inhoudt dat de eerste 2 digits het netwerkadres bevat; elke digit staat voor 8 bits.

Machines krijgen namen van de Domain Name Service; programma's komen met een naam als 'www.linuxcare.com' en vragen aan de name servers om dit in een IP adres te vertalen. Dit IP adres wordt daarna gebruikt als het bestemmings IP adres om met deze knoop te communiceren.

Rusty is slecht in het schrijven van documentatie, zeker voor de beginner :-)

Veel plezier!

Rusty.