Dasar Transfer Data sing Bisa Dipercaya

Kanggo sing nggoleki Darmabakti kanggo mangerteni jaringan lan protokol.

Sedhela

Artikel ngrembug dhasar transmisi data dipercaya, ngleksanakake conto ing Go, kalebu UDP lan TCP. Adhedhasar kaping, два, telu lan buku "Jaringan Komputer. Top-Down Approach", yen ora saben wong ngrembug mung Tannenbaum lan Oliferov.

Protokol lapisan transportasi

Nyedhiyakake sambungan logis antarane pangolahan aplikasi sing mlaku ing macem-macem host. Saka perspektif aplikasi, sambungan logis katon kaya saluran sing langsung nyambungake proses.

Protokol lapisan transportasi didhukung dening sistem pungkasan, nanging ora dening router jaringan (kajaba - DPI). Ing sisih pangirim, lapisan transportasi ngowahi data lapisan aplikasi sing ditampa saka proses aplikasi ngirim dadi paket lapisan transportasi sing disebut segmen.

Iki ditindakake kanthi pamisah (yen perlu) pesen lapisan aplikasi dadi pecahan lan nambahake header lapisan transportasi kanggo saben.

Lapisan transportasi banjur ngliwati segmen kasebut menyang lapisan jaringan pangirim, ing ngendi segmen kasebut dibungkus ing paket lapisan jaringan (datagram) lan dikirim. Ing pungkasan panampa, lapisan jaringan ngekstrak segmen lapisan transportasi saka datagram lan diterusake menyang lapisan transportasi. Sabanjure, lapisan transportasi ngolah segmen sing ditampa supaya data kasebut kasedhiya kanggo aplikasi panampa.

Prinsip transmisi data sing dipercaya

Transmisi data sing bisa dipercaya liwat saluran sing aman

Kasus paling prasaja. Sisih ngirim mung nampa data saka lapisan ndhuwur, nggawe paket ngemot, lan dikirim menyang saluran.

Server

package main

import (
    "log"
    "net"
)

func main() {
    // IP-адрес сервера и порт
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }

    // создаем сокет с портом
    serverConn, err := net.ListenUDP("udp", serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    // отложенное закрытие соединения
    defer serverConn.Close()

    // создаем буфер для данных
    buf := make([]byte, 1024)

    // ждем соединение
    for {
        // читаем запрос
        n, addr, err := serverConn.ReadFromUDP(buf)
        // передаем данные в ВЕРХНИЙ уровень: в нашем случае stdout
        println(string(buf[0:n]), " form ", addr.IP.String())
        if err != nil {
            log.Fatal(err)
        }
        // ответа нет, т.к. это UDP + надежный канал
    }
}

Pelanggan

package main

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

