Berkeley stikkontakter - Berkeley sockets

Berkeley-sockets er en applikationsprogrammeringsgrænseflade (API) til internetstik og Unix-domæne-stik , der bruges til interprocesskommunikation (IPC). Det implementeres almindeligvis som et bibliotek med moduler, der kan forbindes. Det stammer fra 4.2BSD Unix -operativsystemet, som blev udgivet i 1983.

En sokkel er en abstrakt repræsentation ( håndtag ) for det lokale slutpunkt for en netværkskommunikationssti. Berkeley -sockets API repræsenterer det som en filbeskrivelse ( filhåndtag ) i Unix -filosofien, der giver en fælles grænseflade til input og output til datastrømme .

Berkeley -sokler udviklede sig med lidt ændringer fra en de facto -standard til en komponent i POSIX -specifikationen. Udtrykket POSIX -sockets er i det væsentlige synonymt med Berkeley -sockets , men de er også kendt som BSD -sockets , hvilket anerkender den første implementering i Berkeley Software Distribution .

Historie og implementeringer

Berkeley -stikkontakter stammer fra 4.2BSD Unix -operativsystemet , udgivet i 1983, som et programmeringsinterface. Men først i 1989 kunne University of California, Berkeley frigive versioner af operativsystemet og netværksbiblioteket uden licensbegrænsninger for AT&T Corporation 's proprietære Unix.

Alle moderne operativsystemer implementerer en version af Berkeley -stikket. Det blev standardgrænsefladen for applikationer, der kører på Internettet . Selv Winsock -implementeringen til MS Windows, skabt af ikke -tilknyttede udviklere, følger nøje standarden.

BSD stikdåser API er skrevet i sproget C programmering . De fleste andre programmeringssprog giver lignende grænseflader, typisk skrevet som et indpakningsbibliotek baseret på C API.

BSD- og POSIX -fatninger

Da Berkeley socket API udviklede sig og i sidste ende gav POSIX socket API, blev visse funktioner forældet eller fjernet og erstattet af andre. POSIX API er også designet til at blive genindført .

Alternativer

Den STREAMS -baserede Transport Layer Interface (TLI) API tilbyder et alternativ til socket API. Mange systemer, der leverer TLI API, leverer også Berkeley socket API.

Non-Unix-systemer udsætter ofte Berkeley-socket-API'et med et oversættelseslag for et native netværks-API. Plan 9 og Genode bruger filsystem-API'er med kontrolfiler frem for filbeskrivelser.

Overskriftsfiler

Berkeley -socket -grænsefladen er defineret i flere header -filer. Navnene og indholdet på disse filer adskiller sig lidt mellem implementeringerne. Generelt omfatter de:

Socket API -funktioner

Flowdiagram over klient-server-transaktion ved hjælp af sockets med Transmission Control Protocol (TCP).

Berkeley socket API'en indeholder typisk følgende funktioner:

• socket () opretter en ny socket af en bestemt type, identificeret med et helt tal, og tildeler systemressourcer til den.
• bind () bruges typisk på serversiden og forbinder en socket med en socketadressestruktur, det vil sige en specificeret lokal IP -adresse og et portnummer.
• lyt () bruges på serversiden og får en bunden TCP -sokkel til at gå ind i lyttetilstand.
• connect () bruges på klientsiden og tildeler et gratis lokalt portnummer til en stikkontakt. I tilfælde af et TCP -stik, forårsager det et forsøg på at etablere en ny TCP -forbindelse.
• accept () bruges på serversiden. Det accepterer et modtaget indgående forsøg på at oprette en ny TCP -forbindelse fra fjernklienten og opretter en ny sokkel, der er tilknyttet stikadresseadparet for denne forbindelse.
• send () , recv () , sendto () og recvfrom () bruges til at sende og modtage data. Standardfunktionerne write () og read () kan også bruges.
• close () får systemet til at frigive ressourcer, der er allokeret til en socket. I tilfælde af TCP afbrydes forbindelsen.
• gethostbyname () og gethostbyaddr () bruges til at løse værtsnavne og adresser. Kun IPv4.
• select () bruges til at suspendere og vente på, at en eller flere af den medfølgende liste over stikkontakter er klar til læsning, klar til at skrive eller som har fejl.
• poll () bruges til at kontrollere tilstanden af ​​en stikkontakt i et sæt stikkontakter. Sættet kan testes for at se, om en stikkontakt kan skrives til, læses fra, eller om der opstod en fejl.
• getsockopt () bruges til at hente den aktuelle værdi af en bestemt socket -mulighed for den angivne socket.
• setsockopt () bruges til at indstille en bestemt socket -mulighed for den angivne socket.

stikkontakt

Funktionsstikket () opretter et slutpunkt for kommunikation og returnerer en filbeskrivelse til stikket. Den bruger tre argumenter:

