06 Nivel Transport

Universitatea Politehnica Bucureşti - Facultatea de Automatică şi Calculatoare
Nivelul transport
Protocoale de comunicaţie – Curs 5 1

Comunicarea între aplicații

• Rețeaua asigură transmiterea pachetelor (datagrame) între calculatoare
gazdă.
• Transportul asigură comunicarea între aplicații:
– Legătura proceselor de aplicație cu punctele de acces la rețea (SAP).
– Identificarea unică a fiecărui punct de acces prin <adresă_rețea, port>:
• Transferul între gazde folosește adresă_rețea.
• Comunicarea cu procesele folosește portul.
Gazdă 1 Gazdă 2
Proces 1 Proces 3
Proces 2 Proces 4

Servicii ale nivelului transport

• Servicii furnizate:
– Transfer de date între procese de aplicație, folosind rețele de diverse tipuri.
– Interfaţă uniformă cu utilizatorii.
• Caracteristici:
– Servicii capăt la capăt (host to host).
– Două tipuri de servicii:
• Orientate pe conexiune (connection oriented) – TCP.
• Fără conexiune (connectionless) – UDP.

Socket Application Programming Interface

(socket API)
• Wiki: “An Application Programming Interface (API) is a set of
routines, data structures, object classes and/or protocols
provided by libraries and/or operating system in order to support the
building of applications”.
• Socket API este:
– O interfaţă pentru servicii de transport, între programele de aplicaţii şi
software-ul de transport.
– Originar din Berkeley BSD UNIX, ca extensie a sistemului I/E Unix.
– Disponibil pe Windows, Solaris şi alte SO.
– Disponibil în C, C++, Java şi alte limbaje.
– Oferit ca bibliotecă utilizator sau funcţii OS.
• Un socket = punctul în care procesul de aplicație se atașează la
rețea
– Foloseşte descriptori (numere) pentru identificare (ca la fişiere).
– Bazat pe modelul fişierelor open-read-write-close.
• Nu e standard de jure, ci standard de facto.
Socket API
• Aplicaţii:
– Cu transfer de date folosind conexiuni.
– Cu transfer de date fără conexiuni.
• Aplicaţii:
– Iterative, cu tratare secvenţială a transferurilor.
– Concurente, cu tratare în paralel a transferurilor.
• Aplicații:
– Server: oferă informații.
– Client: solicită informații.
• Criterii:
– La volum mic de date transferate:
• De obicei aplicaţii iterative, fără conexiuni.
– La volum mare de date transferate:
• De obicei aplicaţii concurente, care folosesc conexiuni.

Primitive de serviciu socket API

socket_descriptor = socket(protocol_family, communication_type,
protocol);
close(socket_descriptor);
bind(socket_descriptor, local_address, address_length);
listen socket_descriptor, queue_size);
new_socket_descriptor = accept(socket_descriptor,
client_socket_address, client_addresslen);
connect(client_socket_descriptor, server_socket_address,
server_sockaddress_length);
sendto(socket_descriptor, data_address, data_length, flags,
dest_address, destaddress_length);
recvfrom(socket_descriptor, buffer_address, buffer_length,
flags, sender_address, sendaddress_length);
write(socket_descriptor, data_address, data_length);
read(socket_descriptor, buffer_address, buffer_length);


• socket_descriptor = socket(protocol_family,
communication_type, protocol)‫‏‬
– Deschide un socket.
– Returnează socket_descriptor, folosit în apelurile următoare (dacă>0!).
– protocol_family selectează familia de protocoale:
• PF_INET: protocoale Internet.
• PF_APPLETALK: protocoale AppleTalk.
– communication_type selectează tipul de comunicare:
• SOCK_DGRAM: fără conexiune (datagramă).
• SOCK_STREAM: orientat pe conexiune (flux de octeți).
– protocol specifică protocolul:
• IPPROTO_TCP: pentru TCP.
• IPPROTO_UDP: pentru UDP.
• Sau 0, pentru a se alege protocolul pe baza valorilor setate pentru
protocol_family și communication_type.


• close(socket_descriptor)‫‏‬
– Termină utilizarea descriptorului socket_descriptor.
• bind(socket_descriptor, address, address_length)‫‏‬

– Leagă socket cu o adresă şi un port.
– Pentru server: leagă la port local.
– Pentru client: leagă la adresa şi port la distanţă (server).


