Grundlagen Rechnernetze und Verteilte Systeme

Transkript

1 Grundlagen Rechnernetze und Verteilte Systeme SoSe 2012 Kapitel 3: Vermittlungsschicht Prof. Dr.-Ing. Georg Carle Stephan M. Günther, M.Sc. Nadine Herold, M.Sc. Dipl.-Inf. Stephan Posselt Fakultät für Informatik Lehrstuhl für Netzarchitekturen und Netzdienste IN0010, SoSe 2012, Kapitel 3 1

2 Worum geht es in diesem Kapitel? 1 Motivation 2 Vermittlungsarten 3 Adressierung im Internet 4 Wegwahl (Routing) 5 Nachfolge von IP(v4): IPv6 IN0010, SoSe 2012, Kapitel 3: Motivation 2

3 Einordnung im ISO/OSI-Modell 7 Anwendungsschicht Horizontale Kommunikation 7 Application Layer Vertikale Kommunikation Darstellungsschicht Sitzungsschicht Transportschicht Vermittlungsschicht Sicherungsschicht Presentation Layer Session Layer Transport Layer Network Layer Data Link Layer 1 Physikalische Schicht 1 Physical Layer Kanal (Kupfer, Lichtwellenleiter, Funk) IN0010, SoSe 2012, Kapitel 3: Motivation 3

4 Motivation Sind Direktverbindungsnetze wie Ethernet skalierbar? Alle angeschlossenen Computer sind direkt bzw. über wenige Switches erreichbar MAC-Adressen bieten keine logische Struktur zur Adressierung Gruppierung von Geräten in kleinere Netze (Subnetze) durch MAC-Adressen nicht unterstützt Aufgaben der Vermittlungsschicht: Kopplung unterschiedlicher Direktverbindungsnetze Strukturierte Aufteilung in kleinere Subnetze Logische und global eindeutige Adressierung von Geräten Wegwahl zwischen Geräten über mehrere Hops hinweg IN0010, SoSe 2012, Kapitel 3: Motivation 4

5 Worum geht es in diesem Kapitel? 1 Motivation 2 Vermittlungsarten 3 Adressierung im Internet 4 Wegwahl (Routing) 5 Nachfolge von IP(v4): IPv6 IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten 5

6 Vermittlungsarten Es gibt drei grundlegende Vermittlungsarten: Leitungsvermittlung Reserviere eine dedizierte Leitung zwischen Sender und Empfänger Nachrichtenvermittlung Wähle für jede Nachricht individuell einen Weg Paketvermittlung Teile eine Nachricht in mehrere kleinere Pakete auf und versende jedes Paket unabhängig von den anderen Im Folgenden charakterisieren wir diese drei Vermittlungsarten anhand des Beispielnetzwerks s i j t mit n = 2 Vermittlungsknoten hinsichtlich der Gesamtdauer T einer Übertragung von l Datenbits über die Distanz d und motivieren so die Vorteile der Paketvermittlung. IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten 6

7 Leitungsvermittlung Während einer verbindungsorientierten Übertragung können drei Phasen unterschieden werden: 1 Verbindungsaufbau Austausch von Signalisierungsnachrichten zum Aufbau einer dedizierten Verbindung zwischen Sender und Empfänger. Dieser Schritt beinhaltet die Wegwahl, welche vor Beginn der Datenübertragung durchgeführt wird. 2 Datenaustausch Kanal steht den Kommunikationspartnern zur exklusiven Nutzung bereit. Auf die Adressierung des Kommunikationspartners kann während der Übertragung weitgehend verzichtet werden (Punkt-zu-Punkt-Verbindung). 3 Verbindungsabbau Austausch von Signalisierungsnachrichten zum Abbau der Verbindung. Die durch die Verbindung belegten Ressourcen werden für nachfolgende Verbindungen freigegeben. IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Leitungsvermittlung 7

8 Übertragungszeit bei Leitungsvermittlung Wir nehmen an, dass die Serialisierungszeit von Signalisierungsnachrichten vernachlässigbar klein ist, die Verarbeitungszeiten und Wartezeiten in jedem Knoten vernachlässigbar klein sind und dass der Sender s einen Datenblock der Länge L an einem Stück übertragen möchte. Distanz d s i j t Verbindungsaufbau Datentransfer Verbindungsabbau T LV = 2t p + t s + 2t p = t s + 4t p = L r + 4 d νc IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Leitungsvermittlung 8

9 Vorteile der Leitungsvermittlung Gleichbleibende Güte der dedizierten Verbindung nach dem Verbindungsaufbau Schnelle Datenübertragung ohne Notwendigkeit, weitere Vermittlungsentscheidungen treffen zu müssen Nachteile der Leitungsvermittlung Ressourcenverschwendung, da Leitung zur exklusiven Nutzung reserviert wird Verbindungsaufbau kann komplex sein und benötigt u. U. weit mehr Zeit, als die Ausbreitungsverzögerungen vermuten lassen (z. B. Einwahl ins Internet mittels Modem) Hoher Aufwand bei der Schaltung physikalischer Verbindungen Einsatz in heutigen Netzwerken Leitungsvermittlung wird häufig durch Paketvermittlung ersetzt (z. B. Voice over IP) In vielen Vermittlungsnetzen wird Leitungsvermittlung zumindest virtualisiert in Form von Virtual Circuits unterstützt (z. B. Frame Relay, ATM, MPLS) IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Leitungsvermittlung 9

10 Nachrichtenvermittlung Veränderungen bei der Nachrichtenvermittlung: Aufbau und Abbau einer dedizierten Verbindung entfallen Der gesamten Nachricht der Länge L wird ein Header der Länge L H vorangestellt Header Nachricht Der Header beinhaltet insbesondere Adressinformationen, die geeignet sind, Sender und Empfänger auch über mehrere Zwischenstationen hinweg eindeutig zu identifizieren Die so entstehende PDU wird als Ganzes übertragen Hoffnung: Zeitersparnis, da die Phasen zum Aufbau und Abbau der Verbindung entfallen. Analogie: Post / DHL / Paketdienste Absender verpackt Ware und versieht das Paket mit Adressinformationen (Header) Die Adressen identifizieren Absender und Empfänger weltweit eindeutig und haben eine logische Struktur, die eine effiziente Zuordnung im Transportnetz der Post erlaubt IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Nachrichtenvermittlung 10

11 Übertragungszeit bei Nachrichtenvermittlung Erinnerung: Hier n = 2 Vermittlungsknoten i und j. Distanz d s i j t T NV = (n + 1) t s + t p = (n + 1) LH + L r + d νc IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Nachrichtenvermittlung 11

12 Multiplexing auf Nachrichtenebene Das Wegfallen fest vorgegebener Pfade ermöglicht die gemeinsame Nutzung von Teilstrecken Dies entspricht dynamischem Zeitmultiplex (Time Division Multiplex, TDM) s t i j Vorteile: Flexibles Zeitmultiplex von Nachrichten Bessere Ausnutzung der Kanalkapazität Keine Verzögerung beim Senden des ersten Pakets durch Verbindungsaufbau Nachteile: Pufferung von Nachrichten, wenn (i, j) ausgelastet Verlust von Nachrichten durch begrenzten Puffer möglich (Stausituation Kapitel 4) Mehrfache Serialisierung der ganzen Nachricht IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Nachrichtenvermittlung 12

13 Paketvermittlung Unterschiede zur Nachrichtenvermittlung: Nachrichten werden nicht mehr als Einheit übertragen sondern in kleinere Pakete unterteilt: Nachricht P1 P2 P3 P4 Jedem Paket wird ein eigener Header vorangestellt, der alle Informationen zur Weiterleitung und ggf. auch zur Reassemblierung enthält: H P1 H P2 H P3 H P4 Pakete werden unabhängig voneinander vermittelt, d. h. Pakete derselben Nachricht können über unterschiedliche Wege zum Empfänger gelangen. Im Allgemeinen müssen die einzelnen Pakete nicht gleich groß sein, es gibt aber Anforderungen an die minimale (p min ) und maximale (p max) Paketgröße. IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 13

14 Übertragungszeit bei Paketvermittlung Erinnerung: Hier n = 2 Vermittlungsknoten i und j. Vereinfachend nehmen wir an, dass die Nachrichtenlänge ein Vielfaches von p max ist. ( alle Pakete haben dieselbe Größe p max). Distanz d s i j t T PV = 1 r ( L p max ) L h + L + d νc + n Lh + p max r IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 14

15 Übertragungszeit bei Paketvermittlung Erinnerung: Hier n = 2 Vermittlungsknoten i und j. Vereinfachend nehmen wir an, dass die Nachrichtenlänge ein Vielfaches von p max ist. ( alle Pakete haben dieselbe Größe p max). Distanz d s i j t T PV = 1 r ( L p max ) L h + L + d νc + n Lh + p max r IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 14

16 Übertragungszeit bei Paketvermittlung Erinnerung: Hier n = 2 Vermittlungsknoten i und j. Vereinfachend nehmen wir an, dass die Nachrichtenlänge ein Vielfaches von p max ist. ( alle Pakete haben dieselbe Größe p max). Distanz d s i j t T PV = 1 r ( L p max ) L h + L + d νc + n Lh + p max r IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 14

17 Übertragungszeit bei Paketvermittlung Erinnerung: Hier n = 2 Vermittlungsknoten i und j. Vereinfachend nehmen wir an, dass die Nachrichtenlänge ein Vielfaches von p max ist. ( alle Pakete haben dieselbe Größe p max). Distanz d s i j t T PV = 1 r ( L p max ) L h + L + d νc + n Lh + p max r IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 14

18 Multiplexing auf Paketebene Durch die Vermittlung kleiner Pakete statt langer Nachrichten werden Engpässe fairer genutzt Gehen Pakete verloren, müssen nur Teile einer größeren Nachricht wiederholt werden s t i j Vorteile: Flexibles Zeitmultiplex einzelner Pakete Pufferung kleiner Pakete statt ganzer Nachrichten Nachteile: Verlust von Paketen durch begrenzten Puffer möglich Jedes Paket benötigt seinen eigenen Header (Overhead) Empfänger muss Pakete wieder zusammensetzen IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 15

19 Vergleich der drei Verfahren Leitungsvermittlung: T LV = L r + 4 d νc Zahlenbeispiel: Nachrichtenvermittlung: T NV = (n + 1) L h + L + d r νc Paketvermittlung: T PV = 1 ( ) L L h + L + d r p max νc + n Lh + p max r Die Distanz zwischen Sender und Empfänger beträgt d = 1000 km Für Glasfaserleitungen beträgt ν = 0.9 Es kommen n = 5 Vermittlungsknoten zum Einsatz Die Datenrate beträgt auf allen Teilstrecken r = 1 Mbit/s Die Länge der zu sendenden Nachricht beträgt L = 5 MiB Die maximale Paketgröße betrage p max = 1480 B Die Headergröße pro Nachricht / Paket betrage L h = 20 B Es ergeben sich folgende Zahlenwerte: T LV 42 s, T NV 5033 s und T PV 43 s. IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 16

