SMS HTTP Gateway Interface: Enviando SMS desde tu equipo


Los mensajes de texto SMS es una de las vías de comunicación más antiguas que existen desde el establecimiento de las redes GSM. No obstante, hasta ahora ha sido un recurso poco flexible para el usuario final y tan solo ha sido explotado por medianas o grandes empresas. La limitación principal se debe a la separación entre las dos redes, Internet y GSM. Existen servicios que se encargan de crear un puente o “Gateway” entre estas dos redes; éstos ofrecen una API para desarrollar interfaces personalizadas o aplicaciones que permitan el envío de SMS a través de Internet. El servicio contratado para este artículo es SMSTrend de One-eteré, que ofrece varias APIs distintas según sea el lenguaje o conexión que se desee implementar.

En este artículo presentamos un sencillo pero versátil script en Perl que simplifica el envío de SMS desde consola haciendo uso de la API HTTP del servicio contratado. Además, están implementadas otras opciones como el envío programado y su cancelación, la comprobación del crédito y del historial. Enviar mensajes de texto será tan fácil como escribir en la consola:

Código :

$ sms send +34610123456 "Cuerpo del mensaje"

Este script se comunica mediante HTTP y envía las variables por POST. Para ello, hace uso de las librerías LWP y HTTP de Perl. En el siguiente fragmento de código se muestran los elementos principales de la comunicación, el script completo se encuentra en el repositorio: https://github.com/hvpareja/CPAN-SMSTrend

Código :

#!/usr/bin/perl -w
# Chapter 0: ----------------------------------------------------------
# Headers, dependences and options ------------------------------------
# You can choose between the following actions:
# 1. Send a new message
# 2. Check status for a given message (order_id needed - see below -)
# 3. Cancel a programed sending
# 4. View message history
# 5. Check the remaining credit
# 6. Configure SMSTrend account
# 7. View help
# For future versions we will be able to receive SMS, but not yet
# 0.1 Headers
# Library to handle HTTP packets
use HTTP::Request::Common qw(POST);
# User Agent definition to send HTTP request
use LWP::UserAgent;

[...]

# Chapter 5: ----------------------------------------------------------
# HTTP Request building -----------------------------------------------
# Build HTTP headers
my $ua  = LWP::UserAgent->
new();
my $req = POST($url, [
                      "login"         => $login,
                      "password"      => $password,
                      "sender"        => $sender,
                      "message_type"  => $message_type,
                      "recipient"     => $recipient,
                      "message"       => $message,
                      "scheduled_delivery_time"  => $sheduled_delivery_time,
                      "order_id"                 => $order_id,
                      "from"                     => $from,
                      "to"                       => $to
                      ]);
# ---------------------------------------------------------------------
# Chapter 6: ----------------------------------------------------------
# HTTP Request sending ------------------------------------------------
# Send the 
petition and wait for response
my $response = $ua->request($req)->as_string();
# ---------------------------------------------------------------------

[...]

# Chapter 8: ----------------------------------------------------------
# Output communication info and end program ---------------------------
# Put in standar output the interpetation (failed and why or success)
print $response;
exit;
# ---------------------------------------------------------------------

El único inconveniente de este sistema es que no se puede evadir el pago de los mensajes de texto, sin embargo, puede ser una inversión muy útil para aquellos usuarios que quieren implementar sistemas de notificación en su trabajo. Además, puede ser un buen punto de partida para crear aplicaciones de difusión de información o incluso un recurso de emergencia para enviar mensajes masivos a un grupo grande de destinatarios. Un ejemplo de un envío masivo de mensajes de texto, donde cada teléfono está guardado en un fichero de texto:

Archivo: amigos.txt

612123456
612143457
690673458
605123459
676143410
612163411

En la consola:

Código :

$ for numero in $(<amigos.txt); do 
> sms send +34$numero "Feliz Navidad"
> done

