GBN ist die Abkürzung für Go-Back-N. GBN ist ein Protokoll für die Übermittlung von Paketen in einer Pipeline. Der Sender sendet also Pakete, während andere noch auf dem Weg sind.

Um das Protokoll zu erklären, wird immer folgende Darstellung gebraucht:

        | Sender                            |  Empfänger
--------|-----------------------------------|-----------------------------------
Pakete: ||X  X  X  X| X  X  X  X  X  X  X   | |X| X  X  X  X  X  X  X  X  X  X
Nr.:    ||0  1  2  3| 4  5  6  7  8  9 10   | |0| 1  2  3  4  5  6  7  8  9  10

Der Sender definiert ein sogenanntes Fenster mit N Paketen. Dieses Fenster kann sich (nach rechts) bewegen. Nur Pakete innerhalb dieses Fensters können versendet werden. Sie werden nun vom Sender alle nacheinander versendet, ohne explizit darauf zu warten, dass ein ACK zurückgeschickt wird.

Versenden aller Pakete innerhalb des Fensters:

        | Sender                            |  Empfänger
--------|-----------------------------------|-----------------------------------
Pakete: ||I  I  I  I| X  X  X  X  X  X  X   | |X| X  X  X  X  X  X  X  X  X  X
Nr.:    ||0  1  2  3| 4  5  6  7  8  9 10   | |0| 1  2  3  4  5  6  7  8  9 10

Für jedes Paket, dass der Empfänger erhält, wird überprüft, ob es die Nummer trägt, die er erwartet. Wenn dem so ist, so sendet er ein ACK zurück mit der Nummer, die er als nächstes erwartet. Der Sender empfängt dieses ACK und verschiebt sein Fenster um eines weiter nach rechts.

Erfolgreiche Übermittlung des Pakets 0:

        | Sender                            |  Empfänger
--------|-----------------------------------|-----------------------------------
Pakete: |O |I  I  I  X|  X  X  X  X  X  X   | O |X| X  X  X  X  X  X  X  X  X
Nr.:    |0 |1  2  3  4|  5  6  7  8  9 10   | 0 |1| 2  3  4  5  6  7  8  9 10

Das wäre eigentlich bereits alles. Der Sender kann nun beispielsweise auch das Paket mit der Nummer 4 senden. Der Empfänger empfängt vielleicht bereits das Paket 1 und auch 2 und sendet dies per ACK zurück. Der Sender kann somit das Fenster wiederum weiterschieben und die neuen Pakete 5 und 6 versenden.

        | Sender                            |  Empfänger
--------|-----------------------------------|-----------------------------------
Pakete: |O  I  I |I  I  I  I|  X  X  X  X   | O  O  O |X| X  X  X  X  X  X  X
Nr.:    |0  1  2 |3  4  5  6|  7  8  9 10   | 0  1  2 |3| 4  5  6  7  8  9 10

Falls nun ein Fehler passieren sollte, beispielsweise, dass kein ACK zurückkommt, so würde der Sender einfach nach einer gewissen Zeit nochmals alle Pakete des Fensters versenden. Geht irgendein Datenpaket verloren, so meldet der Empfänger einfach jeweils zurück, welche Nummer das Paket haben muss, das er als nächstes empfangen kann.

Dieses Verfahren ist absolut fehlerfrei, irgendwann wird der Empfänger alles empfangen haben. Leider aber ist es im schlimmsten Fall immer noch sehr ineffizient: Wenn nur ein Fehler passiert, kann es sein, dass das gesamte Fenster nochmals vollständig übermittelt werden muss (deshalb heisst dieses Verfahren aus Go-back-N). Somit wäre es eher angebracht, kleine Fenster zu machen, jedoch wäre dann das ganze Pipelining im Eimer.