C y Python mediante sockets

Hoy toca el paso de comunicar un lenguaje de bajo nivel y consumo de recursos (C/C++) con uno que es un poco más avanzado y que consume más recursos (CPU y Memoria), como Python.

La historia general es que necesitaba comunicar una Fonera (la cuál no tiene muchos recursos) con un servidor central (RaspberryPi) que tiene toda la infraestructura desarrollada en Python. Para no complicarme la vida, hice un pequeño servidor en C para la Fonera y un cliente en Python para la Raspberry.

Este código corresponde a la Fonera, y lo podemos guardar como server.c (en Mega)

 #include <stdlib.h>  
 #include <stdio.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <netinet/in.h>  
 #include <string.h>  
 #include <unistd.h>  
   
 #define MAXLINE 4096 /* buffer length */  
 #define SERV_PORT 10001 /* port */  
 #define LISTENQ 8 /* maximum number of client connections */  
   
   
 /* This function read a character from a buffer (fd) until it reads   
   the character (until), and it saves in (data). */  
 int read_until(int fd, char *data, char until) {  
   int len = 0;  
   char a[1];  
   int n;  
   
   do {  
   
     n = recv(fd, a, 1, 0);  
     if (n>0) // OK  
       data[len++] = a[0];  
   
   } while (a[0]!=until);  
   
   data[len] = '\0';  
   return len;  
 }  
   
 int main (int argc, char **argv) {  
   int listenfd, connfd, n;  
   socklen_t client_len;  
   char buf[MAXLINE];  
   struct sockaddr_in cliaddr, servaddr;  
   
   // Socket creation  
   listenfd = socket (AF_INET, SOCK_STREAM, 0);  
   
   // Preparing the socket address  
   servaddr.sin_family = AF_INET;  
   servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   servaddr.sin_port = htons(SERV_PORT);  
   
   bind (listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));  
   
   listen (listenfd, LISTENQ);  
   
   printf("Server running! Waiting...\n");  
   
   while(1) {  
     client_len = sizeof(cliaddr);  
     connfd = accept (listenfd, (struct sockaddr *) &cliaddr, &client_len);  
     printf("Received request...\n");  
   
     read_until(connfd, buf, '\n');  
   
     printf("Received content: %s" , buf);  
   
     // Proccess the content  
     // ...  
     sleep(3); //Simulating process time  
     // Send response  
     send(connfd, buf, strlen(buf), 0);  
   
     // Close client connection  
     close(connfd);  
   } // And wait for another client  
   
   // Close listening socket  
   close (listenfd);  
   
 }  

Lo compilamos para la Fonera y lo ejecutamos: (Compilando C/C++ para La Fonera (MIPS))

 $ mips-linux-gcc server.c -o server
 $ ./server

Ahora pasamos a crear el código en Python para guardarlo en la RaspberryPi como client.py (en Mega)

 import socket  
 import sys  
   
 SERVER = '192.168.1.69' # Server IP or domain  
 PORT = 10001 # Server port  
   
 """  
  This function read a character from a buffer (fd) until it reads   
  the character (until), and return the string.  
 """  
 def read_until(fd, until):  
   to_ret = ''  
   try:  
     a = fd.recv(1)  
     while a[0] != until:  
       to_ret += a  
       a = fd.recv(1)  
   
     to_ret += a  
   except:  
     print "Error: Socket closed (or another thing!) :P"  
     return None  
   return to_ret;  
   
 def main():  
   # Create a TCP/IP socket  
   sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
   
   # Connect the socket to the port where the server is listening  
   server_address = (SERVER, PORT)  
   print 'Connecting to %s in port %s' % server_address  
   sock.connect(server_address)  
   
   try:  
       
     # Send message  
     message = 'request:variable\n'  
     print 'Sending: %s' % message  
     sock.sendall(message)  
   
     # Wait the response  
     data = read_until(sock, '\n')  
     print 'Received: %s' % data  
   
   finally:  
     print 'Closing socket'  
     sock.close()  
   
 if __name__ == '__main__':  
   main()  

NOTA: En la dirección IP habría que poner la IP de la Fonera (servidor), en mi caso es la 192.168.1.69

Ya sólo tendríamos que ejecutar el cliente en la Raspberry con:

 $ python client.py  

En ese momento, el cliente enviará al servidor el mensaje (request:variable\n), el servidor simulará su procesamiento durante 3 segundos y devolverá la respuesta. En esta caso, la respuesta coincide con los datos recibidos, pero no tiene que ser así.

Referencias:

• http://www.cs.dartmouth.edu/~campbell/cs50/socketprogramming.html
• http://pymotw.com/2/socket/tcp.html