• domæne , som angiver protokolfamilien for den oprettede socket. For eksempel:
  • AF_INET til netværksprotokol IPv4 (kun IPv4)
  • AF_INET6 til IPv6 (og i nogle tilfælde bagudkompatibel med IPv4)
  • AF_UNIX til lokal stikkontakt (ved hjælp af en særlig filsystemknude)
• type , en af:
  • SOCK_STREAM (pålidelig strømorienteret service eller Stream Sockets )
  • SOCK_DGRAM (datagram service eller Datagram Sockets )
  • SOCK_SEQPACKET (pålidelig sekvenseret pakkeservice )
  • SOCK_RAW ( råprotokoller oven på netværkslaget)
• protokol, der angiver den faktiske transportprotokol, der skal bruges. De mest almindelige er IPPROTO_TCP , IPPROTO_SCTP , IPPROTO_UDP , IPPROTO_DCCP . Disse protokoller er angivet i filen netinet/in.h . Værdien 0 kan bruges til at vælge en standardprotokol fra det valgte domæne og typen.

Funktionen returnerer -1, hvis der opstod en fejl. Ellers returnerer det et helt tal, der repræsenterer den nyligt tildelte deskriptor.

binde

bind () forbinder en socket med en adresse. Når der oprettes et stik med socket () , får det kun en protokolfamilie, men der tildeles ikke en adresse. Denne tilknytning skal udføres, før soklen kan acceptere forbindelser fra andre værter. Funktionen har tre argumenter:

• sockfd , en deskriptor, der repræsenterer stikkontakten
• my_addr , en markør til en sockaddr -struktur, der repræsenterer adressen, der skal bindes til.
• addrlen , et felt af typen socklen_t, der angiver størrelsen på sockaddr -strukturen.

bind () returnerer 0 ved succes og -1 hvis der opstår en fejl.

Lyt

Når en stikkontakt er blevet knyttet til en adresse, forbereder listen () den på indgående forbindelser. Dette er imidlertid kun nødvendigt for de strømorienterede (forbindelsesorienterede) datatilstande, dvs. for sokkeltyper ( SOCK_STREAM , SOCK_SEQPACKET ). lyt () kræver to argumenter:

• sockfd , en gyldig socket -deskriptor .
• backlog , et helt tal, der repræsenterer antallet af ventende forbindelser, der kan stå i kø på et hvilket som helst tidspunkt. Operativsystemet placerer normalt en grænse for denne værdi.

Når en forbindelse er accepteret, fjernes den. Ved succes returneres 0. Hvis der opstår en fejl, returneres -1.

acceptere

Når en applikation lytter efter strømorienterede forbindelser fra andre værter, får den besked om sådanne hændelser (se funktionen select () ) og skal initialisere forbindelsen ved hjælp af funktion accept () . Det opretter et nyt stik for hver forbindelse og fjerner forbindelsen fra lyttekøen. Funktionen har følgende argumenter:

• sockfd , deskriptoren for lyttestikket, der har forbindelsen i kø.
• cliaddr , en markør til en sockaddr -struktur for at modtage klientens adresseoplysninger.
• addrlen , en markør til en socklen_t placering, der angiver størrelsen på klientadressestrukturen, der skal godkendes (). Når accept () returnerer, indeholder denne placering størrelsen (i bytes) af strukturen.

accept () returnerer den nye socket -deskriptor for den accepterede forbindelse eller værdien -1, hvis der opstår en fejl. Al yderligere kommunikation med fjernværten sker nu via denne nye stik.

Datagramstikkontakter kræver ikke behandling ved accept (), da modtageren umiddelbart kan besvare anmodningen ved hjælp af lytterstikket.

forbinde

connect () opretter et direkte kommunikationslink til en bestemt fjernvært, der identificeres af dens adresse via en stikdåse, identificeret med dens filbeskrivelse.

Når du bruger en forbindelsesorienteret protokol, etablerer dette en forbindelse. Visse typer protokoller er forbindelsesløse, især brugerdatagramprotokollen . Når det bruges sammen med forbindelsesløse protokoller, definerer connect den eksterne adresse til afsendelse og modtagelse af data, hvilket tillader brug af funktioner som f.eks. Send og genoptag . I disse tilfælde forhindrer forbindelsesfunktionen modtagelse af datagrammer fra andre kilder.

connect () returnerer et helt tal, der repræsenterer fejlkoden: 0 repræsenterer succes, mens –1 repræsenterer en fejl. Historisk set er BSD-afledte systemer i en socket-descriptor-tilstand udefineret, hvis opkaldet til tilslutning mislykkes (som det er angivet i Single Unix Specification), derfor bør bærbare applikationer lukke socket-deskriptoren med det samme og få en ny deskriptor med stikkontakten (), hvis opkaldet til tilslutning () mislykkes.

