🥇Grunderna för pålitlig dataöverföring

Till dem som strävar vill förstå nätverk och protokoll.

Kortfattat

Denna artikel behandlar grunderna för säker datatransmission och tillhandahåller exempel på Go, inklusive UDP och TCP. Inspirerat av ett, två, tre och boken "Computer Networks. Nedtill upp-ansats", eftersom alla bara diskuterar Tanenbaum och Olifer.

Transportprotokoll

Ger en logisk anslutning mellan applikationsprocesser som körs på olika värdar. En logisk anslutning, från applikationernas perspektiv, framstår som en kanal som direkt kopplar samman processerna.

Transportprotokoll underhålls av slutliga system men inte av nätverksroutrar (utom — DPI). På avsändarsidan omvandlar transportlagret de applikationsdata som mottas från den skickande applikationsprocessen till transportnivåpaket, kallade segment.

Detta görs genom att dela upp (vid behov) applikationsmeddelanden i fragment och lägga till en transportlagersrubrik till varje.

Därefter överför transportlagret segmentet till avsändarens nätverksnivå, där segmentet inkapslas i ett nätverksnivåpaket (datagram) och skickas. På mottagarsidan hämtar nätverksnivån transportlagssegmentet från datagrammet och överför det uppåt till transportlagret. Sedan bearbetar transportlagret det mottagna segmentet så att dess data blir tillgängliga för mottagarens applikation.

Principer för säker datatransmission

Säker datatransmission över en helt pålitlig kanal

Det enklaste fallet. Avsändarsidan tar helt enkelt emot data från övre lagret, skapar ett paket som innehåller dem och skickar det genom kanalen.

Servern

package main

import (
    "log"
    "net"
)

func main() {
    \\ Serverns IP-adress och port
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }

    \\ Skapa en socket med porten
    serverConn, err := net.ListenUDP("udp", serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    \\ Fördröjd stängning av anslutningen
    defer serverConn.Close()

    \\ Skapa en buffert för data
    buf := make([]byte, 1024)

    \\ Vänta på anslutning
    for {
        \\ Läs förfrågan
        n, addr, err := serverConn.ReadFromUDP(buf)
        \\ Skicka data till ÖVRE nivån: i vårt fall stdout
        println(string(buf[0:n]), " form ", addr.IP.String())
        if err != nil {
            log.Fatal(err)
        }
        \\ Det finns inget svar eftersom det är UDP + en pålitlig kanal
    }
}

Klient

package main

import (
    "fmt"
    "log"
    "net"
    "time"
)

func main() {
    \\ Serverns IP-adress och port
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }
    \\ Lokal IP-adress och port
    localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
    if err != nil {
        log.Fatal(err)
    }
    \\ Ställ in anslutning
    conn, err := net.DialUDP("udp", localAddr, serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    \\ Fördröjd stängning av anslutningen
    defer conn.Close()

    for {
        \\ Ta emot data från ÖVRE nivån
        fmt.Print("Ange en fras > ")
        var msg string
        _, err := fmt.Scanf("%s", &msg)
        if err != nil {
            log.Fatal(err)
        }
        \\ Ström av bytes skickas, inte sträng
        buf := []byte(msg)
        \\ Skriv (skicka) till anslutningen
        _, err = conn.Write(buf)
        if err != nil {
            log.Fatal(err)
        }
        \\ Vänta en sekund
        time.Sleep(time.Second * 1)
    }
}

Pålitlig dataöverföring över en kanal med potentiella fel

Nästa steg är att anta att alla sända paket har mottagits i den ordning de skickades, men bitarna kan vara skadade, eftersom kanalen ibland överför data med förvrängningar.

I sådana fall tillämpas mekanismer:

felupptäckning;
återkoppling;
återöverföring.

Protokoll för pålitlig dataöverföring, som har sådana mekanismer för upprepning av överföring, kallas protokoll med automatisk begäran om återöverföring (Automatic Repeat reQuest, ARQ).
Dessutom bör man beakta möjligheten för fel i kvittenserna, när mottagarsidan inte får någon information om resultatet av överföringen av det senaste paketet.
Lösningen på denna uppgift, som även används i TCP, är att lägga till ett nytt fält med paketdata som innehåller sekvensnummer för paketet.

Tillförlitlig dataöverföring över en opålitlig kanal som kan orsaka förvrängning och paketförlust

Tyvärr förekommer paketförlust i nätverket samtidigt som förvrängningar.
Och för att lösa detta problem krävs mekanismer:

för att identifiera paketförlust;
återleverans av förlorade paket till mottagarsidan.

Utöver paketförlusten måste man även överväga möjligheten av kvittotabort, eller om inget har förlorats, att kvittot levereras med betydande fördröjning. I alla fall görs samma sak: paketet sänds om. För att kontrollera tiden i denna mekanism används en nedräknare som möjliggör att fastställa slutet av väntetiden. Så i paketet net är TCPKeepAlive-parametern som standard inställd på 15 sekunder:

// defaultTCPKeepAlive is a default constant value for TCPKeepAlive times
// See golang.org/issue/31510
const (
    defaultTCPKeepAlive = 15 * time.Second
)

Avsändarsidan måste starta nedräknaren varje gång ett paket sänds (både vid första och återleverans), hantera avbrott från nedräknaren och stoppa den.

Så vi har blivit bekanta med de viktigaste begreppen för protokoll för pålitlig dataöverföring:

kontrollsummor;
paketordningsnummer;
timers;
positiva och negativa kvitton.

Men det är inte allt!

