Uebung 5

Uebung5/U5.txt

@@ -0,0 +1,135 @@
+Übungsblatt 5 Rechnernetze Nils Böhnke
+
+Aufgabe1
+Allgemein:
+-Man soll mit 2 oder mehr Karten so nahe wie möglich an 21 Punkte kommen ohne diese zu überschreiten
+-Bilderkarten wie (König, Dame, Bube) zählen 10 Punkte, Asse entweder 1 oder 11
+-Dealer oder Croupier spielt nach festen Regeln: zieht Karten bis mindestens 17 erreicht wird
+-Blackjack schlägt jede andere Kombination mit 21 (Ass + 10)
+
+Klasse Croupier:
+-kartendecks: Liste aller Karten (aus 1-8 vollständigen Decks)
+-hand: Liste der Karten in seiner Hand
+-spieler_haende: SpielerId -> Hand des Spielers
+-ausgegebene_karten: Liste aller bisher gezogenen Karten
+-kartenzaehler: Verbindung Referenz zum Kartenzähler
+
+-erstelle_kartendeck(anzahl_decks): Erstellt n Decks mit allen Karten
+-mische_karten(): zufälliges Neuanordnen des Decks
+-karte_geben(): Gibt Karte aus dem Deck und speichert sie
+-spiel_starten(spieler): Teilt sich selbst uns Spieler Karten aus
+-spiel durchfuehren(): Führt Spiel mit Spielern durch
+-wert_berechnen(Hand): Punktwert ermitteln
+-auswertung(spieler_hand): vergleicht Hand mit eigener
+-gewinn_berechnen(einsatz, ergebnis): Berechnet Auszahlung 
+-statistik_abfragen(): Statistik von Kartenzähler abrufen
+
+
+Klasse Spieler:
+-kapital: Aktueller Kontostand
+-einsatz: Aktueller Einsatz für Runde
+-hand: Aktuelle Kartenhand
+-id: SpielerId
+-kartenzaehler: Referenz zum Kartenzähler
+
+-einsatz_berechnen(true_count): Berechnet optimalen Einsatz
+-empfehlung_anfragen(Hand, dealer_karte): Fragt beim Zähler nach optimalem Spielzug
+-spielzug_ausfuehren(Empfehlung): Führt Aktion aus - Hit, Stand etc.
+-karte_erhalten(karte): Fügt Karte zur Hand hinzu
+-spielausgang_verarbeiten(Ergebnis, gewinnbetrag): Kapital anpassen
+-zuruecksetzten(): Einsatz und Hand nach Runde zurücksetzten
+
+
+Klasse Kartenzähler:
+Brainstorming:
+-anzahl_decks: Zahl der gespielten Decks
+-running_count: Aktuelle Count-Summe nach Hi-Lo
+-verwendete_karten: Liste aller gespielten Karten
+-statistik: Werte wie blackjacks, gewinne, count_verlauf, gesamtspiele
+
+-spiel_starten(anzahl_decks): Initialisiert Zähler mit Info vom Croupier
+-karte_gesehen(karte): Wertet gezogene Karte für Count aus
+-true_count_berechnen(): Berechnet true Count aus Running Count/ geschätzte Rest_Decks
+-aktion_empfehlen(Hand, dealer_karte): Gibt optimale Spielentscheidung zurück
+-spielausgang_speichern(ergebnis): Statistik aktualisieren
+-statistik_geben(): Gibt aktuelle Statistik auf Anfrage zurück
+
+Umgesetzt:
+-self.anzahl_decks: Diese Variable speichert die Gesamtanzahl der Kartendecks (z.B. 6 oder 8), mit denen das aktuelle Spiel gespielt wird
+-self.laufender_zaehlwert: Dies ist der "Running Count" des Kartenzählers
+-self.anzahl_karten_gespielt: Diese Variable verfolgt die Gesamtanzahl der Karten
+-self.historie_karten: Eine Liste, die alle Karten speichert, die in der aktuellen Runde ausgeteilt wurden
+-self.statistik_gewinne: Ein Dictionary, das die Anzahl der gewonnenen Runden für jeden Spieler (identifiziert durch seine ID) speichert
+-self.statistik_blackjacks: Dictionary, das die Anzahl der Blackjacks für jeden Spieler speichert
+-self.statistik_runden_gespielt: Dictionary, das die Gesamtzahl der gespielten Runden für jeden Spieler aufzeichnet
+-karten_verarbeiten(self, karten_str_liste): nimmt eine Liste von Karten-Strings entgegen, die vom Croupier übermittelt werden
+-true_count_berechnen(self): Diese Funktion berechnet den "True Count"
+-aktion_empfehlen(self, spieler_hand_werte, croupier_offene_karte_wert, true_count): empfängt die Werte der Spielerhand
+-optimale_einsatzhoehe_empfehlen(self, true_count): Empfehlung für die Höhe des nächsten Einsatzes des Spielers zurück
+-statistik_aktualisieren(self, spieler_id, gewonnen, hatte_blackjack): Statistiken für einen Spieler nach jeder Runde zu aktualisieren
+-gib_statistiken_an_croupier(self, spieler_id=None): bereitet die gesammelten Statistiken auf und gibt sie zurück, entweder für einen spezifischen Spieler oder für alle Spieler
+-reset_runden_statistik(self): Setzt die Zählwerte zurück
+-verarbeite_eingehende_nachricht(self, nachricht, sender_adresse): empfängt und leitet eingehende UDP-Nachrichten weiter
+
+
+Aufgabe2: 
+User Datagram Protocol (UDP) ist verbindungslos
+-Zustellung ist nicht garantiert
+-Reihenfolge ist nicht garantiert
+-Keine automatische Wiederholung bei Verlust
+-Keine Absicherung gegen Duplikate
+
+-Empfänger quittiert Nachricht um Zustellung zu garantieren
+-> System zur Quittierung
+-Einheitliches Json Format zur klaren Definition von Nachrichten
+-Feste IP-Adressen/ Ports
+
+Anhand von den vergangenen Übungen ist festzuhalten, dass die Kommunikation kompatible sein muss, dafür müssen Abstimmungen über die genaue und einheitliche Kommunikation festgelegt werden, um Nachrichten richtig verarbeiten zu können. Dadurch kann fehlerhafte Kommunikation vermieden werden, indem die Spezifikationen ausgearbeitet und ausgehandelt werden.
+
+
+Aufgabe3:
+Ich musste gemäß des ersten Buchstaben vom Nachnamen den Kartenzähler implementieren (siehe Code).
+Um die Situation testen zu können, habe ich versucht den Croupier zu entwickeln, grundsätzlich funktionieren die Programme, jedoch entsteht beim Croupier ein WinError 10054. Nach Recherche kann dies mit der Firewall zusammenhängen.
+
+$ python Croupier.py ***.*.*.* ***** ***.*.*.* ***** ***.*.*.* ***** *
+[Croupier] Deck mit 6 Decks gemischt. Gesamt: 312 Karten.
+[Croupier] Lauscht auf ***.*.*.* *****
+
+==============================
+[Croupier] Spiel startet mit 6 Decks.
+==============================
+[Croupier] -> Gesendet an ***.*.*.* *****: Typ='game_start_info' Payload={'num_decks': 6}...
+
+--- Runde 1 ---
+[Croupier] -> Gesendet an ***.*.*.* *****: Typ='request_bet' Payload={}...
+[Croupier] Fehler beim Empfangen vom Spieler: [WinError 10054] Eine vorhandene Verbindung wurde vom Remotehost geschlossen
+[Croupier] Spieler hat keinen g▒ltigen Einsatz gesendet oder Timeout.
+[Croupier] Spieler hat keinen g▒ltigen Einsatz gemacht oder Spiel beendet.
+
+
+Hier noch die Ausgabe von dem Kartenzähler:
+
+$ python Kartenzaehler.py ***.*.*.* ***** ***.*.*.* ***** ***.*.*.* *****
+[Kartenz▒hler] Lauscht auf ***.*.*.* *****
+[Kartenz▒hler] <- Empfangen von 127.0.0.1:12001: Typ='game_start_info' Payload={'num_decks': 6}
+[Kartenz▒hler] Z▒hlwerte zur▒ckgesetzt. Statistiken bleiben bestehen.
+[Kartenz▒hler] Spiel initialisiert: 6 Decks.
+Traceback (most recent call last):
+  File "...", line 475, in <module>
+    kartenzaehler_programm.run()
+  File "...", line 449, in run
+    time.sleep(0.01)
+
+
+
+Aufgabe4:
+Wir haben als Gruppe zusammengearbeitet und die Aufgabe so entwickelt, dass die Rahmenbedingungen stimmen und die Programm bei der Kommunikation keine Probleme aufweisen.
+Dabei war darauf zu achten, dass das Nachrichtensystem einheitlich ist, um eine einheitliche Kommunikation zu garantieren.
+
+Durch die Vorabsprache sind keine größeren Probleme aufgetreten, nur die Firewall mit dem WinError 10054 hat Probleme bereitet.
+
+
+
+
+
+

