Zásuvky Berkeley - Berkeley sockets

Berkeley sockets je rozhraní pro programování aplikací (API) pro internetové zásuvky a sokety domény Unix , používané pro meziprocesovou komunikaci (IPC). Je běžně implementován jako knihovna propojitelných modulů. Původem byl operační systém 4.2BSD Unix , který byl vydán v roce 1983.

Zásuvka je abstraktní reprezentace ( rukojeť ) pro místní koncový bod sítě komunikační cesty. Rozhraní Berkeley sockets API jej představuje jako deskriptor souboru ( popisovač souboru ) ve filozofii Unixu, který poskytuje společné rozhraní pro vstup a výstup datových proudů .

Zásuvky Berkeley se s malou úpravou změnily z de facto standardu na součást specifikace POSIX . Termín zásuvky POSIX je v zásadě synonymem pro zásuvky Berkeley , ale jsou také známé jako zásuvky BSD , což je potvrzení první implementace v distribuci softwaru Berkeley .

Historie a implementace

Zásuvky Berkeley pocházejí z operačního systému 4.2BSD Unix , vydaného v roce 1983, jako programovací rozhraní. Teprve v roce 1989 však mohla Kalifornská univerzita v Berkeley uvolnit verze operačního systému a síťové knihovny bez licenčních omezení patentovaného Unixu AT&T Corporation .

Všechny moderní operační systémy implementují verzi rozhraní soketu Berkeley. Stalo se standardním rozhraním pro aplikace běžící na internetu . I implementace Winsock pro MS Windows, vytvořená nepřidruženými vývojáři, standard přesně dodržuje.

BSD Sockets API je napsán v programovacím jazyce C . Většina ostatních programovacích jazyků poskytuje podobná rozhraní, obvykle napsaná jako knihovna wrapperů založená na C API.

Zásuvky BSD a POSIX

Jak se rozhraní API Berkeley soketu vyvíjelo a nakonec přineslo rozhraní API POSIX soketu, některé funkce byly zastaralé nebo odstraněny a nahrazeny jinými. Rozhraní POSIX API je také navrženo tak, aby bylo možné provést reentrant .

Alternativy

Tyto STREAMS založené Transport Layer Interface (TLI) API nabízí alternativu k socket API. Mnoho systémů, které poskytují API TLI, také poskytuje API Berkeley soketu.

Non-Unix systémy často vystavují Berkeley socket API s překladovou vrstvou nativnímu síťovému API. Plan 9 a Genode používají spíše API souborového systému s řídícími soubory než deskriptory souborů.

Soubory záhlaví

Rozhraní soketu Berkeley je definováno v několika souborech záhlaví. Názvy a obsah těchto souborů se mezi implementacemi mírně liší. Obecně zahrnují:

Funkce Socket API

Vývojový diagram transakce klient-server pomocí soketů s protokolem TCP (Transmission Control Protocol).

API Berkeley socket obvykle poskytuje následující funkce:

• socket () vytvoří nový soket určitého typu, identifikovaný celočíselným číslem, a přidělí mu systémové prostředky.
• bind () se obvykle používá na straně serveru a spojuje soket se strukturou adresy soketu, tj. zadanou místní IP adresou a číslem portu.
• listen () se používá na straně serveru a způsobí, že vázaný soket TCP přejde do stavu naslouchání.
• connect () se používá na straně klienta a soketu přiřazuje volné číslo místního portu. V případě soketu TCP způsobí pokus o navázání nového připojení TCP.
• na straně serveru se používá přijmout () . Přijímá přijatý příchozí pokus o vytvoření nového připojení TCP ze vzdáleného klienta a vytvoří nový soket spojený s párem adres soketů tohoto připojení.
• send () , recv () , sendto () a recvfrom () se používají k odesílání a přijímání dat. Lze také použít standardní funkce write () a read () .
• close () způsobí, že systém uvolní prostředky přidělené soketu. V případě TCP je připojení ukončeno.
• gethostbyname () a gethostbyaddr () se používají k překladu názvů a adres hostitelů. Pouze IPv4.
• select () se používá k pozastavení, čekání na to, aby jeden nebo více poskytnutých seznamů soketů bylo připraveno ke čtení, připraveno k zápisu nebo obsahujících chyby.
• poll () se používá ke kontrole stavu soketu v sadě soketů. Sada může být testována, aby se zjistilo, zda lze do jakéhokoli soketu zapisovat, číst z něj nebo zda došlo k chybě.
• getsockopt () se používá k načtení aktuální hodnoty konkrétní možnosti soketu pro zadaný soket.
• setsockopt () se používá k nastavení konkrétní možnosti soketu pro zadaný soket.