20 Wo werden die Verfahren eingesetzt? Leitungsvermittlung: Analoge Telefonverbindungen (POTS) Interneteinwahl ( letzte Meile ) Standortvernetzung von Firmen Virtuelle Kanäle (engl. Virtual Circuits) in unterschiedlichen Arten von Vermittlungsnetzen (Frame Relay, ATM, MPLS,... ) Nachrichtenvermittlung: Kaum praktische Anwendung auf Schicht 3 Aber: Nachrichtenvermittlung existiert aus Sicht höherer Schichten (ab Schicht 5 aufwärts) Paketvermittlung: In den meisten modernen Datennetzen Zunehmend auch zur Sprachübertragung (Voice over IP) Digitales Radio / Fernsehen Viele Peripherieschnittstellen an Computern (PCI, USB, Thunderbolt) IN0010, SoSe 2012, Kapitel 3: Vermittlungsarten Paketvermittlung 17

21 Übersicht 1 Motivation 2 Vermittlungsarten 3 Adressierung im Internet 4 Wegwahl (Routing) 5 Nachfolge von IP(v4): IPv6 IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet 18

22 Adressierung im Internet Die Sicherungsschicht (Schicht 2) bietet mehr oder weniger fairen Medienzugriff, einen ausreichenden Schutz vor Übertragungsfehler und Adressierung innerhalb eines Direktverbindungsnetzes. Die Vermittlungsschicht (Schicht 3) ergänzt dies um Möglichkeiten zur global eindeutigen und strukturierten / logischen Adressierung sowie Verfahren zur Bestimmung von (möglichst) optimalen Pfaden. Wir beschränken uns in diesem Kapitel auf die Betrachtung von IP (Internet Protocol, 1981) bzw. seinem Nachfolger IPv6 (1998). Alternative Protokolle waren / sind zum Beispiel: IPX (Internetwork Packet Exchange, 1990) DECnet Phase 5 (1987) AppleTalk (1983) SMTP, HTTP, POP3, Telnet, SSH, UDP, TCP IP ALOHA, CSMA, Token Passing RZ, NRZ, Manchester, MLT-3, PSK, ASK, QAM Schichten des OSI-Modells IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet 19

23 Internet Protocol (IPv4) [3] Wir betrachten das folgende Beispielnetz, welches auf einem aktuellen Ethernet-Standard basiert: c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB1 00:1f:3f:35:2a: :0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA Port 0 S SB /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB2 de:ad:be:ef:01: :21:5a:6f:a8:7d /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB3 80:1f:02:15:90:ea Wie viele Einträge enthält die Switchingtabelle von SA? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 20

24 Internet Protocol (IPv4) [3] Wir betrachten das folgende Beispielnetz, welches auf einem aktuellen Ethernet-Standard basiert: c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB1 00:1f:3f:35:2a: :0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA Port 0 S SB /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB2 de:ad:be:ef:01: :21:5a:6f:a8:7d /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB3 80:1f:02:15:90:ea Wie viele Einträge enthält die Switchingtabelle von SA? Genau einen Entrag für jeden bekannten Host Die meisten MAC-Adressen werden auf Port 0 abgebildet Eine Zusammenfassung von Einträgen ist i. A. nicht möglich, da MAC-Adressen nicht die Position eines Knotens innerhalb eines Netzwerks wiederspiegeln Port MAC 0 00:1f:3f:35:2a:84 0 de:ad:be:ef:01: :1f:02:15:90:ea 1 c8:2a:14:4f:dc: :0c:ce:e2:c8:2e 3 00:21:5a:6f:a8:7d.. Es erscheint sinnvoll, von physikalischen Adressen zu abstrahieren IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 20

25 Wir betrachten dasselbe Netzwerk mit einem Router (R) in der Mitte: c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 Netz A Netz B /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB1 00:1f:3f:35:2a: :0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA Port 0 R SB /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB2 de:ad:be:ef:01: :21:5a:6f:a8:7d /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB3 80:1f:02:15:90:ea Jeder Computer erhält zusätzlich eine IP Adresse, welche in vier Gruppen zu je einem Byte durch Punkte getrennt dargestellt werden (Dotted Decimal Notation). In diesem Beispiel identifiziert das 4. Oktett einen Computer innerhalb eines Netzes. Die ersten drei Oktette identifizieren das Netzwerk, in dem sich der Computer befindet. Der Router R trifft Weiterleitungsentscheidungen auf Basis der IP-Adresse. Jedes Paket muss mit einer Absender- und Ziel-IP (IP-Header) versehen werden: MAC Header IP Header Daten (Payload) CRC Layer 3 PDU IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 21

26 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Abbildung: IPv4-Header (minimale Länge: 20 Byte) Version Gibt die verwendete IP-Version an. Gültige Werte sind 4 (IPv4) und 6 (IPv6). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

27 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Abbildung: IPv4-Header (minimale Länge: 20 Byte) IHL (IP Header Length) Gibt die Länge des IP Headers inkl. Optionen in Vielfachen von 32 Bit an. Wichtig, da der IPv4-Header durch Optionsfelder variable Länge hat. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

28 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) TOS (Type of Service) Abbildung: IPv4-Header (minimale Länge: 20 Byte) Dient der Klassifizierung und Priorisierung von IP-Paketen (z. B. Hinweis auf zeitsensitive Daten wie Sprachübertragungen). Möglichkeit zur Staukontrolle (Explicit Congestion Notification) auf Schicht 3 (optional). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

29 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Total Length Abbildung: IPv4-Header (minimale Länge: 20 Byte) Gibt die Gesamtlänge des IP-Pakets (Header + Daten) in Bytes an. Die Maximallänge eines IP-Pakets beträgt damit Byte. Der Sender passt die Größe ggf. an, um Fragmentierung zu vermeiden. Die maximale Paketlänge, so dass keine Fragmentierung notwendig ist, bezeichnet man als Maximum Transmission Unit (MTU). Diese ist Abhängig von Schicht 2/1 und beträgt bei FastEthernet 1500 Byte. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

30 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Abbildung: IPv4-Header (minimale Länge: 20 Byte) Identification Für jedes IP-Paket (zufällig) gewählter 16 Bit langer Wert. Dient der Identifikation zusammengehörender Fragmente (IP-Fragmentierung später). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

31 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Flags Bit 16: Reserviert und wird auf 0 gesetzt. Abbildung: IPv4-Header (minimale Länge: 20 Byte) Bit 17: Don t Fragment (DF). Ist dieses Bit 1, so darf das IP-Paket nicht fragmentiert werden. Bit 18: More Fragments (MF). Gibt an, ob weitere Fragmente folgen (1) oder dieses Paket das letzte Fragment ist (0). Wurde das Paket nicht fragmentiert, wird es ebenfalls auf 0 gesetzt. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

32 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Fragment Offset Abbildung: IPv4-Header (minimale Länge: 20 Byte) Gibt die absolute Position der Daten in diesem Fragment bezogen auf das unfragmentierte Paket in ganzzahligen Vielfachen von 8 Byte an. Ermöglicht zusammen mit dem Identifier und MF-Bit die Reassemblierung fragmentierter Pakete in der richtigen Reihenfolge. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

33 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) TTL (Time to Live) Abbildung: IPv4-Header (minimale Länge: 20 Byte) Leitet ein Router ein IP-Paket weiter, so dekrementiert er das TTL-Feld um 1. Erreicht das TTL-Feld den Wert 0, so verwirft ein Router das Paket und sendet eine Benachrichtigung an den Absender (ICMP Time Exceeded später). Dieser Mechanismus beschränkt die Pfadlänge im Internet und verhindert endlos kreisende Pakete infolge von Routing Loops. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

34 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Protocol Abbildung: IPv4-Header (minimale Länge: 20 Byte) Identifiziert das Protokoll auf Schicht 4, welches in der Payload (Daten) des IP-Pakets enthalten ist. Relevant u. a. für das Betriebssystem, um Pakete dem richtigen Prozess zuordnen zu können. Gültige Werte sind beispielsweise 0x06 (TCP) und 0x08 (UDP). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

35 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Header Checksum Abbildung: IPv4-Header (minimale Länge: 20 Byte) Einfache, auf Geschwindigkeit optimierte Checksumme, welche nur den IP-Header (ohne Daten) schützt. Die Checksumme ist so ausgelegt, dass die Dekrementierung des TTL-Felds einer Inkrementierung der Checksumme entspricht. Es ist also keine Neuberechnung der Checksumme bei der Weiterleitung von Paketen notwendig. Es ist lediglich Fehlererkennung aber keine Korrektur möglich. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

36 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Abbildung: IPv4-Header (minimale Länge: 20 Byte) Source Address IP-Adresse des Absenders. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

37 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Abbildung: IPv4-Header (minimale Länge: 20 Byte) Destination Address IP-Adresse des Empfängers. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

38 IP-Header Der IP-Header beinhaltet nicht nur Quell- und Ziel-Adresse. Die Verwendung der wichtigsten Felder wird später in diesem Kapitel anhand von Beispielen genauer erläutert werden. Offset 0 B 4 B 8 B 12 B 16 B 20 B Version IHL TOS Total Length Identification Flags Fragment Offset TTL Protocol Header Checksum Source Address Destination Address Options / Padding (optional) Options / Padding Abbildung: IPv4-Header (minimale Länge: 20 Byte) IP unterstützt eine Reihe von Optionen (z. B. Zeitstempel, Route Recording,... ), welche als optionale Felder an den IP-Header angefügt werden können. Nicht alle diese Optionen sind 4 Byte lang. Da die Länge des IP-Headers jedoch ein Vielfaches von 4 Byte betragen muss, werden kürzere Optionen ggf. auf den nächsten gültigen Wert gepadded. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 22

39 Einschub: Host-Byte-Order und Network-Byte-Order Es gibt zwei unterschiedle Byte-Orders: 1 Big Endian: Niederwertigstes Byte steht an höchstwertigster Adresse Intuitve Schreibweise entspricht der Reihenfolge im Speicher, z. B. die Dezimalzahl 256 in hexadezimaler Schreibweise als 0x Little Endian: Niederwertigstes Byte steht an niederwertigster Adresse Kontraintuitiv, da die Daten im Speicher verkehrt herum abgelegt werden, z. B. die Dezimalzahl 256 in hexadezimaler Schreibweise als 0x0001. x86-kompatible Computer verwenden intern Little Endian. Bei der Kommunikation mit anderen Computern stellt das aber möglicherweise ein Problem dar. Deswegen: Konvertierung in Network Byte Order. Network Byte Order Vor dem Versenden von Daten müssen Daten aus der Host Byte Order (Little Endian bei x86) in Network Byte Order (Big Endian) konvertiert werden. Analoges gilt beim Empfang von Daten. Dies betrifft z. B. die Felder Total Length, Identification, Flags+Fragment Offset und Header Checksum aus dem IP-Header. Nicht betroffen sind 1 Byte lange Felder. Quell- und Zieladresse liegen gewöhnlich als Array von 1 Byte langen Werten vor, weswegen auch diese kein Problem darstellen. Die Konvertierung zwischen beiden Formaten erfolgt für 16 Bit lange Werte in C beispielsweise durch die Funktionen htons() und ntohs(): htons(0x0001) = 0x0100 Host to Network Short ntohs(0x0100) = 0x0001 Network to Host Short Für 32 Bit lange Werte gibt es analog htonl() und ntohl() ( l für Long). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 23

