Muirauqa's Brain

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
===== Allgemein =====
==== Misc ====
  * **Verteiltes System** \\ Kommunzierende Komponenten die als eins erscheinen.

  * **Vermitteltes Netz** \\ "simples" Netz mit Vermittlern (z.B. Switchen) zwischen //Hosts//
  * **Verbundnetz** \\ "komplexes" Netz mit Vermittlern (z.B. Routern) zwischen //Netzen//

  * Fehler mit Nachrichten
    * Komponenten
      * ausfallen
    * Nachrichten
      * verändert
      * dupliziert
      * verloren
      * vertauscht (reihenfolge)
      * fehlzustellung (unerwartete Nachricht)
    * Leitungen
      * Durchsatz gering
      * Latenz hoch

  * Asymetrische Kommunikation: Master/Slave
  * Symetrische Kommunikation: Konkurrenzbetrieb (Konfliktlösung nötig, z.B. Medienzugriff)

  * Flusssteuerung: Empfänger
    * Pufferreservierung (Explizite Reservierung druch Sender)
    * Credits (Implizite Reservierung durch Empfänger)
    * Fenster
    * Stop and Go: Eins nach dem anderen (Doof bei großem RTD)
  * Staukontrolle: Netz
    * Drosselung
    * Abnahmegarantie
    * Verwerfen
    * Konstante Last

^ ^ (upward) multiplexing ^ downward multiplexing / splitting ^
^ Schicht N+1 | viele | eins |
^ Schicht N-1 | eins | viele |
(für ↑ und ↓)

==== Verzögerungen ====
med = Medium/Leiter

  * Im medium
    * **Signalverzögerung** \\ $t_S = \frac{l_{\text{med}}}{v_\text{med}} = \frac{\text{Leitungslänge}}{\text{Ausbreitungsgeschwinigkeit}}$
    * **Nachrichtenverzögerung** \\ $t_N = \frac{\text{Nachrichtenlänge}}{\text{Uebertragungsrate}}$
  * Im Knoten
    * **Verarbeitungsverzögerung** \\ Last unahängig
    * **Warteschlangenverzögerung** \\ Last abhängig

==== Schichten ====
^ Nr ^ Deutsch ^ Englisch ^
|  7  | Anwendungs~                    | application ~   |
|  6  | Darstellungs~                  | presentation ~  |
|  5  | Kommunikationssteuerungs~ (!)  | session ~       |
|  4  | Transport~                     | transport ~     |
|  3  | Vermittlungs~                  | network ~       |
|  2  | Sicherungs~                    | data link ~     |
|  1  | Bitübertragungs~               | physical ~      |

  * DHCP: Application Layer
  * DNS: Application Layer
  * ICMP: Network Layer (über IP)
  * IGMP: Network Layer (über IP)
  * ARP: Link Layer
  * NDP: Link Layer
==== Schnitte ====
  * Systemschnitt
    * Auf unterster Schicht
    * Zwischen Systemkomponenzen (z.B. Host und Netz, Netz und Netz)
    * Schachtel- / Verfeinerbar
  * Dienstschnitt
    * Zwischen Schichten
  * Protokollschnitt
    * "Virtuell"
    * Zwischen zwei Protokollinstanzen (z.B. IP und IP, TCP und TCP)

==== Dienst ====
=== Namen ===
^ Deutsch ^ Englisch ^ Beschreibung ^
| Diensterbrinnger   | Service provider           | Protokollinstanz der Schicht (N) |
| Dienstnutzer       | Service user               | Protokollinstanz der höheren Schicht (N+1) |
| Dienstelemente     | service primitives         | |
| Dienstzugangspunkt | Service Access Point = SAP | |

=== Zusamenhänge ===
  * Diensterbringer hat einen SAP pro Verbindung (Multiplexing)
  * Dienstnutzer nutzt SAP

=== Ablauf ===
  * Request
  * Indication
  * Response
  * Confirmation