gethostbyname og gethostbyaddr

Funktionerne gethostbyname () og gethostbyaddr () bruges til at løse værtsnavne og adresser i domænenavnesystemet eller den lokale værts andre resolvermekanismer (f.eks. /Etc /hosts -opslag). De returnerer en markør til et objekt af typen struct hostent , som beskriver en Internet Protocol -vært . Funktionerne bruger følgende argumenter:

• navn angiver værtens DNS -navn.
• addr angiver en markør til en struct in_addr, der indeholder adressen på værten.
• len angiver længden i bytes af addr .
• type angiver adressefamilietypen (f.eks. AF_INET) for værtsadressen.

Funktionerne returnerer en NULL -markør i tilfælde af fejl, i hvilket tilfælde det eksterne heltal h_errno kan kontrolleres for at se, om dette er en midlertidig fejl eller en ugyldig eller ukendt vært. Ellers returneres en gyldig struct hostent * .

Disse funktioner er ikke udelukkende en komponent i BSD socket API, men bruges ofte sammen med API -funktionerne. Desuden betragtes disse funktioner nu som ældre grænseflader til forespørgsel på domænenavnesystemet. Nye funktioner, der er fuldstændig protokolagnostiske (understøtter IPv6), er blevet defineret. Disse nye funktioner er getaddrinfo () og getnameinfo () , og er baseret på en ny addrinfo -datastruktur .

Protokol og adressefamilier

Berkeley socket API er en generel grænseflade til netværk og kommunikation mellem processer og understøtter brugen af ​​forskellige netværksprotokoller og adressearkitekturer.

Følgende viser en prøveudtagning af protokolfamilier (forud for den symbolske standardsidentifikator) defineret i en moderne Linux- eller BSD -implementering:

Et stik til kommunikation oprettes med socket()funktionen ved at angive den ønskede protokolfamilie ( PF_ -identifikator) som et argument.

Det originale designkoncept for socketgrænsefladen skelner mellem protokoltyper (familier) og de specifikke adressetyper, som hver kan bruge. Det blev forestillet, at en protokolfamilie kan have flere adressetyper. Adressetyper blev defineret af yderligere symbolske konstanter ved hjælp af præfikset AF i stedet for PF . De AF- -identifiers er beregnet til alle datastrukturer, der specifikt beskæftiger sig med adressen type og ikke protokollen familien. Dette koncept om adskillelse af protokol og adressetype har imidlertid ikke fundet implementeringsstøtte, og AF -konstanterne blev defineret af den tilsvarende protokolidentifikator, hvilket efterlod sondringen mellem AF- og PF -konstanter som et teknisk argument uden praktisk konsekvens. Der er faktisk meget forvirring i den korrekte anvendelse af begge former.

POSIX.1—2008 -specifikationen angiver ikke nogen PF -konstanter, men kun AF -konstanter

Rå fatninger

Rå stikkontakter giver en enkel grænseflade, der omgår behandlingen af ​​værtens TCP/IP -stak. De tillader implementering af netværksprotokoller i brugerrum og hjælp til fejlfinding af protokolstakken. Rå stikkontakter bruges af nogle tjenester, f.eks. ICMP , der fungerer på internetlaget i TCP/IP -modellen.

Blokerende og ikke-blokerende tilstand

Berkeley-sokler kan fungere i en af ​​to tilstande: blokering eller ikke-blokering.

Et blokeringsstik returnerer ikke kontrollen, før den har sendt (eller modtaget) nogle eller alle data, der er angivet for operationen. Det er normalt, at et blokeringsstik ikke sender alle data. Ansøgningen skal kontrollere returværdien for at afgøre, hvor mange bytes der er blevet sendt eller modtaget, og den skal sende data, der ikke allerede er behandlet, igen. Ved brug af blokeringsstik skal der overvejes særlig at acceptere (), da det stadig kan blokere efter angivelse af læsbarhed, hvis en klient afbryder forbindelsen under forbindelsesfasen.

En ikke-blokerende socket returnerer det, der er i modtagerbufferen, og fortsætter straks. Hvis det ikke er skrevet korrekt, er programmer, der bruger ikke-blokerende sockets, særligt modtagelige for raceforhold på grund af variationer i netværksforbindelseshastighed.

En stikkontakt er typisk indstillet til blokering eller ikke -blokeringstilstand ved hjælp af funktionerne fcntl og ioctl .

Afslutning af stikkontakter

Operativsystemet frigiver ikke de ressourcer, der er tildelt til en stikkontakt, før stikket er lukket. Dette er især vigtigt, hvis forbindelsesopkaldet mislykkes og vil blive forsøgt igen.