40 Zurück zu unserem Beispiel: c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; Netz A Netz B /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; 00:1f:3f:35:2a: PCA1 PCB1 04:0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA Port 0 R SB /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB2 de:ad:be:ef:01: :21:5a:6f:a8:7d /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; 80:1f:02:15:90:ea PCA3 PCB3 Innerhalb von Netz A erreichen sich alle Hosts weiterhin direkt über SA. Will PCA1 nun ein Paket an PCB2 schicken, so geht das nicht mehr direkt: Die Weiterleitung von A nach B erfolgt über R auf Basis von IP-Adressen PCA1 muss also dafür sorgen, dass R das Paket erhält Dazu trägt PCA1 als Ziel-MAC die Adresse des lokalen Interfaces von R ein Als Ziel-IP wird die IP-Adresse von PCB2 verwendet R muss adressierbar sein und benötigt daher auf jedem Interface eine eigene MAC-Adresse und (wie wir gleich sehen werden) auch eine IP-Adresse: eth0 00:13:c4:ef:42:5c R eth1 00:13:c4:ef:42:5d IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 24

41 c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 Netz A Netz B /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB1 00:1f:3f:35:2a: :0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA Port 0 R SB /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB2 de:ad:be:ef:01: :21:5a:6f:a8:7d /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCB3 80:1f:02:15:90:ea Offene Probleme: Angenommen der Sender kennt nur die IP-Adresse des Ziels. Wie kann die MAC-Adresse des Next-Hops bestimmt werden? (Adressauflösung) Woher weiß PCA1, dass er Netz B über R erreichen kann? (Routing Table) Angenommen das Ziel eines Pakets befindet sich nicht in einem direkt an R angeschlossenen Netz. Woher kennt R die richtige Richtung? (Routing Table) Wie wird diese Routing Table erzeugt? (statisches Routing, Routing Protokolle) Was ist, wenn R mehrere Wege zu einem Ziel kennt? (Longest Prefix Matching) Wie funktioniert die Unterteilung einer IP-Adresse in Netz- und Hostanteil? (Classfull Routing, Classless Routing, Subnetting) Woher kennt der Sender überhaupt die IP des Ziels? (DNS Schicht 7) IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Protocol (IP) 25

42 Adressauflösung [4] PC1 will eine Nachricht an PC2 senden Die IP-Adresse von PC2 ( ) sei ihm bereits bekannt Wie erhält PC1 die zugöhrige MAC-Adresse? c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC1 04:0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC2 S Port 0 R IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 26

43 Adressauflösung [4] PC1 will eine Nachricht an PC2 senden Die IP-Adresse von PC2 ( ) sei ihm bereits bekannt Wie erhält PC1 die zugöhrige MAC-Adresse? c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC1 04:0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC2 S Port 0 R Address Resolution Protocol (ARP) 1 PC1 sendet einen ARP Request: Who has ? Tell PC2 antwort mit einem ARP Reply: is at 04:0c:ce:e2:c8:2e Offset B Hardware Type Protocol Type 4 B 8 B Hardware Addr. Length Protocol Addr. Length Operation Sender Hardware Address (first 32 Bit) 12 B 16 B Sender Hardware Address (last 16 Bit) Sender Protocol Address (last 16 Bit) Sender Protocol Address (first 16 Bit) Target Hardware Address (first 16 Bit) 20 B 24 B Target Hardware Address (last 32 Bit) Target Protocol Address Abbildung: ARP-Paket für IPv4 über Ethernet IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 26

44 Beispiel: c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC1 ARP-Request L2: c8:2a:14:4f:dc:02 ff:ff:ff:ff:ff:ff 04:0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC2 S Port 0 R Hinweis: L2: xx:xx:xx:xx:xx:xx yy:yy:yy:yy:yy:yy stellt Absender- und Ziel-MAC auf Schicht 2 dar x0001 (Ethernet) 0x0800 (IPv4) 0x06 0x04 0x0001 (Request) 0xdc02 (Sender Hardware Address) 0x0101 (Sender Protocol Address) 0xc82a144f 0x (Target Hardware Address) 0xc0a80102 (Target Protocol Address) (a) ARP Request 0xc0a8 0x0000 Der ARP-Request wird an die MAC-Broadcastadresse ff:ff:ff:ff:ff:ff geschickt, weswegen S den Rahmen an alle angeschlossenen Hosts weiterleitet. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 27

45 Beispiel: c8:2a:14:4f:dc: /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC1 04:0c:ce:e2:c8:2e /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PC2 S ARP-Reply L2: 04:0c:ce:e2:c8:2e c8:2a:14:4f:dc:02 Port 0 R Hinweis: L2: xx:xx:xx:xx:xx:xx yy:yy:yy:yy:yy:yy stellt Absender- und Ziel-MAC auf Schicht 2 dar x0001 (Ethernet) 0x0800 (IPv4) 0x06 0x04 0x0001 (Request) 0xc82a144f 0xdc02 (Sender Hardware Address) 0xc0a8 0x0101 (Sender Protocol Address) 0x0000 0x (Target Hardware Address) 0xc0a80102 (Target Protocol Address) (c) ARP Request x0001 (Ethernet) 0x0800 (IPv4) 0x06 0x04 0x0002 (Reply) 0x040ccee2 0xc82e 0xc0a8 0x0102 0xc82a 0x144fdc02 0xc0a80101 (d) ARP Reply Der ARP-Request wird an die MAC-Broadcastadresse ff:ff:ff:ff:ff:ff geschickt, weswegen S den Rahmen an alle angeschlossenen Hosts weiterleitet. Der ARP-Reply wird als MAC-Unicast versendet (adressiert an PC1). Die Rollen Sender / Target sind zwischen Request und Reply vertauscht (vgl. Inhalte der grünen und roten Felder). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 27

46 Was ist nun, wenn das Ziel nicht im selben Netz liegt (z. B. PCA1 an PCB2)? Jeder Host sollte einen Default Gateway kennen, an den er alle Pakete schickt, deren Zieladressen nicht im eigenen Netz liegen. Die Zugehörigkeit einer Adresse zum jeweiligen Netz erkennt ein Host durch Vergleich der eigenen Adresse mit der Zieladdresse. Im Moment gehen wir noch davon aus, dass die ersten 3 Oktette einer IP-Adresse das Netz identifizieren und liegen in unterschiedlichen Netzen. /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; eth eth PCB1 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA R SB PCB2 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 PCB3 1 PCA1 erkennt, dass nicht im eigenen Netz liegt. Sein Default-Gateway ist IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 28

47 Was ist nun, wenn das Ziel nicht im selben Netz liegt (z. B. PCA1 an PCB2)? Jeder Host sollte einen Default Gateway kennen, an den er alle Pakete schickt, deren Zieladressen nicht im eigenen Netz liegen. Die Zugehörigkeit einer Adresse zum jeweiligen Netz erkennt ein Host durch Vergleich der eigenen Adresse mit der Zieladdresse. Im Moment gehen wir noch davon aus, dass die ersten 3 Oktette einer IP-Adresse das Netz identifizieren und liegen in unterschiedlichen Netzen. /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; ARP-Request L2: PCA1 ff:ff:ff:ff:ff:ff L3: - /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; eth eth PCB1 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA ARP-Reply R SB PCB2 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; L2: R.eth0 PCA1 L3: - /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 PCB3 1 PCA1 erkennt, dass nicht im eigenen Netz liegt. Sein Default-Gateway ist PCA1 löst die MAC-Adresse zu auf. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 28

48 Was ist nun, wenn das Ziel nicht im selben Netz liegt (z. B. PCA1 an PCB2)? Jeder Host sollte einen Default Gateway kennen, an den er alle Pakete schickt, deren Zieladressen nicht im eigenen Netz liegen. Die Zugehörigkeit einer Adresse zum jeweiligen Netz erkennt ein Host durch Vergleich der eigenen Adresse mit der Zieladdresse. Im Moment gehen wir noch davon aus, dass die ersten 3 Oktette einer IP-Adresse das Netz identifizieren und liegen in unterschiedlichen Netzen. /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; Daten L2: PCA1 R.eth0 L3: PCA1 PCB2 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; eth eth PCB1 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA R SB PCB2 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 PCB3 1 PCA1 erkennt, dass nicht im eigenen Netz liegt. Sein Default-Gateway ist PCA1 löst die MAC-Adresse zu auf. 3 PCA1 sendet das Datenpaket an R: Dabei adressiert er R mittels der eben bestimmten MAC-Adresse (Schicht 2). Als Ziel-IP (Schicht 3) verwendet er die IP von PCB2. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 28

49 Was ist nun, wenn das Ziel nicht im selben Netz liegt (z. B. PCA1 an PCB2)? Jeder Host sollte einen Default Gateway kennen, an den er alle Pakete schickt, deren Zieladressen nicht im eigenen Netz liegen. Die Zugehörigkeit einer Adresse zum jeweiligen Netz erkennt ein Host durch Vergleich der eigenen Adresse mit der Zieladdresse. Im Moment gehen wir noch davon aus, dass die ersten 3 Oktette einer IP-Adresse das Netz identifizieren und liegen in unterschiedlichen Netzen. /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; Daten L2: PCA1 R.eth0 L3: PCA1 PCB2 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA1 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; eth eth PCB1 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA2 SA R SB PCB2 ( ) /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; L2: R.eth1 PCB2 L3: PCA1 PCB2 /** * Event loop. Starts the hardware, prepares the listening sockets, and enters * the event loop. Incoming traffic in the WiFi interface is relayed to the * corresponding modules (if connected) and traffic from modules is relayed to * the WiFi interface. */ static int run( int argc, char **argv ) int i; struct working_set ws; struct srvsock srv[2]; fd_set rfds; // Prepare everything init_working_set(&ws); init_hardware(&ws,argv[1],argv[2]); init_listening_sockets(&ws,srv); // Start the event loop _run = 1; LOG( LOG_INFO, "startup complete" ); while( _run == 1 ) rfds = ws.rfdset; if( 0 > select(ws.maxfd+1, &rfds, NULL, NULL, NULL) ) DIE( "select() failed: %s, %d", strerror(errno), errno ); // Look for incoming connections for( i=0; i<2; i++ ) if( FD_ISSET(srv[i].fd, &rfds) ) accept_connection(&ws, &srv[i], &(ws.so[i])); // Loop over sockets and relay traffic for( i=0; i<cnt; i++ ) if( 0 > ws.so[i].fd ) continue; if( FD_ISSET(ws.so[i].fd, &rfds) ) ws.sock_handler[i](ws.so,&(ws.sigmask)); // Handle signals (if any) if( ws.sigmask ) handle_signals(&ws); for( i=0; i<cnt; i++ ) sock_close( &(ws.so[i]) ); return _run; PCA3 PCB3 1 PCA1 erkennt, dass nicht im eigenen Netz liegt. Sein Default-Gateway ist PCA1 löst die MAC-Adresse zu auf. 3 PCA1 sendet das Datenpaket an R: Dabei adressiert er R mittels der eben bestimmten MAC-Adresse (Schicht 2). Als Ziel-IP (Schicht 3) verwendet er die IP von PCB2. 4 R akzeptiert das Paket, bestimmt das ausgehende Interface und leitet das Paket weiter an PCB2. Dabei adressiert R wiederum PCB2 anhand seiner MAC-Adresse (erfordert ggf. einen weiteren ARP-Schritt). IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 28