== Unbestätigt ==
^ Dienstnutzer A ^ Dienst ^ Dienstnutzer B ^
|  Request -> | | |
| | | -> Indication  |

== Bestätigt ==
^ Dienstnutzer A ^ Dienst ^ Dienstnutzer B ^
|  Request -> | | |
| | | -> Indication  |
| | | <- Response  |
|  Confirmation <- | | |

== Vom Diensterbringer initiiert (push) ==
^ Dienstnutzer A ^ Dienst ^
|  Indication <- | |

== Aufforderung mit Anzeige vom Erbringer (lokale Anfrage) ==
^ Dienstnutzer A ^ Dienst ^
|  Request -> | |
|  Indication <- | |

==== Schnitstellen- / Protokollinformationen ====
Nach unten (↓)
|                                |         |                                                   |         |  Höhere Schicht (N+1)                      |
|  :::                           |  :::    |  :::                                              |  :::    |  ↓                                         |
|  **ID** \\ Interface Data      |  **+**  |  **ICI** \\ Interface Control Information         |  **=**  |  **IDU** \\ Interface Data Unit            |
|  Blocking                      |         |  Wird in N konsumiert \\ (Steuert N)              |         |                                            |
|  ↓                             |  :::    |                                                   |  :::    |  :::                                       |
|  **SDU** \\ Service Data Unit  |  :::    |  :::                                              |  :::    |  :::                                       |
|  ↓                             |  :::    |  :::                                              |  :::    |  :::                                       |
|  Segmengting                   |  :::    |  Wird in N erzeugt \\ (Beschreibt N (Header))     |  :::    |  :::                                       |
|  **UD** \\ User Data           |  **+**  |  **PCI** \\ Protocol Control Information          |  **=**  |  **PDU** = (N-1)-ID \\ Protocol Data Unit  |
|                                |         |                                                   |         |  + (N-1)ICI = (N-1)-IDU                    |
|  :::                           |  :::    |  :::                                              |  :::    |  ↓                                         |
|  :::                           |  :::    |  :::                                              |  :::    |  Niedrigere Schicht (N-1)                  |

Nach oben (↑)
|                                |         |                                                   |         |  Höhere Schicht (N+1)                      |
|  :::                           |  :::    |  :::                                              |  :::    |  ↑                                         |
|  **ID** \\ Interface Data      |  **+**  |  **ICI** \\ Interface Control Information         |  **=**  |  **IDU** \\ Interface Data Unit            |
|  Deblocking                    |         |  ???                                              |         |                                            |
|  ↑                             |  :::    |                                                   |  :::    |  :::                                       |
|  **SDU** \\ Service Data Unit  |  :::    |  :::                                              |  :::    |  :::                                       |
|  ↑                             |  :::    |  :::                                              |  :::    |  :::                                       |
|  Reassembly                    |  :::    |  Wird in N konsumiert \\ (Beschreibt N (Header))  |  :::    |  :::                                       |
|  **UD** \\ User Data           |  **+**  |  **PCI** \\ Protocol Control Information          |  **=**  |  **PDU** \\ Protocol Data Unit             |
|                                |         |                                                   |         |  ↑                                         |
|  :::                           |  :::    |  :::                                              |  :::    |  Niedrigere Schicht (N-1)                  |

==== Blockung ====
^  Schichten  ^  Rich- \\ tung  ^  Von          ^^     ^  Nach        ^^  Name  ^
^ :::         ^ :::             ^  Qt.   ^  Sub  ^ ::: ^  Qt.  ^  Sub  ^ :::    ^
|  N+1 <-> N  |  ↓  |  n  |   ID  |  ->  |  1  |  SDU  | Blocking  |
|  :::        |  ↑  |  1  |  SDU  |  ->  |  n  |   ID  | Deblocking  |
|  N <-> N-1  |  ↓  |  1  |  SDU  |  ->  |  n  |   UD  | Segmengting  |
|  :::        |  ↑  |  n  |   UD  |  ->  |  1  |  SDU  | Reassembly  |