Cada día, cualquier persona recibe un gran volumen de información a través de Internet. El uso correcto de un sistema como este, ya sea por parte de un particular o de una empresa, puede llegar de forma más directa al usuario final, atravesando un casi-olvidado atajo y evitando el saturado tráfico de información en las redes sociales.

[EDITO (8 Noviembre de 2012)] He liberado una nueva versión del script en el que se implementa una nueva opción: el envío de mensajes masivos.

Con esta nueva opción no se necesita ejecutar el bucle explicado más arriba, en el que cada sms enviado requería una petición HTTP. Ahora, con una sola conexión, podremos enviar sms a la lista completa, de la siguiente forma:

$ sms fsend amigos.txt "Feliz Navidad"

La única diferencia es que es necesario que cada número de teléfono tenga el prefijo de pais (+34 en el caso de España) ya en el archivo de texto.

Referencias:

      1. SMSTrend:

http://www.enviarmensajessms.es/gatewaysms.htm

      2. GitHub Repository:

https://github.com/hvpareja/CPAN-SMSTrend

Enviar y recibir email desde consola (mutt)


Quiero dejar huella en mi blog de un recurso que uso muy a menudo en mi trabajo, se trata de Mutt, un cliente de correo electrónico basado en texto muy ligero y a la vez potente. ¿Y por qué tanto interés en clientes de correo de consola cuando tenemos programas mucho más accesibles e intuitivos en nuestro Mac o PC? Para mí, surgió a partir de la necesidad de olvidarme de los pesados procesos que dejaba corriendo en mi equipo, la idea era implementar en mis tareas una línea de código que fuera capaz de enviarme un email cada vez que ocurriera algo que me interesara. Además, podría enviar como archivos adjuntos los resultados de mis cálculos, tablas, gráficas, imágenes, etc.

Así pues, quiero dejar en esta bitácora un manual de instalación, configuración y uso básico, y posteriormente, algún ejemplo para automatizar el envío de emails asociado a procesos; nada que se salga del uso básico.

Captura del manual de mutt

Captura del manual de mutt

1. Instalación de mutt

Instalar mutt en nuestro sistema es tan fácil como cualquier otro programa que esté alojado en un repositorio GNU/Linux mediante apt-get o como en mi caso mediante Fink.

Nota: Si eres usuario de MacOS debes conocer Fink. Si no lo conoces te animo a que le eches un vistazo a su web: http://www.finkproject.org/

Para proceder a la descarga e instalación es necesario ejecutar la siguiente línea en la consola:

$ fink install mutt

Basta con esperar a que concluya la descarga y se instale. Una vez que haya terminado el proceso verificaremos que está correctamente instalado ejecutando simplemente:

$ mutt

Antes de comenzar a enviar correos electrónicos desde la consola debemos configurar correctamente los servidores de entrada y/o salida de éstos.

2. Configuración de los servidores de correo

Para configurar mutt tenemos que crear un archivo de configuración llamado .muttrc en la carpeta $HOME de nuestro sistema que contenga todas las direcciones y puertos necesarias para establecer la comunicación SMTP, POP y/o IMAP.

En este ejemplo, dado que me ubico en la Universidad de Málaga, muestro los datos de configuración de nuestros servidores, así, si el lector también está dentro de algunos colectivos de la UMA, tan solo tiene que copiar los siguientes parámetros de configuración.

# Firma (si existe el archivo .signature)
#set signature = ~/.signature

# Ajustes para la conexion SMPT
set smtp_pass="miFalsisimaPass"
set smtp_url="smtp://correo.uma.es:587"

# CONFIGURACION PARA MENSAJES ENTRANTES
# Ajustes para la conexion IMAP
set imap_user="hvalverde@uma.es"
set imap_pass="miFalsisimaPass"
set folder="imaps://buzon.uma.es:993"
set spoolfile="+INBOX"