50 Merke: MAC-Adressen dienen zur Adressierung innerhalb eines (Direktverbindungs-)Netzes und werden beim Routing verändert. IP-Adressen dienen der End-zu-End-Adressierung zwischen mehreren (Direktverbindungs-)Netzen und werden beim Routing nicht verändert. Anmerkungen Das Ergebnis einer Adressauflösung wird i. d. R. im ARP-Cache eines Hosts zwischengespeichert, um nicht bei jedem zu versendenden Paket erneut eine Adressauflösung durchführen zu müssen. Die Einträge im ARP-Cache altern und werden nach einer vom Betriebssystem festgelegten Zeit invalidiert (5-10 Minuten). Den Inhalt des ARP-Caches kann man sich unter Linux, OS X und Windows mittels des Befehls arp -a anzeigen lassen. ARP-Replies können auch als MAC-Broadcast verschickt werden, so dass alle Computer innerhalb einer Broadcast-Domain den Reply erhalten. Abhängig vom Betriebssystem werden derartige unaufgeforderten ARP-Replies (engl. unsolicited ARP reply) häufig auch gecached. Fragen: Was würde passieren, wenn... zwei Computer innerhalb derselben Broadcast-Domain identische MAC-Adressen aber unterschiedliche IP-Adressen haben? ein Computer absichtlich auf ARP-Requests antwortet, die nicht an ihn gerichtet waren? ein Computer unsinnige ARP-Replies via MAC-Broadcasts verschickt? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressauflösung 29

51 Internet Control Message Protocol (ICMP) [5] IP dient der logischen Adressierung von Knoten. Dabei kann es zu Fehlern kommen, z. B. ein Paket wird zu oft weitergeleitet (evtl. durch eine Routing-Schleife), ein Router kennt keinen Weg zum Zielnetz, der letzte Router zum Ziel kann die MAC-Adresse des Empfängers nicht auflösen... Das Internet Control Message Protocol (ICMP) dient dazu, in derartigen Fällen den Absender über das Problem zu benachrichtigen und stellt zusätzlich Möglichkeiten bereit, um z. B. die Erreichbarkeit von Hosts zu prüfen ( Ping ) oder Pakete umzuleiten (Redirect). Bit Offset Version IHL TOS (0x00 für ICMP) Total Length Identification Flags Fragment Offset TTL Protocol (0x0001 für ICMP) Header Checksum Source Address Destination Address Type Code Checksum Typ-abhängiger Anteil des Headers Daten (optional) IP-Header ICMP Abbildung: Allgemeiner ICMP-Header mit vorangestelltem IP-Header IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 30

52 ICMP Echo Request / Echo Reply Type = 0x08 Code = 0x00 Checksum Type = 0x00 Code = 0x00 Checksum Identifier Sequence Number Identifier Sequence Number Daten (optional) Daten (optional) (a) ICMP Echo Request (b) ICMP Echo Reply PC1 PC2 Ping von PC1 nach PC2: PC1 wählt einen zufälligen Identifier (16 Bit Wert), die Sequenznummer wird für jeden gesendeten Echo-Request um eins inkrementiert. Der Echo Request wird von Routern wie jedes IP-Paket weitergeleitet. Erhält PC2 den Echo Request, so antwortet er mit einem Echo Reply. Dabei werden Identifier, Sequenznummer und Daten aus dem Request kopiert und zurückgeschickt. Sollte die Weiterleitung zu PC2 fehlschlagen, so wird eine ICMP-Nachricht mit dem entsprechenden Fehlercode an PC1 zurückgeschickt. Frage: Wozu dient der Identifier? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 31

53 ICMP Time Exceeded Type = 0x0b Code = 0x00,0x01 Checksum unused IP-Header + die ersten 8 Byte des Pakets, das verworfen wurde PC1 PC2 Der IP-Header besitzt ein TTL-Feld, welches bei der Weiterleitung eines Pakets durch den jeweiligen Router um eins dekrementiert wird. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 32

54 ICMP Time Exceeded Type = 0x0b Code = 0x00,0x01 Checksum unused IP-Header + die ersten 8 Byte des Pakets, das verworfen wurde PC1 TTL = 4 TTL = 3 TTL = 2 TTL = 1 TTL = 0 PC2 Der IP-Header besitzt ein TTL-Feld, welches bei der Weiterleitung eines Pakets durch den jeweiligen Router um eins dekrementiert wird. Erreicht es den Wert 0, so wird das betreffende Paket verworfen. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 32

55 ICMP Time Exceeded Type = 0x0b Code = 0x00,0x01 Checksum unused IP-Header + die ersten 8 Byte des Pakets, das verworfen wurde PC1 PC2 ICMP Time Exceeded Der IP-Header besitzt ein TTL-Feld, welches bei der Weiterleitung eines Pakets durch den jeweiligen Router um eins dekrementiert wird. Erreicht es den Wert 0, so wird das betreffende Paket verworfen. Der Router generiert ein ICMP Time Exceeded und schickt es an den Absender des verworfenen Pakets zurück. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 32

56 ICMP Time Exceeded Type = 0x0b Code = 0x00,0x01 Checksum unused IP-Header + die ersten 8 Byte des Pakets, das verworfen wurde PC1 PC2 ICMP Time Exceeded Der IP-Header besitzt ein TTL-Feld, welches bei der Weiterleitung eines Pakets durch den jeweiligen Router um eins dekrementiert wird. Erreicht es den Wert 0, so wird das betreffende Paket verworfen. Der Router generiert ein ICMP Time Exceeded und schickt es an den Absender des verworfenen Pakets zurück. Da der Header und die ersten 8 Byte des verworfenen Pakets an den Absender zurückgeschickt werden, kann dieser genau bestimmen, welches Paket verworfen wurde. Frage: Welche Informationen sind in diesen ersten 8 Byte enthalten, wenn das verworfene Paket ein ICMP Echo Request war? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 32

57 ICMP Traceroute PC1 PC2 Obwohl Pakete zwischen PC1 und PC2 (in Hin- und Rückrichtung) jeweils unterschiedliche Wege nehmen können, werden in der Praxis meist nur einer oder sehr wenige genutzt. Welchen Pfad nehmen Pakete von PC1 nach PC2? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 33

58 ICMP Traceroute L3: PC1 PC2 TTL = 1,2,... PC1 PC2 ICMP Time Exceeded Obwohl Pakete zwischen PC1 und PC2 (in Hin- und Rückrichtung) jeweils unterschiedliche Wege nehmen können, werden in der Praxis meist nur einer oder sehr wenige genutzt. Welchen Pfad nehmen Pakete von PC1 nach PC2? Traceroute: PC1 sendet z. B. ICMP Echo Requests an PC2 wobei das TTL-Feld zu Beginn auf 1 gesetzt wird und danach schrittweise um jeweils 1 erhöht wird. Router entlang des Pfads von PC1 nach PC2 werden schrittweise die Pakete verwerfen und jeweils ein TTL Exceeded an PC1 zurücksenden. Anhand der IP-Quelladresse dieser Fehlernachrichten kann PC1 den Pfad hin zu PC2 nachvollziehen. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 33

59 ICMP Traceroute L3: PC1 PC2 TTL = 1,2,... PC1 PC2 ICMP Time Exceeded Obwohl Pakete zwischen PC1 und PC2 (in Hin- und Rückrichtung) jeweils unterschiedliche Wege nehmen können, werden in der Praxis meist nur einer oder sehr wenige genutzt. Welchen Pfad nehmen Pakete von PC1 nach PC2? Traceroute: PC1 sendet z. B. ICMP Echo Requests an PC2 wobei das TTL-Feld zu Beginn auf 1 gesetzt wird und danach schrittweise um jeweils 1 erhöht wird. Router entlang des Pfads von PC1 nach PC2 werden schrittweise die Pakete verwerfen und jeweils ein TTL Exceeded an PC1 zurücksenden. Anhand der IP-Quelladresse dieser Fehlernachrichten kann PC1 den Pfad hin zu PC2 nachvollziehen. 2. Programmieraufgabe: Implementiere Traceroute IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 33

60 Beispiel: slacky: moepi$ traceroute -n traceroute to ( ), 64 hops max, 52 byte packets ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms ms * Fragen / Probleme: Ein Router hat mehrere IP-Adressen. Welche wählt er als Absender-Adresse der Fehlerbenachrichtigungen? Wählt er immer dieselbe Adresse? Was ist, wenn es tatsächlich mehrere gleichzeitig genutzte Pfade oder Pfadabschnitte gibt? Müssen Router überhaupt Fehlerbenachrichtigungen versenden? Angenommen der Pfade von A B ist symmetrisch. Warum werden sich die Ausgaben von Traceroute dennoch unterscheiden? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Internet Control Message Protocol (ICMP) 34

61 Dynamic Host Configuration Protocol (DHCP) [5] Woher bekommen Computer eigentlich ihre IP-Adresse? Statische Konfiguration von Hand Dynamisch von einem DHCP-Server zugewiesene IP-Adresse Ablauf: 1 Client sendet DHCP-Discover (Layer 2 Broadcast) Client Server Client DHCP-Discover DHCP-Discover Server IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Dynamic Host Configuration Protocol (DHCP) 35

62 Dynamic Host Configuration Protocol (DHCP) [5] Woher bekommen Computer eigentlich ihre IP-Adresse? Statische Konfiguration von Hand Dynamisch von einem DHCP-Server zugewiesene IP-Adresse Ablauf: 1 Client sendet DHCP-Discover (Layer 2 Broadcast) 2 DHCP-Server antwortet mit DHCP-Offer, wodurch er dem Client eine IP-Adresse anbietet Client Server Client DHCP-Offer DHCP-Discover DHCP-Offer Server IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Dynamic Host Configuration Protocol (DHCP) 35

63 Dynamic Host Configuration Protocol (DHCP) [5] Woher bekommen Computer eigentlich ihre IP-Adresse? Statische Konfiguration von Hand Dynamisch von einem DHCP-Server zugewiesene IP-Adresse Ablauf: 1 Client sendet DHCP-Discover (Layer 2 Broadcast) 2 DHCP-Server antwortet mit DHCP-Offer, wodurch er dem Client eine IP-Adresse anbietet 3 Client antwortet mit DHCP-Request, wodurch er die angebotene Adresse anfordert Client Server Client DHCP-Request DHCP-Discover DHCP-Offer DHCP-Request Server IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Dynamic Host Configuration Protocol (DHCP) 35