Qt. = Quantity \\
Sub = Subject

Concentration/Separation???


===== Layer 1 =====
SDU
  * 1 Bit (seriell)
  * n Bit (parallel)

  * **Bitrate** \\ Bit / Sekunde
  * **Baud** \\ Symbole / Sekunde (Ohne "rate"; Bei Parallel aufpassen)

Übertragung
  * **synchron** \\ Immer fixes Raster
  * **asynchron** \\ Nur für eine Nachricht fixes Raster (UART Start/Stop Bit)

Frequenzbereich
  * Endpunkt: Spektrum
    * Δ min/max Fourierfrequenz
  * Medium: Bandbreite
    * Übertragung ohne (50%) Verzerrung
    * Breite des bereichs mit >50% Leistung

Abtasttheorem: Abtastrate ≥ 2 ⋅ Bandbreite

Nyquist (rauschfrei): $C_\text{Ny} = 2 \cdot B \cdot \log_2(M)$

Shannon (Mit rauschen): $C_\text{Sh} = B \cdot \log_2\left(1 + \frac{2}{N}\right)$

Bandbreite ⋅ Zeit = const

Bandbreite ⋅ Länge = const

Dämpfung wächst exponentiell mit Länge

  * D/A
    * Codierung (Darstellung)
  * A/D
    * Diskretisierung (Zeitachse)
    * Quantisierung (Wertachse)

Digital => Diskrete Signale

$s(t) = A_0 \cdot \sin(2\pi \cdot f \cdot t + \Theta)$

Störungen (Kupfer)
  * Nebensprechen
  * Einstrahlung
  * Ausstrahlung
  * Reflexion
  * Erdschleife
  * Skin-Effekt

==== LWL ====
Störeinflüsse
  * Modendispersion
  * Materialdispersion

Arten
  * Gradientenindex 50μm
  * Stufenindex
    * Multimode: 100μm - 400μm
    * Monomode: 5μm

==== Codierung ====
  - Quellenkodierung (komprimierung)
    * verlustfrei
      * Run Length Encoding (RLE)
      * Huffmann
    * verlustbehaftert
  - Kanalkodierung (Fehlererkennung)
    * Parität
    * Block Check Character (BCC)
    * Cyclic Redundancy Check (CRC)
    * Selbstkorrigierende codes
  - Leitungskodierung (Bit -> Signal)
    * **Non Return to Zero** (NRZ) \\ "Normal"
    * **Return to Zero** (RZ) \\ Impulse
    * **AMI-Code** \\ 0 => 0V \\ 1 => abwechselnd +/- (''11'' = ''+-'')
    * **Manchaster Code** \\ 0 <=> Steigende Flanke (in der Mitte) \\ 1 <=> Fallende Flanke (in der Mitte)
    * **Differenzieller Manchaster Code** \\ 0 <=> Kein Flankenwechsel (am Übergang) \\ 1 <=> Flankenwechsel (am Übergang) 

=== Huffmann ===
  - Tabelle mit abs. Zeichenhäuigkeit
  - Loop
    - sort(Abs. Häufigkeit)
    - zwei kleinsten zusammenführen
  - Binärbaumäste mit ''0''/''1'' beschriften
  - Web von Wurzel zu Zeichen = Codewort

=== Fehlererkennung ===
== Parität ==
  * even: Ist die Zahl an 1en gerade?
  * odd: Ist die Zahl an 1en undgerade?

== Block Check Character (BCC) ==
  - Segmente mit Parität am Ende
  - Parität über jedes //n//te Segment-Bit + deren Parität

== Cyclic Redundancy Check (CRC) ==
  * |Prüfsumme| = |Polynom| - 1
  * Grad = |Polynom| - 1

== Selbstkorrigierende codes ==
  * Hamming //Abstand//%%/%%//Distanz//: Anzahl unterschiedlicher Bits //zweier// Wörter
  * Hamming //Gweicht//: Kleinster Hamming Abstand //aller// Wörter

  * Um Fehler zu //erkennen//: Anzahl falscher Bits < Hamming Gweicht 
  * Um Fehler zu //korrigieren//: Anzahl korrigierbarer Bits < 1/2 Hamming Gweicht