Una vez echo esto ya estamos en condiciones de recibir correos electrónicos en nuestro nuevo cliente pero estamos a un paso más de poder enviarlos debido al tipo de cifrado (TLS) que nos obliga a usar  la Universidad de Málaga. Lo único que nos queda por hacer para que todo esté correcto es establecer una primera conexión con el servidor de correo saliente enviando un correo de prueba tal y como se explica más abajo (véase sección 3.1.).

3. Uso básico

3.1 Enviar correos de forma interactiva

En primer lugar ejecutamos mutt desde la consola

$ mutt

y entraremos en la interfaz del programa, donde encontraremos varias opciones que tienen asignada una letra. Para redactar un nuevo correo electrónico debemos pulsar la letra “m”, entonces aparecerá en el pie de la consola la palabra “To:” donde debemos introducir la dirección de correo electrónico a quien queremos enviar el mensaje. Introducimos una cualquiera (preferiblemente alguna que podamos consultar después para verificar el envío) y pulsamos “Enter”. Posteriormente introducimos el asunto y por último se abrirá un editor de texto donde introduciremos el cuerpo del mensaje. En mi caso se abre el editor “Vim”, donde debemos seguir la siguiente secuencia de tareas para escribir y guardar el mensaje en la bandeja de salida:

1. Pulsar la letra “i” para poder comenzar a escribir.

2. Escribir cualquier cosa (p.e. “¡Hola mundo!”).

3. Pulsar ESC para salir del modo de edición.

4. Escribir “:wq” (<dos_puntos><write><quit>).

Una vez hecho esto, nuestro mensaje está listo para ser enviado, basta con pulsar la opción “enviar” con la tecla “y”.

Recibiremos entonces un certificado que debemos “aceptar siempre” para que quede registrado en la configuración de mutt y no tengamos que repetir el proceso anterior. Ahora podremos enviar emails con una sola línea de código como se explica en el punto 3.3.

3.2 Recibir correos

Aunque este no es el principal objetivo de este artículo, he decidido mostrar una captura de pantalla de la bandeja de entrada de mi cuenta de la universidad para demostrar que el archivo de configuración que hemos creado en el punto 2 está escrito correctamente. Si, efectivamente, la configuración del servidor imap es correcta, recibiremos los correos electrónicos en el momento en el que ejecutemos mutt.

Bandeja de entrada

Bandeja de entrada

3.3 Enviar correos de forma automática

En mi opinión, este es el punto más interesante del artículo: la línea de código que debemos escribir para enviar un correo electrónico con una sola instrucción de consola. Brevemente, debemos introducir un texto por una tubería o pipe a mutt, e introducir el resto de los parámetros por argumentos, e. g.:

$ echo "Este será el cuerpo del mensaje" | mutt -s "Este será el asunto" destino@server.com

Ejecutando la línea anterior le enviaremos un mensaje a “destino@server.com” cuyo cuerpo hemos introducido por la entrada estándar y cuyo asunto hemos definido en el argumento “-s”.

Otro argumento básico es “-c”, cuyo valor debe ser otra dirección de correo electrónico que irá en el campo “CC” o “Carbon Copy”, e. g.:

$ echo "Este será el cuerpo del mensaje" | mutt -s "Este será el asunto" -c other@server.com destino@server.com

Otra utilidad de mutt es que puede enviar archivos adjuntos usando el argumento “-a”. Cuando se usa esta opción es necesario añadir dos guiones “–” después de la lista de archivos que hayamos adjuntado, e. g.:

$ echo "Ey, te adjunto estos archivos:\n 1. Curriculum\n 2. DNI\n" | mutt -s "Archivos personales" -c other@server.com -a file1.pdf file2.pdf -- destino@server.com

Es recomendable echarle un vistazo al manual de mutt (véase primera imagen) ejecutando:

$ man mutt

Existen multitud de parámetros que pueden ser muy útiles.

Una vez que dominamos estos comandos podemos implementarlos en nuestros scripts de consola (sh) o incluso en nuestros programas.

Dudas, comentarios, etc., sean bienvenidos.