Programació en xarxes Programació en xarxes

Programació en xarxes Programació en xarxes
Presentació: Nom. Index de les tres parts de la prova? OBJECTIU: comprovació de l'aptitud pedagògica de l'aspirant i el seu domini de les tècniques necessàries per a l'exercici docent CONCLUSIÓ: Degut a que el temps per aquesta prova es limitat, em centraré en les parts de la programació que són competència directa del professor i només esmentaré de forma ràpida les qüestions que venen fixades de forma normativa per alguns dels ents reguladors dels Cfs. El meu objectiu és intentar demostrar en aquest temps límitat la meva capacitat com a docent, que puc ser bon comunicador, amb iniciativa i creativitat, sensible amb la diversitat a l'aula i als conflictes i/o problemes que poden sortir i que obviament predisposat a la innovació i adaptació a les circumstàncies

IPC. Inter-Process Communications
Aplicacions distribuïdes Cal entendre que un sistema distribuït no implica necessàriament una col·laboració entre màquines diferents sinó que pot ser entre processos diferents (IPC): Cues de missatges Memòria compartida Semàfors TCP/UDP sockets Unix Domain Sockets XML XML-RPC or SOAP Internet Communications Engine (ICE) (C++), DCOP a KDE... Bàsicament veurem exemples d'arquitectura client-servidor però sense obviar altres arquitectures distribuïdes com Peer To Peer (P2P).

Conceptes previs Protocols de transport. TCP vs UDP
Comunicacions orientades a connexió i no orientades a connexió. Estats Adreces IP i ports Sockets

Nivell 4 OSI. Nivell de Transport
És l'encarregat de la transferència lliure d'errors entre un emissor i un receptor encara que no estiguin directament connectats. INTERNET Emissor Receptor

Nivell de Transport. Funcions
Orientat a connexió (Connection-oriented): La capa de xarxa(nivell 3 OSI) no proveeix de connexió. TCP introdueix el concepte de connexió a la capa de transport. Ordre de lliurament (Same Order Delivery) La capa de xarxa no garanteix que els paquets arribin en el mateix ordre que han sortit de l'emissor. La forma més senzilla és numerar els paquets i reordenar-los al receptor. Dades fiables (Reliable data) Els paquets es poden perdre per la xarxa per problemes de congestió, errors, interferències, etc. S'utilitzen tècniques com la detecció de paquets corruptes (checksums) i la retransmissió d'errors. Atenció: les transmissions 100% sense errors no existeixen el que s'intenta és que hi hagi el mínim d'errors no detectats.

Control de flux (Flow Control): La memòria dels dispositius de xarxa és limitada i sense un control de flux un dispositiu amb una alta capacitat de transmissió pot saturar fàcilment un dispositiu més lent i amb poca memòria. Actualment això no es gaire problema ja que, les memòries són molt més barates que l'ample de banda. Control de la congestió (Congestion avoidance): Quan els paquets es perden es tornen a retransmetre. Si no tenim un control de congestió que permeti parar la transmissió durant una estona, el reenviament automàtic i immediat dels errors pot empitjorar el problema.

Orientació a bytes (Byte orientation): En comptes de treballar a nivell de paquets, la capa de transport permet treballar a nivell de bytes. La comunicació és un stream de bytes. Facilita la programació, ja que permet que una connexió de xarxa es pugui tractar igual que les comunicacions d'entrada/sortida (fitxers, dispositius, etc.) Ports Els ports són una forma essencial de permetre múltiples serveis en una mateixa localització (Adreça IP). NOTA: Els ports són part de la capa de transport en el model TCP/IP, però formen part de la capa de sessió al model OSI.

TCP vs UDP Els dos protocols de nivell de transport més utilitzats són TCP i UDP. TCP és més fiable però més lent. S'utilitza en comunicacions on la integritat de les dades és vital (per exemple la transferència de fitxers). UDP és menys fiable però més ràpid (aprox. 40% ). S'utilitza en aplicacions on la velocitat és important i ens podem permetrà la pèrdua d'algunes dades (P. ex. serveis en temps real com la telefonia IP o videoconferència)