===== Layer 2 =====
  * network
  * data link
    * LLC (Logical Link Control)
    * MAC (Multiple Access Control)
  * physical
==== MAC ====
  * Random Access Verfahren
    * Pure ALOHA
    * Slotted ALOHA
    * Reservation ALOHA
  * Zuteilungsverfahren
    * zental
      * Polling
    * dezentral
      * Token Ring
  * Reservierungsverfahren
    * Fest
      * CDMA
    * Dynamisch

Konfliktparameter \[ K = \frac{\text{max. Signallaufzeit}}{\text{Nachrichtenübertragungszeit}} \]

Kollision => Zufällige wartezeit

=== ALOHA ===
  * **Pure** \\ Senden wann will
  * **Slotted** \\ Senden zu Tack (an Slot grenze)
  * **Reservation** \\ Steuerungs/Reservierungs Slot (Wie GSM)

=== CSMA ===
Carries Sense Multiple Access

K << 1

  * **unslotted** \\ Theoretischer Sendebeginn wann will & frei
  * **slotted** \\ Theoretischer Sendebeginn zu Takt & frei

  * **nonpersistent** \\ Tatsächlicher Sendebeginn = Theoretischer Sendebeginn (1-persistent)
  * **p-persistent** \\ Tatsächlicher Sendebeginn verschiebt sich mit 1-p Warscheinlichkeit (RTD/2 oder 1 Slot)

== Ethernet ==
  * nonpersistent
  * Truncated Binary Exponention Backoff
  * Jam: 4-6 Byte

  - 64 Bit Preamble
  - 48 Bit Ziel Adresse
  - 48 Bit Quell Adresse
  - Typ
  - Daten (64 - 1500 Byte)
    - Nutzdaten
    - Padding
  - 4 Byte CRC

=== MACA ===
"Multiple Access with Collision Avoidance"

Verhindert //hidden station problem//

  - Sendewilliger: CS
  - Sendewilliger: Sendet RTS (Request To Send)
  - Alle RTS Empfänger: Reserverieren für RTS Sender
  - Alle RTS Empfänger: Senden CTS (Clear To Send)
  - Alle CTS Empfänger: Reserverieren für CTS Sender
  - Sendewilliger Sendet

Für WLAN: MACAW (Multiple Access with Collision Avoidance for Wireless)