func main() {
    // IP-адрес сервера и порт
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:12000")
    if err != nil {
        log.Fatal(err)
    }
    // локальный IP-адрес и порт
    localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
    if err != nil {
        log.Fatal(err)
    }
    // установка соединения
    conn, err := net.DialUDP("udp", localAddr, serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    // отложенное закрытие соединения
    defer conn.Close()

    for {
        // получение данных от ВЕРХНЕГО уровня
        fmt.Print("Введите строчное предложение > ")
        var msg string
        _, err := fmt.Scanf("%s", &msg)
        if err != nil {
            log.Fatal(err)
        }
        // передается поток байт, а не строка
        buf := []byte(msg)
        // запись (передача) в соединение
        _, err = conn.Write(buf)
        if err != nil {
            log.Fatal(err)
        }
        // 1 секундочку
        time.Sleep(time.Second * 1)
    }
}

Transmisi data sing bisa dipercaya liwat saluran kanthi kemungkinan kesalahan

Langkah sabanjure yaiku nganggep yen kabeh paket sing dikirim ditampa miturut urutan sing dikirim, nanging bit-bit kasebut bisa rusak amarga saluran kasebut kadhangkala ngirim data kanthi distorsi.

Ing kasus iki, mekanisme ing ngisor iki digunakake:

• deteksi kesalahan;
• Tanggepan;
• transmisi maneh.

Protokol transfer data sing bisa dipercaya sing nduweni mekanisme sing padha kanggo mbaleni transmisi kaping pirang-pirang diarani protokol Repeat ReQuest (ARQ).
Kajaba iku, iku worth considering kamungkinan kasalahan ing kuitansi, nalika pihak sing nampa ora bakal nampa informasi bab asil transfer paket pungkasan.
Solusi kanggo masalah iki, uga digunakake ing TCP, kanggo nambah kolom anyar menyang paket data ngemot nomer urutan paket.

Transmisi data sing bisa dipercaya liwat saluran sing ora bisa dipercaya tundhuk distorsi lan mundhut paket

Bebarengan karo distorsi, sayangé, ana mundhut paket ing jaringan.
Lan kanggo ngatasi masalah iki, mekanisme dibutuhake:

• nemtokake kasunyatan mundhut paket;
• ngirim maneh paket ilang menyang pihak sing nampa.

Kajaba iku, saliyane mundhut paket, perlu kanggo nyedhiyakake kemungkinan mundhut kuitansi utawa, yen ora ana sing ilang, pangiriman kanthi wektu tundha sing signifikan. Ing kabeh kasus, perkara sing padha ditindakake: paket kasebut dikirim maneh. Kanggo ngontrol wektu, mekanisme iki nggunakake timer countdown, sing ngidini sampeyan nemtokake pungkasan interval nunggu. Dadi ing paket net TCPKeepAlive disetel dadi 15 detik kanthi standar:

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

Sisih ngirim kudu miwiti timer saben wektu paket dikirim (loro pisanan lan kaping pindho), nangani interupsi saka timer lan mungkasi.

Dadi, kita wis kenal karo konsep kunci protokol transfer data sing dipercaya:

• checksums;
• nomer urutan paket;
• timer;
• kuitansi positif lan negatif.

Nanging ora mung kuwi!

Protokol transfer data sing bisa dipercaya kanthi pipelining

Ing varian sing wis kita nimbang, protokol pangiriman sing dipercaya banget ora efisien. Iku wiwit "alon mudhun" transmisi diwenehake dening saluran komunikasi minangka RTT mundhak. Kanggo nambah efisiensi lan nggunakake kapasitas saluran komunikasi, pipelining digunakake.

Panggunaan pipelining nyebabake:

• nambah sawetara nomer urutan, amarga kabeh paket sing dikirim (kajaba transmisi ulang) kudu diidentifikasi kanthi unik;
• perlu kanggo nambah buffer ing sisih ngirim lan nampa.

Rentang nomer urutan lan syarat ukuran buffer gumantung marang tumindak sing ditindakake protokol kanggo nanggepi korupsi, mundhut, lan wektu tundha paket. Ing kasus pipelining, ana rong cara kanggo mbenerake kesalahan:

• bali N paket bali;
• pengulangan selektif.

Mbalik N paket - sliding window protocol

Pangirim kudu ndhukung telung jinis acara:

• nelpon kanthi protokol tingkat sing luwih dhuwur. Nalika fungsi ngirim data diarani "saka ndhuwur", sisih ngirim pisanan mriksa tingkat ngisi jendhela (yaiku, anane pesen dikirim N nunggu panrimo). Yen jendhela kosong, paket anyar digawe lan dikirim, lan nilai variabel dianyari. Yen ora, sisih ngirim bali data menyang lapisan ndhuwur, lan iki pratondo implisit sing jendhela wis kebak. Biasane lapisan ndhuwur bakal nyoba ngirim data maneh sawise sawetara wektu. Ing aplikasi nyata, pangirim bisa uga bakal buffer data (tinimbang ngirim langsung) utawa duwe mekanisme sinkronisasi (kayata semafor utawa gendera) sing ngidini lapisan ndhuwur nelpon fungsi ngirim mung nalika jendhela kosong. .
• nampa konfirmasi. Ing protokol, kanggo paket kanthi nomer urutan N, pangenalan umum ditanggepi sing nuduhake yen kabeh paket kanthi nomer urutan sadurunge N kasil ditampa.
• interval nunggu wis kadaluwarsa. Kanggo nemtokake kasunyatan mundhut lan wektu tundha saka paket lan kuitansi, protokol nggunakake timer. Yen interval wektu entek kadaluwarsa, sisih ngirim ngirim maneh kabeh paket sing ora diakoni.

Ambalan selektif

Nalika ukuran jendhela lan produk tundha panyebaran throughput gedhe, akeh paket bisa uga ana ing pipa. Ing kasus kaya mengkono, kesalahan paket siji bisa nyebabake akeh paket dikirim maneh, sing paling akeh ora dibutuhake.

Conto:

Paling apik teori praktik diklumpukake ing implementasine praktis TCP. Lan yen ana sing ngerti carane paling apik - welcome.

Server

package main

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

func main() {
    // создаем сокет с портом 
    ln, err := net.Listen("tcp", ":8081")
    if err != nil {
        log.Fatalln(err)
    }
    // ожидание вызова
    conn, _ := ln.Accept()

    for {
        // считывание данных
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // вывод сообщения в stdout
        fmt.Print("Message Received:", string(msg))
        // перевод строки в верхний регистр
        newMsg := strings.ToUpper(msg)
        // отправка данных
        conn.Write([]byte(newMsg + "n"))
    }
}

Pelanggan

package main

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

func main() {
    // установка соединения
    conn, err := net.Dial("tcp", "127.0.0.1:8081")
    if err != nil {
        log.Fatalln(err)
    }

    for {
        // считывание данных с stdin
        reader := bufio.NewReader(os.Stdin)
        fmt.Print("Text to send: ")
        // построчно
        text, err := reader.ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // отправка
        fmt.Fprintf(conn, text+"n")
        // прием
        msg, err := bufio.NewReader(conn).ReadString('n')
        if err != nil {
            log.Fatalln(err)
        }
        // вывод полученного ответа
        fmt.Print("Msg from Server: " + msg)
    }
}

kesimpulan

Mekanisme kanggo njamin transfer lan panggunaan data sing dipercaya

Mekanisme
Aplikasi, komentar

Priksa jumlah
Digunakake kanggo ndeteksi kesalahan bit ing paket sing dikirim

Timer
Ngetung interval wektu entek lan nuduhake yen wis kadaluwarsa. Sing terakhir tegese kanthi kemungkinan dhuwur paket utawa kuitansi kasebut ilang sajrone transmisi. Yen paket dikirim kanthi wektu tundha, nanging ora ilang (kadaluwarsa prematur interval wektu entek), utawa kuitansi ilang, retransmission ndadékaké menyang duplikat paket ing sisih panampa.

nomer seri
Digunakake kanggo nomer urut paket data sing dikirim saka pangirim menyang panampa. Kesenjangan ing nomer urutan paket sing ditampa ngidini panrima ndeteksi mundhut paket. Nomer urutan paket sing padha tegese paket kasebut minangka duplikat saben liyane

Konfirmasi
Digawe dening mburi panampa lan nuduhake menyang mburi ngirim sing cocog paket utawa klompok paket wis kasil ditampa. Biasane, pangenalan ngemot nomer urutan paket sing wis ditampa. Gumantung ing protokol, konfirmasi individu lan klompok dibedakake

Konfirmasi negatif
Digunakake dening panampa kanggo ngandhani pangirim yen paket kasebut ditampa kanthi ora bener. Pengakuan negatif biasane kalebu nomer urutan paket sing ora ditampa kanthi bener

Jendela, conveyorization
Matesi sawetara nomer urutan sing bisa digunakake kanggo ngirim paket. Multicast lan jabat tangan bisa nambah throughput protokol kanthi signifikan dibandhingake karo nunggu pangakuan. Kaya sing bakal kita deleng, ukuran jendhela bisa diwilang adhedhasar kemampuan resepsi lan buffering saka mburi panampa, uga tingkat beban jaringan.

Conto liyane nggunakake Go kanggo jaringan

В repositori.

Source: www.habr.com