Uebung6/U6.txt

@@ -0,0 +1,150 @@
+Übungsblatt 6 Rechnernetze Nils Böhnke
+
+Aufgabe1
+1. Sliding-Window
+-Wird zur Fehler- und Flusskontrolle eingesetzt
+-Ermöglicht einem Sender mehrere Datenpakete (Segmente) zu versenden ohne auf eine Bestätigung (ACK) von jedem einzelnen Pakets zu warten
+-Wie ein Fenster was sich über einen Strom von Daten bewegt
+->Sendefenster: Bereich von Sequenznummer die der Sender senden darf, umfasst Pakete welche bereits gesendet aber noch nicht bestätigt wurde, und Pakete welche gesendet werden können
+->Fenstergröße: Größe definiert maximale Anzahl von Paketen die Sender unbestätigt gleichzeitig senden darf
+->Empfangsfenster: Bereich von Sequenznummer die Empfänger akzeptiert und erwartet
+-Wenn Sender Paket sendet, rückt Sendefenster vor
+-Wenn Empfänger Paket empfängt und bestätigt rückt Empfangsfenster auf seiner Seite vor
+-Empfang der Bestätigung (ACK) rückt Sendefenster weiter
+-Geht Paket verloren Timeout, Sender sendet Paket erneut
+Wofür:
+-Für Effizienz von Netzwerkprotokollen
+-Ohne müsste Sender nach jedem Paket auf Bestätigung warten -> hohe Latenz, ineffiziente Auslastung der Bandbreite
+-> Flusskontrolle und Fehlerkontrolle
+
+2.TCP Tahoe
+-TCP-Kongestionskontrollalgorithmus: vermeidet Überlastung im Netzwerk zu vermeiden 
+-Effizienten Datentransport zu gewährleisten
+-Langsamer Start: nach dem Verbindungsaufbau oder Timeout beginnt Überlastungsfenster sehr klein; für jedes empfangene ACK wird Überlastungsfenster um 1 MSS erhöht; Ziel Bandbreite zu finden
+-Überlastungsvermeidung: wenn Schwelle erreicht Wechsel Langsamer Start -> Überlastungsvermeidung; Überlastungsfenster wächst bei jeder Runde von gesendeten Paketen
+-Schnelle Neuübertragung: wenn Sender drei doppelte ACK für selbes Segment empfängt nimmt Sender an, das Segment verloren gegangen ist und sofort überträgt ohne auf Timeout zu warten
+Wofür:
+-Sorgt für eine effiziente Nutzung verfügbarer Bandbreite, aber auch auf Überlastung zu reagieren
+-Konservative Reaktion auf Paketverlust durch Rückkehr zu Langsamer Start um Netzwerk nicht zu überlasten
+
+3.TCP Reno:
+-Weiterentwicklung von TCP Tahoe -> Leistung bei Paketverlusten zu verbessern
+-Schnelle Wiederherstellung: Wird ausgelöst, wenn drei doppelte ACKs empfangen werden
+wofür:
+-Verbessert Leistung von TCP
+
+4.TCP Vegas:
+-Ist ein präventiver Algorithmus 
+-Versucht Überlastung zu vermeiden in dem es Netzwerkauslastung mit Messung analysiert
+-Beobachtet Round Trip Time (RTT), wenn diese steigt versucht der Algorithmus das zu erkennen und gegenzusteuern, sodass die Warteschlange von Paketen nicht geflutet wird
+-Misst minimale RTT und aktuelle RTT und berechnet Unterschied
+-Fensteranpassung basiert auf der Differenz
+-Weniger Paketverluste und höherer Durchsatz 
+Wofür:
+-Der RTT Algorithmus zur Überlastungssteuerung um Paketverluste zu vermeiden
+
+
+Liste:
+-Schicht 7: Anwendungsschicht (Application Layer)
+->HTTP (Hypertext Transfer Protocol) HTTP wird von Webbrowsern und Webservern verwendet, um Hypertext-Dokumente und andere Webinhalte auszutauschen
+->FTP (File Transfer Protocol) FTP wird zum Übertragen von Dateien zwischen Clients und Servern verwendet
+->SMTP (Simple Mail Transfer Protocol) SMTP ist das Standardprotokoll für den Versand von E-Mails
+->POP3 (Post Office Protocol version 3) IMAP ist ein weiteres Protokoll zum Abrufen von E-Mails
+->DNS (Domain Name System) DNS übersetzt menschenlesbare Domainnamen in numerische IP-Adressen
+->SSH (Secure Shell) SSH ermöglicht eine sichere Fernverwaltung von Computern und sichere Dateiübertragungen
+->DHCP (Dynamic Host Configuration Protocol) Hosts dynamisch IP-Adressen und andere Netzwerkkonfigurationsparameter zuzuweisen
+-Schicht 6: Darstellungsschicht (Presentation Layer)
+->TLS (Transport Layer Security) / SSL (Secure Sockets Layer) TLS/SSL sorgen für die Verschlüsselung, Authentifizierung und Datenintegrität von Daten, die über eine Netzwerkschicht gesendet werden
+-Schicht 5: Sitzungsschicht (Session Layer)
+->ADSP (AppleTalk Data Stream Protocol) verbindungsorientiertes Protokoll im AppleTalk-Stack, das Ende-zu-Ende-Byte-Stream-Dienste mit Flusskontrolle bietet
+-Schicht 4: Transportschicht (Transport Layer)
+->TCP (Transmission Control Protocol) TCP bietet eine zuverlässige, verbindungsorientierte und strombasierte Datenübertragung zwischen Anwendungen auf verschiedenen Hosts
+->UDP (User Datagram Protocol) UDP bietet eine unzuverlässige, verbindunglose Datagramm-Übertragung
+-Schicht 3: Vermittlungsschicht (Network Layer)
+->IP (Internet Protocol) verantwortlich für die logische Adressierung (IP-Adressen) und das Routing von Paketen
+->ICMP (Internet Control Message Protocol) von Routern und Hosts verwendet, um Fehlerberichte und Kontrollnachrichten über das Netzwerk zu senden
+->IGMP (Internet Group Management Protocol) Mitgliedschaft von Hosts in Multicast-Gruppen zu verwalten
+-Schicht 2: Sicherungsschicht (Data Link Layer)
+->ARP (Address Resolution Protocol) ogische IP-Adresse in eine physikalische MAC-Adresse auf derselben lokalen Netzwerksegment zu übersetzen
+-> Ethernet definiert sowohl das Format der Datenframes als auch die physikalischen Eigenschaften für die Übertragung von Daten
+-Schicht 1: Bitübertragungsschicht (Physical Layer)
+->WLAN (Wireless Local Area Network) drahtlose Kommunikation
+
+Aufgabe2: 
+a) nmap -sn 192.168.1.0/24
+NMAP führt einen Ping-Scan durch das Ergebnis sind, wie viele Hosts online sind, diese werden anpingt, bei mir sind es 0 Hosts. Nmap done: 256 IP addresses (0 hosts up) scanned in 247.91 seconds
+
+b) nmap -O scanme.nmap.org
+Das Betriebssystem ist Linux 4.X|5.X.
+
+c) whois nmap.org
+18. Januar 1999
+
+d) nmap -sS -T4 -p 1-1000 192.168.1.0/24
+-sS: SYN-Scan (schnell & unauffällig), T4: Timing-Modus („Aggressiv“, aber stabil),-p 1-1000: Scan der ersten 1000 TCP-Ports, 192.168.1.0/24: Zielnetz
+
+e) Nmap sendet ein Syn-Paket, die Reaktion: SYN-ACK-> Port offen, RST->Port geschlossen
+Nmap sendet kein ACK zurück, bricht die Verbindung ab -> Half open
+Ist weniger auffällig und Schneller, Ideal für Port-Erkennung 
+
+f) Durch den überwiegenden Scan von Internetseiten ist Port 80 und 443 angegeben.
+
+
+Aufgabe3:
+
+DHCP wird benutzt, um einem Gerät eine IP-Adresse zuzuweisen, um diese zu erzeugen kann man beispielsweise die Netzwerkverbindung zurücksetzten, da um ein DHCP-Paket zu empfangen oder senden ein Client eine DHCP-Anfrage zu stellen.
+
+
+Nachdem ich mit ipconfig /release und ipconfig /renew einen neuen Handshake erzwungen habe, wurden mir vier Anfragen aufgezeigt.
+
+
+Hier ein paar Beobachtungen:
+Die Source address ist 0.0.0.0 und die Anfrage wird an Destination address 255.255.255.255 gesendet.
+
+Pakete über UDP gesendet Client Port ist 67 und Server-Port 68, Identifikation über Mac-Adresse.
+
+UDP- und IPV4-Header.
+
+Option: (12) Host Name enthält den Namen des Hosts.
+
+Die anderen Frames spiegeln im Prinzip das gleiche, aus diesem Grund wird nicht jeder beschrieben.
+
+
+Aufgabe4:
+
+Betrachtet man die Initialisierung, so lässt sich feststellen, dass für jeden Knoten eine Tabelle angelegt wird. In den Zeilen kann man zu einem Knoten ablesen, in den Spalten via, also über einen Knoten. Im Graphen und in der Tabelle sind die Kosten, also Kantengweichte zu den jeweils benachbarten Routern eingetragen.
+
+Schaut man sich nun Router A in der Initialisierung an, ist ein benachbarter Knoten B mit Kantengweicht von A zu B mit 3 und der andere benachbarte Knoten von A zu C mit Kantengewicht mit 23.
+
+Bei der Aktualisierung werden nun Pfade erweitert. Man kann nu andere Wege zu den bekannten Knoten untersuchen und die Kosten mittels der Addition berechnen. So kann man von A nach C über B beispielsweise gelangen und die Kosten belaufen sich auf 5. Des Weiteren wird über C D erschlossen. 
+
+Dies wird solange wiederholt, bis alle vorgesehenen Kästchen ausgefüllt und die niedrigsten Werte bestimmt sind.
+
+Bei den anderen Routern passiert das Gleiche.
+
+
+Algorithmus:
+
+1) Erstelle für jeden Knoten im Graphen eine Tabelle
+-> Erstelle für jeden anderen Knoten der nicht der Hauptknoten der Tabelle ist eine Spalte für via Knoten
+-> Erstelle für jeden anderen Knoten in der jeweiligen Knotentabelle eine Zeile
+
+2) Eintragen von allen direkten Distanzen
+
+3) Tabelle erweitern bis alle Plätze voll sind, Kantengewichte addieren
+
+4) Den Prozess beenden, wenn alle Plätze voll sind, alle optimalen Distanzen sind berechnet 
+
+
+a) & b) in PDF
+
+c) D sendet keine Updates mehr, keine Antwort
+   Nach einer gewissen Zeit wird D als nicht mehr erreichbar markiert, Timeout
+   Router aktualisieren ihre Tabellen und senden neue Updates, andere Router erfahren                           davon, Route wird entfernt
+   Router können betroffene Routen als unendlich markieren 
+
+
+
+
+
+