Artigo Acadêmico 3 Trabalho Interdisciplinar - Faculdade de Ciências Sociais Aplicadas - FACISA Estrutura da Apresentação • Cenário • Problema • Justificativa • Objetivos • Referencial Teórico • Metodologia • Resultados • Conclusão/Recomendaçõe s
Desenvolvimento de Aplicações TCP/IP com Sockets Márcio de Sousa Dias [email protected].
Apr 22, 2015
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Arquitetura Internet TCP/IP
Internet Protocol (IP): Datagrama não confiável Transmission Control Protocol (TCP): Conexão User Data Protocol (UDP): Datagrama não confiável
A p licação
T ransp o r te
In te r-R ed e
In te rface de R ede
In tra -R ed e
A p licação
S essão
A p resen tação
T ransp o r te
R ed e
E n lace
F ís ico
T C P U D P
IP
F
T
P
T
T
P
H
M
T
P
S ELN
T
ET
N
F
S
N
M
P
S
A rqu ite tu ra In te rn e t T C P /IP e A p licações M o de lo O S I
Endereçamento Internet Endereço IP: 32 bits (4 octetos)
exemplo: 146.164.10.2 duas partes: Id. da rede + Id. do host
Classes de endereçamento: Classe A: 1 octeto para Rede (16 milhões de hosts)
1.x.x.x a 126.x.x.x
Classe B: 2 octetos para Rede (65 mil hosts)128.1.x.x a 191.254.x.x
Classe C: 3 octetos para Rede (254 hosts)192.1.1.x a 223.254.254.x
Sistema de domínios e servidores de nomes: Organização hierárquica Nomes: br ufrj.br nce.ufrj.br ipanema.nce.ufrj.br
Modelo Cliente-Servidor TCP/IP Comunicação ponto a ponto Paradigma de Comunicação Cliente/Servidor Servidores baseados em conexão/datagrama:
TCP garante confiabilidade (overhead e delays) UDP depende do Ambiente. Só usado quando:
• o protocolo da aplicação controla confiabilidade;
• confia no broadcast ou multicast do hardware; ou
• a aplicação não pode tolerar o atraso computacional exigido nos circuitos virtuais do TCP.
Servidores com/sem estado Com estado: mensagens menores, processamento simples;
protocolo mais complexo para controlar estados e erros Sem estado: protocolo deve realizar operações idempotentes
A Interface de Sockets Objetivo:
Funções para comunicação com múltiplos protocolos TCP/IP é uma família de protocolo nesse contexto Especificar tipo de serviço, e não o nome do protocolo
tabe la de desc r ito res
0
1
2
3
4
5
es tru tu ra de dadosin te rna pa ra :
A rqu ivo 0
A rqu ivo 1
A rqu ivo 2
A rqu ivo 5
A rqu ivo 3
A rqu ivo 4
tabe la de desc r ito res
0
1
2
3
4
5
es tru tu ra de dadosin te rna pa ra o socke t:
com oan tes
fam íl ia : P F _ IN E T
serv iço : S O C K _S T R E A M
Loca l IP :
R em ote IP :
Loca l P o rt:
R em ote P o rt:
Usando um socket: Esperar pedido de conexão: socket passivo Iniciar uma conexão: socket ativo
Usando SocketsCLIENTE
s = socket(...);
connect(s,...);
write(s,...);
read(s,...);
close(s);
(TCP/UDP)SERVIDOR(TCP Iterativo)
s = socket(...);
bind(s,...);
write(s1,...);
read(s1,...);
close(s1);
listen(s,...);
s1 = accept(s,...);
Principais Funções de Sockets#include <sys/types.h>#include <sys/socket.h>
Estrutura de Dados para Endereço do Socket
/* Structure used by kernel to store most addresses. */struct sockaddr { u_short sa_family; /* address family */ char sa_data[14]; /* up to 14 bytes of direct address */};
/* Socket address, internet style. */struct sockaddr_in { short sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8];};
Principais Funções de Socketsocket: Cria um novo socket para comunicação em rede.int socket (int af, int type, int proto);
connect: Após criação do socket, um cliente chama connect para estabelecer uma conexão ativa com um servidor remoto.int connect (int s, const struct sockaddr *addr, int addrlen);
bind: Quando um socket é criado, ele não possui noção dos endereços (local e remoto). Uma aplicação chama bind para especificar o endereço local da porta. Um servidor chama bind para especificar a porta pela qual aceitará conexões.int bind (int s, const struct sockaddr *addr, int addrlen);
listen: Quando um socket é criado, ele não é ativo nem passivo. Servidor orientados a conexão chamam listen para colocar o socket em modo passivo epara torná-lo apto a aceitar conexões.int listen (int s, int qlen);
accept: O servidor chama accept para aceitar a próxima requisição de conexão. Ela cria um novo socket para cada conexão requisitada. O socket original continua sendo usado para aceitar novas conexões, enquanto o novo socket é utilizado efetivamente para comunicação com o cliente.int accept (int s, struct sockaddr *addr, int *addrlen);
Escondendo DetalhesCLIENTE
s = socket(...);
connect(s,...);
(TCP)
SERVIDOR(TCP)
s = socket(...);
bind(s,...);
listen(s,...);
s1 = accept(s,...);
...
s = connectTCP(...);
write(s,...);
...write(s,...);
...
...
...
...
...
s = passiveTCP(...);
...s1 = accept(s,...);
(TCP/UDP)
s = connectUDP(...);
...write(s,...);
(UDP)
Aplicações Clientes Exemplo de Cliente TCP: daytime
#include <stdio.h>#include <stdlib.h>#include “connect.h”
int main (){ char buffer[200]; int n, s;
s = connectTCP( “barra.nce.ufrj.br”, “daytime” ); while( (n = read( s, buffer, sizeof(buffer) )) > 0 ) {
buffer[n] = ‘\0’;puts( buffer );
} close(s);
exit(0);}
Aplicações Clientes Exemplo de Cliente TCP: echo
#include <stdio.h>#include <stdlib.h>#include “connect.h”
int main (){ char buffer[200]; int n, s;
s = connectTCP( “barra.nce.ufrj.br”, “echo” ); while( strlen( gets(buffer) ) ) {
write( s, buffer, strlen(buffer) );while( (n = read( s, buffer, sizeof(buffer) )) > 0 ){ buffer[n] = ‘\0’; printf( buffer );}
} close(s);
exit(0);}
Aplicações Clientes
TCP/UDP ‘conectado’
Quando aplicado a sockets de tipo SOCK_DGRAM, a função connect apenas armazena o endereço para posterior uso.
UDP não ‘conectado’
s = so ck e t( ...) ;
co n n ec t(s , rem ad d r , s izeo f( ...) ) ;
w r i te (s ,...) ;
read (s ,...) ;
c lo se (s ) ;
s = socket(...);
sendto( s,..., remaddr, sizeof(...) );
recvfrom( s,..., remaddr, remaddrlen );
close(s);
Revelando os Detalhes (1)
Identificar Localização do Servidor: host + porta Identificando Host: Converter endereço IP para 32 bits
struct hostent { char * h_name; /* official name of host */ char ** h_aliases; /* alias list */ short h_addrtype; /* host address type */ short h_length; /* length of address */ char ** h_addr_list; /* list of addresses */#define h_addr h_addr_list[0]};
#include <netdb.h>
struct hostent * phe;char *hostname = “barra.nce.ufrj.br”; /* ou “146.164.8.7” */
if( phe = gethostbyname(hostname) ){ /* Endereço IP 32 bits: phe->h_addr */ }else{ /* Erro: nome do host não encontrado */ }
Revelando os Detalhes (2)
Identificando Porta de Serviços Conhecidos:
struct servent { char * s_name; /* official service name */ char ** s_aliases; /* alias list */ short s_port; /* port # */ char * s_proto; /* protocol to use */};
#include <netdb.h>
struct servent *pse;
if( pse = getservbyname( “smtp”, “tcp” ) ){ /* Número da Porta: pse->s_port */ }else{ /* Erro: nome do serviço não encontrado */ }
Revelando os Detalhes (3)
Identificando Protocolo pelo Nome:
struct protoent { char * p_name; /* official protocol name */ char ** p_aliases; /* alias list */ int p_proto; /* official protocol number */};
#include <netdb.h>
struct protoent *ppe;
if( ppe = getprotobyname( “udp” ) ){ /* Número Oficial do Protocolo: ppe->p_proto */ }else{ /* Erro: nome de protocolo não encontrado */ }
ServidoresIterativo
com conexãoIterativo
sem conexão
Concorrentecom conexão
Concorrentesem conexão
socket apenas para conexão
Servidores Servidores Iterativos
s = socket(...);
bind(s,...);
write(s1,...);
read(s1,...);
close(s1);
listen(s,...);
s1 = accept(s,...);
TCP (Com Conexão)
s = socket(...);
bind(s,...);
sendto( s,..., clienteaddr, ... );
recvfrom( s,..., clientaddr, ... );
UDP (Sem Conexão)
Servidores Servidor Concorrente TCP (com Conexão)
s = socket(...);
bind(s,...);
write(s1,...);
read(s1,...);
close(s1);
listen(s,...);
s1 = accept(s,...);
Processo Master
fork();
Processo Slave
close(s1);
close(s);
Servidores Múltiplas conexões compartilhando dados:
Concorrência Aparente: I/O assíncrono
Concorrência por Threads
Servidores I/O Assíncrono: select
Permite um processo esperar pelo primeiro descritor de arquivo (dentro de um conjunto) que esteja pronto.int select( int numfds, fd_set *in_fds, fd_set *out_fds, fd_set *exc_fds, struct timeval
*timeout ); Conjunto de Descritores de Arquivo:
Tipo do Dado: fd_setMacros de Manipulação: FD_ZERO ( fd_set *conjunto ) FD_SET ( int arquivo, fd_set *conjunto ) FD_ISSET ( int arquivo, fd_set *conjunto ) FD_CLR ( int arquivo, fd_set *conjunto )
Servidoresint s1, s2, nfs;fd_set afds, rfds; ... nfs = gettablesize();FD_ZERO( &afds );FD_SET( s1, &afds );FD_SET( s2, &afds );
for(;;) {bcopy( (char*)&afds, (char*)&rfds, sizeof(rfds) );if( select( nfs, &rfds, NULL, NULL, NULL) >= 0 ) {
if( FD_ISSET(s1, &rfds) ){ s3 = accept( s1, ... ); ...
FD_SET( s3, &afds ); ... }if( FD_ISSET(s2, &rfds) ){ read( s2, ... );
write( s2, ... );close( s2 );FD_CLR( s2, &afds ); }
}else /* Erro */
}
Protocolo de Aplicação
SMTP (Simple Mail Transfer Protocol) HTTP (HiperText Transfer Protocol) FTP (File Tranfer Protocol)
Related Documents
