[(Schöne) Webversion](https://gist.github.com/anonymous/baecde1ddc5ed348c77671513ce0339c)

RVS Klausur 1 WS 17/18
======================

Gedächtnisprotokoll
-------------------
Rechnernetze und Verteilte Systeme
----------------------------------

6.3.2018

### Aufgabe 1

Eine Glasfaserleitung zwischen Berlin und Frankfurt ist 200.000 km lang. Die Endpunkte übertragen mit einer Frequenz von 10 GBit/s (1 GBit = 10<sup>9</sup> Bits). Die Geschwindigkeit der Bits durch das Kabel beträgt 550 km/s. *3P*

1. Welche Arten von Verzögerung gibt es in Netzwerken? Erklären sie jede Art **kurz**. *2P*
2. Wie viele Bits können gleichzeitig in dem Kabel sein? *1P*

### Aufgabe 2

Ein Betriebssystem bietet eine Implementierung der *Berkeley-Socket-API* an. *2P*

1. Welche Befehle der Berkeley-API muss ein Server aufrufen, um danach Anfragen annehmen zu können? *1,5P*
2. Welchen Befehl verwendet der Server, um dann eine Anfrage anzunehmen? *0,5P*

### Aufgabe 3

Welche Vorteile hat *Circuit Switching* gegenüber *Packet Switching*? *3P*

### Aufgabe 4

*Network Address Translation* ist eine weit verbreitete Technik, um IP-Adressen zu sparen. Es läuft auf nahezu jedem DSL-Router. *3P*

1. Erklären sie das Grundprinzip von *NAT*. *2P*
2. Was für Kommunikationsprobleme können durch *NAT* entstehen? *1P*

### Aufgabe 5

In einem verteilten System ist der Knoten mit der ID **10** der Koordinator.

```
              (8)
       (7)          (10)

      (3)             (5)

          (2)    (4)
```

1. Die Knoten mit den IDs **4** und **7** bemerken den Ausfall gleichzeitig. Erklären Sie, was als nächstes Passiert, wenn ein *Bully-Algorithmus* verwendet wird. *4P*

### Aufgabe 6

Es soll eine Datenbank über die Teilnehmer von Veranstaltungen an einer Universität angelegt werden. Die Datenbank ist über eine *RESTful API* manipulierbar, die unter der Domain `api.tkn.tu-berlin.de` erreichbar ist. *4P*

| Ressource                             | HTTP-Befehl | Beschreibung                                             |
| ------------------------------------- | ----------- | -------------------------------------------------------- |
| `/courses/<courseName>`               | `GET`       | Gibt eine Liste der Teilnehmer der Veranstaltung zurück. |
| `/courses/<courseName>`               | `DELETE`    | Löscht eine Veranstaltung.                               |
| `/courses/<courseName>/<studentName>` | `GET`       | Gibt Informationen über einen Teilnehmer zurück.         |
| `/courses/<courseName>/<studentName>` | `DELETE`    | Löscht einen Teilnehmer.                                 |

1. Ist eine der gezeigten Ressourcen eine *Collection*? Wenn ja, welche Informationen bekäme man beim Abrufen? Wie würde ein Abruf aussehen (Befehl & URL)? *1P*
2. Die Note eines Teilnehmers soll geändert werden. Wie sieht die Anfrage aus (Befehl & URL)? *1P*
3. Was wäre die *Payload* zu dieser Anfrage? *1P*
4. Ein Teilnehmer, der noch nicht in dem Kurs ist, soll neu zu einem Kurs hinzugefügt werden. Der Server soll aussuchen, wo der Eintrag abgelegt wird. Wie sieht die Anfrage aus (Befehl & URL)? *1P*

### Aufgabe 7

Für eine *DHT* (*Distributed Hashtable*) wird *Chord* als Implementierung verwendet. *6P*

```
       242               4
          , ---***--- .
      ,-´               `-.
236  /                     \  11
    /                       \
   |                         |
   |                         |
   |                         | 32
    \                       /
     \                     /
      `-.               ,-´ 77
     132  `- . ___ , -´
            126
```

1. Welcher Knoten ist je für einen Eintrag mit dem Hash **126** und **244** zuständig? *1P*
2. Der Knoten **77** erhält eine *Lookup-Anfrage* nach dem Hash **240**. Zeichnen Sie in die Grafik ein, welche Nachrichten hierfür zwischen den Knoten ausgetauscht werden. Es gibt noch keine *Finger-Table*. *2P*
3. Stellen sie die *Finger-Table* für Knoten **4** auf. *3P*

### Aufgabe 8

Bei *HTTP* gibt es *persistente Verbindungen*. Was bringt eine solche Verbindung? *1P*

### Aufgabe 9

*DNS* (*Domain Name System*) wird verwendet, um *Domains* im Internet verwenden zu können. *3P*

1. Zeigen (Skizze) und erklären sie eine rekursive DNS-Anfrage an eine *Top-Level-Domain*. *2P*
2. Bei DNS-Antworten wird eine *TTL* (*Time to live*) mitgesendet. Wozu dient diese und warum ist eine hohe *TTL* wünschenswert? *1P*

### Aufgabe 10

Sie empfangen den Datensatz 1011001011001001000111111, der bereits eine *CRC*-Prüfsumme enthält. Das Generatorpolynom ist x<sup>4</sup>+x+1.

1. Ist das Paket gültig? Geben Sie ihre Rechnung und einen Antwortsatz an. *3P*

### Aufgabe 11

In *RPC* können Daten verloren gehen. *3P*

1. Nennen und erklären Sie **kurz** die zwei RPC-Smeantiken. *2P*
2. Welche Konsequenzen ziehen Sie in Bezug auf die Semantiken, wenn nur idempotente Aufrufe verwendet werden? *1P*

### Aufgabe 12

In einem verteilten Datenset wird ein Voting-System verwendet, um Fehler zu vermeiden. Warum wird eine Leseanfrage abgelehnt, wenn 2 r-Stimmen und 3 w-Stimmen vorliegen? *2P*

### Aufgabe 13

*TCP* verwendet Strategien zur Verbindugsoptimierung. *6P*

1. Wozu dienen *Flow Control* und *Congestion Control*? Was unterscheidet sie? *2P*
2. Was ist ein *Congestion Collapse*? *4P*

### Aufgabe 14

Es wird zur Zeitsynchronisation *NTP* verwendet. *3P*

1. Zeigen (Skizze) und Erklären Sie die Berechnung und Herleitung des *Offset* bei *NTP*. *2P*
2. Welche Vereinfachung nimmt NTP für die Berechnung des Offset an? *1P*

### Aufgabe 15

Sie verwenden ein *"best effort"*-Transportprotokoll. Nennen Sie, mit welchen Umständen Sie zu rechnen haben. Nennen Sie außerdem für jeden Umstand eine Lösungsstrategie. *3P*

### Aufgabe 16

Ein Gerät findet sich in einem neuen Netzwerk (kennt keine anderen Teilnehmer). *2P*

1. Wie findet sich das Gerät per DHCP in das Netzwerk ein? *1P*
2. Wie lange ist die erhaltene IP-Adresse gültig? Wann wird sie erneuert? *1P*

### Aufgabe 17

Ein Netzwerk verwendet *CSMA/CD* zur Kollisionsvermeidung. Erkläre in diesem Zusammenhang *Exponential Binary Backoff*. *2P*

### Aufgabe 18

Ein IP-Netz ist in Subnetze verschiedener Klassen eingeteilt. *3P*

1. Weshalb ist es sinnvoll *CIDR* anstatt von Klassennetzen zu verwenden? *1P*
2. Wie viele `/20`-Netze passen in das Netz `136.42.0.0/16`? *1P*
3. Was ist der Unterschied zwischen *Peering* und *Transit*? *1P*

### Aufgabe 19

*Go-Back-N* ist ein Algorithmus der zur sicheren Datenübertragung hilft. *5P*

1. Welche Vorteile hat *Go-Back-N* gegenüber *Send-and-Wait*? *2P*
2. Welche Mechanismen verwendet *Go-Back-N*? Welche Probleme behebt es? *1P*
3. Welche Vorteile hat *Go-Back-N* Gegenüber *Selective Repeat*? *2P*

### Aufgabe 20

3 Prozesse laufen parallel und erhalten Chronologie mit Hilfe einer *Vektoruhr*. Notieren Sie den Zustand der jeweiligen Vektoruhren an den markierten Punkten. *3P*

```
P1 ⬤--------------------------------⬤--------⬤---⬤-----------------
                                    /            \ /
                                   /              X
                                  /              / \
P2 ⬤---------⬤-------⬤--------⬤-------------⬤---⬤------⬤--------
             /          \                                     \
            /            \                                     \
           /              \                                     \
P3 ⬤-----⬤---------------⬤--------⬤-----------------⬤-------⬤----
```
