Los programas utilizan sockets para comunicarse con otros programas, que pueden estar situados en computadoras distintas.

Un socket queda definido por la dirección IP de la máquina, el puerto en el que escucha, y el protocolo que utiliza.

Los tipos y funciones necesarios para trabajar con sockets se encuentran en Python en el módulo socket, como no podría ser de otra forma.

Los sockets se clasifican en sockets de flujo (socket.SOCK_STREAM) o sockets de datagramas (socket.SOCK_DGRAM) dependiendo de si el servicio utiliza TCP, que es orientado a conexión y fiable, o UDP, respectivamente. En esta lección sólo cubriremos los sockets de flujo, que cubren un 90% de las necesidades comunes.

Los sockets también se pueden clasificar según la familia. Tenemos sockets UNIX (socket.AF_UNIX) que se crearon antes de la concepción de las redes y se basan en ficheros, sockets socket.AF_INET que son los que nos interesan, sockets socket.AF_INET6 para IPv6, etc.

Para crear un socket se utiliza el constructor socket.socket() que puede tomar como parámetros opcionales la familia, el tipo y el protocolo. Por defecto se utiliza la familia AF_INET y el tipo SOCK_STREAM.

Veremos durante el resto de la lección cómo crear un par de programas cliente y servidor a modo de ejemplo.

Lo primero que tenemos que hacer es crear un objeto socket para el servidor

socket_s = socket.socket()

Tenemos ahora que indicar en qué puerto se va a mantener a la escucha nuestro servidor utilizando el método bind. Para sockets IP, como es nuestro caso, el argumento de bind es una tupla que contiene el host y el puerto. El host se puede dejar vacío, indicando al método que puede utilizar cualquier nombre que esté disponible.

socket_s.bind(("localhost", 9999))

Por último utilizamos listen para hacer que el socket acepte conexiones y accept para comenzar a escuchar. listen requiere de un parámetro que indica el número de conexiones máximas que queremos aceptar; evidentemente, este valor debe ser al menos 1.

accept se mantiene a la espera de conexiones entrantes, bloqueando la ejecución hasta que llega un mensaje.

Cuando llega un mensaje, accept desbloquea la ejecución, devolviendo un objeto socket que representa la conexión del cliente y una tupla que contiene el host y puerto de dicha conexión.

socket_s.listen(10)

socket_c, (host_c, puerto_c) = socket_s.accept()

Una vez que tenemos este objeto socket podemos comunicarnos con el cliente a través suyo, mediante los métodos recv y send (o recvfrom y sendfrom en UDP) que permiten recibir o enviar mensajes respectivamente. El método send toma como parámetros los datos a enviar, mientras que el método recv toma como parámetro el número máximo de bytes a aceptar.

recibido = socket_c.recv(1024)
print "Recibido: ", recibido
socket_c.send(recibido)

Una vez que hemos terminado de trabajar con el socket, lo cerramos con el método close.

Crear un cliente es aún más sencillo. Solo tenemos que crear el objeto socket, utilizar el método connect para conectarnos al servidor y utilizar los métodos send y recv que vimos anteriormente. El argumento de connect es una tupla con host y puerto, exactamente igual que bind.

socket_c = socket.socket()
socket_c.connect(("localhost", 9999))
socket_c.send("hola")

Veamos por último un ejemplo completo. En este ejemplo el cliente manda al servidor cualquier mensaje que escriba el usuario y el servidor no hace más que repetir el mensaje recibido. La ejecución termina cuando el usuario escribe “quit”.

Este sería el código del script servidor:

import socket

s = socket.socket()
s.bind(("localhost", 9999))
s.listen(1)

sc, addr = s.accept()

while True:
      recibido = sc.recv(1024)
      if recibido == "quit":
         break
      print "Recibido:", recibido
      sc.send(recibido)

print "adios"

sc.close()
s.close()

Y a continuación tenemos el del script cliente:

import socket

s = socket.socket()
s.connect(("localhost", 9999))

while True:
      mensaje = raw_input("> ")
      s.send(mensaje)
      if mensaje == "quit":
         break

print "adios"

s.close()

En el modelo de sockets de flujo contamos con un objeto de tipo Socket en el cliente y en el servidor uno o más objetos Socket asociados a un ServerSocket. La E/S se realiza a través de objetos InputStream y OutputStream asociados a los Sockets.

El servidor crea un socket servidor que tiene como parámetro el puerto en el que a va estar escuchando las peticiones entrantes:
ServerSocket servicio = new ServerSocket(9999);

accept se mantiene a la espera de conexiones entrantes, bloqueando la ejecución. Cuando se establece una conexión se devuelve una instancia de Socket con la que llevar a cabo la comunicación.
Socket socketServicio = servicio.accept();

Los clientes crean objetos Socket para comunicarse con el servidor, por ejemplo localhost en el puerto 9999:
Socket cliente = new Socket("localhost", 9999);

Una vez iniciada la conexión, podemos usar getOutputStream y getInputStream para obtener los flujos de salida y entrada de datos de los sockets.
PrintWriter salida = new PrintWriter(socketServicio.getOutputStream(), true);
BufferedReader entrada = new BufferedReader(new InputStreamReader(cliente.getInputStream()));

Y utilizar los métodos de los flujos de datos para enviar o recibir información del otro lado de la conexión:
salida.println("Soy el servidor");
System.out.println("Recibido " + entrada.readLine());

Por último, una vez terminada la ejecución, tenemos que cerrar los flujos de datos y el socket (en ese orden):
salida.close();
socketServicio.close();

entrada.close();
cliente.close();

Un ejemplo típico para enseñar estos conceptos en la práctica es un servidor eco, cuyo código podéis descargar a continuación. Para probarlo podeis utilizar telnet para conectaros al puerto 9999 en localhost (telnet localhost 9999) y por cada cadena de texto enviada al servidor, este nos responderá con el mismo texto. Utiliza el comando ‘bye’ para terminar la conexión.

Descarga ServidorEco.java