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

Anuncios

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.

Suscripciones RSS (II). Optimizando la lectura de Google Reader.


En un post anterior se hizo un pequeño esquema-introducción al funcionamiento de los feeds RSS y aprendimos a usar Google Reader hasta sacarle cierto partido. Pero ahí no acaba la cosa, todavía podemos mejorar nuestra experiencia en nuestras lecturas diarias.

Lo que queremos conseguir ahora es no tener que abrir el navegador para comprobar si hay nuevas entradas de nuestras suscripciones, sino que queremos recibir notificaciones. Para ello, existen muchos programas (lectores de RSS o clientes de RSS) que tienen la capacidad de conectarse a Google Reader y descargar todas las entradas a tu ordenador o, lo que es mejor, a tu smartphone. Lo bueno que nos trae estos programas son las siguientes características:

  • Leas donde leas la entrada, esta quedará marcada como “leída” y gracias a que existe conexión con Google Reader, los feeds quedarán leidos en todos los clientes que tengas en todos los puntos de acceso. Se actualiza en tu cuenta. Parece una nimiedad pero es importante cuando tienes muchas suscripciones saber cuál has leido y cuál no.
  • Recibes notificaciones instantáneas de las nuevas actualizaciones tal y como si te mandaran un email. Evidentemente, las notificaciones son 100% modificables en la mayoría de los casos.
  • Puedes disponer de un display en tu barra de tareas que indica los feeds que te quedan por leer.
  • Existen formas de visualización rápida para navegar por los títulos sin tan siquiera abrir la ventana del programa.
  • Puedes conectar tus cuentas de redes sociales: Facebook, Twitter, Diggit, LinkedIn, Blogger (evidentemente), Tumblr, etc., para compartir las entradas interesantes con un solo click y desde el mismo cliente RSS (esta función me encanta).
  • Cuentan con potentes motores de búsqueda en tus feeds. Son muy útiles para releer entradas y no recuerdas dónde ni en qué fecha las leiste. También para hacer síntesis de un tema, etc.

¿Cuáles son estos clientes que optimizan la lectura de feeds de esta manera? Bien, basta con googlear para obtener cientos de resultados pero, ya que estamos, os doy algunas reseñas: Sigue leyendo

Suscripciones RSS, ¿todavía no las usas?


De la comunicación web mediante “sindicación RSS” habría mucho que contar si se quiere profundizar en el funcionamiento de esta forma de manejar los datos. Sin embargo, quiero escribir un post fundamentalmente práctico, con el fin de que vosotros, mis amigos, consideréis usar esta herramienta para estar al tanto de las modificaciones que se efectúan en vuestras webs favoritas, ya sean blogs, portales de noticias, galerías de fotos, etc.

Cualquier página web (de contenidos dinámicos) con un mínimo de calidad tiene un icono como el de la figura 1 donde puedes hacer click. ¿Qué es esto?

Figura 1. Icono de RSS

Bien, como seguro que sabes, el contenido de cualquier blog, por ejemplo, está almacenado en una base de datos. Estos datos se muestran, normalmente como una página web HTML. Sin embargo, éstos podrían mostrarse de otra forma, una forma que no solo los navegadores sean capaces de mostrar, sino también cualquier otra aplicación (ver Figura 2). Esta estructura es XML. Es un lenguaje de bases de datos muy estandarizado y que es utilizado por gran cantidad de aplicaciones, más de las que piensas.

Figura 2. Esquema del flujo de datos de un sitio de contenido dinámico.

Bien, lo que vamos a hacer en este tutorial es comenzar a aprovechar estos XML para optimizar la lectura diaria que hacemos a los blogs de nuestros amigos y a los portales de noticias.

Vamos a usar “Google Reader” para gestionar nuestras suscripciones vía RSS:

Sigue leyendo

Tutorial para conectar la agenda de tu iPhone/iPod touch con el Directorio UMA


Como se indica en el post de introducción a esta serie de tutoriales con LDAP, este es el que atañe a los dispositivos con IOS como tu iPhone o tu iPod Touch. Las versiones del SO que soportan este tipo de conexiones son las superiores a la 3.0.

Vamos a conectar la agenda de tu IOS (iPhone/iPod) a la agenda de los servidores de la Universidad de Málaga.

¿Cómo? Facilísimo.

Sigue leyendo

Tutorial para conectar tu Agenda de Mac OSX con el Directorio UMA


Lo prometí ayer, y hoy lo tenéis aquí, aunque existen algunos “peros” que se deben subsanar en un futuro próximo:

Vamos a conectar la Agenda de tu Mac OSX a la agenda de los servidores de la Universidad de Málaga.

A pesar de que fue enormemente fácil realizar la conexión con MS Office Outlook, con la Agenda de mac vamos a tardar 5 segundos. Eso sí, en este caso, todavía no es posible hacer búsquedas, al menos en mi caso.

En la imagen siguiente, está ilustrado lo que ya viene explicado en el tutorial oficial del Soporte de Apple:

Sigue leyendo

El directorio de todo el personal de la Universidad de Málaga en tu propia libreta de direcciones (Índice de tutoriales)


En otra ocasión he comentado y valorado algunos de los servicios que ofrece la UMA en el ámbito de internet.

Hoy le llega el turno al “Directorio UMA”, también conocido como DUMA. Sin entrar en muchos detalles técnicos, tan solo os explico que este directorio es una base de datos donde se recoge la información de todos los integrantes de la universidad: alumnos, profesores, PDI y PAS. Es, dicho de otro modo, una libreta de direcciones. Está construida con OpenLDAP.

Logo OpenLDAP

Este tipo de bases de datos se denominan LDAP y los permisos de acceso a estos datos están gestionados por los administradores del sistema.

En el caso que nos compete a los integrantes de la UMA (en mi caso, alumno), podemos acceder a estos datos por distintas vías como por ejemplo:

El uso que vamos a hacer nosotros de esta base de datos es conectarla a nuestras agendas de contactos para acceder a estos datos rápidamente como si estuvieran en nuestro equipo. De esta forma, si no sabes la dirección de correo electrónico del profesor al que le vas a escribir, tan solo tendrás que escribir su nombre en el destinatario y tendrás la dirección instantáneamente. En esta primera parte voy a explicar cómo conectar el Directorio UMA a la agenda de Microsoft Office Outlook y en los sucesivos post explicaré cómo conectarla a la agenda de tu Mac OSX y a tu iPhone/iPod touch.

Además de usar estas aplicaciones, puedes navegar por internet en busca de otro software de manejo de bases de datos LADP que se ajuste a tus necesidades.

Índice de los tutoriales:

De la misma forma que nos conectamos al DUMA, pueden seguirse exactamente los mismos pasos para acceder a otras libretas de direcciones (LDAP) de otras instituciones o privadas.

[Edito por disponer de nueva información]

Como ven en los comentarios de este post, existe un hilo abierto con el SCI al respecto y podéis leer información de primera mano, mucho más valiosa que la mía. De todos modos quiero hacer énfasis en lo que creo que es más importante a tener en cuenta a este respecto, cito textualmente:

2) La misión fundamental del directorio, en muchos casos, siendo la UMA
uno de ellos, no es servir de páginas blancas, si no actuar de
repositorio de identidades. Las páginas blancas son un simple
“subproducto” ;)

Desde aquí, gracias a la atención recibida por el SCI (aún no tengo permiso para citar su nombre).