zásuvka

Funkce socket () vytvoří koncový bod pro komunikaci a vrátí popisovač souboru pro soket. Používá tři argumenty:

• doména , která určuje rodinu protokolů vytvořeného soketu. Například:
  • AF_INET pro síťový protokol IPv4 (pouze IPv4)
  • AF_INET6 pro IPv6 (a v některých případech zpětně kompatibilní s IPv4)
  • AF_UNIX pro místní soket (pomocí speciálního uzlu souborového systému)
• typ , jeden z:
  • SOCK_STREAM (spolehlivá služba orientovaná na proud nebo Stream Sockets )
  • SOCK_DGRAM (služba datagramu nebo zásuvky datagramu )
  • SOCK_SEQPACKET (spolehlivá sekvenční paketová služba)
  • SOCK_RAW (surové protokoly na vrcholu síťové vrstvy)
• protokol určující skutečný transportní protokol, který se má použít. Nejběžnější jsou IPPROTO_TCP , IPPROTO_SCTP , IPPROTO_UDP , IPPROTO_DCCP . Tyto protokoly jsou specifikovány v souboru netinet/in.h . Hodnotu 0 lze použít k výběru výchozího protokolu z vybrané domény a typu.

Funkce vrátí -1, pokud došlo k chybě. V opačném případě vrátí celé číslo představující nově přiřazený deskriptor.

svázat

bind () spojuje soket s adresou. Když je soket vytvořen pomocí socket () , je mu přidělena pouze rodina protokolů, ale není mu přiřazena adresa. Toto přidružení musí být provedeno, aby soket mohl přijímat připojení od jiných hostitelů. Funkce má tři argumenty:

• sockfd , deskriptor představující soket
• my_addr , ukazatel na strukturu sockaddr představující adresu, na kterou se má vázat.
• addrlen , pole typu socklen_t určující velikost struktury sockaddr .

bind () vrací 0 při úspěchu a -1, pokud dojde k chybě.

poslouchat

Poté, co byl soket spojen s adresou, Listen () jej připraví pro příchozí připojení. To je však nutné pouze pro datové režimy orientované na proud (orientované na připojení), tj. Pro typy soketů ( SOCK_STREAM , SOCK_SEQPACKET ). Listen () vyžaduje dva argumenty:

• sockfd , platný deskriptor soketu.
• nevyřízené položky , celé číslo představující počet čekajících připojení, která lze zařadit do fronty v libovolném okamžiku. Operační systém obvykle na tuto hodnotu stanoví omezení.

Jakmile je připojení přijato, je odpojeno. Při úspěchu se vrátí 0. Pokud dojde k chybě, vrátí se -1.

přijmout

Když aplikace naslouchá streamově orientovaným spojením od jiných hostitelů, je na takové události upozorněna (viz funkce select () ) a musí inicializovat připojení pomocí funkce receive () . Vytvoří nový soket pro každé připojení a odebere připojení z fronty naslouchání. Funkce má následující argumenty:

• sockfd , deskriptor naslouchacího soketu, který má připojení ve frontě.
• cliaddr , ukazatel na strukturu sockaddr pro příjem informací o adrese klienta.
• addrlen , ukazatel na umístění socklen_t, který určuje velikost struktury adresy klienta předané akceptovat (). Když se vrátí receive () , toto umístění obsahuje velikost (v bajtech) struktury.

accept () vrací nový deskriptor soketu pro přijaté připojení, nebo hodnotu -1, pokud dojde k chybě. Veškerá další komunikace se vzdáleným hostitelem nyní probíhá prostřednictvím této nové zásuvky.

Datagramové sokety nevyžadují zpracování pomocí receive (), protože přijímač může okamžitě reagovat na požadavek pomocí naslouchacího soketu.

připojit

connect () navazuje přímé komunikační spojení na konkrétního vzdáleného hostitele identifikovaného jeho adresou prostřednictvím soketu, identifikovaného jeho deskriptorem souboru.

Při použití protokolu orientovaného na připojení se tím vytvoří připojení. Některé typy protokolů jsou bez připojení, zejména protokol User Datagram Protocol . Při použití s nespojované protokoly, spojová definuje vzdálená adresa pro odesílání a přijímání dat, což umožňuje použití funkcí, jako je odesílání a recv . V těchto případech funkce connect brání příjmu datagramů z jiných zdrojů.

connect () vrací celé číslo představující chybový kód: 0 představuje úspěch, zatímco –1 představuje chybu. Historicky je v systémech odvozených z BSD stav deskriptoru soketu nedefinován, pokud volání k připojení selže (jak je uvedeno ve specifikaci Single Unix), takže přenosné aplikace by měly okamžitě zavřít deskriptor soketu a získat nový deskriptor s socket (), v případě, že volání connect () selže.