Protokoll för pålitlig dataöverföring med pipelining

I det alternativ som vi redan har granskat är protokollet för pålitlig leverans mycket ineffektivt. Det börjar "sakta ner" överföringen som tillhandahålls av kommunikationskanalen när RTT ökar. För att öka effektiviteten och bättre utnyttja bandbredden i kommunikationskanalen används pipelining.

Användning av pipelining leder till:

ökat intervall för paketordningsnummer, eftersom alla skickade paket (utom återlevererade) måste kunna identifieras entydigt;
behovet av att öka buffrar på sändande och mottagande sida.

Intervall för paketordningsnummer och krav på bufferstorlekar beror på de åtgärder som protokollet vidtar som svar på förvrängning, pakettapp och paketfördröjning. Vid pipelining finns det två metoder för felkorrigering:

återgång av N paket tillbaka;
urval av upprepning.

Återvändande av N paket tillbaka — glidande fönsterprotokoll

Avsändaren måste stödja tre typer av händelser:

anrop till ett protokoll av högre nivå. När funktionen för att skicka data anropas "uppifrån", kontrollerar den sändande sidan först hur mycket utrymme som finns i fönstret (det vill säga om N meddelanden har skickats och väntar på bekräftelser). Om fönstret inte är fullt, bildas ett nytt paket och sänds, och variablerna uppdateras. Annars returnerar den sändande sidan datan till den högre nivån, vilket är en tyst indikation på att fönstret är fullt. Vanligtvis gör den högre nivån ett nytt försök att skicka data efter en tid. I en verklig applikation skulle avsändaren sannolikt antingen buffra data (istället för att direkt skicka dem) eller ha en synkroniseringsmekanism (till exempel en semafor eller flagga) som tillåter den högre nivån att anropa funktionen för att skicka data endast när fönstret inte är fullt.
mottagande av bekräftelse. I protokollet utfärdas en gemensam bekräftelse för paketet med nummer N, som anger att alla paket med nummers som föregår N har tagits emot framgångsrikt.
timeout. För att fastställa förluster och fördröjningar av paket och bekräftelser använder protokollet en timer. Om timeouten inträffar skickar den sändande sidan om alla skickade, obekräftade paket.

selektivt återutsändande

När fönstrets storlek och produkten av bandbredd och spridningsfördröjning är stora, kan det finnas många paket i rörledningen. I ett sådant fall kan felet hos ett enskilt paket orsaka återutsändning av många paket, varav de flesta inte behövdes.

Exempel

Bästa teoretiska metoder samlas i praktisk tillämpning TCP. Och om någon vet hur man gör det bättre — välkommen.

Servern

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
)

func main() {
    // skapa en socket med port
    ln, err := net.Listen("tcp", ":8081")
    if err != nil {
        log.Fatalln(err)
    }
    // vänta på anrop
    conn, _ := ln.Accept()

    for {
        // läsa data
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // skriva meddelande till stdout
        fmt.Print("Meddelande mottaget:", string(msg))
        // göra meddelandet till versaler
        newMsg := strings.ToUpper(msg)
        // skicka data
        conn.Write([]byte(newMsg + "n"))
    }
}

Klient

paket huvud

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
)

func huvud() {
    	// etablera anslutning
    conn, err := net.Dial("tcp", "127.0.0.1:8081")
    if err != nil {
        log.Fatalln(err)
    }

    for {
        	// läsa data från stdin
        reader := bufio.NewReader(os.Stdin)
        fmt.Print("Text att skicka: ")
        	// rad för rad
        text, err := reader.ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        	// skicka
        fmt.Fprintf(conn, text+"n")
        	// ta emot
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        	// skriv ut det mottagna svaret
        fmt.Print("Meddelande från server: " + msg)
    }
}

Utdata

Mekanismer som säkerställer pålitlig datatransmission och dess användning

Mekanismen
Tillämpning, kommentar

Kontrollsumma
Används för att upptäcka bitfel i det överförda paketet

Timer
Nedräkning av tidsintervallet och indikation på dess utgång. Detta innebär att paketet eller dess bekräftelse sannolikt har gått förlorad under överföringen. Om paketet levereras med fördröjning, men inte går förlorat (för tidig tidsutgång), eller om bekräftelsen går förlorad, resulterar en omöverföring i en duplicering av paketet på mottagarens sida.

Sekvensnummer
Används för sekventiell numrering av datapaket som överförs från avsändare till mottagare. Hål i sekvensnumren på de mottagna paketen gör att mottagaren kan upptäcka paketförlust. Duplicerade sekvensnummer av paket indikerar att paketen dupliceras.

Bekräftelse
Genereras av mottagarsidan och anger till avsändarsidan att det aktuella paketet eller paketgrupp har mottagits framgångsrikt. Bekräftelsen innehåller vanligtvis sekvensnummer för de framgångsrikt mottagna paketen. Beroende på protokollet särskiljs individuella och grupperade bekräftelser.

Negativ bekräftelse
Används av mottagaren för att meddela avsändaren att paketet har mottagits felaktigt. Den negativa bekräftelsen inkluderar vanligtvis sekvensnumret för det paket som inte har mottagits korrekt.

Fönster, pipelining
Begränsar intervallet av ordningsnummer som kan användas för att överföra paket. Gruppenöverföring och handskakning gör det möjligt att avsevärt öka protokollens bandbredd jämfört med läget avvaktan på bekräftelser. Som vi kommer att se kan fönsterstorleken beräknas baserat på mottagarens mottagnings- och buffringskapacitet samt nätverksbelastningen.