64 Dynamic Host Configuration Protocol (DHCP) [5] Woher bekommen Computer eigentlich ihre IP-Adresse? Statische Konfiguration von Hand Dynamisch von einem DHCP-Server zugewiesene IP-Adresse Ablauf: 1 Client sendet DHCP-Discover (Layer 2 Broadcast) 2 DHCP-Server antwortet mit DHCP-Offer, wodurch er dem Client eine IP-Adresse anbietet 3 Client antwortet mit DHCP-Request, wodurch er die angebotene Adresse anfordert 4 DHCP-Server antwortet mit DHCP-ACK, wodurch er die angeforderte Adresse zur Nutzung freigibt, oder mit DHCP-NACK, wodurch er die Nutzung der Adresse untersagt Client Server Client DHCP-ACK/NACK Server DHCP-Discover DHCP-Offer DHCP-Request DHCP-ACK/NACK IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Dynamic Host Configuration Protocol (DHCP) 35

65 Anmerkungen Die vom DHCP-Server zugewiesene Adresse wird auch als Lease bezeichnet und ist in ihrer Gültigkeit zeitlich begrenzt Clients erneuern ihr Lease in regelmäßigen Abständen beim DCHP-Server. Gerade in kleineren (privaten) Netzwerken übernimmt häufig ein Router die Rolle des DHCP-Servers. Zusammen mit der IP-Adresse und Subnetzmaske können DHCP-Server viele weitere Optionen ausliefern: DNS-Server zur Namensauflösung ( Kapitel 6) Hostname und Domänen-Suffix ( Kapitel 6) Statische Routen, insbesondere einen Default-Gateway Maximum Transmission Unit NTP-Server zur Zeitsynchronisation... Aus Redundanzgründen werden manchmal mehrere DHCP-Server pro Netzwerk verwendet, wobei sich die Adressbereiche der beiden Server nicht überschneiden dürfen oder zusätzliche Mechanismen zur Synchronisation der Adresspools notwendig sind. Ein versehentlich ins Netzwerk eingebrachter DHCP-Server (z. B. durch einen achtlos angeschlossenen Router oder Access Point) kann beträchtliche Auswirkungen auf das Netzwerk haben und ist häufig schwer zu finden: Im Netz eines Lehrstuhls gab es einst einen solchen Rogue-DHCP-Server, der trotz intensiver Suche nicht gefunden werden konnte. Über die MAC-Adressen der vom Server stammdenden DHCP-Nachrichten stellte sich am Ende heraus, dass es sich um ein Nokia-Smartphone im WLAN handelte! Die Anzahl der Verdächtigen hatte sich damit stark eingeschränkt (; IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Dynamic Host Configuration Protocol (DHCP) 36

66 Adressklassen (Classful Routing) Zu Beginn des Kapitels hatten wir in einem Beispiel beschrieben, dass die ersten drei Oktette einer IP-Adresse das Netz identifizieren und das vierte Oktett Hosts innerhalb eines Netzes adressiert. Diese Aufteilung war lediglich ein Beispiel, entsprechend der Adress-Klasse C. Historisch ist der IP-Adresseraum in folgende fünf Klassen unterteilt: Klasse 1. Oktett Erste Adresse Letzte Adresse Netz-/Hostanteil Anzahl Netze Adressen pro Netz A 0xxxxxxx N.H.H.H 2 7 = = B 10xxxxxx N.N.H.H 2 14 = = C 110xxxxx N.N.N.H 2 21 = = 256 D 1110xxxx Reserviert für Multicast E 1111xxxx Reserviert Grafische Darstellung: IP-Adressraum als Quadrat Farbige Flächen markieren die fünf Adressklassen Die einzelnen Klasse-A-Netze sind als Drahtgitter angedeutet Nächste Folie zeigt die tatsächliche Verteilung und Ausnutzung des Adressraums [1] (selbe Farbkodierung). A D E C B IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressklassen (Classful Routing) 37

67

68

69 Verschwendung des Adressraums Als IPv eingeführt wurde, konnte man sich nicht vorstellen, dass ~2 32 Adressen aufgeteilt in die Klassen A, B und C nicht ausreichend würden. Es wurden große Adresseblöcke an Firmen, Behörden und Bildungseinrichungen vergeben, z. B. ganze Klasse-A Netze an HP, IBM, AT&T, Apple, MIT, Generel Electric, US Army,... Folge: Ineffiziente Aufteilung und Nutzung des Adressraums Große Netze mit internen Routern weitere Unterteilung in Subnetze notwendig Situation heute: Vergabe des letzten IPv4 Adressblocks am durch die IANA 1 an eine der fünf Regional Internet Registries (RIRs), das APNIC 2 IPv4-Adressraum praktisch aufgebraucht Langsame Einführung von IPv6 Am 6. Juni 2012 ist wieder World IPv6 Day ( 1 Internet Assigned Numbers Authority 2 Asia-Pacific Network Information Center (APNIC) IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Adressklassen (Classful Routing) 40

70 Subnetting (Classless Routing) Bereits 1993 wurde mit CIDR 3 ein Verfahren zur Unterteilung von IP-Netzen eingeführt: Zusätzlich zur IP-Adresse erhält ein Interface eine ebenfalls 32 Bit lange Subnetzmaske Die Subnetzmaske unterteilt die IP-Adresse in einen Netzanteil und einen Hostanteil Eine logische 1 in der Subnetzmaske bedeutet Netzanteil, eine logische 0 Hostanteil UND-Verknüpfung von IP-Adresse und Subnetzmaske ergibt die Netzadresse Die übliche Klassenzugehörigkeit hat damit nur noch im Sprachgebrauch eine Bedeutung Beispiel 1: IP-Adresse Subnetz Maske Netz Host 24 Bit Netzanteil, 8 Bit Hostanteil 2 8 = 256 Adressen Netzadresse: Broadcastadresse: Nutzbare Adressen für Hosts: = Classless Inter-Domain Routing IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 41

71 Subnetting (Classless Routing) Bereits 1993 wurde mit CIDR 3 ein Verfahren zur Unterteilung von IP-Netzen eingeführt: Zusätzlich zur IP-Adresse erhält ein Interface eine ebenfalls 32 Bit lange Subnetzmaske Die Subnetzmaske unterteilt die IP-Adresse in einen Netzanteil und einen Hostanteil Eine logische 1 in der Subnetzmaske bedeutet Netzanteil, eine logische 0 Hostanteil UND-Verknüpfung von IP-Adresse und Subnetzmaske ergibt die Netzadresse Die übliche Klassenzugehörigkeit hat damit nur noch im Sprachgebrauch eine Bedeutung Beispiel 2: IP-Adresse Subnetz Maske Netz Host 25 Bit Netzanteil, 7 Bit Hostanteil 2 7 = 128 Adressen Netzadresse: Broadcastadresse: Nutzbare Adressen für Hosts: = Classless Inter-Domain Routing IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 41

72 Subnetting (Classless Routing) Bereits 1993 wurde mit CIDR 3 ein Verfahren zur Unterteilung von IP-Netzen eingeführt: Zusätzlich zur IP-Adresse erhält ein Interface eine ebenfalls 32 Bit lange Subnetzmaske Die Subnetzmaske unterteilt die IP-Adresse in einen Netzanteil und einen Hostanteil Eine logische 1 in der Subnetzmaske bedeutet Netzanteil, eine logische 0 Hostanteil UND-Verknüpfung von IP-Adresse und Subnetzmaske ergibt die Netzadresse Die übliche Klassenzugehörigkeit hat damit nur noch im Sprachgebrauch eine Bedeutung Beispiel 3: IP-Adresse Subnetz Maske Netz Host 26 Bit Netzanteil, 6 Bit Hostanteil 2 6 = 64 Adressen Netzadresse: Broadcastadresse: Nutzbare Adressen für Hosts: = 62 3 Classless Inter-Domain Routing IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 41

73 Supernetting Dasselbe Prinzip funktioniert auch in die andere Richtung: Beispiel: Zusammenfassung mehrerer zusammenhängender kleinerer Netze zu einem größeren Netz Wird häufig von Routern angewendet, um die Anzahl der Einträge in der Routingtabelle zu reduzieren IP-Adresse Subnetz Maske Netz Host 23 Bit Netzanteil, 9 Bit Hostanteil 2 9 = 512 Adressen Netzadresse: Broadcastadresse: Nutzbare Adressen für Hosts: = 510 Präfixschreibweise: Anstelle die Subnetzmaske auszuschreiben, wird häufig nur die Länge des Netzanteils (Anzahl führender Einsen in der Subnetzmaske) angegeben, z. B /23. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 42

74 Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 43

75 Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn es gibt keine passende Subnetzmaske: /23 enthält die Netze ,1.0/ /23 enthält die Netze ,3.0/ /23 ist keine gültige Netzadresse, denn UND-Verknüpfung der Adresse mit der Subnetzmaske ergibt als Netzadresse! ist eine Hostadresse im Netz /23. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 43

76 Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn es gibt keine passende Subnetzmaske: /23 enthält die Netze ,1.0/ /23 enthält die Netze ,3.0/ /23 ist keine gültige Netzadresse, denn UND-Verknüpfung der Adresse mit der Subnetzmaske ergibt als Netzadresse! ist eine Hostadresse im Netz /23. Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 43

77 Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn es gibt keine passende Subnetzmaske: /23 enthält die Netze ,1.0/ /23 enthält die Netze ,3.0/ /23 ist keine gültige Netzadresse, denn UND-Verknüpfung der Adresse mit der Subnetzmaske ergibt als Netzadresse! ist eine Hostadresse im Netz /23. Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn die beiden Netze sind nicht benachbart: Das Netz /22 würde zwar beide Subnetze enthalten, zusätzlich aber auch die beiden Netze ,3.0/24. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 43

78 Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn es gibt keine passende Subnetzmaske: /23 enthält die Netze ,1.0/ /23 enthält die Netze ,3.0/ /23 ist keine gültige Netzadresse, denn UND-Verknüpfung der Adresse mit der Subnetzmaske ergibt als Netzadresse! ist eine Hostadresse im Netz /23. Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn die beiden Netze sind nicht benachbart: Das Netz /22 würde zwar beide Subnetze enthalten, zusätzlich aber auch die beiden Netze ,3.0/24. Frage: Können die vier Netze ,5,6,7.0/24 zu einem größeren Netz zusammengefasst werden? IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 43

79 Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn es gibt keine passende Subnetzmaske: /23 enthält die Netze ,1.0/ /23 enthält die Netze ,3.0/ /23 ist keine gültige Netzadresse, denn UND-Verknüpfung der Adresse mit der Subnetzmaske ergibt als Netzadresse! ist eine Hostadresse im Netz /23. Frage: Können die beiden Netze /24 und /24 zu einem größeren Netz zusammengefasst werden? Antwort: Nein, denn die beiden Netze sind nicht benachbart: Das Netz /22 würde zwar beide Subnetze enthalten, zusätzlich aber auch die beiden Netze ,3.0/24. Frage: Können die vier Netze ,5,6,7.0/24 zu einem größeren Netz zusammengefasst werden? Antwort: Ja, das Netz /22 umfasst genau diese vier Netze. IN0010, SoSe 2012, Kapitel 3: Adressierung im Internet Subnetting (Classless Routing) 43

80 Übersicht 1 Motivation 2 Vermittlungsarten 3 Adressierung im Internet 4 Wegwahl (Routing) 5 Nachfolge von IP(v4): IPv6 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) 44

81 Statisches Routing Wir betrachten im Folgenden das unten abgebildete Beispielnetzwerk: R2 eth1: /24 eth2: / / /24 eth0: /29 Internet eth1: /24 eth0: /29 R3 eth1: /29 eth0: /24 eth2: /30 eth0: /30 PC R1 R4 Die Farben der Links und Interface-Adressen verdeutlichen die einzelnen Subnetze Das Netzwerk /29 (rot) verfügt über 6 nutzbare Hostadressen Das Netzwerk /30 (grün) ist ein Transportnetz mit nur 2 nutzbaren Hostadressen Die übrigen Netze sind /24 Netze mit jeweils 254 nutzbaren Hostadressen Frage: Wie entscheidet R1, an welchen Next-Hop ein Paket weitergeleitet werden soll? IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) 45