Protocols orientats a connexió. TCP
Connection-oriented Els dispositius de cada banda de la connexió (emissor i receptor) utilitzen un protocol preliminar a l'enviament de dades per establir una connexió punta a punta. Sovint també s'anomenen serveis de xarxa fiables (reliable) per què es garanteix que les dades arribaren en l'ordre adequat. La comunicació pot estar en diferents estats La comunicació es duu a terme en tres fases: Fase 1: Establiment de la connexió Fase 2: Transmissió de dades Fase 3: Tancament de la connexió:

Protocols orientats a connexió. TCP
Encaixada de mans TCP (Handshake) Acabament de la connexió

Estats de la connexió I seguidament connecteu-vos a la web de la UPC
En els protocols orientats a connexió, la connexió passa per diferents estats. Pràctica: Comanda netstat. Executeu: I seguidament connecteu-vos a la web de la UPC Comanda netstat a la wiki del curs $ netstat --inet -t -a -c | grep upc.es:www tcp casa-linux.local: raiden.upc.es:www CLOSE_WAIT tcp casa-linux.local: raiden.upc.es:www ESTABLISHED tcp casa-linux.local: raiden.upc.es:www SYN_SENT tcp casa-linux.local: raiden.upc.es:www ESTABLISHED tcp casa-linux.local: raiden.upc.es:www LAST_ACK tcp casa-linux.local: raiden.upc.es:www TIME_WAIT

Protocols no orientats a connexió. UDP
Datagrames S'envien directament paquets de l'emissor al receptor sense establir prèviament una connexió. User Datagram Protocol (UDP) No és una connexió fiable, ja que els paquets poden arribar en qualsevol ordre, duplicats, es poden perdre... Protocols: DNS, DHCP, VoIP, Videoconferència, jocs en xarxa.

Adreces IP Les adreces IPs estan formades per 32 Bits
Permeten adreçar una mica menys de 4300 milions de màquines. El format més comú és el decimal amb punts. Altres notacions correspon als 32 bits:

Ports Ports Un port és una connexió virtual que pot ser utilitzada per les aplicacions per intercanviar dades. Els ports més comuns són els dels protocols TCP i UDP Notació: Decimal (22, 80) o Hexadecimal El fitxer /etc/services manté una llista de ports i els seus serveis associats. $ cat /etc/services | more tcpmux /tcp # TCP port service multiplexer echo /tcp echo /udp

Sockets Sockets Dispositius virtuals de comunicacions bidireccionals.
Hi han tantes famílies de sockets com protocols Unix Domain Sockets Internet Sockets (TCP, UDP i RAW) CANAL DE COMUNICACIONS

Unix domain socket Unix domain socket (UDS o IPC socket)
Són sockets virtuals, similars als sockets d'Internet que s'utilitzen en sistemes operatius POSIX per a la comunicació entre processos (IPC) També anomenats POSIX Local IPC Sockets. Components Tipus: Datagrama o Stream Camí absolut del fitxer $ ls -la /var/run/mysqld/mysqld.sock srwxrwxrwx 1 mysql mysql :42 /var/run/mysqld/mysqld.sock

Sockets d'Internet Components d'un socket d'Internet
Protocol (TCP, UDP, RAW IP) Adreça IP local Número de port local Adreça IP remota Número de port remot TCP CANAL DE COMUNICACIONS IP: Port: 4565 IP: Port: 80