gethostbyname a gethostbyaddr

Funkce gethostbyname () a gethostbyaddr () se používají k překladu názvů a adres hostitelů v systému názvů domén nebo v jiných mechanismech překladače místního hostitele (např. Vyhledávání /etc /hosts). Vracejí ukazatel na objekt typu struct hostent , který popisuje hostitele internetového protokolu . Funkce používají následující argumenty:

• name udává název DNS hostitele.
• addr určuje ukazatel na strukturu in_addr obsahující adresu hostitele.
• len určuje délku adresy v adresách .
• type určuje typ rodiny adres (např. AF_INET) adresy hostitele.

Funkce v případě chyby vrátí ukazatel NULL. V takovém případě lze zkontrolovat externí celé číslo h_errno a zjistit, zda se jedná o dočasné selhání nebo neplatný nebo neznámý hostitel. Jinak je vrácen platný hostitel struktury * .

Tyto funkce nejsou striktně součástí rozhraní API BSD socket, ale často se používají ve spojení s funkcemi API. Kromě toho jsou tyto funkce nyní považovány za starší rozhraní pro dotazování systému názvů domén. Byly definovány nové funkce, které jsou zcela agnostické pro protokol (podporující IPv6). Tyto nové funkce jsou getaddrinfo () a getnameinfo () a jsou založeny na nové datové struktuře addrinfo .

Rodiny protokolů a adres

Berkeley socket API je obecné rozhraní pro síťovou a meziprocesovou komunikaci a podporuje použití různých síťových protokolů a adresových architektur.

Následující seznam uvádí vzorkování rodin protokolů (kterým předchází standardní symbolický identifikátor) definovaných v moderní implementaci Linuxu nebo BSD :

Soket pro komunikaci je vytvořen s socket()funkcí zadáním požadované rodiny protokolů ( PF_ -identifier ) jako argumentu.

Původní koncepce návrhu rozhraní soketu rozlišovala mezi typy protokolů (rodinami) a konkrétními typy adres, které každý může používat. Bylo představeno, že rodina protokolů může mít několik typů adres. Typy adres byly definovány dalšími symbolickými konstantami pomocí předpony AF místo PF . Identifikátory AF jsou určeny pro všechny datové struktury, které se konkrétně zabývají typem adresy, a nikoli rodinou protokolů. Tento koncept oddělení protokolu a typu adresy však nenašel podporu implementace a AF -konstanty byly definovány odpovídajícím identifikátorem protokolu, přičemž rozdíl mezi konstantami AF a PF ponechal jako technický argument bez praktických důsledků. Ve správném používání obou forem skutečně existuje velký zmatek.

Specifikace POSIX.1—2008 neurčuje žádné PF -konstanty, ale pouze AF -konstanty

Surové zásuvky

Surové sokety poskytují jednoduché rozhraní, které obchází zpracování pomocí zásobníku TCP/IP hostitele. Umožňují implementaci síťových protokolů v uživatelském prostoru a pomáhají při ladění zásobníku protokolů. Surové sokety používají některé služby, například ICMP , které fungují na internetové vrstvě modelu TCP/IP.

Režim blokování a neblokování

Zásuvky Berkeley mohou pracovat v jednom ze dvou režimů: blokování nebo neblokování.

Blokovací soket nevrací řízení, dokud neodeslal (nebo nepřijal) některá nebo všechna data specifikovaná pro tuto operaci. Je normální, že blokovací soket neposílá všechna data. Aplikace musí zkontrolovat návratovou hodnotu, aby určila, kolik bytů bylo odesláno nebo přijato, a musí znovu odeslat všechna data, která již nebyla zpracována. Při používání blokovacích soketů je třeba věnovat zvláštní pozornost funkci accept (), protože po označení čitelnosti se může stále blokovat, pokud se klient během fáze připojení odpojí.

Neblokující soket vrací vše, co je ve vyrovnávací paměti pro příjem, a okamžitě pokračuje. Pokud nejsou napsány správně, programy využívající neblokující sokety jsou obzvláště citlivé na podmínky závodu kvůli rozdílům v rychlosti připojení k síti.

Zásuvka je obvykle nastavena na režim blokování nebo neblokování pomocí funkcí fcntl a ioctl .

Zakončovací zásuvky

Operační systém neuvolní prostředky přidělené soketu, dokud není soket uzavřen. To je zvláště důležité v případě, že volání připojení selže a bude opakováno.