• Format generic adresă:
struct sockaddr
{ u_char sa_len; /* total length of address */
u_char sa_family; /* family of the address */
char sa_data[14]; /* generic address */
}
• Format adresă TCP/IP:

struct sockaddr_in
{ u_char sin_len; /* total length of address */
u_char sin_family; /* family of the address */
u_short sin_port; /* protocol port number */
struct in_addr sin_addr; /* IP address */
char sin_zero[8] /* unused */
}

Serviciu fără conexiune

• Observații:
– Apelul bind e opțional
la inițiator (client).
– Serverul de obicei lucrează
în buclă infinită.
– Atenție la ordinea
apelurilor sendto
și recvfrom.


• Operații server:
– Crează socket:
int s = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
– Setează port pentru socket:
int bind (int socket_descriptor, struct sockaddr* local_address,
int address_length)
bind(s, &addr, sizeof(addr)); // detalii slide următor
– Primește mesaje:
int recvfrom (int socket_descriptor, char* buffer_address, int
buffer_length, int flags, struct sockaddr* sender_address,
unsigned int* sendaddress_length)
recvfrom(s, buf, BUFLEN, 0, NULL, NULL);
– Oprește trimitere / recepție date:
shutdown (s, SHUT_RD / SHUT_RDWR / SHUT_WR);
– Închide socket (termină utilizare socket)
close (s);