Altres Sockets Altres protocols: inet6 (Ipv6) ax25 (AMPR AX.25)
netrom (AMPR NET/ROM) ipx (Novell IPX) ddp (Appletalk DDP) x25 (CCITT X.25) $ netstat -a --ipx netstat: no support for `AF IPX' on this system.

Berkeley Sockets API Berkeley sockets Application Programming Interface (API) Llibreria per desenvolupar aplicacions de xarxa amb C Aporta la capacitat de comunicació entre processos (IPC) a través de xarxa (tot i que també s'utilitza per comunicacions locals) També coneguda com BSD socket API perquè va ser originalment utilitzat amb el sistema operatiu BSD Unix (1983) És un estàndard de facto i referència per altres llenguatges de programació

Berkeley Sockets API Instal·lació Manuals: Llibreries: Capçaleres
Les trobareu a /usr/include: <sys/types.h>, <sys/socket.h> <sys/un.h> sudo apt-get install manpages-dev manpages-es $ dpkg -S sys/socket.h libc6-dev: /usr/include/sys/socket.h $ sudo apt-get install libc6-dev

Berkeley Sockets API. Crides de sistema
Domini del socket PF_UNIX/AF_UNIX, PF_LOCAL/AF_LOCAL: Unix socket PF_INET/AF_INET: socket d'internet Protocol Número extret del fitxer /etc/protocols Per TCP i UDP és 0 (IP). Recursos Socket() a la wiki del curs int socket(int domain, int type, int protocol);

Crides de sistema. socket()
Unix Domain Socket TCP socket UDP Socket int socket_fd; if ((socket_fd = socket(PF_UNIX, SOCK_STREAM/SOCK_DGRAM, 0)) == -1) { perror("Error obrint el socket\n"); exit(1); } int socket_fd; if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("Error obrint el socket\n"); exit(1); } int socket_fd; if ((socket_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { perror("Error obrint el socket\n"); exit(1); }

Crides de sistema. bind()
sockfd Descriptor de fitxer del socket (valor de retorn de socket()) Estructura sockaddr Depèn del domini del socket (hi ha una estructura pels sockets d'Internet i un altre pels sockets UNIX) Mida de l'estructura S'obté mitjançant la funció sizeof(). Recursos: Bind a la wiki del curs int bind(int sockfd, const struct sockaddr *my_addr, socklen_t addrlen);

Sockets d'Internet socket() Estructura de C: Un socket d'Internet s'identifica per la seva família, l'adreça IP i el port. tcp_socket = socket(PF_INET, SOCK_STREAM, 0); udp_socket = socket(PF_INET, SOCK_DGRAM, 0); raw_socket = socket(PF_INET, SOCK_RAW, protocol); struct sockaddr_in { sa_family_t sin_family; /* address family: AF_INET */ u_int16_t sin_port; /* port in network byte order */ struct in_addr sin_addr; /* internet address */ }; /* Internet address. */ struct in_addr { u_int32_t s_addr; /* address in network byte order */

Unix Domain Socket Recursos man unix Socket() Estructura C: Tipus
SOCK_STREAM: stream-oriented socket SOCK_DGRAM: Datagram oriented socket Recursos man unix unix_socket = socket(PF_UNIX, type, 0); error = socketpair(PF_UNIX, type, 0, int *sv); struct sockaddr_un { sa_family_t sun_family; /* AF_UNIX */ char sun_path[UNIX_PATH_MAX]; /* pathname */ };

Netstat Unix Sockets Internet Sockets $ netstat -a --unix
Active UNIX domain sockets (servers and established) Proto RefCnt Flags Type State I-Node Path unix [ ACC ] STREAM LISTENING /tmp/orbit-sergi/linc-1aca a4e26db unix [ ACC ] STREAM LISTENING /tmp/orbit-sergi/linc-1ac8-0-28f681304b90 unix [ ACC ] STREAM LISTENING @/tmp/dbus-IegbJtvc49 unix [ ] STREAM CONNECTED /tmp/.esd-1000/socket unix [ ] STREAM CONNECTED /tmp/orbit-sergi/linc-19cc-0-c6668c86a5cd $ netstat -a --inet Active Internet connections (servers and established) Proto Recv-Q Send-Q Local Address Foreign Address State tcp *:nfs *:* LISTEN tcp *:swat *:* LISTEN tcp *: *:* LISTEN tcp localhost:mysql *:* LISTEN tcp casa-linux.local: nobel.upc.es:imaps ESTABLISHED udp localhost: localhost: ESTABLISHED

Crides de sistema. bind()
Codi exemple Cal inicialitzar l'estructura amb memset() o bzero() Cal fer una conversió de tipus (struct sockaddr *) &sin struct sockaddr_in sin; int sock_descriptor; int port = 8000; sock_descriptor = socket(AF_INET, SOCK_STREAM, 0); //Inicialització de l'estructura sockaddr_in memset(&sin, 0 , sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = htons(port); if (bind (sock_descriptor, (struct sockaddr *)&sin, sizeof(sin)) == -1) { perror("Error al cridar bind..."); exit(1); }

Crides de sistema. listen()
Només s'aplica als sockets orientats a connexió. sockfd Descriptor de fitxer del socket (valor de retorn de socket()) Cua de connexions Determina la mida màxima de la cua d'espera de peticions de connexió Recursos: listen() a la wiki del curs int listen(int sockfd, int backlog);

Crides de sistema. accept()
sockfd Descriptor de fitxer del socket (valor de retorn de socket()) Estructura sockaddr Accept extreu la primera petició de connexió de la cua i crea un nou socket per establir la comunicació entre client i servidor. El socket nou passa a l'estat d'escolta (LISTENING). El socket original no es veu afectat per accept. Recursos: accept() a la wiki del curs int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

Crides de sistema. connect()
Només s'utilitza amb sockets orientats a connexió sockfd Descriptor de fitxer del socket (valor de retorn de socket()) Estructura sockaddr Conté la informació del socket al que ens connectem (adreça IP i port) Recursos: connect() a la wiki del curs int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);

Crides de sistema. connect()
int socket_fd; struct sockaddr_in adreca; char * host_name = " "; // int port = 8000; if ((server_host_name = gethostbyname(host_name)) == 0) { perror("Error resolent l'adreça del servidor\n"); exit(1); } memset(&adreca, 0, sizeof(adreca)); adreca.sin_family = AF_INET; adreca.sin_addr.s_addr = htonl(INADDR_ANY); adreca.sin_addr.s_addr = ((struct in_addr *)(server_host_name->h_addr))->s_addr; adreca.sin_port = htons(port); if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("Error creant el socket\n\n"); if (connect(socket_fd, (void *)&adreca, sizeof(adreca)) == -1) { perror("Error conectant-se al socket\n");

Crides de sistema. send()
Crides send: send() només es pot utilitzar amb sockets connectats sendto() és pot utilitzar tant en sockets connectats (TCP) com en sockets no connectats (UDP) Els flags normalment no s'utilitzen (valor 0). Codi d'error EMSGSIZE si el missatge és massa llarg. Recursos: send a la wiki del curs ssize_t send(int s, const void *buf, size_t len, int flags); ssize_t sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen); ssize_t sendmsg(int s, const struct msghdr *msg, int flags);

Crides de sistema. recv()
Crides recv: recv() només es pot utilitzar amb sockets connectats recvfrom() és pot utilitzar tant en sockets connectats (TCP) com en sockets no connectats (UDP) Els flags normalment no s'utilitzen (valor 0). Recursos: recv a la wiki del curs ssize_t recv(int s, void *buf, size_t len, int flags); ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen); ssize_t recvmsg(int s, struct msghdr *msg, int flags);

Exemple Client-Servidor. TCP
Servidor Echo Trobareu l'exemple a la wiki del curs i al servidor SVN. Treballant en parelles provarem l'aplicació. Tots dos components de la parella han d'executar tan tel servidor com el client Passos del servidor 1er: Crea un socket amb socket() Si les crides de sistema tornen un valor -1 és que tenim un error. Utilitzem la funció perror() per mostrar els errors per la sortida estàndard. sock_descriptor = socket(AF_INET, SOCK_STREAM, 0);

Passos del servidor 2on: Utilitzar bind per lligar el socket a un port de la màquina local Previàment cal preparar l'estructura sockaddr_in Netejar la memoria amb memset() Convertir adreces i ports a format hexadecimal amb htonl() i htons(). La constant INADDR_ANY indica que escoltem des de qualsevol de les adreces IP locals. memset(&sin,0 , sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = htons(port); if (bind(sock_descriptor, (struct sockaddr *)&sin, sizeof(sin)) == -1) { perror("Error al cridar bind..."); exit(1); }

Passos del servidor 3er: Posar el socket en estat LISTENING amb listen() Creem una cua de peticions de 20. 4rt: Utilitzem un bucle infinit per acceptar peticions de forma continuada. La crida de sistema accept extreu una nova petició de la cua i crea un nou socket per establir la comunicació client-servidor. if (listen(sock_descriptor, 20) == -1) { perror("Error al cridar listen..."); exit(1);} while(1) { temp_sock_descriptor = accept(sock_descriptor, (struct sockaddr *)&pin,&address_size); }

Passos del servidor 5é: La funció accept() atura l'execució fins que no arribi una nova petició Dins del bucle utilitzem les funcions recv(), send() i similars per transmetre les dades entre el client i el servidor. La transmissió de dades es fa a través d'un buffer de caràcters (String). 6é: Tancament implícit del socket de comunicacions. if (recv(temp_sock_descriptor, buf, 16384, 0) == -1) { //control d'errors } printf("S'ha rebut del client el següent String:%s\n", buf); if (send(temp_sock_descriptor, buf, strlen(buf), 0) == -1) { //Control d'errors close(temp_sock_descriptor);

Compilació i execució Utilitzant el make: Make compila tant el client com el servidor. Execució: Provar el servidor amb telnet $ make $ ./server $ telnet localhost 8000 Trying Connected to localhost. Escape character is '^]'. hola Connection closed by foreign host.

Passos del client: 1er: Crea un socket amb socket() 2on: Connectar-se al servidor amb connect() if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("Error creant el socket\n"); exit(1); } if ((server_host_name = gethostbyname(host_name)) == 0) { // Tractament d'errors} memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = htonl(INADDR_ANY); sin.sin_addr.s_addr = ((struct in_addr *)(server_host_name->h_addr))->s_addr; sin.sin_port = htons(port); if (connect(socket_fd, (void *)&sin, sizeof(sin)) == -1) { // Tractament d'errors }

Passos del client 3er: Comunicació bidireccional amb el servidor utilitzant recv() i send(). 4rt: Acabar la connexió amb close(). printf("Enviant missatge %s al servidor...\n", str); if (send(socket_fd, str, 8192, 0) == -1) { // Tractament d'errors..} printf("..Misatge enviat .. esperant la resposta...\n"); if (recv(socket_fd, buf, 8192, 0) == -1) { // Tractament d'errors} printf("\nResposta del servidor:\n\n%s\n", buf); close(socket_fd);

Estats d'un socket. Establiment de connexió
CLOSED Client Servidor socket() 1a Fase bind() listen() CLOSED connect() SYN LISTEN SYN_SEND SYN+ACK SYN_RECV ESTABLISHED ACK ESTABLISHED send() recv() send() recv() TRANSMISSIÓ DE DADES 2a Fase close() 3aFase FIN_WAIT 1 Tancament Passiu FIN CLOSE_WAIT ACK FIN_WAIT 2 FIN+ACK LAST_ACK TIMED_WAIT ACK timeout CLOSED CLOSED

Estats d'un socket El diagrama d'estats complert és el següent

Estats d'un socket Timeouts
En les comunicacions sempre hi han errors (de programació, dispositius que es pengen, caigudes de xarxa, etc). Per evitar que els sockets es quedin penjats en una esta fins indeterminadament s'estableixen uns timeouts.

Exemple UDP. Enviar missatges
Diferències: No s'utilitzen les crides de sistema encarregades d'establir connexions (listen(), accept() i connect()) Al utilitzar send() o recv() cal indicar el socket explícitament Pràctica Per parelles proveu d'enviar-vos missatges via UDP. Proveu d'augmentar la quantitat de missatges que envieu (P. ex. a ). Que passa si talleu la comunicació (desconnecteu el cable de xarxa si cal...) a mitja transmissió? Recursos: Exemple UDP a la wiki del curs

Exemple UDP. Enviar missatges
netstat UDP Receive Send netstat UNIX $ netstat -a -u --inet -c| grep 6789 $ netstat -a -u --inet -c $ netstat -a -u --unix -c| grep /tmp/mysocket

Exemple Unix. Enviar missatges
Diferències: Definició del socket sockaddr_un: No hi adreces IP ni ports, simplement un fitxer del sistema. Recursos: Exemple UNIX sockets a la wiki socket_descriptor = socket(AF_LOCAL, SOCK_DGRAM, 0) bzero(&sun, sizeof(sun)); sun.sun_family = AF_LOCAL; strcpy(sun.sun_path,"/tmp/mysocket");

Programació en xarxes Programació en xarxes

Presentaciones similares

Presentación del tema: "Programació en xarxes Programació en xarxes"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Programació en xarxes Programació en xarxes

Presentaciones similares

Presentación del tema: "Programació en xarxes Programació en xarxes"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback