Universidad Autónoma de Colombia

Comunicación de procesosSockets

Ingeniería de Sistemas

Electiva Tecnológica

Comunicación en sistemas distribuidos

• La comunicación de procesos es fundamental en cualquier sistema distribuido

• Existen diferentes posibilidades todas ellas basadas en el paso de mensajes– Mecanismos de bajo nivel, el programador debe

preocuparse de establecer los protocolos de comunicación, representación de datos, etc. • Colas de mensajes• Sockets

– Mecanismo de alto nivel, ofrecen abstracciones donde el programador no debe preocuparse de establecer protocolos• Llamadas a procedimientos remotos• Invocación de métodos remotos (entornos orientados a objetos)

Comunicación cliente-sevidor

Protocolo típico: petición-respuesta

Muy utilizada en entornos distribuidos (más del 90% de los sistemas distribuidos utilizan la arquitectura cliente-servidor)

NÚCLEO

cliente

petcición

respuesta

servidor

Máquina A Máquina B

NÚCLEO

RED

Comunicación de grupos

• Utiliza mensajes multicast• Útil para:– Ofrecer tolerancia a fallos basado en servicios

replicados– Localizar objetos en sistemas distribuidos– Mejor rendimiento mediante datos replicados– Actualizaciones múltiples– Operaciones colectivas en cálculo paralelo

Sockets• Aparecieron en 1981 en UNIX BSD 4.2– Intento de incluir TCP/IP en UNIX– Diseño independiente del protocolo de comunicación

• Un socket es punto final de comunicación (dirección IP y puerto)

• Abstracción que:– Ofrece interfaz de acceso a los servicios de red en el

nivel de transporte• Protocolo TCP• Protocolo UDP

– Representa un extremo de una comunicación bidireccional con una dirección asociada

Sockets: introducción

• Sujetos a proceso de estandarización dentro de POSIX (POSIX 1003.1g)

• Actualmente – Disponibles en casi todos los sistemas UNIX – En prácticamente todos los sistemas operativos• WinSock: API de sockets de Windows

– En Java como clase nativa

Sockets UNIX

• Dominios de comunicación• Tipos de sockets• Direcciones de sockets• Creación de un socket• Asignación de direcciones• Solicitud de conexión• Preparar para aceptar conexiones• Aceptar una conexión• Transferencia de datos

Dominios de comunicación

• Un dominio representa una familia de protocolos• Un socket está asociado a un dominio desde su

creación• Sólo se pueden comunicar sockets del mismo

dominio• Algunos ejemplos:– PF_UNIX (o PF_LOCAL): comunicación dentro de una

máquina– PF_INET: comunicación usando protocolos TCP/IP

• Los servicios de sockets son independientes del dominio

Tipos de sockets

• Stream (SOCK_STREAM)– Orientado a conexión– Fiable, se asegura el orden de entrega de mensajes– No mantiene separación entre mensajes– Si PF_INET se corresponde con el protocolo TCP

• Datagrama (SOCK_DGRAM)– Sin conexión– No fiable, no se asegura el orden en la entrega – Mantiene la separación entre mensajes– Si PF_INET se corresponde con el protocolo UDP

• Raw (SOCK_RAW)– Permite el acceso a los protocolos internos como IP

Direcciones de sockets

• Cada socket debe tener asignada una dirección única• Las direcciones se usan para:– Asignar una dirección local a un socket (bind)– Especificar una dirección remota (connect o sendto)

• Dependientes del dominio• Se utiliza la estructura genérica struct sockaddr• Cada dominio usa una estructura específica– Direcciones en PF_UNIX (struct sockaddr_un)

• Nombre de fichero– Direcciones en PF_UNIX (struct sockaddr_in)– Uso de conversión de tipos (casting) en las llamadas

Direcciones de sockets en PF_INET

• Host (32 bits) + puerto (16 bits)• Una dirección IP se almacena en una estructura de

tipo:– struct in_addr

• Estructura struct sockaddr_in– Debe iniciarse a 0– sin_family: dominio (AF_INET)– sin_port: puerto– sin_addr: dirección del host

• Función que facilita el nombre de la máquina en la que se ejecuta:

int gethostname(char *name, int namelen);

Obtención de la dirección de host

• Usuarios manejan direcciones en forma de texto:– decimal-punto: 138.100.8.100– dominio-punto: laurel.datsi.fi.upm.es

• Algunas funciones para trabajar con direcciones:– char *inet_ntoa(struct in_addr in);

• Devuelve una dirección en notación decimal-punto.– struct hostent *gethostbyname(char *str);

• Convierte una dirección en notación dominio-punto a una estructura que describe máquina.

• Algunos campos de la estructura struct hostent:– char *name nombre oficial de la máquina– char **h_addr_list lista de direcciones

Ejemplo• Programa que obtiene la dirección en formato

decimal-punto a partir de un formato dominio-punto.void main(int argc, char **argv) { struct hostent *hp; struct in_addr in;

hp = gethostbyname(argv[1]); if (hp == NULL) { printf(“Error en gethostbyname\n”); exit(0); } memcpy(&in.s_addr,*(hp->h_addr_list),sizeof(in.s_addr)); printf(“%s es %s\n”, hp->h_name, inet_ntoa(in));}

Direcciones de sockets II

• En TCP/IP los números se emplean con formato big-endian.

• En computadores que no utilicen este formato es necesario emplear funciones para traducir números entre el formato que utiliza TCP/IP y el empleado por el propio computador: u_long htonl (u_long hostlong)u_short htons (u_short hostshort)u_long ntohl (u_long netlong)u_short ntohs (u_short netshort)

• Las primera traduce un número de 32 bits representado en el formato del computador al formato de red (TCP/IP).

Creación de un socket

• int socket(int dominio, int tipo, int protocolo)– Crea un socket devolviendo un descriptor de

fichero– dominio: PF_XXX– tipo: SOCK_XXX– protocolo: dependiente del dominio y tipo• 0 elige el más adeucado• Especificados en /etc/protocols

• El socket creado no tiene dirección asignada

Asignación de direcciones• int bind(int sd, struct sockaddr *dir, int long)– sd: descriptor devuelto por socket– dir: dirección a asignar– long: longitud de la dirección

• Si no se asigna dirección (típico en clientes)– Se le asigna automáticamente (puerto efímero) en la su

primera utilización (connect o sendto)• Direcciones en dominio PF_INET– Puertos en rango 0..65535. Reservados: 0..1023. Si 0, el

sistema elige uno– Host: una dirección local IP

• INNADDR_ANY: elige cualquiera de la máquina• El espacio de puertos para streams y datagramas es

indendiente

Solicitud de conexión

• Realizada en el cliente• int connect(int sd, struct sockaddr *dir, int

long)– sd: descriptor devuelto por socket– dir: dirección del socket remoto– long: longitud de la dirección

• Si el socket no tiene dirección asignada, se le asigna una automáticamente

• Normalmente se usa con streams

Preparar para aceptar conexiones

• Realizada en el servidor stream después de socket y bind

• int listen(int sd, int baklog)– sd: descriptor devuelto por socket– backlog:• Número máximo de peticiones pendientes de aceptar

que se encolarán (algunos manuales recomiendan 5)

• Hace que el socket quede preparado para aceptar conexiones.

Aceptar una conexión

• Realizada en el servidor stream después de socket, bind y listen

• Cuando se produce la conexión, el servidor obtiene:– La dirección del socket del cliente– Un nuevo descriptor que queda conectado al socket

del cliente• Después de la conexión quedan activos dos

sockets en el servidor:– El original para aceptar nuevas conexiones– El nuevo para enviar/recibir datos por la conexión

Aceptar una conexión

• int accept(int sd, struct sockaddr *dir, int *long)– sd: descriptor devuelto por socket– dir: dirección del socket del cliente devuelta– long: parámetor valor-resultado• Antes de la llamada: tamaño de dir• Después de la llamada: tamaño de la dirección del

cliente que se devuelve.

Obtener la dirección de un socket

• Obtener la dirección a partir del descriptor– int getsockname(int sd, struct sockaddr *dir, int *long)

• sd: descriptor devuelto por socket• dir: dirección del socket devuelta• long: parámetro valor-resultado (igual que en accept)

• Obtener la dirección del socket en el toro extremo de la conexión:– int gerpeername(int sd, struct sockaddr *dir, int *long)

• sd: descriptor devuelto por socket• dir: dirección del socket remoto• long: parámetro valor-resultado

Transferencia de datos con streams• Una vez realizada la conexión, ambos extremos puede

transferir datos.• Envío:

– int write(int sd, char *mem, int long);• Devuelve el nº de bytes enviados

– También puede utilizarse el servicio send.• Recepción:

– int read(int sd, char *mem, int long);• Devuelve el nº de bytes recibidos

– También puede utilizarse el servicio recv• Es importante comprobar siempre el valor que devuelven

estas llamadas: pueden no transferirse todos los datos.

Transferencia de datos con streams II

• Función que envía un bloque de datos con reintentos:

int enviar(int socket, char *mensaje, int longitud)

{

int r;int l = longitud;

do {r = write(socket, mensaje, l);l = l – r;mensaje = mensaje + r;

} while ((l>0) && (r>=0));

if (r < 0)return (-1); /* fallo */

else return(0);

}

Transferencia de datos con datagramas

• No hay conexión real• Para usar un socket para transferir basta con:

– Crearlo: socket– Asignarle una dirección: bind (si no, lo hará el sistema)

• Envío:– int sendto(int sd, char *men, int long, int flags,

struct sockaddr *dir, int long)• Devuelve el nº de bytes enviados• dir: dirección del socket remoto y long la longitud

• Rccepción:– int recvfrom(int sd, char *men, int long, int flags,

struct sockaddr *dir, int long)• Devuelve el nº de bytes enviados• dir: dirección del socket remoto y long la longitud

Cerrar un socket

• Se usa close para cerrar ambos tipos de sockets