82 Routing Table R2 eth1: /24 eth2: / / /24 eth0: /29 Internet eth1: /24 eth0: /29 R3 eth1: /29 eth0: /24 eth2: /30 eth0: /30 PC R1 R4 Definition: Routing Table In der Routing-Tabelle speichert ein Router (oder Host) die Netzadresse eines Ziels, die zugehörige Subnetzemaske (oder das Präfix), den zugehörigen Next-Hop (auch Gateway genannt), das Interface, über welches dieser Next-Hop erreichbar ist, und die Kosten bzw. die Metrik bis zum Ziel. IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 46

83 Routing Table R2 eth1: /24 eth2: / / /24 eth0: /29 Internet eth1: /24 eth0: /29 R3 eth1: /29 eth0: /24 eth2: /30 eth0: /30 PC R1 R4 Beispiel: Routing-Tabelle für R1 Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 Die Netze /24 wurden zusammengefasst Die Route wird auch als Default Route bezeichnet Interessant: R1 kennt zwei (eigentlich sogar drei) Routen zum Netz /24! IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 46

84 Longest Prefix Matching 1 R1 berechnet das logische UND aus der Zieladresse des Pakets und den Masken ( Genmasks ) in seiner Routingtabelle 2 Das Ergebnis wird mit dem Eintrag in der Spalte Destination verglichen 3 Stimmt das Ergebnis damit überein, werden Gateway und zugehöriges Interface bestimmt 4 Nachdem Die MAC-Adresse des Gateways ggf. via ARP aufgelöst wurde, wird das Paket mit einem neuen Ethernet Header versehen und weitergeleitet Beispiel: R1 erhalte ein Paket mit Zieladresse Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 47

85 Longest Prefix Matching 1 R1 berechnet das logische UND aus der Zieladresse des Pakets und den Masken ( Genmasks ) in seiner Routingtabelle 2 Das Ergebnis wird mit dem Eintrag in der Spalte Destination verglichen 3 Stimmt das Ergebnis damit überein, werden Gateway und zugehöriges Interface bestimmt 4 Nachdem Die MAC-Adresse des Gateways ggf. via ARP aufgelöst wurde, wird das Paket mit einem neuen Ethernet Header versehen und weitergeleitet Beispiel: R1 erhalte ein Paket mit Zieladresse Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 IP-Adresse Subnetz Maske Netzadresse kein Match, da IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 47

86 Longest Prefix Matching 1 R1 berechnet das logische UND aus der Zieladresse des Pakets und den Masken ( Genmasks ) in seiner Routingtabelle 2 Das Ergebnis wird mit dem Eintrag in der Spalte Destination verglichen 3 Stimmt das Ergebnis damit überein, werden Gateway und zugehöriges Interface bestimmt 4 Nachdem Die MAC-Adresse des Gateways ggf. via ARP aufgelöst wurde, wird das Paket mit einem neuen Ethernet Header versehen und weitergeleitet Beispiel: R1 erhalte ein Paket mit Zieladresse Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 IP-Adresse Subnetz Maske Netzadresse kein Match, da IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 47

87 Longest Prefix Matching 1 R1 berechnet das logische UND aus der Zieladresse des Pakets und den Masken ( Genmasks ) in seiner Routingtabelle 2 Das Ergebnis wird mit dem Eintrag in der Spalte Destination verglichen 3 Stimmt das Ergebnis damit überein, werden Gateway und zugehöriges Interface bestimmt 4 Nachdem Die MAC-Adresse des Gateways ggf. via ARP aufgelöst wurde, wird das Paket mit einem neuen Ethernet Header versehen und weitergeleitet Beispiel: R1 erhalte ein Paket mit Zieladresse Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 IP-Adresse Subnetz Maske Netzadresse kein Match, da IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 47

88 Longest Prefix Matching 1 R1 berechnet das logische UND aus der Zieladresse des Pakets und den Masken ( Genmasks ) in seiner Routingtabelle 2 Das Ergebnis wird mit dem Eintrag in der Spalte Destination verglichen 3 Stimmt das Ergebnis damit überein, werden Gateway und zugehöriges Interface bestimmt 4 Nachdem Die MAC-Adresse des Gateways ggf. via ARP aufgelöst wurde, wird das Paket mit einem neuen Ethernet Header versehen und weitergeleitet Beispiel: R1 erhalte ein Paket mit Zieladresse Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 IP-Adresse Subnetz Maske Netzadresse Match, da = Gateway ist IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 47

89 Definition: Longest Prefix Matching Die Routingtabelle wird von längeren Präfixen (spezifischeren Routen) hin zu kürzeren Präfixen (weniger spezifische Routen) durchsucht. Der erste passende Eintrag liefert das Gateway (Next-Hop) eines Pakets. Diesen Prozess bezeichnet man als Longest Prefix Matching. Beachte: Destination Mask Gateway Metric Iface eth eth eth eth eth eth2 Der Eintrag für /23 liefert ebenfalls einen Match, ist aber weniger spzifisch als der für /24 (1 Bit kürzeres Präfix). Die Default Route liefert immer einen Match (logisches UND mit der Maske ). Es ist nicht garantiert, dass das Gateway der Default Route ( Gateway of last resort ) eine Route zum Ziel kennt ( ICMP Destination Unreachable / Host Unreachable). Routen zu direkt verbundenen Netzen (also solchen, zu denen ein Router selbst gehört) können automatisch erzeugt werden. Das Gateway ist in diesem Fall der Router selbst (bzw. eine seiner IP-Adressen). Routen zu entfernten Netzen müssen gelernt werden entweder durch händisches Eintragen (statisches Routing) oder durch Routing Protokolle (dynamisches Routing). IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Routing Table und Longest Prefix Matching 48

90 Dynamisches Routing Mittels Routing Protokollen können Router miteinander kommunizieren und Routen untereinander austauschen. Routingprotokolle können nach Ihrer Funktionsweise wie folgt gruppiert werden: Distanz-Vektor-Protokolle Router kennen nur Richtung (Next Hop) und Entfernung (Kosten) zu einem Ziel (vgl. Straßenschild mit Richtungs- und Entfernungsangabe) Router haben keine Information über die Netzwerktopologie Router tauschen untereinander lediglich kummulierte Metriken aus (z. B. den Inhalt Ihrer Routingtabellen) Funktionsprinzip basiert auf dem Algorithmus von Bellman-Ford Link-State-Protokolle Router informieren einander detailliert über den aktuellen Zustand einzelner Links Router verfügen über vollständige Topologieinformationen Häufig komplexe Nachbarschaftsbeziehungen und Update-Nachrichten Basierend auf den Topologieinformationen bestimmt jeder Router kürzeste Pfade, z. B. mittels Dijkstras Algorithmus IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 49

91 Algorithmus von Bellman-Ford p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 50

92 Algorithmus von Bellman-Ford p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i // Initialisierung for i N do p[i] = 1 0 i = s d[i] = sonst end for T = s // Menge der erreichbaren Knoten 4 ( 1, 0) ( 1, ) 3 2 ( 1, ) ( 1, ) ( 1, ) 5 ( 1, ) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 50

93 Algorithmus von Bellman-Ford p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i // Initialisierung for i N do p[i] = 1 0 i = s d[i] = sonst end for T = s // Menge der erreichbaren Knoten // Berechnung der Pfade while d[j] changes for some j N do S = // Aktualisierte Knoten for i T do // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then p[j] = i d[j] = d[i] + c ij S = S j end if end for end for T = T S end while ( 1, 0) (1, 4) (1, 3) 1 6 ( 1, ) 2 (1, 1) 4 5 ( 1, ) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 50

94 Algorithmus von Bellman-Ford p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i // Initialisierung for i N do p[i] = 1 0 i = s d[i] = sonst end for T = s // Menge der erreichbaren Knoten 4 ( 1, 0) 1 1 // Berechnung der Pfade while d[j] changes for some j N do S = // Aktualisierte Knoten for i T do // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then p[j] = i d[j] = d[i] + c ij S = S j end if end for end for T = T S end while 3 (1, 4) (3, 8) (2, 2) 1 2 (1, 1) 4 5 (2, 5) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 50

95 Algorithmus von Bellman-Ford p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i // Initialisierung for i N do p[i] = 1 0 i = s d[i] = sonst end for T = s // Menge der erreichbaren Knoten 4 ( 1, 0) 1 1 // Berechnung der Pfade while d[j] changes for some j N do S = // Aktualisierte Knoten for i T do // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then p[j] = i d[j] = d[i] + c ij S = S j end if end for end for T = T S end while 3 (1, 4) (3, 8) (2, 2) 1 2 (1, 1) 4 5 (4, 3) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 50

96 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

97 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 ( 1, ) ( 1, ) ( 1, ) ( 1, ) 5 ( 1, ) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

98 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 (1, 4) (1, 1) // Berechnung der Pfade while T N do i = Q.dequeue() T = T i // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then Q.decreaseKey(j, d[i] + c ij ) p[j] = i end if end for end while ( 1, ) 4 (1, 3) ( 1, ) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

99 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 (1, 4) (1, 1) // Berechnung der Pfade while T N do i = Q.dequeue() T = T i // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then Q.decreaseKey(j, d[i] + c ij ) p[j] = i end if end for end while ( 1, ) 4 (2, 2) (2, 5) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

100 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 (1, 4) (1, 1) // Berechnung der Pfade while T N do i = Q.dequeue() T = T i // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then Q.decreaseKey(j, d[i] + c ij ) p[j] = i end if end for end while ( 1, ) 4 (2, 2) (4, 3) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

101 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 (1, 4) (1, 1) // Berechnung der Pfade while T N do i = Q.dequeue() T = T i // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then Q.decreaseKey(j, d[i] + c ij ) p[j] = i end if end for end while ( 1, ) 4 (2, 2) (4, 3) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