Když aplikace zavře soket, zničí se pouze rozhraní soketu. Je zodpovědností jádra interně zničit soket. Někdy může soket přejít do stavu TIME_WAIT na straně serveru až na 4 minuty.

Na systémech SVR4close() může použití dat zahodit. V shutdown()těchto systémech může být vyžadováno použití nebo SO_LINGER, aby byla zaručena dodávka všech dat.

Příklad klient-server pomocí TCP

Transmission Control Protocol (TCP) je orientovaný na připojení protokol, který nabízí celou řadu oprav chyb a výkonu funkcí pro přenos bajtů proudů. Proces vytvoří soket TCP voláním socket()funkce s parametry pro rodinu protokolů ( PF INET , PF_INET6 ), režim soketu pro Stream Sockets ( SOCK_STREAM ) a identifikátor protokolu IP pro TCP ( IPPROTO_TCP ).

Server

Zřízení serveru TCP zahrnuje následující základní kroky:

• Vytvoření soketu TCP pomocí volání socket ().
• Vázání soketu na naslouchací port ( bind () ) po nastavení čísla portu.
• Příprava zásuvky pro naslouchání připojení (což z ní činí zásuvku pro naslouchání) s voláním k naslouchání () .
• Přijímání příchozích připojení ( přijmout () ). To blokuje proces, dokud není přijato příchozí připojení, a vrátí popisovač soketu pro přijaté připojení. Počáteční deskriptor zůstává deskriptorem naslouchání a přijetí () lze kdykoli znovu zavolat pomocí tohoto soketu, dokud není uzavřeno.
• Komunikace se vzdáleným hostitelem pomocí funkcí API send () a recv () , stejně jako s obecnými funkcemi write () a read () .
• Zavření každé zásuvky, která byla otevřena po použití, pomocí funkce close ()

Následující program vytvoří server TCP naslouchající na portu číslo 1100:

  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  
  int main(void)
  {
    struct sockaddr_in sa;
    int SocketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (SocketFD == -1) {
      perror("cannot create socket");
      exit(EXIT_FAILURE);
    }
  
    memset(&sa, 0, sizeof sa);
  
    sa.sin_family = AF_INET;
    sa.sin_port = htons(1100);
    sa.sin_addr.s_addr = htonl(INADDR_ANY);
  
    if (bind(SocketFD,(struct sockaddr *)&sa, sizeof sa) == -1) {
      perror("bind failed");
      close(SocketFD);
      exit(EXIT_FAILURE);
    }
  
    if (listen(SocketFD, 10) == -1) {
      perror("listen failed");
      close(SocketFD);
      exit(EXIT_FAILURE);
    }
  
    for (;;) {
      int ConnectFD = accept(SocketFD, NULL, NULL);
  
      if (ConnectFD == -1) {
        perror("accept failed");
        close(SocketFD);
        exit(EXIT_FAILURE);
      }
  
      /* perform read write operations ... 
      read(ConnectFD, buff, size)
      */
  
      if (shutdown(ConnectFD, SHUT_RDWR) == -1) {
        perror("shutdown failed");
        close(ConnectFD);
        close(SocketFD);
        exit(EXIT_FAILURE);
      }
      close(ConnectFD);
    }

    close(SocketFD);
    return EXIT_SUCCESS;  
}

Klient

Programování klientské aplikace TCP zahrnuje následující kroky:

• Vytvoření soketu TCP.
• Připojení k serveru ( connect () ), předáním sockaddr_instruktury s sin_familynastavením na AF_INET , sin_portnastavením na port, který koncový bod naslouchá (v pořadí bajtů sítě), a sin_addrnastavením na IP adresu naslouchajícího serveru (také v síťovém bajtu) objednat).
• Komunikace se vzdáleným hostitelem pomocí funkcí API send () a recv () , stejně jako s obecnými funkcemi write () a read () .
• Zavření každé zásuvky, která byla otevřena po použití, pomocí funkce close ().

  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  
  int main(void)
  {
    struct sockaddr_in sa;
    int res;
    int SocketFD;

    SocketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (SocketFD == -1) {
      perror("cannot create socket");
      exit(EXIT_FAILURE);
    }
  
    memset(&sa, 0, sizeof sa);
  
    sa.sin_family = AF_INET;
    sa.sin_port = htons(1100);
    res = inet_pton(AF_INET, "192.168.1.3", &sa.sin_addr);

    if (connect(SocketFD, (struct sockaddr *)&sa, sizeof sa) == -1) {
      perror("connect failed");
      close(SocketFD);
      exit(EXIT_FAILURE);
    }
  
    /* perform read write operations ... */
  
    close(SocketFD);
    return EXIT_SUCCESS;
  }