Når en applikation lukker en socket, ødelægges kun grænsefladen til stikket. Det er kernens ansvar at ødelægge stikket internt. Nogle gange kan en stikkontakt gå ind i en TIME_WAIT -tilstand på serversiden i op til 4 minutter.

På SVR4 -systemer kan brug af close()data kassere. Brugen af shutdown()eller SO_LINGER kan være påkrævet på disse systemer for at garantere levering af alle data.

Klient-server-eksempel ved hjælp af TCP

Den Transmission Control Protocol (TCP) er en forbindelsesorienteret protokol, der giver en bred vifte af fejlkorrektion og ydeevne funktioner til transmission af bytestrømme. En proces opretter et TCP -stik ved at kalde socket()funktionen med parametrene for protokolfamilien ( PF INET , PF_INET6 ), sokkeltilstanden for Stream Sockets ( SOCK_STREAM ) og IP -protokolidentifikatoren for TCP ( IPPROTO_TCP ).

Server

Etablering af en TCP -server indebærer følgende grundlæggende trin:

• Oprettelse af et TCP -stik med et opkald til stikkontakt ().
• Binding af stikket til lytteporten ( bind () ) efter indstilling af portnummeret.
• Forbereder stikket til at lytte efter forbindelser (hvilket gør det til et lytterstik), med et opkald til at lytte () .
• Accepter indgående forbindelser ( accept () ). Dette blokerer processen, indtil en indgående forbindelse er modtaget, og returnerer en socket -deskriptor for den accepterede forbindelse. Den oprindelige deskriptor forbliver en lyttebeskrivelse, og accept () kan til enhver tid kaldes igen med denne stikdåse, indtil den er lukket.
• Kommunikation med fjernværten med API-funktionerne send () og recv () , samt med de generelle funktioner skrive () og læse () .
• Lukning af hvert stik, der blev åbnet efter brug med funktionen luk ()

Følgende program opretter en TCP -server, der lytter til portnummer 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

Programmering af en TCP -klientapplikation indebærer følgende trin:

• Oprettelse af et TCP -stik.
• Oprettelse af forbindelse til serveren ( connect () ), ved at passere en sockaddr_instruktur med sin_familysættet til AF_INET , sin_portsat til porten lytter slutpunktet (i netværksbyte rækkefølge) og sin_addrindstilles til IP -adressen på lytte -serveren (også i netværksbyte bestille).
• Kommunikation med fjernværten med API-funktionerne send () og recv () , samt med de generelle funktioner skrive () og læse () .
• Lukning af hvert stik, der blev åbnet efter brug med funktionen luk ().

  #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;
  }

Klient-server-eksempel ved hjælp af UDP

Den User Datagram Protocol (UDP) er en forbindelsesløs protokol uden nogen garanti for levering. UDP -pakker kommer muligvis ud af drift, flere gange eller slet ikke. På grund af dette minimale design har UDP betydeligt mindre overhead end TCP. At være forbindelsesløs betyder, at der ikke er et begreb om en strøm eller permanent forbindelse mellem to værter. Sådanne data omtales som datagrammer ( Datagram Sockets ).

UDP -adresserum, rummet for UDP -portnumre (i ISO -terminologi, TSAP'erne ), er fuldstændig adskilt fra TCP -porte.

Server

Et program kan konfigurere en UDP -server på portnummer 7654 som følger. Programmerne indeholder en uendelig loop, der modtager UDP -datagrammer med funktionen 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

Det følgende er et klientprogram til afsendelse af en UDP -pakke, der indeholder strengen "Hello World!" til adresse 127.0.0.1 ved portnummer 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;
}

I denne kode er buffer en markør til de data, der skal sendes, og buffer_length angiver størrelsen på dataene.

Referencer

De jure -standarddefinitionen af ​​Sockets -grænsefladen er indeholdt i POSIX -standarden, kendt som:

• IEEE Std. 1003.1-2001 Standard for informationsteknologi — Portable Operating System Interface (POSIX).
• Open Group Technical Standard: Base Specifications, Issue 6, december 2001.
• ISO/IEC 9945: 2002

Information om denne standard og løbende arbejde med den er tilgængelig fra Austin -webstedet .

IPv6 -udvidelserne til basisstik -API'en er dokumenteret i RFC 3493 og RFC 3542.

• W. Richard, Stevens; Stephen A., Rago (24. maj 2013). Avanceret programmering i UNIX -miljøet (tredje udgave). Addison-Wesley Professional . ISBN 978-0321637734. Hentet 27. februar 2015 .

eksterne links

• UNIX-programmerings supplerende dokumenter (PSD: 20-1)
• Beej's Guide to Network Programming - 2007
• Porting af Berkeley Socket -programmer til Winsock - Microsofts dokumentation.
• Programmering af UNIX -stik i C - Ofte stillede spørgsmål - 1996
• Linux -netværksprogrammering - Linux Journal , 1998