102 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 (1, 4) (1, 1) // Berechnung der Pfade while T N do i = Q.dequeue() T = T i // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then Q.decreaseKey(j, d[i] + c ij ) p[j] = i end if end for end while (3, 8) 4 (2, 2) (4, 3) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

103 Dijkstras Algorithmus p[i]: Vorgänger von Knoten i im Graphen d[i]: Distanz von der Wurzel zu Knoten i Priority Queue Q, welche Elemente nach Schlüsseln sortiert ausgibt ( 1, 0) for i N do p[i] = 1 0 i = s d[i] = sonst Q.enqeue(i, d[i]) end for T = // Menge der bearbeiteter Knoten 4 3 (1, 4) (1, 1) // Berechnung der Pfade while T N do i = Q.dequeue() T = T i // Für alle Nachbarn von i: for j : (i, j) E do if d[i] + c ij < d[j] then Q.decreaseKey(j, d[i] + c ij ) p[j] = i end if end for end while (3, 8) 4 (2, 2) (4, 3) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 51

104 Eigenschaften des Algorithmus von Bellman-Ford: Im n-ten Durchlauf der while-schleife werden alle Pfade der Länge höchstens n berücksichtigt (vergleiche min-plus-produkt in n-ter Potenz) Keine komplexen Datenstrukturen notwendig Verteilte (dezentrale) Implementierung ohne Kenntnis der Topologie möglich (Beispiel) Eigenschaften des Algorithmus von Dijkstra: Es werden immer Pfade über den im jeweiligen Schritt am günstigsten erreichbaren Knoten gesucht (Greedy-Prinzip) Wurde ein Knoten abgearbeitet, so ist garantiert, dass der kürzeste Pfad zu diesem Knoten gefunden ist Resourcenintensiver als der Algorithmus von Bellman-Ford, da komplexere Datenstrukturen notwendig (aber asymptotisch bessere Laufzeit) Vollständige Kenntnis der Netzwerktopologie erforderlich IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 52

105 Routing Information Protocol (RIP) Einfach Distanz-Vektor-Protokoll RIPv1 standardisiert in RFC 1058 (1988) Unterstützung für CIDR in RIPv2 hinzugefügt (RFC 2453, 1998) Einzige Metrik: Hop Count Hop Count Limit von 15, weiter entfernte Ziele sind nicht erreichbar Funktionsweise: Router senden in regelmäßigen Abständen (Standardwert 30 s) den Inhalt ihrer Routingtabelle an die Multicast-Adresse Jeder RIP-Router akzeptiert diese Update-Nachrichten, inkrementiert die Metrik der enthaltenen Routen um 1 und vergleicht die Routen mit bereits vorhandenen Routen aus seiner Routingtabelle: Enthält das Update eine noch unbekannte Route, wird diese in die eigene Routingtabelle übernommen Enthält das Update eine Route zu einem bekannten Ziel aber mit niedrigeren Kosten, so wird die vorhandene Route durch das Update ersetzt Andernfalls wird die vorhandene Route beibehalten Bleiben fünf aufeinanderfolgende Updates von einem Nachbarn aus, so werden alle Routen über diesen Next Hop aus der Routingtabelle entfernt. 4 Multicast wird im Rahmen der Vorlesung nicht näher behandelt. Stellen Sie sich die Funktionsweise hier wie einen Broadcast im lokalen Subnetz vor. IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 53

106 Beispiel mit vereinfachter Darstellung: Zwischen jeweils zwei Routern befindet sich sinnvollerweise ein Switch, welcher den Anschluss weiterer Computer an das jeweilige Subnetz ermöglicht Anstelle von IP- und Netzadressen tragen wir in die Routingtabellen lediglich die Namen der Router ein Für direkt erreichbare Nachbarn tragen wir kein Gateway ein Update-Nachrichten werden rundenweise verschickt (erst A, dann B,... ) D Dst GW Cost A - 0 C - 0 A B C Dst GW Cost A - 0 C - 0 Dst GW Cost B - 0 D - 0 Dst GW Cost B - 0 D - 0 E - 0 E Dst GW Cost C - 0 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 54

107 Beispiel mit vereinfachter Darstellung: Zwischen jeweils zwei Routern befindet sich sinnvollerweise ein Switch, welcher den Anschluss weiterer Computer an das jeweilige Subnetz ermöglicht Anstelle von IP- und Netzadressen tragen wir in die Routingtabellen lediglich die Namen der Router ein Für direkt erreichbare Nachbarn tragen wir kein Gateway ein Update-Nachrichten werden rundenweise verschickt (erst A, dann B,... ) D Dst GW Cost A - 0 C - 0 A B C Dst GW Cost A - 0 C - 0 Dst GW Cost B - 0 D - 0 Dst GW Cost B - 0 D - 0 E - 0 E Dst GW Cost C - 0 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 54

108 Beispiel mit vereinfachter Darstellung: Zwischen jeweils zwei Routern befindet sich sinnvollerweise ein Switch, welcher den Anschluss weiterer Computer an das jeweilige Subnetz ermöglicht Anstelle von IP- und Netzadressen tragen wir in die Routingtabellen lediglich die Namen der Router ein Für direkt erreichbare Nachbarn tragen wir kein Gateway ein Update-Nachrichten werden rundenweise verschickt (erst A, dann B,... ) D Dst GW Cost A - 0 C - 0 A B C Dst GW Cost A - 0 C - 0 Dst GW Cost B - 0 D - 0 C B 1 Dst GW Cost B - 0 D - 0 E - 0 A B 1 E Dst GW Cost C - 0 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 54

109 Beispiel mit vereinfachter Darstellung: Zwischen jeweils zwei Routern befindet sich sinnvollerweise ein Switch, welcher den Anschluss weiterer Computer an das jeweilige Subnetz ermöglicht Anstelle von IP- und Netzadressen tragen wir in die Routingtabellen lediglich die Namen der Router ein Für direkt erreichbare Nachbarn tragen wir kein Gateway ein Update-Nachrichten werden rundenweise verschickt (erst A, dann B,... ) D Dst GW Cost A - 0 C - 0 B C 1 E C 1 A B C Dst GW Cost A - 0 C - 0 D C 1 E C 1 Dst GW Cost B - 0 D - 0 C B 1 Dst GW Cost B - 0 D - 0 E - 0 A B 1 E Dst GW Cost C - 0 B C 1 D C 1 A C 2 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 54

110 Beispiel mit vereinfachter Darstellung: Zwischen jeweils zwei Routern befindet sich sinnvollerweise ein Switch, welcher den Anschluss weiterer Computer an das jeweilige Subnetz ermöglicht Anstelle von IP- und Netzadressen tragen wir in die Routingtabellen lediglich die Namen der Router ein Für direkt erreichbare Nachbarn tragen wir kein Gateway ein Update-Nachrichten werden rundenweise verschickt (erst A, dann B,... ) D Dst GW Cost A - 0 C - 0 B C 1 E C 1 A B C Dst GW Cost A - 0 C - 0 D C 1 E C 1 Dst GW Cost B - 0 D - 0 C B 1 E D 2 Dst GW Cost B - 0 D - 0 E - 0 A B 1 E Dst GW Cost C - 0 B C 1 D C 1 A C 2 IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 54

111 Beispiel mit vereinfachter Darstellung: Zwischen jeweils zwei Routern befindet sich sinnvollerweise ein Switch, welcher den Anschluss weiterer Computer an das jeweilige Subnetz ermöglicht Anstelle von IP- und Netzadressen tragen wir in die Routingtabellen lediglich die Namen der Router ein Für direkt erreichbare Nachbarn tragen wir kein Gateway ein Update-Nachrichten werden rundenweise verschickt (erst A, dann B,... ) D Dst GW Cost A - 0 C - 0 B C 1 E C 1 A B C Dst GW Cost A - 0 C - 0 D C 1 E C 1 Dst GW Cost B - 0 D - 0 C B 1 E D 2 Dst GW Cost B - 0 D - 0 E - 0 A B 1 E Dst GW Cost C - 0 B C 1 D C 1 A C 2 Nach diesem Schritt kennt jeder Router eine kürzeste Route zu jedem anderen Router Da mehrere gleich lange Pfade existieren, bleibt es dem Zufall (der Reihenfolge der Updatenachrichten) überlassen, ob beispielsweise Router A als Next Hop zu E Router D oder B lernt IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 54

112 Das vorangegangene Beispiel lässt sich leicht auf gewichtete Kanten erweitern: Metrik ist nicht mehr die Anzahl der Hops zum Ziel, sondern das Kantegewicht Router addieren auf erhaltene Updates das Kantengewicht des Links, über den das Update empfangen wurde Tutorübungen Problem: Bis jeder Router den besten Next Hop bestimmen kann, dauert es ggf. mehrere Runden Eine obere Schranke für die Anzahl der notwendigen Nachrichten, die jeder Router senden muss, ist die maximale Entfernung zwischen zwei Routern in Hops Die maximale Entfernung beträgt bei RIP 15 Hops Da Updates nur alle 30 s verschickt werden, ergibt sich eine maximale Verzögerung von s = 7.5 min IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 55

113 Das vorangegangene Beispiel lässt sich leicht auf gewichtete Kanten erweitern: Metrik ist nicht mehr die Anzahl der Hops zum Ziel, sondern das Kantegewicht Router addieren auf erhaltene Updates das Kantengewicht des Links, über den das Update empfangen wurde Tutorübungen Problem: Bis jeder Router den besten Next Hop bestimmen kann, dauert es ggf. mehrere Runden Eine obere Schranke für die Anzahl der notwendigen Nachrichten, die jeder Router senden muss, ist die maximale Entfernung zwischen zwei Routern in Hops Die maximale Entfernung beträgt bei RIP 15 Hops Da Updates nur alle 30 s verschickt werden, ergibt sich eine maximale Verzögerung von s = 7.5 min Lösung: Triggered Updates Sobald ein Router eine Änderung an seiner Routingtabelle vornimmt, sendet er sofort ein Update Dies führt zu einer Welle von Updates durch das Netzwerk Konvergenzzeit wird reduziert, aber das Netzwerk während der Updates ggf. stark belastet IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 55

114 Anderes Problem: Count to infinity Link zwischen C und E fällt aus Reihenfolge, in der Updates versendet werden, ist dem Zufall überlassen D Dst GW Cost A - 0 C - 0 B C 1 E C 1 A B C Dst GW Cost A - 0 C - 0 D C 1 E C 1 Dst GW Cost B - 0 D - 0 C B 1 E D 2 Dst GW Cost B - 0 D - 0 E - 0 A B 1 X E Dst GW Cost IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 56

115 Anderes Problem: Count to infinity Link zwischen C und E fällt aus Reihenfolge, in der Updates versendet werden, ist dem Zufall überlassen D Dst GW Cost A - 0 C - 0 B C 1 E C 1 A B C Dst GW Cost A - 0 C - 0 D C 1 E C 1 Dst GW Cost B - 0 D - 0 C B 1 E D 2 Dst GW Cost B - 0 D - 0 A B 1 X E Dst GW Cost IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 56