Příklad klient-server pomocí UDP

User Datagram Protocol (UDP) je bez spojení protokol bez záruky doručení. Pakety UDP mohou dorazit mimo provoz, vícekrát nebo vůbec. Kvůli tomuto minimálnímu designu má UDP podstatně menší režii než TCP. Být bez připojení znamená, že neexistuje koncept streamu ani trvalé spojení mezi dvěma hostiteli. Taková data se označují jako datagramy ( datagramové zásuvky ).

Adresní prostor UDP, prostor čísel portů UDP (v terminologii ISO, TSAP ), je zcela odlišný od prostoru portů TCP.

Server

Aplikace může nastavit server UDP na portu číslo 7654 následujícím způsobem. Programy obsahují nekonečnou smyčku, která přijímá datagramy UDP s funkcí recvfrom () .

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h> /* for close() for socket */ 
#include <stdlib.h>

int main(void)
{
  int sock;
  struct sockaddr_in sa; 
  char buffer[1024];
  ssize_t recsize;
  socklen_t fromlen;

  memset(&sa, 0, sizeof sa);
  sa.sin_family = AF_INET;
  sa.sin_addr.s_addr = htonl(INADDR_ANY);
  sa.sin_port = htons(7654);
  fromlen = sizeof sa;

  sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if (bind(sock, (struct sockaddr *)&sa, sizeof sa) == -1) {
    perror("error bind failed");
    close(sock);
    exit(EXIT_FAILURE);
  }

  for (;;) {
    recsize = recvfrom(sock, (void*)buffer, sizeof buffer, 0, (struct sockaddr*)&sa, &fromlen);
    if (recsize < 0) {
      fprintf(stderr, "%s\n", strerror(errno));
      exit(EXIT_FAILURE);
    }
    printf("recsize: %d\n ", (int)recsize);
    sleep(1);
    printf("datagram: %.*s\n", (int)recsize, buffer);
  }
}

Klient

Následuje klientský program pro odesílání UDP paketu obsahujícího řetězec „Hello World!“ na adresu 127.0.0.1 na čísle portu 7654.

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>

int main(void)
{
  int sock;
  struct sockaddr_in sa;
  int bytes_sent;
  char buffer[200];
 
  strcpy(buffer, "hello world!");
 
  /* create an Internet, datagram, socket using UDP */
  sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if (sock == -1) {
      /* if socket failed to initialize, exit */
      printf("Error Creating Socket");
      exit(EXIT_FAILURE);
  }
 
  /* Zero out socket address */
  memset(&sa, 0, sizeof sa);
  
  /* The address is IPv4 */
  sa.sin_family = AF_INET;
 
   /* IPv4 addresses is a uint32_t, convert a string representation of the octets to the appropriate value */
  sa.sin_addr.s_addr = inet_addr("127.0.0.1");
  
  /* sockets are unsigned shorts, htons(x) ensures x is in network byte order, set the port to 7654 */
  sa.sin_port = htons(7654);
 
  bytes_sent = sendto(sock, buffer, strlen(buffer), 0,(struct sockaddr*)&sa, sizeof sa);
  if (bytes_sent < 0) {
    printf("Error sending packet: %s\n", strerror(errno));
    exit(EXIT_FAILURE);
  }
 
  close(sock); /* close the socket */
  return 0;
}

V tomto kódu je vyrovnávací paměť ukazatelem na data, která mají být odeslána, a buffer_length určuje velikost dat.

Reference

De jure standard definition rozhraní Sockets je obsažena v POSIX standard, známý jako:

• IEEE Std. 1003.1-2001 Standard pro informační technologie-rozhraní přenosného operačního systému (POSIX).
• Open Group Technical Standard: Base Specifications, Issue 6, December 2001.
• ISO/IEC 9945: 2002

Informace o tomto standardu a probíhajících pracích na něm jsou k dispozici na webových stránkách Austinu .

Rozšíření IPv6 API základního soketu jsou dokumentována v RFC 3493 a RFC 3542.

• W. Richard, Stevens; Stephen A., Rago (24. května 2013). Pokročilé programování v prostředí UNIX (třetí ed.). Addison-Wesley Professional . ISBN 978-0321637734. Citováno 27. února 2015 .

externí odkazy

• Doplňkové dokumenty programátora UNIX (PSD: 20-1)
• Beej's Guide to Network Programming - 2007
• Portování programů Berkeley Socket na Winsock - dokumentace společnosti Microsoft.
• Programování UNIXových zásuvek v C - často kladené otázky - 1996
• Síťové programování Linuxu - Linux Journal , 1998