==== LLC ====
LLC ⊆ HDLC (genauer gesagt des //Asynchronus Balanced Mode// also //symetrische// Verbindung (alle gleichberechtigt))


HDLC-Flag: ''01111110'' (6x die ''1'')

Bit stuffing
  * Sender
    * Nach 5x ''1'', 1x ''0'' einfügen
  * Empfänger
    ''1111100'' => ''111110''
    ''1111101'' => ''111111''
    ''1111110'' => Flag
    ''1111111'' => Error

==== PPP ====
  * //link-layer protocols//
    * LCP (Link Control Protocol)
    * Authentification
  * //NCP// (Network Control Protocol)
    * IPCP
  * //network-layer protocols// (Daten)
    * IP

//Protokollklasse// ≙ Range an Type Nummern. Alles drunter ist PPP payload.

<code>
                                           Authentification
                        LCP                      (LCP)
   +------+ UP     +-----------+           +--------------+
   |      |------->|           | OPENED    |              | SUCCESS/NONE
   | Dead |        | Establish |---------->| Authenticate |--+
   |      |<-------|           |           |              |  |
   +------+   FAIL +-----------+           +--------------+  |
      ^                                   FAIL |             |
      |                  +---------------------+             |
      |                  |                                   |
      |                  V                                   |
      |            +-----------+                +---------+  |
      |       DOWN |           |        CLOSING |         |  |
      +------------| Terminate |<---------------| Network |<-+
                   |           |                |         |
                   +-----------+                +---------+
                        LCP                         NCP
                                          network-layer protocols
</code>
Netzwerk verbindungen können während einer PPP session belibig auf und zu gemacht werden.

==== VLAN ====
Potenzielle möglichkeiten Hosts zusammen zu schalten auf basis von ...
  * Ports
  * MAC-Adressen
  * Adressen der Vermittlungsschicht

Lösung: tagging durch erste VLAN fähige Komponente


===== Layer 3 =====
Aufgaben
  * Vermittlung (Pfadschaltung)
  * Wegewahl (Routing)

Vermittlungsverfahren
  * Circuit Switching (Leitungsvermittlung)
    * ISDN
  * Message Switching / Store and Forward (Nachrichtenvermittlung / Speichervermittlung)
    * IP
    * E-Mail
  * Packet Switching (Paketvermittlung)
    * ATM

Socket = (IP-Adresse, Port-Nummer)

==== IPv4 ====
=== Kopf ===
  * Version
  * IHL (Internet Header Length)
  * ToS (Type of Service)
  * Paketlänge
  * Fragment Offset
  * TTL (Time To Live)
  * Prüfsumme (Nur für header)
  * Quelladresse
  * Zieladresse

^  Feld             ^  Breite  ^  Schritweite  ^  Min  ^
|  IHL              |    4 Bit |  4 Byte | 5 (20 Byte) |
|  Paketlänge       |   16 Bit |  1 Byte | |
|  Fragment Offset  |   13 Bit |  8 Byte | |
=== Klassen ===
^  Klasse  ^  Prefix  ^
|  A  | ''0''...    |
|  B  | ''10''...   |
|  C  | ''110''...  |
|  D  | ''1110''... |

^  Adresse  ^^  Als  ^ Bezeichnet  ^
^  Netz  ^  Host  ^ ::: ^ ::: ^
|  ''0000''  |  ''0000''  |   Absender | //Dieser// Host in //diesem// Netz |
|  ''1111''  |  ''1111''  |  Empfänger | //Alle// Hosts in //allen// Netzen |
|  ''NNNN''  |  ''0000''  |  -  |"Name des Netzes" |
|  ''NNNN''  |  ''1111''  |  Empfänger | //Alle// Hosts in //diesem// Netz |

^  Bin  ^  Hex  ^  Dec  ^  1 cnt  ^
|  ''1000 0000'' |  128 |  ''80''  |  1  |
|  ''1100 0000'' |  192 |  ''C0''  |  2  |
|  ''1110 0000'' |  224 |  ''E0''  |  3  |
|  ''1111 0000'' |  240 |  ''F0''  |  4  |
|  ''1111 1000'' |  248 |  ''F8''  |  5  |
|  ''1111 1100'' |  252 |  ''FC''  |  6  |
|  ''1111 1110'' |  254 |  ''FE''  |  7  |
|  ''1111 1111'' |  255 |  ''FF''  |  8  |

==== IPv6 ====
=== Kopf ===
  * 40 Byte (fix)
  * Keine Prüfsumme
  * Fragmentierung wie IPv4 mit extra //Fragment HEader//
=== Adressen ===
  * 128 Bit
  * 8 Blöcke
  * 64 Bit Interface ID
  * Link Local address: ''FF80::<64 Bit Interface ID>''
==== Routing ====
  * **QSB** (Quell-Senken-Baum) \\ Eine definierte Wurzel, alles andere sind Senken
    * **SDF-Algorithmus** (Shortest Delay First Algorithmus) ≙ **Dijkstra** \\ Iterativ: Wähle Knoten/Kante, mit dem günstigsten Pfad zur Wurzel

Verfahren
  * //Flooding//
  * //Hot-Potato//
  * //Statisch//
  * **Adaptiv**
    * **zentral**
    * **verteilt**
      * **link state** (Dijkstra)
        * //OSPF//
      * **distance vektor**
        * //RIP//
        * //BGP//

=== Statisch ===
//Einmal// erstellt / fix

=== Hot-Potato ===
Port mit kürzerster Warteschlange

=== OSPF ===
//Link Status// zu //Nachbarn//, per Flooding undverändert an //alle// senden. Die machen dan Dijkstra.

=== RIP ===
== Sender ==
//Kosten// zu //allen Zielen//, unverändert nur an //Nachbar// senden

== Empfänger ==
Wenn der Weg zum Nachbar + dessen Distanz zu deinem Ziel kürzer ist als was ich habe => übernehmen

== Nachteile ==
  * Zählen bis unendlich
  * Langsamme Ausbreitung => Inkonsistenzen

=== BGP ===
Kosten sind finanzieller/organisatorischer Natur.

==== Multicast ====
=== Adressen ===
  * 224.0.0.0 - 239.255.255.255
  * 224.0.0.0 - 224.0.0.255 Local Scoped
  * 224.0.0.1 Alle Mulicast Hosts (MAC Multicast)
  * 224.0.0.2 Alle Mulicast Router (MAC Multicast)
  * Sender muss nicht in Gruppe sein
  * Gruppenmitgliedschaft per IGMP (Internet Group Management Protocol)

=== IGMP ===

Router
  * Regelmäsige //Query//
  * IP: 224.0.0.1
  * HW: ff:ff:ff:ff:ff:ff
  * TTL: 1

Host
  * Routers Query => //Membership Report//
  * Möchten Gruppe beitreten  => //Membership Report//

=== Routing ===
== Trees ==
  * Source Distribution Tree (Quellenbasierte Bäume)
    * Shortest Path Tree
    * Reverse Path Forwarding
  * Shared Distribution Tree (Gemeinsamer Gruppenbaum)
    * Minimal Spanning Tree
    * Centered Spanning Tree (CBT)

**Shortest Path Tree** \\
Dijkstra

**Reverse Path Forwarding**
  - Multicast Nachricht an Port mit schnellstem Pfad zum Absender eingegangen => Flooding
  - Keine Empfänger => Zurückmelden: Keine Empfänger

**Centered Spanning Tree**
   * Ein router wird als Zentrum definiert

Beitreten
   * //Join// wird an zentralen Router Geschickt
   * Alle Router auf dem weg merken sich das

== Multicast Open Shortest Path First  ==
Konzept: Reverse Path Forwarding

LSA (Link State Advertisment)
== Distance Vector Multicast Routing ==
Konzept: Minimal Spanning Tree
===== Layer 4 =====
Socket = (IP-Adresse, Portnummer)
TCP-Verbindung = (Socket A, Socket B)
==== Kopf ====
^  Feld          ^  Breite  ^  Schritweite  ^  Min  ^
|  Header Länge  |   4 |  4 Byte | 5 (20 Byte) |
|  SeqNr         |  32 |  1 Byte | |
|  AckNr         |  32 |  1 Byte | |
|  Fenstergröße  |  16 |  1 Byte | |

Flags
  * ACK
  * RST
  * SYN
  * FIN

Prüfsumme
  * Pseudeo Netwerk header
  * TCP Header
  * Rumpf

=== Ports ===
16 Bit
^   Von  ^  Bis  ^  Name  ^
|      0 | 1023   | Well Known       |
|   1024 | 49151  | Registered       |
|  49152 | 65535  | Dynamic/Private  |

^  Port  ^  Dienst  ^
|   21 | FTP    |
|   22 | SSH    |
|   23 | Tenet  |
|   25 | SMTP   |
|  143 | IMAP   |

==== Quittungen ====
  * Positiv (Muss so)
  * Negativ (Bringt nix)
  * Sammel (für //aufeinanderfollgende// PDUs)
  * Selektive (für //Teilmenge// von PDUs)

==== Wiederholung ====
  * Go-Back-N (Alles ab verlorenengegangener PDU)
  * Selektiv (Nur verlorenengegangene PDUs)

==== Fenstertechnick allgemein ====
Implizite Flussteuerung
  * Sendefenster von //snq// bis //snq + w// ("q", wie "quittiert")
  * Empfangsfenster von //sne// bis //sne + w*// ("e", wie "erwartet")
  * Unterschiedliches //w// und //w*// möglich
  * Nur sinvoll: //w// ≥ //w*//
  * Muss gelten: |Sequenznummern| ≥ //w + w*//
  * Gilt immer: $\text{seq} \le \text{sne} \le \text{seq} + w$
  * Empfänger ACKt //immer//
  * Für jede gesendete/empfangene bestätigung, die an der Fenster unterkante ist ist, geht es eins weiter.

==== TCP ====
  * Piggybacking: ACK wird mit Daten gesendet
  * Sammelquitungen

  * Erhöhe meine SeqNr //nach// dem senden
  * Erwarte Quittung, die wie meine SeqNr erhöht wurde/der erhöhten entspricht
  * //Nur// bei ''SYN'' und ''FIN'' um eins erhöhen

  * Aufbau
    * ''SYN''
    * ''SNY ACK''
    * ''ACK''
  * Daten
    * ''ACK''
    * ''ACK''
    * ''ACK''
    * ...
  * Abbau
    * ''FIN ACK'' (->)
    * ''ACK'' (<-)
    * ''FIN ACK'' (<-)
    * ''ACK'' (->)

**Nagle Algorithmus** \\ Bischen warten bis genug daten gemeinsam übertragen werden können
=== Flussteuerung ===
  * Credit Verfahren
  * Fenstergröße ≙ Noch freier Buffer

=== Staukontrolle ===
Effektives Sendefenster = min (//cwnd//, //RecWin//)

== Tahoe Algorithmus ==
  * Slowstart
    - //cwnd := MSS//
    - ''ACK'' empfangen => //cnwd// *= 2
  * Congestion avoidance Phase (ab threshold)
    - ''ACK'' empfangen => //cnwd// += //MSS//

  * 1. und 2. ''ACK'' Duplikat in Reihe
    * unset Segment senden
    * //threshold// unverändert
    * //cwnd// nicht ändern
  * ab 3. ''ACK'' Duplikat in Reihe
    * Verlorengegangene Daten senden (//AckNr//) (fast retransmit)
    * //threshold// unverändert
    * //cwnd := threshold + MSS ⋅ Dupikatsnummer// (fast recovery)
  * Timeout & früherer retransmit
    * //threshold// unverändert
    * //cwnd := MSS//
  * Timeout & früherer retransmit
    * //threshold := ½ ⋅ cwnd//
    * //cwnd := MSS//

== Retransmission Timer ==
Bischen größer als RTT

RTT wird aus Δ ''SYN''//(n)// und ''ACK''//(n)// gemittelt

Verbesserung: **Karn Algorithmus**
  * Wiederholung & kein Timeout: RTT unverändert
  * Wiederholung & Timeout: RTT verdoppeln
==== UDP ====
8 Byte Header

===== Layer 7 =====
  * Verzeichnisdienste
    * X.500
    * LDAP (X.500 lite)
    * DNS
==== DNS ====
  * Authoritative NS für eine Zone
    * Primary NS
    * Secondary NS

Resolver sagt er ist //nicht authoritativ//

  * Iterative Anfrage
  * Rekursive Anfrage


Flags
  * Query/Reply
  * authoritativ
  * recursion desired
  * recursion available

==== Mail ====
  * MTS (Message Transfer System)
    * MTAs (Message Transfer Agent)
  * MHS (Message Handling System)
    * MTS
    * USs (User Agent)

=== SMTP ===
Ablauf
  * handshakeing (greeting)
  * transfer
  * closure

Nachricht wird mit "''.''" in eigener Zeile beendet

==== Web ====
  * URI
    * URL: Lagerort
    * URN: Logischer Name

Problem Zustandslos
  * Statusvariablen per GET
  * Cookies
  * Sessions

Problem Langsam
  * Pipelining: ''GET 1.png, 2.png, 3.png''

==== FTP ====
Befehle sind //out-of-bound//
  * control channel (C -> S)
  * data connection
    * aktiv (C <- S)
    * passiv (C -> S)
===== Abkürzungen =====
|  ARP      | Address Resolution Protocol |
|  BCC      | Block Check Character |
|  BGP      | Border Gateway Protocol |
|  CBT      | Centered Spanning Tree |
|  CRC      | Cyclic Redundancy Check |
|  CSMA     | Carries Sense Multiple Access |
|  CSMA/CD  | Carries Sense Multiple Access / Collision Detection |
|  CTS      | Clear To Send |
|  cwnd     | congestion window |
|  DDE      | Daten//e//nd//e//inrichtung |
|  DHCP     | Dynamic Host Configuration Protocol |
|  DNS      | Domain Name System |
|  DVMRP    | Distance Vector Multicast Routing |
|  EGP      | Exterior Gateway Protocol |
|  FQDN     | Fully Qualified Domain Name |
|  FTP      | File Transfer Protocol |
|  HDLC     | Hight Level Data link Control |
|  HTTP     | Hypertext Transfer Protocol |
|  ICI      | Interface Control Information |
|  ICMP     | Internet message protocol |
|  ID       | Interface Data |
|  IDU      | Interface Data Unit |
|  IGMP     | Internet Group Management Protocol |
|  IGP      | Interior Gateway Protocol |
|  IHL      | Internet Header Length |
|  IMAP     | Internet Mail Access Protocol |
|  IPCP     | Internet Protocol Control Protocol |
|  IP       | Internet Protocol |
|  ISO-OSI  | Open Systems Interconnection |
|  LCP      | Link Control Protocol |
|  LDAP     | Lightweight Directory Access Protocol |
|  LLC      | Logical Link Control |
|  LSA      | Link State Advertisment |
|  LSP      | Link state Packet |
|  MACA     | Multiple Access with Collision Avoidance |
|  MACAW    | Multiple Access with Collision Avoidance for Wireless |
|  MAC      | Multiple Access Control |
|  MHS      | Message Handling System |
|  MOSPF    | Multicast Open Shortest Path First |
|  MSS      | Maximum Segment Size |
|  MTA      | Message Transfer Agent |
|  MTS      | Message Transfer System |
|  NCP      | Network Control Protocol |
|  NRZ      | Non Return to Zero |
|  NS       | Name Server |
|  OSPF     | Open Shortest Path First |
|  PCI      | Protocol Control Information |
|  PDU      | Protocol Data Unit |
|  POP3     | Post Office Protocol |
|  PPP      | Point-to-Point Protocol |
|  QSB      | Quell-Senken-Baum |
|  RIP      | Routing Information Protocol |
|  RLE      | Run Length Encoding |
|  RPF      | Reverse Path Forwarding |
|  RR       | Resource Record |
|  RTD      | Round Trip Delay |
|  RTS      | Request To Send |
|  RTT      | Round Trip Time |
|  RZ       | Return to Zero | 
|  SAP      | Service Access Point (Dienstzugangspunkt) |
|  SDF      | Shortest Delay First |
|  SDU      | Service Data Unit |
|  SMTP     | Simple Mail Transfer Protocol |
|  TCP      | Transmission Control Protocol |
|  ToS      | Type of Service |
|  TTL      | Time To Live |
|  UDP      | User Datagram Protocol |
|  UD       | User Data |
|  URI      | Unified Resource Identifier |
|  URL      | Uniform Resource Locator |
|  URN      | Unified Resource Name |
|  US       | User Agent |
|  VLAN     | Virtual Local Area Network |
|  VL       | Verbindungs//los// |
|  VO       | Verbindungs//orientiert// |
|  VPN      | Virtual Private Network |
users/skruppy/ext/uni/4/rnvs.txt · Zuletzt geändert: 2013/08/28 05:24 von skruppy