• Operații setare adresă:
– Format adresă TCP/IP:
struct sockaddr_in { u_char sin_len; /* total length of address */
u_char sin_family; /* family of the address */
u_short sin_port; /* protocol port number */
struct in_addr sin_addr; /* IP address */
char sin_zero[8] /* unused */
}
– Apelare
struct sockaddr_in serv_addr;
memset ((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET; // adrese pentru Internet
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //adresa IP a masinii
serv_addr.sin_port = htons(portno); //de la host la network byte order


• Operații client:
– Crează socket:
int s = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
– Trimite mesaje:
int sendto (int socket_descriptor, char* data_address, int
data_length, int flags, struct sockaddr* dest_address, int
destaddress_length)
sendto (s, buf, BUFLEN, 0, &addr, sizeof(addr));
– Oprește trimitere / recepție date:
shutdown (s, SHUT_RD / SHUT_RDWR / SHUT_WR);
– Închide socket (termină utilizare socket)
close (s);

Un exemplu de client UDP

// Sursa: http://people.cs.uchicago.edu/~mark/51081/labs/LAB6/sock.html
int main(int argc, char *argv[]) {
int sd, rc, i; struct sockaddr_in cliAddr, remoteServAddr; struct hostent *server;
if( (server = gethostbyname(argv[1])) == NULL)
{ printf("%s: unknown host '%s'\n", argv[0], argv[1]); exit(1); }
printf("%s: -> '%s' (IP : %s) \n", argv[0], h->h_name, inet_ntoa(*(struct in_addr
*)h->h_addr_list[0]));
remoteServAddr.sin_family = h->h_addrtype;
memcpy((char *) &remoteServAddr.sin_addr.s_addr, h->h_addr_list[0], h->h_length);
remoteServAddr.sin_port = htons(REMOTE_SERVER_PORT);
if( (sd = socket(PF_INET,SOCK_DGRAM,0)) <0 )

{ printf("%s: cannot open socket \n",argv[0]); exit(1); }
cliAddr.sin_family = AF_INET;
cliAddr.sin_addr.s_addr = htonl(INADDR_ANY);
cliAddr.sin_port = htons(0); // alegere automata a unui port disponibil
if( (rc = bind(sd, (struct sockaddr *) &cliAddr, sizeof(cliAddr))) <0)

{ printf("%s: cannot bind port\n", argv[0]); exit(1); }
for(i=2;i<argc;i++) {
rc = sendto(sd, argv[i], strlen(argv[i])+1, 0, (struct sockaddr *)
&remoteServAddr, sizeof(remoteServAddr));
if(rc<0) { printf("%s: cannot send data %d \n",argv[0],i-1); close(sd); exit(1); }
}
return 0;
}
Un exemplu de server UDP

int sd, rc, n, cliLen; struct sockaddr_in cliAddr, servAddr; char msg[MAX_MSG];
if( (sd=socket(PF_INET, SOCK_DGRAM, 0)) <0)

{ printf("%s: cannot open socket \n",argv[0]); exit(1); }
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // adresa pt server
servAddr.sin_port = htons(LOCAL_SERVER_PORT); // portul pentru server
if((rc = bind (sd, (struct sockaddr *) &servAddr,sizeof(servAddr))) <0)‫‏‬

{printf("%s: cannot bind port number %d\n", argv[0], LOCAL_SERVER_PORT); exit(1);}
printf("%s: waiting for data on port UDP %u\n", argv[0],LOCAL_SERVER_PORT);
while(1) { /* server infinite loop */

memset(msg,0x0,MAX_MSG); /* init buffer */
cliLen = sizeof(cliAddr); /* receive message */
if((n=recvfrom(sd, msg, MAX_MSG, 0, (struct sockaddr *) &cliAddr, &cliLen)) < 0)‫‏‬
{
printf("%s: cannot receive data \n",argv[0]); continue;
}
printf("%s: from %s:UDP%u:
%s\n",argv[0],inet_ntoa(cliAddr.sin_addr),ntohs(cliAddr.sin_port),msg);
}
return 0;
}
Un alt exemplu de client UDP

Un alt exemplu de server UDP

Un alt exemplu UDP – Makefile

Un alt exemplu UDP – Rulare


• listen(socket_descriptor, queue_size)‫‏‬
– Folosit de server, aşteaptă cereri de conexiune:
• queue_size numărul maxim de cereri în aşteptare.
• new_ socket_descriptor = accept(socket_descriptor,

client_socket_address, client_addresslen)
– Folosit de server, acceptă următoarea cerere de conectare
• new_socket_descriptor capătul la server al noii conexiuni.
• socket_descriptor rămâne neschimbat şi continuă să primească noi cereri
de conectare.
• client_socket_address adresa clientului.
• client_addresslen lungimea adresei.


• connect(client_sock_desc, server_socket_address,
server_sockaddress_length)‫‏‬
– Folosit de client la conectarea cu serverul (servicii cu conectare, TCP).
– Serverul este implicit la următoarele operaţii send / recv.
• send(sock_desc, data_address, data_length, flags)
– Pentru transmitere (servicii cu conectare).
– Returnează numărul de octeți trimiși
• Poate fi mai mic decât data_length!
• recv(sock_desc, data_address, data_length, flags)
– Pentru recepţie (servicii cu conectare).
– Returnează numărul de octeți primiți
• Poate fi mai mic decât data_length!
– flags indică opţiuni speciale:
• MSG_OOB: trimite / primeşte date out-of-band.
• MSG_PEEK: livrează date primite, dar tratează ca necitite.
Serviciu orientat pe conexiune

• Observații:
– Apelul accept
returnează un
nou socket.
– Serverul de obicei
lucrează în buclă
infinită.
– Atenție la ordinea
apelurilor
send și recv.


• Operații server:
– Crează socket (pasiv):
int sp = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
– Setează port pentru socket:
bind (sp, &addr, sizeof(addr));
– Stabilește numărul maxim de cereri de conectare în așteptare:
int listen (int socket_descriptor, int queue_size)
listen (sp, 5);
– Repetat – Acceptă o cerere de conectare:
int accept (int listen_socket_descriptor, struct sockaddr*
client_socket_addr, int* client_addrlen)
int sa = accept (sp, NULL, NULL);
– Repetat – Trimite / primește date pe sa (socket activ).


• Operații client:
– Crează socket:
int s = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
– Conectare la server (uzual pentru servicii cu conectare):
int connect (int client_socket_descriptor, struct sockaddr*
server_socket_address, int server_sockaddress_length)
connect (s, &addr, sizeof(addr));
– 3. Repetat – Trimite / primește date pe s

Închiderea conexiunii TCP

• Operații închidere:
– Eliberează resursele asociate conexiunii.
– Informează capătul celălalt de închiderea conexiunii.
– API:
• shutdown
int shutdown (int socket, int how)
shutdown (s,SHUT_RD/SHUT_RDWR/SHUT_WR)
– Oprește primirea – rejectează datele care sosesc.
– Oprește transmiterea – ignoră datele încă netrimise.
– Ambele.
• close
int close (int socket)
close (s);
– Închide socket (eliberează structurile de date din kernel).
Un exemplu de client TCP

int main(int argc, char *argv[]){
int sockfd, portno, n; char buffer[256];
struct sockaddr_in serv_addr; struct hostent *server;
portno = atoi(argv[2]);
if((sockfd = socket(PF_INET, SOCK_STREAM, 0))) error("ERROR opening socket");
if((server = gethostbyname(argv[1])) == NULL) error("ERROR, no such host\n");
memset((char*) &serv_addr, 0, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;
memcpy((char*)&serv_addr.sin_addr.s_addr, (char*)server->h_addr, server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0)

error("ERROR connecting");
//trimit mesajul din buffer

if((n=send(sockfd, buffer, strlen(buffer), 0))< 0) error("ERROR writing to socket");
//astept raspuns
memset(buffer, 0, 256);
if((n = recv(sockfd, buffer, 255, 0)) < 0) error("ERROR reading from socket");
printf("[SRV]%s\n",buffer);
close(sockfd);
return 0;
}
Un exemplu de server TCP

int sockfd, newsockfd, portno, clilen, n; char buffer[256];
struct sockaddr_in serv_addr, cli_addr;
if( (sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) error("ERROR opening socket");

portno = atoi(argv[1]);
memset((char*) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);// foloseste adresa IP a masinii
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(struct sockaddr)) < 0) error("ERROR

on binding");
listen(sockfd, MAX_CLIENTS);
// accepta o conexiune de la un client
clilen = sizeof(struct sockaddr_in);
if((newsockfd = accept(sockfd, (struct sockaddr*) &cli_addr, &clilen)) < 0)
error("ERROR on accept");
// astept mesaj
memset(buffer, 0, 256);
if((n = recv(newsockfd, buffer, 255, 0)) < 0) error("ERROR reading from socket");
printf("Here is the message: %s\n", buffer);
//... trimit raspunsul din buffer
n = send(newsockfd, buffer, strlen(buffer), 0);
close(sockfd); close(newsockfd); return 0;
}

Protocoale de transport
• Două potocoale majore:
– UDP (User Datagram Protocol).
– TCP (Transmission Control Protocol).
• Aspecte discutate:
– Formatul datelor.
– Adresare.
– Funcționare.
Protocoale de comunicaţie – Curs 5

UDP – User Datagram Protocol

• UDP livrează datagrame utilizator (user datagrams):
– Livrare “Best effort”, datagramele pot fi:
• Pierdute.
• Primite în altă ordine.
• Etc.
– Sume de control pentru integritate.
• Puncte de capăt UDP = protocol ports (porturi, puncte de acces la
serviciu).
• UDP identifică adresa Internet şi număr port pentru sursă şi
destinaţie.
• Destination port şi Source port pot diferi.
• E utilizat în aplicaţii client-server, de tip DNS.

Antet UDP
• Checksum nefolosit (calculat la fel ca la TCP).
• Nu control flux.
• Nu control erori.
• Nu retransmisie.

Aplicații care folosesc UDP

• DNS.
• Voice over IP.
• Online Games.
• Se folosește atunci când:
– Latența este foarte importantă.
– Livrarea tuturor datelor nu e necesară.
– Retransmisiile sunt implementate de aplicații când e nevoie (DNS).

TCP – Transmission Control Protocol

• Cel mai folosit protocol de transport:
– Web, e-mail, ssh.
– Chat, video streaming.
– Peer-to-peer.
• Livrare sigură pe reţea nesigură (datagrame).
• Câteva porturi (din fişierul /etc/services pe o maşină Unix):
Port Protocol Use

21 FTP File transfer
23 Telnet Remote login
25 SMTP E-mail
69 TFTP Trivial File Transfer Protocol
79 Finger Lookup info about a user
80 HTTP World Wide Web
110 POP-3 Remote e-mail access
119 NNTP USENET news
Porturi uzuale
# This file contains port numbers for well-known services defined by IANA
# Format:
# <service name> <port number>/<protocol> [aliases...] [#<comment>]
daytime 13/tcp
daytime 13/udp
ftp-data 20/tcp #FTP, data
ftp 21/tcp #FTP. control
telnet 23/tcp
smtp 25/tcp mail #Simple Mail Transfer Protocol
domain 53/tcp #Domain Name Server
domain 53/udp #Domain Name Server
tftp 69/udp #Trivial File Transfer
gopher 70/tcp
finger 79/tcp
http 80/tcp www www-http #World Wide Web
kerberos 88/tcp krb5 kerberos-sec #Kerberos
kerberos 88/udp krb5 kerberos-sec #Kerberos
rtelnet 107/tcp #Remote Telnet Service
pop3 110/tcp #Post Office Protocol-Version 3
sunrpc 111/tcp rpcbind portmap #SUN Remote Procedure Call
sunrpc 111/udp rpcbind portmap #SUN Remote Procedure Call
auth 113/tcp ident tap #Identification Protocol
imap 143/tcp imap4 #Internet Message AccessProtocol
bgp 179/tcp #Border Gateway Protocol
irc 194/tcp #Internet Relay Chat Protocol
https 443/tcp MCom
https 443/udp MCom
TCP și fluxurile de octeți

• TCP este orientat pe flux (șir) de octeți (la transmisie și recepție):
– Aplicația transmițătoare scrie octeți pe conexiunea TCP.
– Entitatea TCP sursă memorează octeții într-un buffer și transmite
segmente.
– Entitatea TCP destinație memorează segmentele într-un buffer.
– Aplicația receptoare citește octeți (câți vrea!) de pe conexiunea TCP.
• Numărul de octeți citiți de aplicația receptoare la un apel recv poate diferi
de numărul de octeți scriși de aplicația emițătoare la un apel send.

Caracteristici TCP
• Orientat pe conexiune.
• Interfață flux (stream)
– Transmisie și recepție de șir de octeți.
• Realizează controlul congestiei, adaptând viteza de transmisie la
condițiile rețelei.
• În cadrul unei conexiuni garantează transmisie în ordine și sigură a
datelor.
• Full duplex.
• Folosește ”Three way handshake” pentru o stabilire sigură a
conexiunii.
• Eliberare lină a conexiunii pentru a un pierde date.

Antet segment TCP

• Câmpuri antet:
– Sequence number: numărul primului octet din segment.
– Acknoledgement number: numărul următorului octet așteptat.
– Header length: numărul de cuvinte de 32 biți din header.
– Window size: numărul de octeţi care pot fi trimişi, începând cu octetul confirmat.
– Urgent pointer: deplasamentul, faţă de Seq number, pentru informația urgentă.
– Bit RST: resetare conexiune (ca răspuns la o eroare).
– Bit SYN.
– Bit ACK.
– Bit FIN.
– Bit URG (priority).
– Bit PSH (buffer!).

Antet segment TCP

• URG Urgent pointer valid. • SYN: open connection.
• ACK Acknowledge Number valid.• FIN: close a connection.
• PSH: push information to user. • Options:
• RST: close a connection due to – Max TCP payload (implicit 536 octeţi).
an error. – Selective repeat.

Stabilire conexiune TCP

• Three way handshake.
• Caz normal (a). • Coliziune (b).

Rejectare conexiune
• SYN întarziat • A inițiază conexiune (SYN i)

• B acceptă • SYN k întârziat – A refuză
• A rejectează • B acceptă SYN i – răspunde cu SYN j.

Deconectare abruptă cu pierdere de date
• DR – Disconnect request echivalent cu FIN (TCP)

Problema celor două armate

• Stabilirea unei înţelegeri:
• Procesele funcţionează corect.
• Legăturile de comunicaţie sunt nesigure.

Problema consensului bizantin

• Stabilirea unei înţelegeri:
• Procesele funcţionează imprevizibil (din cauza defectărilor).
• Legăturile de comunicaţie sunt sigure.

Patru scenarii de eliberare a conexiunii
• Caz normal (a). • ACK final pierdut (b).

• Răspuns pierdut (c). • Răspuns şi DR pierdute (d).

Model management conexiune TCP

• Stările folosite în managementul conexiunii TCP
– Stările pe calea normală pentru client (*).
Stare Descriere
CLOSED (ÎNCHIS)‫‏‬ Nici o conexiune nu este activă sau în aşteptare
LISTEN (ASCULTARE)‫‏‬ Serverul aşteaptă recepţionarea unui apel
SYN RCVD (Recepţie SYN)‫‏‬ S-a recepţionat o cerere de conexiune; aştept ACK
SYN SENT (Transmisie SYN) (*)‫‏‬ Aplicaţia a început deschiderea unei conexiuni
ESTABLISHED (STABILIT)‫‏‬ Starea normală de transfer a datelor
FIN WAIT 1 (Aşteptare FIN 1) (*)‫‏‬ Aplicaţia a anunţat că termină
FIN WAIT 2 (Aşteptare FIN 2) (*)‫‏‬ Partenerul este de acord cu eliberarea conexiunii
TIMED WAIT (Aşteptare Temporizată) (*)‫‏‬ Se aşteaptă „moartea” tuturor pachetelor
CLOSING (În curs de INCHIDERE)‫‏‬ Ambele părţi încearcă simultan închiderea
CLOSE WAIT (ÎNCHIDE şi AŞTEAPTĂ)‫‏‬ Partenerul a iniţiat eliberarea conexiunii
LAST ACK (CONFIRMARE FINALĂ)‫‏‬ Se aşteaptă „moartea” tuturor pachetelor

Model management conexiune TCP

• Linie groasă continuă:
– Cale normală pentru client
(activ, cere conectare).
• Linie groasă întreruptă:
– Cale normală server
(pasiv, acceptă).
• Linii subţiri:
– Evenimente excepţionale.
• Fiecare tranziţie are
o etichetă de forma:
– Eveniment / Acţiune.

Corectitudinea segmentelor TCP

• Suma de control (16 biți) din antet
– Include:
• Antet + încărcătură segment TCP;
• Pseudo-antetul (vezi figura);
– Adresele IP sursă și destinație (separarea nivelurilor?!);
– Protocolul (6 pentru TCP);
– Lungime segment TCP (include antetul).
– Algoritm:
• La transmisie:
– Adună cuvinte de 16 biţi în complement faţă de 1;
– Complementează rezultatul;
– Scrie rezultatul în antet.
• La recepţie:
– Adună cuvinte de 16 biţi, rezultatul trebuie să fie zero.
• Acknowledgement number:
– Următorul octet aşteptat.
• Corecția se face prin retransmitere.
Controlul fluxului de date

• Receptorul specifică
fereastra de recepţie.
• Un emiţător blocat
poate trimite:
– Date urgente.
– Un segment de 1 octet
pentru a afla fereastra
• Dacă anunţul
precedent al
receptorului s-a
pierdut.

Probleme cu dimensiunea câmpurilor din antet

• Numere secvenţă pe 32 biţi:
– Timp ciclu de numărare (depinde de viteza transmisie):
• (120 secunde este timpul de viaţă maxim în Internet)‫‏‬.
• 1 săptămână pentru 56kbps.
• 57 minute pentru 10Mbps.
• 34 secunde pentru 1Gbps (mai mic ca 120 secunde!).
– Problema:
• Cum se diferenţiază segmentele cu acelaşi număr de secvenţă?
• Fereastra receptor:
– Transmitere 500 Kb pe legătură de 1 Gbps ocupă 500 μs.
– La întârziere de 20 ms confirmarea se primeşte după 40 ms, rezultând
o ocupare a canalului de 1.25%.
– Ocupare completă în ambele direcţii: produsul bandwidth*delay (BDP)
= 40 milioane biţi.
– Fereastra receptor să fie mai mare ca acest produs.
– Problema: cum se poate mări dimensiunea ferestrei?
Probleme cu dimensiunea câmpurilor din antet

• Realităţi:
– Viteza de comunicare creşte mai repede ca viteza calculatorului.
– “Go back n” are performanţe slabe la bandwidth*delay mare.
• Soluţii:
– Folosirea opţiunilor TCP (RFC 1323):
• TCP Timestamps: rezolvă numerele de secvenţă duplicate (prin asocierea
unei amprente de timp cu fiecare segment).
• Window Scale: factor de scalare a câmpului “Window size” cu până la 214
poziţii binare  se permit ferestre de până la 230 octeţi.
• Câmpuri de date lungi (1500 prea puţin).
– Principiu: proiectare pentru viteză, nu pentru bandwidth.
– Rezervare resurse la stabilire conexiune.
– Format pachete: antete cu puţine câmpuri, antete / date cu sume de
control separate.
– Transmitere date odată cu cerere conectare.
– Minimizare timp prelucrare protocol.
– Minimizare timp copiere.
Controlul congestiei
• Fluxul de date transmis pe o conexiune TCP limitat de minimul
dintre:
– Dimensiunea ferestrei receptorului;
– Capacitatea reţelei (fereastra de congestie).
• Algoritmul de stabilire a ferestrei de congestie:
– Transmite un segment de dimensiune maximă pe conexiunea stabilită;
– Se dublează dimensiunea (rafală de segmente) la fiecare transmisie
confirmată la timp;
– La primul timeout se opreşte procedeul şi fereastra rămâne la valoarea
ultimei transmisii confirmate la timp (fără timeout).
• Algoritmul de control al congestiei:
– Foloseşte un prag (threshold);
– La un timeout pragul setat la jumatate din fereastra de congestie;
– Se aplică procedeul de creştere (exponenţială) a ferestrei de congestie
până se atinge pragul;
– Peste prag se aplică o creştere liniară (un segment maxim o dată).
Controlul congestiei

Gestiunea ceasurilor în TCP
• Densitatea de probabilitate a timpilor de sosire ACK în nivelul legatură de date a).

• Densitatea de probabilitate a timpilor de sosire ACK pentru TCP (b).

Stabilire time-out
• Setare necorespunzătoare <=> performanţe slabe:
– Prea lung: transmiţătorul aşteaptă mult pentru retransmisie.
– Prea scurt: trafic inutil generat de transmiţător.
• Timeout diferit la fiecare conexiune, setat dinamic.
• Timeout bazat pe Round Trip Time (RTT).
• Transmiţătorul alege “Retransmission TimeOut“ (RTO) pe baza
valorilor RTT anterioare:
– M este timpul măsurat până la primirea ack:
• RTT = α*RTT + (1- α)*M, cu α = 7/8;
• RTO = β*RTT, cu β = 2.
– Alegere după deviaţia standard DS, D aproximează DS:
• D = α*D + (1- α)*|RTT-M|;
• RTO = RTT + 4*D.
• Adaptive retransmission algorithm.

Proiectarea pentru performanţă

• Problema: schimbări de context suplimentare pentru a manevra un
pachet cu un manager (controlor) de reţea în spaţiul utilizatorului.
– Controlorul asamblează mesajele și le livrează procesului receptor.
• Soluţia: acumularea mesajelor sosite (memorie tampon) și livrarea
în grup – minimizare număr comutări de context!!!
– Mesajele sosite sunt colectate (în zone tampon) şi transmise grupat
către utilizator.
– Mesajele de trimis tratate similar.

Prelucrare Fast TPDU

• Calea rapidă între transmiţător şi receptor este cu line groasă.
• Paşii urmaţi sunt reprezentaţi cu gri.
• Test caz normal:
– Starea = ESTABLISHED;
– Nu se încearcă închiderea conexiunii; alege fast path
– TPDU normal, suficient spaţiu la receptor.

Prelucrare Fast TPDU

• Transmiţător:
– Păstreaza un prototip în entitatea de transport: câmpuri nemodificate
în unităţi de date consecutive (la fel pentru IP).
– Câmpurile gri din antet TCP (a) şi antet IP (b ) sunt luate din prototip
fără modificări (celelalte se calculează pentru fiecare segment).
• Receptor:
– Localizează înregistrarea conexiunii din TPDU într-o tabela hash.
– Testează pentru cazul normal (similar cu transmisia).
– Actualizează înregistrarea conexiunii (starea curentă).
– Copiază datele la utilizator şi calculează suma de control.
– Transmite confirmarea.
Fast TPDU: Timer management

• “Timing wheel”:
– 1 slot = 1 clock tick.
– Timp curent T=4.
• Programare time-out peste 7
tick-uri:
– Inserează eveniment în lista
de la slot 11.
• Anulare:
– Caută în lista de la slot
corespunzator şi elimină
eveniment.
• La fiecare clock tick, un
pointer avansează cu un slot,
circular.
• Daca slot nevid, procesează
toate evenimentele.
Real-Time Transport Protocol

• Funcţie principală: multiplexare fluxuri RTP, cu transmiterea ca un
singur șir de datagrame UDP.
– Utilizat în aplicații multimedia în timp real (muzică la cerere,
videoconferințe), unicast sau multicast.
– Fără retransmitere, receptorul “interpolează” sau ignoră pachetele
absente (fiecare are un număr de secvență).
• Formatul datelor din "RTP payload" este specific aplicațiilor
– Permite definirea de profile și, pentru un profil, a mai multor formate.
• Poziţia RTP în stiva de protocoale:
• Format pachet:

Antet RTP
• P (Padding): pachet extins la • Timestamp: amprentă de timp
multiplu de 4 octeţi. relativă la începutul fluxului:
• X (eXtension): antet extins – Receptorul să folosească
(primul cuvânt dă lungimea). proba la timpul potrivit.
• Synchro: identifică sursa de
• CC: număr surse multiplexate. sincronizare (fluxul căruia îi
• M: mark, specific aplicaţiei aparţine pachetul) :
(exemplu: start video frame). – Pentru multiplexare de-
• Payload type: MP3. multiplexare.
• Contrib: lista surselor care au
contribuit la conţinutul curent
(folosit pentru mixere).

TCP Tranzacţional (T/TCP)

• Tranzacţie: ACID (Atomicity, Consistency, Isolation, Durability).
• Permite transfer de date la “connection setup”.
– RPC folosind TCP normal: (a) cele 2 sensuri ale conexiunii se închid
separat.
– RPC folosind T/TCP: (b).

Sumar
• Servicii. • Management conexiune TCP.
• Socket API: • Gestiunea ceasurilor în TCP.
– Exemple client-server TCP şi UDP. • Proiectarea pentru
• Elementele protocoalelor de performanţă – Fast TPDU.
transport:
• RTP – Real-Time Transport
– Adresare. Protocol.
– Stabilire conexiune.
• TCP tranzacţional.
– Eliberare conexiune.
– Control flux şi memorare temporară.
– Multiplexare. • http://www.prenhall.com/
tanenbaum/
• UDP – User Datagram Protocol.
• TCP – Transmission Control
Protocol.

06 Nivel Transport

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

06 Nivel Transport

Încărcat de

Drepturi de autor:

Formate disponibile

Universitatea Politehnica Bucureşti - Facultatea de Automatică şi Calculatoare

Protocoale de comunicaţie – Curs 5 1

Comunicarea între aplicații

Protocoale de comunicaţie – Curs 5 2

Servicii ale nivelului transport

Protocoale de comunicaţie – Curs 5 3

Socket Application Programming Interface

Protocoale de comunicaţie – Curs 5 5

Primitive de serviciu socket API

Protocoale de comunicaţie – Curs 5 6

Primitive de serviciu socket API

Protocoale de comunicaţie – Curs 5 7

Primitive de serviciu socket API

• bind(socket_descriptor, address, address_length)‫‏‬

Protocoale de comunicaţie – Curs 5 8

Primitive de serviciu socket API

• Format adresă TCP/IP:

Protocoale de comunicaţie – Curs 5 9

Serviciu fără conexiune

Protocoale de comunicaţie – Curs 5 10

Serviciu fără conexiune

Protocoale de comunicaţie – Curs 5 11

Serviciu fără conexiune

Protocoale de comunicaţie – Curs 5 12

Serviciu fără conexiune

Protocoale de comunicaţie – Curs 5 13

Un exemplu de client UDP

if( (sd = socket(PF_INET,SOCK_DGRAM,0)) <0 )

if( (rc = bind(sd, (struct sockaddr *) &cliAddr, sizeof(cliAddr))) <0)

Un exemplu de server UDP

if( (sd=socket(PF_INET, SOCK_DGRAM, 0)) <0)

if((rc = bind (sd, (struct sockaddr *) &servAddr,sizeof(servAddr))) <0)‫‏‬

printf("%s: waiting for data on port UDP %u\n", argv[0],LOCAL_SERVER_PORT);

while(1) { /* server infinite loop */

Un alt exemplu de client UDP

Protocoale de comunicaţie – Curs 5 16

Un alt exemplu de server UDP

Protocoale de comunicaţie – Curs 5 17

Un alt exemplu UDP – Makefile

Protocoale de comunicaţie – Curs 5 18

Un alt exemplu UDP – Rulare

Protocoale de comunicaţie – Curs 5 19

Primitive de serviciu socket API

• new_ socket_descriptor = accept(socket_descriptor,

Protocoale de comunicaţie – Curs 5 20

Primitive de serviciu socket API

Serviciu orientat pe conexiune

Protocoale de comunicaţie – Curs 5 22

Serviciu orientat pe conexiune

Protocoale de comunicaţie – Curs 5 23

Serviciu orientat pe conexiune

Protocoale de comunicaţie – Curs 5 24

Închiderea conexiunii TCP

Un exemplu de client TCP

memset((char*) &serv_addr, 0, sizeof(serv_addr));

if (connect(sockfd,(struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0)

//trimit mesajul din buffer

Un exemplu de server TCP

if( (sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) error("ERROR opening socket");

if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(struct sockaddr)) < 0) error("ERROR

Protocoale de comunicaţie – Curs 5 27

Protocoale de comunicaţie – Curs 5

UDP – User Datagram Protocol

Protocoale de comunicaţie – Curs 5 29