• Si el socket es de tipo stream, close cierra la conexión en ambos sentidos

• Se puede cerrar un único extremo:– int shutdown(int st, int modo)• sd: descriptor devuelto por socket• modo: SHUT_RD, SHUT_RW o SHUT_RDWR

Configuración de opciones

• Existen varios niveles dependiendo del protocolo afectado como parámetro– SOL_SOCKET: opciones independientes del protocolo– IPPROTO_TCP: nivel de protocolo TCP– IPPTOTO_IP: nivel de protocolo IP

• Consultar opciones asociadas a un socket– int getsockopt(int sd, int nivel, int opc, char *val, int *long)

• Modificar las opciones asociadas a un socket– int setsockopt(int sd, int nivel, int opc, char *val, int long)

• Ejemplos (nivel SOL_SOCKET):– SO_REUSEADDR: permite reutilizar direcciones

Escenario típico con sockets streams

Proceso cliente

Proceso servidor

socket()

socket()

bind()

listen()

accept() Crear thread

read()

close()

accept()

connect()Abrir conexión

read()

close()

Peticiónwrite()

Respuestawrite()

Ejemplo (TCP)

NÚCLEO

clientesumar(5,2)

5+2

Restulado = 7

servidor

Máquina A Máquina B

NÚCLEO

RED

Servidor (TCP)void main(int argc, char *argv[]){

struct sockaddr_in server_addr, client_addr;int sd, sc;int size, val;int size;int num[2], res;

sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); val = 1;

setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *) &val, sizeof(int));

bzero((char *)&server_addr, sizeof(server_addr));server_addr.sin_family = AF_INET;

server_addr.sin_addr.s_addr = INADDR_ANY; server_addr.sin_port = 4200;

bind(sd, &server_addr, sizeof(server_addr));

Servidor (TCP)listen(sd, 5);size = sizeof(client_addr);while (1){

printf("esperando conexion\n");sc = accept(sd, (struct sockaddr *)&client_addr,&size);

read(sc, (char *) num, 2 *sizeof(int)); // recibe la petición

res = num[0] + num[1];

write(sc, &res, sizeof(int)); // se envía el resultado

close(sc); }

close (sd);exit(0);

}

Cliente (TCP)void main(void) {

int sd;

struct sockaddr_in server_addr;

struct hostent *hp;

int num[2], res;

sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

bzero((char *)&server_addr, sizeof(server_addr));

hp = gethostbyname ("arlo.datsi.fi.upm.es");

memcpy (&(server_addr.sin_addr), hp->h_addr, hp->h_length);

server_addr.sin_family = AF_INET;

server_addr.sin_port = 4200;

Cliente (TCP)

// se establece la conexiónconnect(sd, (struct sockaddr *) &server_addr,

sizeof(server_addr));

num[0]=5;num[1]=2;

write(sd, (char *) num, 2 *sizeof(int)); // envía la petición

read(sd, &res, sizeof(int)); // recibe la respuesta

printf("Resultado es %d \n", res); close (sd);

exit(0);}

Servidor (datagramas)

void main(void)

{

int num[2];

int s, res, clilen;

struct sockaddr_in server_addr, client_addr;

s = socket(AF_INET, SOCK_DGRAM, 0);

bzero((char *)&server_addr, sizeof(server_addr));

server_addr.sin_family = AF_INET;

server_addr.sin_addr.s_addr = INADDR_ANY;

server_addr.sin_port = 7200;

bind(s, (struct sockaddr *)&server_addr, sizeof(server_addr));

Servidor (datagramas)

clilen = sizeof(client_addr);

while (1)

{

recvfrom(s, (char *) num, 2* sizeof(int), 0,

(struct sockaddr *)&client_addr, &clilen);

res = num[0] + num[1];

sendto(s, (char *)&res, sizeof(int), 0,

(struct sockaddr *)&client_addr, clilen);

}

}

Cliente (datagramas)void main(int argc, char *argv[]){

struct sockaddr_in server_addr, client_addr;struct hostent *hp;int s, num[2], res;

if (argc != 2){printf("Uso: client <direccion_servidor> \n");exit(0);

}

s = socket(AF_INET, SOCK_DGRAM, 0); hp = gethostbyname (argv[1]);

bzero((char *)&server_addr, sizeof(server_addr));server_addr.sin_family = AF_INET;memcpy (&(server_addr.sin_addr), hp->h_addr, hp->h_length);server_addr.sin_port = 7200;

Cliente (datagramas)bzero((char *)&client_addr, sizeof(client_addr));client_addr.sin_family = AF_INET;client_addr.sin_addr.s_addr = INADDR_ANY;client_addr.sin_port = htons(0);

bind (s, (struct sockaddr *)&client_addr, sizeof(client_addr));

num[0] = 2; num[1] = 5;

sendto(s, (char *)num, 2 * sizeof(int), 0, (struct sockaddr *) &server_addr, sizeof(server_addr));

recvfrom(s, (char *)&res, sizeof(int), 0, NULL, NULL);

printf("2 + 5 = %d\n", res);close(s);

}