116 Anderes Problem: Count to infinity Link zwischen C und E fällt aus Reihenfolge, in der Updates versendet werden, ist dem Zufall überlassen D Dst GW Cost A - 0 C - 0 B C 1 E A 3 A B C Dst GW Cost A - 0 C - 0 D C 1 E A 3 Dst GW Cost B - 0 D - 0 C B 1 E D 2 Dst GW Cost B - 0 D - 0 A B 1 X E Dst GW Cost IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 56

117 Anderes Problem: Count to infinity Link zwischen C und E fällt aus Reihenfolge, in der Updates versendet werden, ist dem Zufall überlassen D Dst GW Cost A - 0 C - 0 B C 1 E A 3 A B C Dst GW Cost A - 0 C - 0 D C 1 E A 3 Dst GW Cost B - 0 D - 0 C B 1 E D 4 Dst GW Cost B - 0 D - 0 A B 1 E D 4 X E Dst GW Cost Je nach Reihenfolge der Updates wird die fehlerhafte Route zu E weiterverbreitet und die Metrik stets inrementiert bis schließlich das Hop Count Limit von 15 erreicht ist. Diesen Vorgang bezeichnet man als Count to infinity. IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 56

118 Lösungen: Split Horizon Neue Regel: Sende dem Nachbarn, von dem Du die Route zu X gelernt hast, keine Route zu X Im vorherigen Beispiel würde A die Route zu E nicht an D, wohl aber an B schicken Split Horizon verbessert die Situation, kann das Problem aber nicht lösen Poison Reverse Anstelle dem Nachbarn, von dem eine Route zu X gelernt wurde, keine Route zu X mehr zu schicken, wird eine Route mit unendlicher Metrik gesendet Im vorherigen Beispiel würde A die Route zu E an D mit Metrik 15 schicken Die fehlerhafte Route würde nach wie vor B erreichen Auch Poison Reverse kann das Problem nicht vollständig lösen Path Vector Sende bei Updates nicht nur Ziel und Kosten, sondern auch den vollständigen Pfad, über den das Ziel erreicht wird Jeder Router prüft vor Installation der Route, ob er selbst in diesem Pfad bereits vorhanden ist Falls ja, handelt es sich um eine Schleife und das Update wird verworfen Path Vector verhindert Routing Loops und damit auch Count to Infinity, vergrößert jedoch die Updates IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 57

119 Übersicht: Ausgewählte Routing-Protokolle Distanz-Vektor-Protokolle RIP (Routing Information Protocol) Sehr einfaches Protokoll, Hop-Count als einzige Metrik, geeignet für eine geringe Anzahl von Netzen, wird von den meisten Routern unterstützt (sogar einige Heimgeräte). IGRP (Interior Gateway Routing Protocol) Proprietäres Routing Protokoll von Cisco, unterstützt komplexere Metriken als RIP EIGRP (Enhanced Interior Gateway Routing Protocol) Proprietäres Routing Protokoll von Cisco, Nachfolger von IGRP, deutlich verbesserte Konvergenzeigenschaften AODV (Ad hoc On-Demand Distance Vector) Einsatz in kabellosen vermaschten Netzwerken, Routen werden nicht proaktiv ausgetauscht sondern on-demand gesucht (reaktives Protokoll) Link-State-Protokolle OSPF (Open Shortest Path First) Industriestandard für mittlere bis große Anzahl von Netzwerken IS-IS (Intermediate System to Intermediate System) Seltener eingesetztes, leistungsfähiges Routingprotokoll, welches unabhängig von IP ist (es handelt sich um ein ISO-standardisiertes Layer-3-Protokoll) HWMP (Hybrid Wireless Mesh Protocol) Ermöglicht Routing in IEEE s (Wireless Mesh Networks) IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Dynamisches Routing 58

120 Autonome Systeme Alle bislang vorgestellten Routingprotokolle bestimmen beste Pfade anhand objetiver Kriterien (Hopcount, Bandbreite, Delay,... ), bieten aber keine bzw. nur eingeschränkte Möglichkeiten, Routen direkt zu beeinflussen. Manchmal ist es aber wünschenswert, Routen auf Basis anderer Kriterien zu wählen: Tatsächlich anfallende monetäre Kosten Netze / Länder, durch die Datenverkehr zu einem Ziel weitergeleitet wird Infrastrukturentscheidungen (z. B. Belastung einzelner Router) Routingentscheidungen auf Basis derartiger Kriterien bezeichnet man als Policy-Based Routing. Definition: Autonomes System Eine Menge von Netzwerken, die unter einheitlicher administrativer Kontrolle stehen, bezeichnet man als Autonomes System (AS). Ein AS wird i. d. R. durch einen 16 Bit Identifier, der sog. AS-Nummer identifiziert. Beim Einsatz von Routingprotokollen wird unterschieden: Innerhalb eines autonomen Systems werden zum Interor Gateway Protocols (IGPs) wie RIP, OSPF, EIGRP oder IS-IS eingesetzt. Zum Austausch von Routen zwischen Autonomen Systemen wird ein Exterior Gateway Protocol (EGP) verwendet. Das einzige in der Praxis verwendete EGP ist das Border Gateway Protocol (BGP). IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Autonome Systeme 59

121 Internet: Stark vereinfachte schematische Darstellung Tier 1 AS 7018 (AT&T) Peering AS 1239 (Sprint) C2P Tier 2 AS 3209 (Vodafone) AS 5511 (Télécom) AS 1257 (Tele2) AS 7922 (Comcast) Tier 3 Provider des gleichen Tiers peeren miteinander an Internet Exchange Points, z. B. DE-CIX. Nutzung von Peering-Verbindungen ist für die Provider meist kostenfrei. Customer-Provider (C2P) Verbindungen sind für die Customer meist kostenpflichtig. Die Border-Router eines jeden AS announcen den Adressbereich, der über dieses AS erreichbar ist. AS 5511 announced seine eigenen Customer an seine Peerings und Upstream-Provider. AS 5511 würde evtl. die Netze von Vodafone an Tele2 announcen, sicher aber nicht an Sprint oder AT&T. Faustregel: Horizontale Verbindungen (Peerings) kosten nichts, für vertikale Verbindungen muss der jeweilige Customer ( kleinere Provider ) bezahlen. IN0010, SoSe 2012, Kapitel 3: Wegwahl (Routing) Autonome Systeme 60

122 Übersicht 1 Motivation 2 Vermittlungsarten 3 Adressierung im Internet 4 Wegwahl (Routing) 5 Nachfolge von IP(v4): IPv6 IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 61

123 Nachfolge von IP(v4): IPv6 Wir haben bereits gesehen, dass der IPv4 Adressraum aus heutiger Sicht zu knapp bemessen ist und historisch bedingt Fehler bei der Adressvergabe gemacht wurden. Außerdem ist die Verarbeitung des IPv4 Headers unnötig komplex: Header variabler Länge ( Angabe der Header- und Datenlänge) Ungenutzte bzw. im Laufe der Zeit redefinierte Felder (TOS, DSCP, ECN) Fragmentierung und Reassemblierung bedeutet erheblichen Mehraufwand IPv6 begegnet diesen Problemen: 128 Bit Adressraum Adressen Das sind etwa Adressen pro m 2 Erdoberfläche (mit Wasserflächen)! Header fester Länge für schnelle Verarbeitung Erweiterbarkeit durch sog. Extension Headers Keine Fragmentierung von IP-Paketen mehr (Anpassung der MTU beim Sender) Viele neue Features zur automatischen Konfiguration, Adressvergabe, Auffindung lokaler Gateways, etc. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 62

124 Notation IPv6 Adressen werden infolge ihrer Länge kompakt in hexadezimaler Schreibweise in Gruppen zu je 16 Bit getrennt durch : dargestellt. Beispiel: 2001:4ca0:2001:0011:2a37:37ff:fe02:3241 / 64 Wie IPv4-Adressen bestehen IPv4-Adressen aus einem Netz- und Hostanteil variabler Länge Die von IPv4-Adressen bekannte Präfixschreibweise wurde übernommen Abkürzende Schreibweisen: In jedem Block von 16 Bit Länge können führende Nullen weggelassen werden Bestehen einer oder mehrere aufeinanderfolgende Blöcke nur aus Nullen, so können diese durch :: abgekürzt werden: fe80::2a37:37ff:fe02:41 / 64 = fe80:0000:0000:0000:2a37:37ff:fe02:3241 / 64 IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 63

125 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Version Gibt die verwendete IP-Version an. Gültige Werte sind 6 (IPv6) und 4 (IPv4). IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

126 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Traffic Class Äquivalent zum TOS-Feld des IPv4 Headers. Wird zur Verkehrspriorisierung (QoS) eingesetzt. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

127 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Flow Label Ebenfalls zur Verkehrspriorisierung eingesetzt. Ermöglicht es, zu demselben Datenstrom (Flow) gehörende Pakete auf Schicht 3 zu identifizieren und gleich zu behandeln. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

128 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Payload Length Länge der Daten inkl. möglicherweise vorhandener Extension Headers. Angabe in Vielfachen von 1 Byte. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

129 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Next Header Identifiziert den Typ des nächsten Headers. Dieser kann entweder ein Extension Header von IPv6 sein oder der Header der im Paket transportierten Daten (z. B. ICMP-, TCP-, UDP-Header). IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

130 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Hop Limit Entspricht dem TTL-Feld des IPv4-Headers. Wird beim Weiterleiten des Pakets durch einen Router um 1 dekrementiert. Erreicht das Feld den Wert 0, wird das Paket verworfen und ein ICMPv6 Time Exceeded an den Absender zurückgeschickt. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

131 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Source Address 128 Bit (16 Byte) lange Absenderadresse. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

132 IPv6-Header (ohne Extension Headers) Byte Offset Version Traffic Class Flow Label Payload Length Next Header Hop Limit 8 Source Address 24 Destination Address Abbildung: IPv6-Header (minimale Länge: 40 Byte) Destination Address 128 Bit (16 Byte) lange Zieladresse. IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 64

133 Kompatibilität: IPv4 und IPv6 sind nicht kompatibel, können aber nebeneinander existieren Knoten verwenden heute häufig eine IPv4 und IPv6 Adresse Router müssen für beide Protokollversionen Routinginformationen getrennt voneinander austauschen und verarbeiten Stand heute: Obwohl IPv6 bereits seit 1998 standardisiert ist (RFC 2460), ist die Umstellung auf IPv6 noch lange nicht abgeschlossen. Der mit Abstand größte Teil des weltweiten Datenverkehrs ist noch immer IPv4: 2 Average Traffic in TBit/s 20 Average Traffic in GBit/s Peak Traffic in TBit/s Peak Traffic in GBit/s (a) IPv4-Verkehr (b) IPv6-Verkehr Abbildung: IPv4- und IPv6-Datenverkehr am DE-CIX [2] IN0010, SoSe 2012, Kapitel 3: Nachfolge von IP(v4): IPv6 65