{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adressen und Netze – Notebook\n",
    "\n",
    "**Informatik 12 · Rechnernetze und Internet**\n",
    "\n",
    "Dieses Notebook braucht **keine** Netzverbindung — es rechnet. Denn fast alles,\n",
    "was ein Router tut, ist Bitrechnerei: Adressen und Masken verknüpfen und dann\n",
    "entscheiden, wohin ein Paket geht.\n",
    "\n",
    "Umgekehrt gilt: Wer die Bitrechnung einmal von Hand programmiert hat, liest eine\n",
    "Netzkonfiguration danach ohne Nachschlagen.\n",
    "\n",
    "Führen Sie zuerst die nächste Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zeile(*teile):\n",
    "    print(\"  \".join(str(t).ljust(18) for t in teile))\n",
    "\n",
    "\n",
    "BEISPIELE = [\n",
    "    (\"192.168.1.37\", 24),\n",
    "    (\"192.168.1.250\", 24),\n",
    "    (\"10.0.14.7\", 16),\n",
    "    (\"172.16.200.5\", 20),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 1 · Adresse in Bits und zurück\n",
    "\n",
    "Schreiben Sie `zu_bits` und `zu_text`: eine IPv4-Adresse als vier Zahlen in eine\n",
    "32-Bit-Zahl umwandeln und wieder zurück.\n",
    "\n",
    "Geben Sie für `192.168.1.37` auch die Binärschreibweise aus, in Vierergruppen\n",
    "getrennt — so wie es im Heft steht.\n",
    "\n",
    "**Frage:** Wie viele verschiedene IPv4-Adressen gibt es überhaupt? Rechnen Sie es aus, nicht nachschlagen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zu_bits(adresse):\n",
    "    \"\"\"'192.168.1.37' -> ganze Zahl\"\"\"\n",
    "    # TODO\n",
    "    return 0\n",
    "\n",
    "\n",
    "def zu_text(zahl):\n",
    "    \"\"\"ganze Zahl -> '192.168.1.37'\"\"\"\n",
    "    # TODO\n",
    "    return \"\"\n",
    "\n",
    "\n",
    "def binaer(zahl):\n",
    "    \"\"\"32 Bit mit Punkten zwischen den Bytes.\"\"\"\n",
    "    bits = format(zahl, \"032b\")\n",
    "    return \".\".join(bits[i:i + 8] for i in range(0, 32, 8))\n",
    "\n",
    "\n",
    "# print(zu_bits(\"192.168.1.37\"))\n",
    "# print(zu_text(zu_bits(\"192.168.1.37\")))\n",
    "# print(binaer(zu_bits(\"192.168.1.37\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 2 · Maske, Netz-ID und Broadcast\n",
    "\n",
    "Aus der Präfixlänge (die Zahl hinter dem Schrägstrich) folgt die Subnetzmaske:\n",
    "so viele Einsen, dann Nullen.\n",
    "\n",
    "Schreiben Sie `maske`, `netz_id` und `broadcast`. Die Netz-ID entsteht durch\n",
    "bitweises UND, die Broadcast-Adresse, indem man alle Hostbits auf 1 setzt.\n",
    "\n",
    "**Frage:** `192.168.1.37/24` und `192.168.1.250/24` liegen im selben Netz, `10.0.14.7/16` nicht. Woran genau erkennt der Rechner das — und was passiert, wenn das Ziel in einem anderen Netz liegt?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maske(praefix):\n",
    "    # TODO: praefix Einsen, Rest Nullen, als 32-Bit-Zahl\n",
    "    return 0\n",
    "\n",
    "\n",
    "def netz_id(adresse, praefix):\n",
    "    # TODO: bitweises UND\n",
    "    return 0\n",
    "\n",
    "\n",
    "def broadcast(adresse, praefix):\n",
    "    # TODO: Hostbits auf 1\n",
    "    return 0\n",
    "\n",
    "\n",
    "# for adresse, praefix in BEISPIELE:\n",
    "#     n = netz_id(adresse, praefix)\n",
    "#     zeile(adresse + \"/\" + str(praefix), zu_text(maske(praefix)),\n",
    "#           zu_text(n), zu_text(broadcast(adresse, praefix)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 3 · Liegen zwei Rechner im selben Netz?\n",
    "\n",
    "Schreiben Sie `gleiches_netz(a, b, praefix)`. Das ist genau die Entscheidung, die\n",
    "Ihr Rechner vor jedem Paket trifft: direkt zustellen oder zum Router schicken.\n",
    "\n",
    "Prüfen Sie alle Paare aus `BEISPIELE` mit Präfix 24.\n",
    "\n",
    "**Frage:** Wie viele Hosts passen in ein Netz mit Präfix $p$? Schreiben Sie die Formel als Funktion und prüfen Sie sie für /24, /16 und /30. Warum steht in der Formel ein $-2$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gleiches_netz(a, b, praefix):\n",
    "    # TODO\n",
    "    return False\n",
    "\n",
    "\n",
    "def hosts(praefix):\n",
    "    # TODO\n",
    "    return 0\n",
    "\n",
    "\n",
    "# for p in [24, 16, 30, 31]:\n",
    "#     print(\"/\" + str(p), hosts(p), \"Hosts\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 4 · Ein Netz aufteilen\n",
    "\n",
    "Ein Betrieb hat `192.168.4.0/24` und braucht vier gleich große Teilnetze.\n",
    "\n",
    "Berechnen Sie die neue Präfixlänge und geben Sie für jedes Teilnetz Netz-ID,\n",
    "erste und letzte nutzbare Adresse und Broadcast aus.\n",
    "\n",
    "**Frage:** Sie verlieren durch die Aufteilung Adressen. Wie viele genau, und wohin sind sie verschwunden?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def teilnetze(basis, praefix, anzahl):\n",
    "    \"\"\"Gibt eine Liste (netz_id, erste, letzte, broadcast) zurueck.\"\"\"\n",
    "    # TODO: neues Praefix bestimmen, dann die Netze der Reihe nach\n",
    "    return []\n",
    "\n",
    "\n",
    "# for n, erste, letzte, b in teilnetze(\"192.168.4.0\", 24, 4):\n",
    "#     zeile(zu_text(n), zu_text(erste), zu_text(letzte), zu_text(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 5 · Eine kleine Routing-Tabelle\n",
    "\n",
    "Ein Router entscheidet anhand einer Tabelle, wohin ein Paket geht. Gilt mehr als\n",
    "ein Eintrag, gewinnt der mit dem **längsten Präfix**.\n",
    "\n",
    "Schreiben Sie `weg(ziel, tabelle)`.\n",
    "\n",
    "**Frage:** Warum gewinnt das längste Präfix und nicht das erste passende? Konstruieren Sie ein Ziel, bei dem die beiden Regeln verschiedene Ausgänge liefern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TABELLE = [\n",
    "    (\"0.0.0.0\", 0, \"Internet\"),\n",
    "    (\"192.168.0.0\", 16, \"Hausnetz\"),\n",
    "    (\"192.168.4.0\", 24, \"Verwaltung\"),\n",
    "    (\"192.168.4.128\", 25, \"Serverraum\"),\n",
    "]\n",
    "\n",
    "\n",
    "def weg(ziel, tabelle):\n",
    "    # TODO: alle passenden Eintraege suchen, laengstes Praefix gewinnt\n",
    "    return None\n",
    "\n",
    "\n",
    "# for ziel in [\"192.168.4.130\", \"192.168.4.5\", \"192.168.9.9\", \"8.8.8.8\"]:\n",
    "#     zeile(ziel, weg(ziel, TABELLE))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Abgabe\n",
    "\n",
    "Fertig ist das Notebook, wenn `192.168.1.37/24` die Netz-ID `192.168.1.0` und den\n",
    "Broadcast `192.168.1.255` liefert, die vier Teilnetze von `192.168.4.0/24` jeweils\n",
    "62 nutzbare Adressen haben und `192.168.4.130` im Serverraum landet.\n",
    "\n",
    "Notieren Sie am Ende die Netz-ID und die Präfixlänge des Netzes, in dem Ihr\n",
    "eigener Rechner steckt — die Werte stehen in den Netzwerkeinstellungen."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
