DNS-klient Tjenesten er laget for å få IP-adressen til en ekstern datamaskin hvis domenet eller URL-adressen til denne datamaskinen er kjent (for eksempel www.mail.ru). I dette tilfellet implementeres prosessen med å skaffe IP-adressen til en ekstern datamaskin gjennom samhandlingen av DNS-klienttjenesten med

Webklient Tjenesten lar deg redigere eller legge til filer som er lagret på Internett. Hvis du ikke trenger denne standard Windows-funksjonen, er det bedre å deaktivere tjenesten Web Client-tjenesten tar opp omtrent 800 KB RAM og kjører med lokale tjenesterettigheter (NT

30.3. TCP Test Client Listing 30.1 viser klienten som vil bli brukt til å teste alle varianter av serveren vår 30.1. TCP-klientkode for å sjekke forskjellige versjoner av serveren //server/client.c 1 #include "unp.h" 2 #define MAXN 16384 /* maksimalt antall byte som

Torrent-klient?Torrent Du er sannsynligvis allerede seriøst lei av disse teoretiske raningene, er du ivrig etter å kjempe og slå hovene dine? Vel, la oss gå videre til praksis. For å begynne å jobbe med torrenter trenger vi to ting: for det første et spesielt nedlastingsprogram, og for det andre -

Klientprogram

Jobber med WinSocket

Socket (socket, connector) er et abstrakt programvarekonsept som brukes til å angi i et applikasjonsprogram endepunktet til en kommunikasjonskanal med et kommunikasjonsmiljø dannet av et datanettverk. Når du bruker TCP/IP-protokoller, kan vi si at en socket er et middel for å koble et applikasjonsprogram til porten (se ovenfor) til en lokal nettverksnode.

Et socket-grensesnitt er ganske enkelt et sett med systemanrop og/eller bibliotekfunksjoner til SI-programmeringsspråket, delt inn i fire grupper:

1. Lokal kontroll

2. Etablere kommunikasjon

3. Datautveksling (input/output)

4. Avsluttende kommunikasjon

5. Eksempel på bruk av WinSocket

Nedenfor diskuterer vi en undergruppe av socket-grensesnittfunksjonene som er tilstrekkelige til å skrive nettverksapplikasjoner som implementerer klient-server-modellen i tilkoblingsorientert modus.

1. Lokale kontrollfunksjoner

Lokale kontrollfunksjoner brukes hovedsakelig til å utføre de forberedende handlingene som er nødvendige for å organisere samspillet mellom to partnerprogrammer. Funksjoner kalles dette fordi deres utførelse er lokal for programmet.

1.1 Opprette en stikkontakt

Opprettelsen av en stikkontakt utføres av følgende systemanrop

#inkludere int socket (domene, type, protokoll) int domene; int type; int protokoll;

Domeneargumentet spesifiserer settet med protokoller som brukes for interaksjon (en type kommunikasjonsdomene for TCP/IP-protokollstabelen må ha den symbolske verdien AF_INET (definert i sys/socket.h).

Typeargumentet spesifiserer interaksjonsmodusen:

SOCK_STREAM - med forbindelsesetablering;

SOCK_DGRAM - uten å opprette en forbindelse.

Protokollargumentet spesifiserer en spesifikk transportlagsprotokoll (fra flere mulige protokoller i protokollstabelen). Hvis dette argumentet er satt til 0, vil standardprotokollen bli brukt (TCP for SOCK_STREAM og UDP for SOCK_DGRAM ved bruk av TCP/IP-protokollpakken).

Når arbeidet er fullført, returnerer denne funksjonen socket-deskriptoren - et ikke-negativt heltall som unikt identifiserer det. Socket-beskrivelsen ligner på UNIX OS-filbeskrivelsen.

Hvis en feil oppdages under driften, returnerer funksjonen tallet "-1".

1.2. Bindingskontakt

For å koble en socket til kommunikasjonsmiljøet dannet av et datanettverk, er det nødvendig å utføre bindesystemanropet, som bestemmer i formatet som er akseptert for nettverket, den lokale adressen til kommunikasjonskanalen med miljøet. kontakten er knyttet til en lokal port. Bindingssystemanropet har følgende syntaks:

#inkludere

#inkludere #inkludere int bind (s, addr, addrlen) int s; struct sockaddr *addr; int addlen;

Argumentet s spesifiserer beskrivelsen av sokkelen som er bundet.

Addr-argumentet bør generelt peke til en datastruktur som inneholder den lokale adressen som er tildelt til socket. For TCP/IP-nettverk er denne strukturen sockaddr_in.

Sockaddr_in-strukturen brukes av flere systemanrop og socket-grensesnittfunksjoner og er definert i include-filen in.h som følger:

struct sockaddr_in (kort sin_familie; u_kort sin_port; struct in_addr sin_adr; char sin_null; );

Sin_family-feltet bestemmer adresseformatet som brukes (protokollsett), i vårt tilfelle (for TCP/IP) skal det ha verdien AF_INET.

Sin_addr-feltet inneholder adressen (nummeret) til nettverksnoden.

Sin_port-feltet inneholder portnummeret på nettverksnoden.

Sin_zero-feltet brukes ikke.

Definisjonen av in_addr-strukturen (fra den samme include-filen) er:

struct in_addr ( union ( u_long S_addr; /*

andre (ikke av interesse for oss)

medlemmer av foreningen */

) S_un; #define s_addr S_un.S_addr );

Sockaddr_in-strukturen må være fullstendig fylt før du sender ut bindsystemkallet. I dette tilfellet, hvis sin_addr.s_addr-feltet har verdien INADDR_ANY, vil systemanropet binde nummeret (adressen) til den lokale nettverksnoden til kontakten.

Hvis vellykket, returnerer bind 0, ellers "-1".

2. Tilkoblingsfunksjoner

For å etablere en klient-server-forbindelse, brukes lytt og godta systemanrop (på serversiden), samt koble til (på klientsiden). For å fylle ut feltene i socaddr_in-strukturen som brukes i koblingsanropet, brukes vanligvis bibliotekfunksjonen gethostbyname, som oversetter det symbolske navnet på verten til nummeret (adressen).

2.1. Venter på at tilkoblingen skal opprettes

Lyttesystemanropet uttrykker ønsket til serverprogrammet som utstedte det om å vente på forespørsler til det fra klientprogrammer og har følgende form:

#inkludere int lytte (s, n) int s; int n;

Argumentet s spesifiserer et socket-håndtak som programmet vil lytte etter forespørsler til det fra klienter. Socket må først opprettes med socket-systemkallet og forsynes med en adresse ved å bruke bind-systemkallet.

Argumentet n spesifiserer maksimal kølengde for innkommende håndtrykkforespørsler. Hvis en klient utsteder en håndtrykkforespørsel når køen er full, vil forespørselen bli avvist.

Suksessen til lyttesystemanropet indikeres med en returkode på null.

For å kontakte et klientprogram til serveren med en forespørsel om å opprette en logisk tilkobling, bruk koble systemanropet, som har følgende skjema

#inkludere

#inkludere #inkludere int koble (s, addr, addrlen) int s; struct sockaddr_in *addr; int addlen;

Argumentet s spesifiserer et håndtak til socket som programmet gjør en tilkoblingsforespørsel til serveren. Socket må først opprettes med socket-systemkallet og forsynes med en adresse ved å bruke bind systemkallet.

Addr-argumentet må peke til en datastruktur som inneholder adressen som er tilordnet til socket" til serverprogrammet som tilkoblingsforespørselen gjøres til. For TCP/IP-nettverk er denne strukturen sockaddr_in. For å generere verdiene til feltene til sockaddr_in-strukturen, er det praktisk å bruke funksjonen gethostbyname.

Addrlen-argumentet spesifiserer størrelsen, i byte, på datastrukturen spesifisert av addr-argumentet.

For at en tilkoblingsforespørsel skal lykkes, er det nødvendig at minst serverprogrammet har utført et lyttesystemanrop for kontakten med den spesifiserte adressen på dette tidspunktet.

Hvis forespørselen er vellykket, returnerer koble systemkallet 0, ellers -1 (angir feilårsakskoden i den globale variabelen errno).

Merk. Hvis på tidspunktet tilkoblingen utføres, kontakten den bruker ikke har blitt bundet til en adresse ved hjelp av bind , vil slik binding utføres automatisk.

Merk. I tilkoblingsløs kommunikasjonsmodus er det ikke nødvendig å utstede systemanropet. Imidlertid er utførelsen i denne modusen ikke en feil - betydningen av handlingene som utføres i dette tilfellet endres ganske enkelt: "standard" -adressen er satt for alle påfølgende datagramsendinger.

2.3. Mottar en tilkoblingsforespørsel

For å godta forespørsler fra klientprogrammer om å etablere kommunikasjon, bruker serverprogrammer aksept systemkallet, som ser slik ut:

#inkludere

#inkludere int akseptere (s, addr, p_addrlen) int s; struct sockaddr_in *addr; int *p_addrlen;

s-argumentet spesifiserer socket-håndtaket som serverprogrammet mottok tilkoblingsforespørselen gjennom (via lyttesystemforespørselen).

Addr-argumentet må peke til et minneområde som er stort nok til å romme en datastruktur som inneholder adressen til kontakten til klientprogrammet som gjorde tilkoblingsforespørselen. Ingen initialisering av dette området er nødvendig.

p_addrlen må peke til et minneområde, spesifisert som et heltall som spesifiserer størrelsen, i byte, på minneområdet spesifisert av addr.

Godta systemanropet henter den første tilkoblingsforespørselen fra køen som vedlikeholdes av lyttesystemanropet og returnerer et håndtak til en ny (automatisk opprettet) socket med samme egenskaper som socket spesifisert av s-argumentet. Dette nye håndtaket må brukes i alle påfølgende kommunikasjonsoperasjonsdata.

I tillegg, etter vellykket gjennomføring, godta:

minneområdet angitt av addr-argumentet vil inneholde en datastruktur (for TCP/IP-nettverk er dette sockaddr_in) som beskriver socket-adressen til klientprogrammet som det gjorde sin tilkoblingsforespørsel gjennom;

heltallet pekt på av p_addrlen vil være lik størrelsen på denne datastrukturen.

Hvis forespørselskøen er tom på tidspunktet aksept blir utført, går programmet inn i en tilstand med å vente på at forespørsler fra klienter skal ankomme på ubestemt tid (selv om denne atferden for aksept kan endres).

Tegnet på akseptfeil er en negativ returverdi (socket-beskrivelsen kan ikke være negativ).

Merk. Godta systemkallet brukes i serverprogrammer som opererer i kun tilkoblingsmodus.

2.4. Genererer en nettverksvertsadresse

For å få adressen til en TCP/IP-nettverksnode ved dets symbolske navn, bruk bibliotekfunksjonen

#inkludere

#inkludere struct hostent *gethostbyname (navn) char *navn;

Navneargumentet spesifiserer adressen til sekvensen av tegn som danner det symbolske navnet på nettverksverten.

Etter vellykket fullføring returnerer funksjonen en peker til vertsstrukturen, definert i include-filen netdb.h og har følgende skjema

struct hostent ( char *h_name; char **h_aliases; int h_addrtype; int h_lenght; char *h_addr; );

Feltet h_navn indikerer det offisielle (primære) navnet på noden.

Feltet h_aliaser peker til en liste over ytterligere nodenavn (synonymer), hvis noen.

Feltet h_addrtype inneholder identifikatoren til protokollsettet som brukes for TCP/IP-nettverk, vil dette feltet ha verdien AF_INET.

h_lenght-feltet inneholder lengden på nodeadressen.

h_addr-feltet peker til et minneområde som inneholder vertsadressen som brukes av systemanrop og socket-grensesnittfunksjoner.

Et eksempel på å kalle opp gethostbyname-funksjonen for å få adressen til en ekstern vert i et klientprogram som bruker koble systemkallet til å generere en forespørsel om å opprette en forbindelse med et serverprogram på denne verten er diskutert nedenfor.

3. Kommunikasjonsfunksjoner

I logisk tilkoblingsmodus, etter vellykket utførelse av et par sammenkoblede systemanrop kobles til (i klienten) og godta (på serveren), blir datautveksling mulig.

Denne utvekslingen kan implementeres av de vanlige lese- og skrivesystemanropene som brukes til å jobbe med filer (i stedet for filbeskrivelser er socket-beskrivelser spesifisert i dem).

I tillegg kan sende- og recv-systemanrop, orientert spesifikt mot arbeid med stikkontakter, brukes i tillegg.

Merk. For å utveksle data i tilkoblingsløs modus, brukes vanligvis sendeto og recvfrom systemanrop. Sendto lar deg spesifisere, sammen med de overførte dataene (som utgjør et datagram), adressen til mottakeren. Recvfrom, samtidig med levering av data til mottakeren, informerer ham om avsenderens adresse.

3.1. Sender data

For å sende data til en nettverkspartner, bruk send systemanropet, som ser slik ut:

#inkludere

#inkludere int send (s, buf, len, flagg) int s; røye *buf; int len; int flagg;

Argumentet s spesifiserer socket-beskrivelsen som data sendes gjennom.

Buf-argumentet peker på minneplasseringen som inneholder dataene som skal overføres.

Len-argumentet spesifiserer lengden (i byte) på dataene som skal overføres.

Flagg-argumentet endrer utførelsen av send systemkallet. Når dette argumentet er satt til null, er sendeanropet nøyaktig det samme som skrivesystemanropet.

Ved suksess returnerer send antall byte med data som er overført fra området spesifisert av buf-argumentet. Hvis datakanalen identifisert av deskriptor s blir "full", så setter send programmet i ventetilstand til det er frigjort.

3.2. Mottar data

For å motta data fra en nettverkspartner, bruk recv-systemanropet, som ser slik ut:

#inkludere

#inkludere int recv (s, buf, len, flagg) int s; røye *buf; int len; int flagg;

Argumentet s spesifiserer socket-beskrivelsen som data mottas gjennom.

Buf-argumentet peker på et minneområde dedikert til å motta data.

Len-argumentet spesifiserer lengden, i byte, av denne regionen.

Flagg-argumentet endrer utførelsen av recv-systemkallet. Når dette argumentet er satt til null, er det å kalle recv nøyaktig det samme som å kalle det leste systemanropet.

Ved suksess returnerer recv antall byte med data mottatt i området spesifisert av buf-argumentet. Hvis datakanalen identifisert av deskriptor s er tom, setter recv programmet i en ventetilstand til data vises i det.

4. Lukkefunksjoner

For å lukke kommunikasjon med en nettverkspartner, brukes lukke- og avslutningssystemet.

4.1. lukke systemanrop

For å lukke en tidligere opprettet socket, bruk den vanlige lukkesystemanropet, som brukes i UNIX OS for å lukke tidligere åpne filer og har følgende form

int close (s) int s;

Imidlertid, i logisk tilkoblingsmodus (som som regel sikrer pålitelig datalevering), vil utvekslingsmekanismer innenfor systemet prøve å sende/motta data som er igjen i overføringskanalen på det tidspunktet kontakten lukkes. Dette kan kreve en betydelig tid intervall, uakseptabelt for noen applikasjoner I en slik situasjon må du bruke avslutningssystemet som er beskrevet nedenfor.

4.2. Tilbakestiller bufrede data

For å "nød" lukke en forbindelse med en partner (ved å "tilbakestille" data som ennå ikke er overført), brukes avstengningssystemkallingen, utføres før lukking og har følgende skjema

int shutdown (s, hvordan) int s; int hvordan;

Argumentet s spesifiserer et håndtak til en tidligere opprettet socket.

How-argumentet spesifiserer handlingene som skal utføres når sokkelens systembuffere tømmes:

2 - tilbakestill alle data som sendes gjennom stikkontakten i alle retninger.

5. Eksempel på bruk av socket-grensesnittet

Denne delen diskuterer bruken av socket-grensesnittet i interaksjonsmodus med etablering av en logisk forbindelse ved å bruke et veldig enkelt eksempel på samspillet mellom to programmer (server og klient) som opererer på forskjellige noder i TCP/IP-nettverket.

serveren, etter å ha akseptert tilkoblingsforespørselen, sender klienten spørsmålet "Hvem er du?";

klienten, etter å ha mottatt spørsmålet, skriver det ut til standardutdata og sender svaret "Jeg er din klient" til serveren og fullfører arbeidet;

serveren skriver ut klientens svar på standardutdata, lukker kommunikasjonen med den og går inn i tilstanden til å vente på neste forespørsel til den.

Merk. Programtekstene som tilbys nedenfor er kun ment å illustrere logikken til interaksjon mellom programmer over nettverket, derfor inneholder de ikke slike attributter til programmer beregnet for praktisk bruk, for eksempel behandling av returkoder for systemanrop og funksjoner, analyse av feilkoder i global variabel errno, reagerer på asynkrone hendelser osv. .P.

5.1. Serverprogram

Teksten til serverprogrammet i SI-programmeringsspråket ser slik ut:

1 #inkluderer

2 #inkluderer

3 #inkluderer

4 #inkluder

5 #inkluder

6 #define SRV_PORT 1234

7 #define BUF_SIZE 64

8 #define TXT_QUEST "Hvem er du?n"

10 int s, s_new;

11 int from_len;

12 røyer buff;

13 struct sockaddr_in sin, from_sin;

14 s = socket(AF_INET, SOCK_STREAM, 0);

15 memset ((char *)&sin, "", sizeof(sin));

16 sin.sin_family = AF_INET;

17 sin.sin_addr.s_addr = INADDR_ANY;

18 sin.sin_port = SRV_PORT;

19 bind (s, (struktur sockaddr *)&sin, sizeof(sin));

20 lytt(er, 3);

22 fra_len = størrelse på(fra_sin);

23 s_new = godta (s, &from_sin, &from_len);

24 write(s_new, TXT_QUEST, sizeof(TXT_QUEST));

25 from_len = lest (s_new, buf, BUF_SIZE);

26 skriv(1, buf, fra_len);

27 shutdown(s_new, 0);

28 close(s_new);

Linje 1...5 beskriver include-filene, som inneholder definisjoner for alle nødvendige datastrukturer og symbolske konstanter.

Linje 6 tildeler det symbolske navnet SRV_PORT til heltallskonstanten 1234. I fremtiden vil denne konstanten bli brukt som serverportnummer. Verdien av denne konstanten må også være kjent for klientprogrammet.

Linje 7 tildeler det symbolske navnet BUF_SIZE til heltallskonstanten 64. Denne konstanten vil bestemme størrelsen på bufferen som brukes til å imøtekomme data mottatt fra klienten.

Linje 8 tildeler det symbolske navnet TXT_QUEST til sekvensen av tegn som utgjør teksten til klientens spørsmål. Det siste tegnet i sekvensen er nylinjetegnet "n". Dette ble gjort for å forenkle utgangen av spørsmålsteksten på klientsiden.

I linje 14 opprettes (åpnes) en socket for å organisere interaksjonsmodusen med etablering av en logisk forbindelse (SOCK_STREAM) i TCP/IP-nettverket (AF_INET), ved valg av transportlagsprotokoll, "standard"-protokollen (0 ) benyttes.

I linjene 15...18 tilbakestilles først sin datastruktur, og deretter fylles dens individuelle felter ut. Bruk av INADDR_ANY-konstanten forenkler koden ved å eliminere behovet for å bruke gethostbyname-funksjonen for å få adressen til den lokale verten som serveren kjører på.

Linje 19 bruker bindingssystemkallet til å binde socket spesifisert av deskriptor s til portnummer SRV_PORT på den lokale noden. Bind vil fullføres på en vellykket måte forutsatt at det ikke lenger er et program som kjører på den samme noden som bruker dette portnummeret på tidspunktet for utførelse.

Linje 20 bruker lyttesystemanropet til å sette tre innkommende tilkoblingsforespørsler i kø til serveren.

Linje 21 fungerer som overskriften for den endeløse løkken av serviceforespørsler fra klienter.

På linje 23, som inneholder aksepter systemanropet, blir programkjøringen suspendert på ubestemt tid hvis køen av forespørsler til serveren om å etablere en forbindelse er tom. Når en slik forespørsel vises, aksepterer fullførte vellykket, og returnerer en socket-deskriptor i s_new-variabelen for å utveksle informasjon med klienten.

På linje 24 sender serveren et spørsmål til klienten ved å bruke skrivesystemanropet.

Linje 25 bruker lesesystemkallet for å lese klientens svar.

På linje 26 sendes svaret til standard utgang, som har fildeskriptor nummer 1. Siden svarlinjen inneholder et linjeskifttegn, vil svarteksten bli plassert på en egen linje i displayet.

Linje 27 inneholder shutdown-systemutgangen, som sletter sokkelens systembuffere som inneholder data som skal leses ("ekstra" data kan havne der som et resultat av feil klientoperasjon).

Linje 28 lukker (sletter) kontakten som brukes til å utveksle data med neste klient.

Merk. Dette programmet (som de fleste ekte serverprogrammer) fullfører ikke arbeidet på egen hånd, og er i en endeløs løkke med behandling av klientforespørsler. Dens utførelse kan bare avbrytes eksternt ved å sende den fullføringssignaler (avbrudd). Et riktig utformet serverprogram bør håndtere slike signaler ved å stenge ned på en elegant måte (ved å lukke, spesielt, kontakten med håndtak s).

Teksten til klientprogrammet i SI-programmeringsspråket ser slik ut:

1 #inkluderer

2 #inkluderer

3 #inkluderer

4 #inkluder

5 #inkluder

6 #define SRV_HOST "delta"

7 #define SRV_PORT 1234

8 #define CLNT_PORT 1235

9 #define BUF_SIZE 64

10 #define TXT_ANSW "Jeg er din klient"

13 int from_len;

14 røyer buff;

15 struct hostent *hp;

16 struct sockaddr_in clnt_sin, srv_sin;

17 s = socket(AF_INET, SOCK_STREAM, 0);

18 memset ((char *)&clnt_sin, "", sizeof(clnt_sin));

19 clnt_sin.sin_family = AF_INET;

20 clnt_sin.sin_addr.s_addr = INADDR_ANY;

21 clnt_sin.sin_port = CLNT_PORT;

22 bind (s, (struktur sockaddr *)&clnt_sin, sizeof(clnt_sin));

23 memset ((char *)&srv_sin, "", sizeof(srv_sin));

24 hp = gethostbyname(SRV_HOST);

25 srv_sin.sin_family = AF_INET;

26 memcpy ((char *)&srv_sin.sin_addr,hp->h_addr,hp->h_length);

27 srv_sin.sin_port = SRV_PORT;

28 koble til (s, &srv_sin, sizeof(srv_sin));

29 from_len = recv (s, buf, BUF_SIZE, 0);

30 skriv(1, buf, fra_len);

31 send(s, TXT_ANSW, størrelse på(TXT_ANSW), 0);

Linje 6 og 7 beskriver konstantene SRV_HOST og SRV_PORT, som definerer navnet på den eksterne verten som serverprogrammet opererer på og portnummeret som serversocket er bundet til.

Linje 8 tildeler det symbolske navnet CLNT_PORT til heltallskonstanten 1235. I fremtiden vil denne konstanten bli brukt som klientportnummer.

Linjene 17...22 lager en socket bundet til en port på den lokale noden.

Linje 24 bruker gethostbyname-bibliotekfunksjonen for å oversette det symbolske navnet på den eksterne verten (i dette tilfellet "delta") som serveren skal operere på til adressen til denne noden, som ligger i en vertstypestruktur.

Linje 26 kopierer adressen til den eksterne noden fra vertsstrukturen inn i det tilsvarende feltet i srv_sin-strukturen, som senere (på linje 28) brukes i koble systemkallet for å identifisere serverprogrammet.

I linjene 29...31 utveksles data med serveren og spørsmålet mottatt fra serveren sendes ut til standardutgang.

Linje 32 lukker (sletter) stikkontakten ved å bruke lukkesystemanropet.

Bibliografi

For å forberede dette arbeidet ble det brukt materialer fra nettstedet http://www.realcoding.net/