The::Beastieux

Sangre de Bestia + Corazón de Pingüino | Un blog acerca de Linux, *BSD, Open Source, Software Libre, Programación …

Archivos en la Categoría: Aplicaciones

Encriptación de Ficheros con GNU Privacy Guard – GPG


GNU Privacy Guard (GPG) es una herramienta de cifrado de datos y firmas digitales, usado como reemplazo de PGP (Pretty Good Privacy) pero con la diferencia que es software libre licenciado bajo la GPL. GPG utiliza el estándar del IETF denominado OpenPGP.

Utilizandolo correctamente, GPG puede proporcionar un gran nivel de seguridad y puede utilizarse para proteger datos almacenados en discos, copias de seguridad, etc.

Lo primero que necesitamos hacer es crear nuestra clave:

$ gpg --gen-key

gpg: AVISO: permisos inseguros del directorio contenedor del fichero de
configuración `~/.gnupg/gpg.conf’
gpg (GnuPG) 1.4.9; Copyright (C) 2008 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor seleccione tipo de clave deseado:

(1) DSA y ElGamal (por defecto)
(2) DSA (sólo firmar)
(5) RSA (sólo firmar)

Su elección: 1

El par de claves DSA tendrá 1024 bits.
las claves ELG-E pueden tener entre 1024 y 4096 bits de longitud.

¿De qué tamaño quiere la clave? (2048) 1024

El tamaño requerido es de 1024 bits
Por favor, especifique el período de validez de la clave.
0 = la clave nunca caduca
n> = la clave caduca en n días
n>w = la clave caduca en n semanas
n>m = la clave caduca en n meses
n>y = la clave caduca en n años

¿Validez de la clave (0)?

La clave nunca caduca

¿Es correcto? (s/n) s

Necesita un identificador de usuario para identificar su clave. El programa
construye el identificador a partir del Nombre Real, Comentario y Dirección
de Correo Electrónico de esta forma:
“Heinrich Heine (Der Dichter) “

Nombre y apellidos: Beastieux Zeroo
Dirección de correo electrónico: the.beastieux@gmail.com
Comentario: The::Beastieux
Ha seleccionado este ID de usuario: “Beastieux Zeroo (The::Beastieux)”
¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? V
Necesita una frase contraseña para proteger su clave secreta.******

gpg: comprobando base de datos de confianza
gpg: 3 dudosa(s) necesarias, 1 completa(s) necesarias,
modelo de confianza PGP
gpg: nivel: 0 validez: 2 firmada: 0 confianza: 0-, 0q, 0n, 0m, 0f, 2u
pub 1024D/597280F0 2011-02-10
Huella de clave = FC3A 0A54 34AC C55F 6E5E E317 8869 8531 5972 80F0
uid Beastieux Zeroo (The::Beastieux) sub 1024g/438636E5 2011-02-10

Luego, podemos subirlo a algún servidor de claves para compartirlo:

$ gpg --keyserver pgp.mit.edu --send-keys mi_clave

Luego de subirlo pueden compartir su clave pública en la web:

Mi GPG

Algunos comandos que podemos hacer uso para realizar operaciones posterior a la creación de nuestra clave:

Listar Claves Públicas:

$ gpg --list-public-keys

Listar Claves Privadas:

$ gpg --list-secret-keys

Exportar Clave Pública:

$ gpg --export -a "Nombre de Usuario" > publica.key

Exportar Clave Privada:

$ gpg --export-secret-keys -a "Nombre Usuario" > privada.key

Importar Clave Pública:

$ gpg --import publica.key

Importar Clave Privada:

$ gpg --allow-secret-key-import --import privada.key

Borrar Clave Pública:

$ gpg --delete-key "Nombre Usuario"

Borrar Clave Privada:

$ gpg --delete-secret-key "Nombre Usuario"

Listar Huellas:

$ gpg --fingerprint

Cifrar Archivo:

$ gpg -e archivo

Descifrar Archivo:

$ gpg --decrypt archivo.gpg

Instalar Driver Nvidia en Linux / Debian Squeeze


Estos son los pasos que debes realizar para poder tener instalado el Driver Nvidia en un Debian Linux y sacarle todo el provecho a tu tarjeta de video:

Instalar los requerimientos:

# aptitude install module-assistant nvidia-kernel-common
# aptitude install nvidia-glx

Activar módulos:

# module-assistant auto-install nvidia
# depmod -a
# modprobe nvidia

Edita el /etc/X11/xorg.conf y busca la linea:

Section "Device"

Cambia la línea Driver para que quede así:

Driver  "nvidia"

Por último, reiniciar el gestor gráfico:

# /etc/init.d/gdm restart

Mumble – Software Libre para Multi-Conferencias


Mumble es Software Libre, multiplataforma de voz sobre IP especializada en multi-conferencia. Si recuerdas a skype, pues Mumble satisface todas esas necesidades, y aún más, tu puedes crear tu propio servidor desde donde podrás dar acceso a tu central de conferencia, invitar usuarios y si quisieras podrías crear tus propias salas de conversación.

Yo lo instalaré un Servidor Mumble en mi Linux/Debian, ustedes podrán encontrarlo en los repositorios de la Distribución Linux que usen:

1- Instalar – Servidor Mumble:

# aptitude install mumble-server
# /etc/init.d/mumble-server start

1.1- Configurar el Servidor:
Para configurar nuestro server deberíamos acceder al fichero siguiente y hacer los cambios que sean convenientes:

# nano /etc/mumble-server.ini

2- Instalar – Cliente Mumble:
Mumble al ser multiplataforma puede ser accedido desde cualquier sistema, si ya conocemos un servidor existente sólo necesitaríamos tener instalado el programa cliente. Podemos encontrar Mumble para PC, en este ejemplo yo lo instalaré en mi Linux/Debian directamente desde los repositorios:

# aptitude install mumble

Ahora para acceder sólo basta con conocer la dirección del servidor y el puerto que por defecto es 64738, el cual no cambié en el servidor local que instalé:


Y como ven, permitió acceder al servidor:

Pueden conseguir la aplicación para Linux, OS X o Windows en: http://mumble.sourceforge.net/.
También podrían instalar Mumble en Android, así mientras unos están en conferencia desde la PC, otros pueden unirse desde el mobil desde donde quieran.

Sin duda, Mumble es una aplicación magnifica y lo recomiendo al 100%, pueden implantarlo para realizar conferencias en su universidad, empresa, o cualquier organización y a un costo cero, vale la pena que lo prueben.

Tutorial de Creación de Plugins para Pidgin en Linux


Como sabrán, quienes siguen a menudo mi blog, hace unos meses creé un plugin para Pidgin – MorseCodeTalk, ahora quiero compartirles un pequeño tutorial para poder crear vuestras propias extensiones.

1- Creamos un Directorio de Trabajo:

# mkdir ~/development

2- Descargar las fuentes de Pidgin y moverlo al directorio creado:
En mi caso he descargado la versión 2.7.9.
http://www.pidgin.im/download/source/
3- Descomprimir las fuentes:

# tar -jxvf pidgin-2.7.9.tar.bz2

4- Configurar las fuentes:

# cd pidgin-2.7.9
# ./configure

4.1- Errores:
Si hay errores de dependencias, instala los plugins que falta:

Ejem: aptitude install intltool

4.2- Opciones:
– Usa –disable-vv si no necesitarás alguna funcionalidad.

Ejem: ./configure --disable-vv --disable-idn --disable-nm --prefix=/opt/pidgin

– prefix es para que se instale en /opt/pidgin

4.3- Advertencia:
Si ya tenías instalado pidgin anteriormente, te saldrá una advertencia, pero no te preocupes, podrás iniciar la nueva versión de Pidgin por consola.

Warning: You have an old copy of Pidgin at /usr/bin/pidgin.

5- Compilar las fuentes:

# make

Esto podría demorar un poco.

6- Crear el Plugin:
Para empezar crear el plugin deberemos dirigirnos al directorio siguiente:

$ cd libpurple/plugins/

Crearemos un plugin de ejemplo llamado holamundo que sólo nos mostrará una ventana de diálogo al activarlo, para ello debemos crear un fichero de acuerdo al lenguaje de programación que usaremos y el editor que prefieran, yo alterno entre gedit(editor gráfico) y nano(editor desde consola).

Pidgin ofrece API’s para crear extensiones en diferentes lenguajes, como C, Perl, Tcl, d-bus, para este ejemplo usaré el lenguaje de entre ellos que más conozco, que es C (no C++).

6.1- Crear el Código del Plugin:

$ nano holamundo.c
#define PURPLE_PLUGINS
#include 
#include "notify.h"
#include "plugin.h"
#include "version.h"

static gboolean
plugin_load(PurplePlugin *plugin) {
    purple_notify_message(plugin, PURPLE_NOTIFY_MSG_INFO, "Hola Mundo!",
                        "Este es mi primer Plugin para Pidgin", NULL, NULL, NULL);

    return TRUE;
}

static PurplePluginInfo info = {
    PURPLE_PLUGIN_MAGIC,
    PURPLE_MAJOR_VERSION,
    PURPLE_MINOR_VERSION,
    PURPLE_PLUGIN_STANDARD,
    NULL,
    0,
    NULL,
    PURPLE_PRIORITY_DEFAULT,

    "core-holamundo",
    "Hola Mundo",
    "1.0",

    "Plugin Hola Mundo",
    "Plugin Hola Mundo",
    "Beastieux Zeroo ",
    "https://saforas.wordpress.com",

    plugin_load,
    NULL,
    NULL,

    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};

static void
init_plugin(PurplePlugin *plugin)
{
}

PURPLE_INIT_PLUGIN(holamundo, init_plugin, info)

La siguiente parte del código nos permite dotar de información suficiente para el plugin, acontinuación describo cada uno de los parámetros:

static PurplePluginInfo info = {
    PURPLE_PLUGIN_MAGIC,    /* Este deberá ser siempre
                               PURPLE_PLUGIN_MAGIC.*/

    PURPLE_MAJOR_VERSION,   /* Este parámetro ayuda a determinar
			       la versión de Pidgin en el que es
			       compilado, del mismo modo permitirá
			       usar el plugin sólo en la versión
			       donde fue compilada */

    PURPLE_MINOR_VERSION,   /* Versión a partir del cual
			       podrá funcionar el Pidgin */

    PURPLE_PLUGIN_STANDARD, /* PurplePluginType: Hay 4 diferentes valores
			       el primero es PURPLE_PLUGIN_UNKNOWN;
                               no debería ser usado, PURPLE_PLUGIN_STANDARD;
			       este es el valor más usado.
			       PURPLE_PLUGIN_LOADER; usamos este cuando
			       queremos cargar plugins no nativos
			       por ejemplo los hechos en Perl o Tcl,
			       por último PURPLE_PLUGIN_PROTOCOL;
			       si tu plugin permitirá conectar
 			       con otras redes.*/

    NULL,		       /* Si estás escribiendo un Core Plugin
			       debería ser NULL, Si estás escribiendo un
			       Pidgin Plugin debes usar PIDGIN_PLUGIN_TYPE.
			       Si estás escribiendo un Finch Plugin
                               debería usar FINCH_PLUGIN_TYPE.*/

    0,			       /* Este parámetro es para determinar los flags.
			       como el disponible para poner a invisible
                               (PURPLE_PLUGIN_FLAG_INVISIBLE).
			       Con ello haremos que el plugin no aparezca
			       en la lista de plugins. */

    NULL,		       /* Este es un GList de dependencias de plugins.*/

    PURPLE_PRIORITY_DEFAULT,   /* Determina la prioridad que libpurple dará
			          a tu plugin. Existen 3 posibilidades,
			          PURPLE_PRIORITY_DEFAULT,
			          PURPLE_PRIORITY_HIGHEST,
			          PURPLE_PRIORITY_LOWEST. */

    "core-holamundo",	        /* Es el ID de tu plugin.*/

    "Hola Mundo",		/* Es el Nombre de tu plugin.*/

    "1.1",			/* Es la Versión de tu plugin.*/

    "Resúmen Hola Mundo",	/* Es el Resúmen de tu plugin.*/

    "Descripción Hola Mundo",	/* Es la descripción de tu plugin.*/

    "Tu Nombre ",	/* Datos del desarrollador del Plugin. */

    "http://...",	/* La Web del Plugin, de donde pueden
				   descargarlo, reportar bugs, etc.*/

    plugin_load,	/* La función que se carga cuando
			   se inicia el plugin.
			   Debería ser de tipo gboolean*/

    NULL,		/* Es llamado cuando libpurple
			   se descarga, también
			   deberá ser de tipo gboolean.*/

    NULL,		/* Es llamado cuando libpurple
			   se destruye, también
			   deberá ser de tipo gboolean.*/

    NULL,		/* Deberá apuntar a un PidginPluginUiInfo.*/

    NULL,		/* Determina si es un PurplePluginLoaderInfo
			   o PurplePluginProtocolInfo*/

    NULL,		/* Puntero que apunta a una estructura
			   PurplePluginUiInfo.
			   Puedes encontrar un ejemplo de ese
			   tipo de código en:
			   libpurple/plugins/pluginpref_example.c */

    NULL,		/* Es una función puntero donde se definen
			   acciones. Debe ser de tipo GList
			   *function_name(PurplePlugin
			   *plugin, gpointer context)*/

    NULL,		/* Es un puntero reservado para el futuro,
			   lo setearemos a NULL
			   porque no lo necesitamos.*/

    NULL,       	/* Es un puntero reservado para el futuro,
			   lo setearemos a NULL
			   porque no lo necesitamos.*/

    NULL,		/* Es un puntero reservado para el futuro,
			   lo setearemos a NULL
			   porque no lo necesitamos.*/

    NULL		/* Es un puntero reservado para el futuro,
			   lo setearemos a NULL
			   porque no lo necesitamos.*/
};

6.2- Compilar el fichero holamundo.c:

$ make holamundo.so

6.3- Copiar el plugin creado en el directorio de pidgin:

$ cp holamundo.so ~/.purple/plugins/

6.4- Ejecutar Pidgin y probar el plugin:

$ /opt/pidgin/bin/pidgin

Para crear un plugin con interfaces más elaboradas podemos usar las librerías GTK, y para la interacción con pidgin usamos las librerías libpurple; una buena combinación de C/GTK/Libpurple, y de los conocimientos necesarios del la estructura funcional de pidgin nos permitirán realizar los complementos que queramos, pueden buscar toda la información necesaria en la wiki de desarrolladores de pidgin. Una recomendación de mi parte es que revisen los códigos fuente de los plugins existentes en Pidgin Plugins, y tomarlos como referencia para construir los suyos, es lo que hice antes de empezar a crear mis propios complementes . Ahora, si quieren hacer la versión para windows, generar el dll tiene un proceso algo mas tedioso, se necesitará la ayuda de cygwin en windows y descargar e instalar todos los paquetes del cual pidgin depende para poder compilar las fuentes.

Instalación y Configuración de un Servidor de Streaming Multimedia con IceCast


Hace mucho tiempo que ya es normal encontrar en la red servicios de transmisión de radio que llegan a todo el planeta, pues en este post voy a explicar cómo realizar la instalación de un Servidor IceCast que es un servicio libre en contraparte al conocido servicio de ShoutCast.

Antes que nada quiero aclarar que esta instalación la realizaré sobre un Debian/Linux, pero la configuración es análoga para cualquier distribución Basada en GNU/Linux.

#aptitude install icecast2 ices2

Icecast2: Servidor de Streaming.
Ices2: Cliente para emitir Stream.

Inicialmente configuraremos el Servicio de Icecast localmente, para ello IP Server = 127.0.0.1 o localhost, el puerto por el que atiende icecast será 8000.

Para las ediciones de los ficheros de texto yo prefiero usar “nano”, ustedes pueden hacer uso del que gusten.  Así mismo, es recomendable que cambien las contraseñas que la instalación trae por defecto, como en <source-password>, <relay-password> y <admin-password>; éste último se refiere a la contraseña de acceso via web: http://127.0.0.1:8000/admin/

Iniciamos con la configuración:

Configuración de Icecast2:

#nano /etc/icecast2/icecast.xml
 <icecast>
    <limits>
        <clients>100</clients>
        <sources>2</sources>
        <threadpool>5</threadpool>
        <queue-size>524288</queue-size>
        <client-timeout>30</client-timeout>
        <header-timeout>15</header-timeout>
        <source-timeout>10</source-timeout>
        <burst-on-connect>1</burst-on-connect>
        <burst-size>65535</burst-size>
    </limits>

    <authentication>
        <source-password>source</source-password>
        <relay-password>source</relay-password>
        <admin-user>admin</admin-user>
        <admin-password>admin</admin-password>
    </authentication>

    <hostname>localhost</hostname>

    <listen-socket>
        <port>8000</port>
    </listen-socket>

    <fileserve>1</fileserve>

    <paths>
        <basedir>/usr/share/icecast2</basedir>
        <logdir>/var/log/icecast2</logdir>
        <webroot>/usr/share/icecast2/web</webroot>
        <adminroot>/usr/share/icecast2/admin</adminroot>
        <alias source="/" dest="/status.xsl"/>
    </paths>

    <logging>
        <accesslog>access.log</accesslog>
        <errorlog>error.log</errorlog>
      	<loglevel>3</loglevel>
      	<logsize>10000</logsize>
    </logging>

    <security>
        <chroot>0</chroot>
        <!--
        <changeowner>
            <user>nobody</user>
            <group>nogroup</group>
        </changeowner>
        -->
    </security>
</icecast>
#nano /etc/default/icecast2
CONFIGFILE="/etc/icecast2/icecast.xml"
USERID=icecast2
GROUPID=icecast
ENABLE=true
#/etc/init.d/icecast2 start

Si hasta este punto todo se ha hecho bien, la siguiente dirección debería cargar correctamente en el navegador: http://127.0.0.1:8000

Configuración de Ices2:

Modo Live: Para Emitir streaming en linea, por ejemplo con la salida desde micro:
Los ficheros de configuración de ices2 lo pueden crear en su directorio personal, según el ejemplo mi directorio personal es /home/beastieux/

$mkdir /home/beastieux/iceconf
$cd /home/beastieux/iceconf
$nano iceconf/ices2-live.xml
<?xml version='1.0'?>
<ices>
<background>0</background>
<logpath>/var/log/icecast2</logpath>
<logfile>ices.log</logfile>
<loglevel>4</loglevel>
<consolelog>1</consolelog>

<stream>

<metadata>
<name>Radio Beastieux</name>
<genre>rock-metal-bossa-chilli</genre>
<description>Radio con la mejor musica de mi computadora</description>
<url>https://saforas.wordpress.com</url>
</metadata>

<input>
<module>alsa</module>
<param name="rate">44100</param>
<param name="channels">2</param>
<param name="device">hw:0,0</param>
<param name="metadata">1</param>
<!--Localización de un fichero metadata.-->
<param name="metadatafilename">./metadata</param>
</input>

<!--Datos del Servidor Icecast2-->
<instance>
<hostname>127.0.0.1</hostname>
<port>8000</port>
<username>source</username>
<password>source</password>
<mount>/radio-beastieux.ogg</mount>
<yp>1</yp>

<encode>
<!--Datos de la velocidad de transmisión, calidad-->
<minimum-bitrate>48000</minimum-bitrate>
<maximum-bitrate>64000</maximum-bitrate>
<nominal-bitrate>64000</nominal-bitrate>
<samplerate>44100</samplerate>
<!--Calidad de codificación del bitrate. Va de 0 a
10. Interesa tener un valor bajo para conexiones
modestas-->
<quality>1</quality>
<!--Número de canales de la entrada -->
<channels>2</channels>
</encode>

<downmix>1</downmix>
<resample>
<in-rate>44100</in-rate>
<out-rate>44100</out-rate>
</resample>

</instance>
</stream>
</ices>

Para emitir el stream sólo lanzar este comando:

$ices2 ices2-live.xml

Luego pueden hablar por el micro o ayudarse con reproductores y sintetizadores para la transmisión, que todo lo que salga por el audio desde su ordenador se estará transmitiendo en vivo.

Modo Playlist: Para Emitir Streaming desde una lista con las direcciones del audio:

$nano /home/beastieux/iceconf/ices2-playlist.xml
<?xml version='1.0'?>
<ices>
<background>0</background>
<logpath>/var/log/icecast2</logpath>
<logfile>ices.log</logfile>
<loglevel>4</loglevel>
<consolelog>1</consolelog>

<stream>
<metadata>
<name>Radio Beastieux</name>
<genre>rock-metal-bossa-chilli</genre>
<description>Radio con la mejor musica de mi computadora</description>
<url>https://saforas.wordpress.com</url>
</metadata>
<!-- El <input> es lo único diferente al fichero ices2-live.xml -->
             <input>
                       <module>playlist</module>
                       <!--Indicar el sitio donde tenemos la lista de reproducción-->
                       <param name="file">/home/beastieux/iceconf/playlist.m3u</param>
                       <param name="type">basic</param>
                       <!--reproduce en modo random-->
                       <param name="random">1</param>
                       <!--A valor 0 reproduce la lista
                              continuamente."-->
                       <param name="once">0</param>
                       <param name="rate">44100</param>
                       <param name="channels">2</param>
                       <param name="device">/dev/dsp</param>

               </input>

<instance>
<hostname>127.0.0.1</hostname>
<port>8000</port>
<username>source</username>
<password>source</password>
<mount>/radio-beastieux.ogg</mount>
<yp>1</yp>

<encode>
<!--Datos de la velocidad de transmisión-->
<minimum-bitrate>48000</minimum-bitrate>
<maximum-bitrate>64000</maximum-bitrate>
<nominal-bitrate>64000</nominal-bitrate>
<samplerate>44100</samplerate>
<!--Calidad de codificación-->
<quality>1</quality>
<!--Número de canales de la entrada -->
<channels>2</channels>
</encode>

<downmix>1</downmix>
<resample>
<in-rate>44100</in-rate>
<out-rate>44100</out-rate>
</resample>

</instance>
</stream>
</ices>

Crear la lista de reproducción:
La lista de reproducción solo es una lista con las direcciones de los archivos de audio, en este caso deben de ser OGG, el fichero debe constar de una dirección por linea. Si tienen un directorio con músicas podrían generar el fichero.m3u automáticamente con algo como:

$find /media/sda2/musicas/ -name "*ogg" > ~/iceconf/playlist.m3u

Para ejecutar el modo automático de emisión desde un playlist con los audios (ogg) añadidos:

$ices2 ices2-playlist.xml

Si quieren escuchar la transmisión vía web pueden ingresar al punto de montaje configurado, para este ejemplo el punto de montaje fue radio-beastieux.ogg, por lo cual accederemos a: http://127.0.0.1:8000/radio-beastieux.ogg

Por último, tanto la ejecución en modo live como en modo playlist con ices2 no debe de niguna manera devolvernos al promt del terminal, si eso ocurre es porque los ficheros están mal configurados o el servidor no está iniciado correctamente. Si todo ha salido bien entonces tendrían su servidor de Icecast básicamente configurado y listo para empezar a emitir normalmente, podrian empezar a transmitir para el mundo entero.

Un Nuevo Mundo Virtual en 3D llamado Avination


Avination es una plataforma virtual de código abierto basado en Second Life, muy idéntico, aunque por el momento con pocos residentes. El visor que ofrece Avination para acceder al mundo virtual, cuyos binarios para los distintos sistemas operativos y código fuente lo pueden obtener del Sitio Oficial de Avination, también ofrece la posibilidad de acceder a Second Life.

En pocas palabras, al igual que Second Life, Avination presenta su propia moneda, regiones, residentes, aunque también ofrece la capacidad de crearse un avatar basado en el de Second Life.

Lo más importante de estos mundos virtuales es la prestación que brinda para poder realizar actividades colaborativas, metodología de enseñanza espacial, diversión, negocios, etc; uno más que se une a la lista de Mundos Virtuales  en la Red.

Morse Code Talk, Un Nuevo Plugin de Pidgin para Comunicarse en Código Morse


Me complace anunciar que acabo de terminar de crear una primera versión de un plugin para Pidgin al que puse por nombre Morse Code Talk, con el cual es posible comunicarse en Código Morse mediante la modalidad de Chat emitiendo o traduciendo los mensajes.

Por el momento el idioma está en inglés y ya está compilado para Linux y Windows, cabe mencionar que para que funcione se requiere contar con Pidgin  2.7.9 o superior.

El Código morse es un Sistema de comunicación mediante señales emitidas representados gráficamente por puntos y rayas que a su vez pueden ser representados por sonidos de corta y larga duración de letras, números y algunos caracteres adicionales según el Alfabeto Internacional.

Tal vez este complemento para Pidgin no sea de interés para muchos, pero puede ser una manera diferente y divertida de comunicarse y sobre todo aprender este alfabeto;  el tiempo que me tomó crear el motor del código morse me sirvió para aprender un poco éste sistema, y creo que con la práctica es probable que se pueda llegar a entender mejor las señales emitidas de esta manera.

En Linux la instalación  es sencilla, solo hace falta descargar el binario empaquetado como: pidgin-morsecodetalk-bin-1.0.0.tar.bz2, descomprimirlo y copiar la librería morsecodetalk.so a ~/.purple/plugins/ dentro del directorio personal (Si no existe el directorio plugins, crearlo). Para windows he creado un instalador, no creo que no tengan problemas al instalarlo.

La versión 1.0.0 del plugin consta con las funciones de:

Emisión de morse a texto y de texto a morse.

Posibilidad de escribir en morse con señales del mouse donde un clic representa a un punto, doble clic una raya y clic derecho un espacio en blanco. Esta funcionalidad se puede deshabilitar y usar únicamente el teclado.

Como se ve en el formulario de configuración, ya están definidas las características con el que contará en una versión futura, como es la emisión de Código Morse en forma de audio con los atributos que se indica.

También se presenta una tabla de ayuda con los caracteres del Alfabeto Morse Internacional.

Para empezar a usarlo es importante saber que cada letra escrita debe estar separada por un espacio y cada palabra escrita debe estar separada por tres espacios: Ejm:

HELP ME = .... . .-.. .--.   -- .

Invito a todos a descargar Morse Code Talk y  probarlo. Cualquier problema que encuentren o recomendaciones con respecto al plugin hacérmelos llegar al correo o comentarlo aquí.

Aplicaciones para Conexión a Escritorios Remotos Mediante VNC


Una de las aplicaciones que suelen utilizarse mucho cuando se gestionan gran cantidad de ordenadores desde un terminal o simplemente cuando se desea acceder a un ordenador lejos o extremadamente lejos por medio de la red son las aplicaciones de escritorio remoto, con el cual podemos acceder visualmente a la interfaz de nuestro ordenador desde el lugar que queramos, siempre y cuando la configuración del servidor nos lo permita.

RealVNC, UltraVNC (Open Source), ThinVNC (Open Source), TigerVNC (Open Source) son algunas aplicaciones de este tipo, con el cual podemos establecer una conexión remota hacia cualquier ordenador como si lo tuvieses frente tuyo. VNC es multiplataforma por lo tanto podemos acceder remotamente desde nuestro ordenador hacia otro, independientemente del sistema operativo que ambos usen. Para establecer la comunicación remota hacia un ordenador destino debe estar en éste último instalado el servidor de VNC (VNC Server) donde se configura el permiso a los ordenadores que pueden acceder mediante una IP, así como también el usuario y la contraseña de acceso; y en los ordenadores desde donde deseamos acceder hace falta únicamente el VNC Cliente (VNC Viewer), encargado de mostrarnos el ordenador destino en pantalla para poder hacer uso de él. En linux por ejemplo, podemos acceder mediante el tsclient (Terminal Services Client), que es un Fronted que controla terminales remotas y soporta el protocolo VNC y otros; en la actualidad viene por defecto junto con Debian/Linux, y posiblemente también con Ubuntu y otras distribuciones.

Desde el Terminal Services Client podemos realizar las configuraciones necesarias como la resolución de la pantalla, recursos locales, programas que quisiéramos abrir al acceder al escritorio retomo, etc.

Hasta la fecha los Clientes VNC han ido evolucionando no solo en posibilidades de configuración, también en cuanto a la portabilidad en diferentes medios, muchos de ellos ya se están desarrollando en versiones para dispositivos móbiles, por ejemplo ahora podemos encontrar algunos en versiones para Android como el Android VNC ViewerReal VNC Viewer for Android desde donde podemos tener el control de un ordenador que tenga el Servidor VNC instalado.

Sincronización del Cliente de Correo Evolution con Gmail


¿Por qué usar un cliente de correo externo?, nadie tiene la obligación de hacerlo si se siente a gusto con el que su proveedor de correo le brinda, sin embargo, algunos clientes de correo como Evolution, Thunderbird, etc… nos brindan muchas más funcionalidades para poder configurar nuestra cuenta asi que deberíamos aprovechar ello al máximo.

En el caso de Evolution, el cliente de correo que nos provee Gnome, la configuración es sencilla. Antes de empezar deberíamos contar con los nombres de los servidores de entrada y salidad de nuestro proveedor; en este ejemplo sincronizaremos nuestra cuenta de Gmail con Evolution.

La configuración prácticamente consta de dos pasos.

Configurar Acceso por POP (Recepción):

Configurar Acceso por SMTP (Envío):

El procedimiento completo debería ser algo como este:

Instalación y Configuración del Emulador de Android en Linux


Hoy voy a jugar por un momento con Android, no tengo un Teléfono Mobil con tal Sistema, por lo tanto haré uso del emulador que podemos conseguirlo de la web de Android Developers:

Descargar: SDK Android

Yo descargué la versión para Linux, pues lo instalaré sobre mi Debian.
Antes que nada vamos a necesitar cumplir ciertos requisitos; primero instalar los componentes de java si aun no lo tienen:

Configurar Java:

#aptitude install sun-java6-jdk sun-java6-jre

Si están usando el sistema a 64-bit necesitarán instalar las librerías de compatibilidad a 32-bit

#aptitude install ia32-libs

Si tienen instalado el GCJ (Gnu Compiler for Java), lo cual no tiene nada de malo pero no lo consideren por ahora, los recomiendo que para hacer correr el Android trabajen con el Sun JDK, pues yo tuve problemas al tratar de hacerlo con GCJ, lo desinstalé momentáneamente:

#aptitude remove gcj-jdk

Luego nos aseguramos de seleccionar el compilador por defecto que usaremos, en ambos casos los que son de Sun, descarten si está seleccionado el GCJ:

#update-alternatives --config javac
#update-alternatives --config java

Configurar Android:
Una vez configurado nuestro entorno de java y descargado el SDK de Android, vamos a descomprimir el paquete descargado, en mi caso acostumbro instalar los programas externos en /opt:

#cp android-sdk_r09-linux_x86.tgz /opt
#cd /opt
#tar -xvf android-sdk_r09-linux_x86.tgz

#cd android-sdk-linux_x86/tools

Finalmente, para tener acceso desde el terminal a los binarios y lista de comando a usar agregamos al PATH el directorio descomprimido:

PATH=$PATH:/opt/android-sdk-linux_x86/tools
export PATH

Y ahora para ejecutarlo, simplemente escribimos en la terminal:

#android

Se abrirá una ventana como esta:

Debemos actualizar e instalar los componentes que nos sean útiles, por el momento yo instalé la plataforma SDK Android Honeycomb revisión1 y la plataforma SDK Android 2.3.1 API 9 revisión2:

Para terminar, nos vamos a Virtual Devices y elegimos crear un nuevo dispositivo Android, este paso lo puedes configurar según como lo desees:

Lo único que nos queda por hacer es ejecutarlo seleccionando el dispositivo creado, dándole clic en “start” y realizar todas las operaciones que nos son permitidas como si fuese realmente un fierro:

 

Código Java – Conexión a Base de Datos Apache Derby (Embebida y Cliente – Servidor)


Este es el Ejemplo #12.3 del Topic: Programación Gráfica en Java, que viene a formar parte del Topic #12 Código Java – Establecer Conexión a Base de Datos con JDBC

Como he explicado en el Topic #12, para realizar las conexiones necesitaremos los drivers respectivos, de acuerdo al motor de base de datos al cual deseemos conectarnos. En este ejemplo estableceremos una conexión con Apache Derby en sus modalidades Embebida y Cliente-Servidor, para el cual es necesario contar con las respectivas librería que pueden ser similares a las que se muestran a continuación:

derby.jar (Embebida)
derbyclient.jar (Cliente - Servidor)

Estas dos librerías corresponden para una base de datos Apache Derby Embebida y Cliente Servidor respectivamente. Si Derby ha sido instalada de la modalidad mostrada en el post Instalación y Ejecución de Apache Derby en Linux, las librerías podrán ubicarse en las siguientes rutas:

/usr/lib/jvm/java-6-sun/db/lib/derby.jar
/usr/lib/jvm/java-6-sun/db/lib/derbyclient.jar

En caso contrario, las librerías deberán ser obtenidas de medios externos.

Ustedes deberán conseguir la librería de acuerdo a la versión de Derby al cual deseen conectarse y establecer los parámetros de conexión como se muestra en el código siguiente:

Conexión a Base de Datos Derby Cliente – Sevidor:

package beastieux.gui;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
/**
 *
 * @author beastieux
 */
public class Ejm12_3_ConectarDerby {

    public CachedRowSet Function(String sql)
    {
            try
            {
                    Class.forName("org.apache.derby.jdbc.ClientDriver");

                    String url = "jdbc:derby://localhost:1527/dbtest";

                    Connection con = DriverManager.getConnection(url);
                    Statement s = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                      ResultSet.CONCUR_READ_ONLY);

                    ResultSet rs= s.executeQuery(sql);

                    CachedRowSet crs = new CachedRowSetImpl();
                    crs.populate(rs);

                    rs.close();
                    s.close();
                    con.close();

                    return crs;

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }

            return null;
    }

    public void StoreProcedure(String sql)
    {

            try
            {
                    Class.forName("org.apache.derby.jdbc.ClientDriver");

                    String url = "jdbc:derby://localhost:1527/dbtest";
                    Connection con = DriverManager.getConnection(url);
                    Statement s = con.createStatement();

                    s.execute(sql);

                    s.close();
                    con.close();

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }
    }
}

Conexión a Base de Datos Derby Embebida:

package beastieux.gui;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
/**
 *
 * @author beastieux
 */
public class Ejm12_3_ConectarDerby {

    public CachedRowSet Function(String sql)
    {
            try
            {
                    Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

                    String url = "jdbc:derby:/home/beastieux/dbtest";

                    Connection con = DriverManager.getConnection(url);
                    Statement s = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                      ResultSet.CONCUR_READ_ONLY);

                    ResultSet rs= s.executeQuery(sql);

                    CachedRowSet crs = new CachedRowSetImpl();
                    crs.populate(rs);

                    rs.close();
                    s.close();
                    con.close();

                    return crs;

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }

            return null;
    }

    public void StoreProcedure(String sql)
    {

            try
            {
                    Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

                    String url = "jdbc:derby:/home/beastieux/dbtest";
                    Connection con = DriverManager.getConnection(url);
                    Statement s = con.createStatement();

                    s.execute(sql);

                    s.close();
                    con.close();

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }
    }
}

En el caso de conexión a base de datos embebida, la URL contiene la ubicación de la base de datos la cual deberá ser reemplazado de acuerdo a su propia configuración:

String url = "jdbc:derby:/home/beastieux/dbtest";

Código Java – Conexión a Base de Datos MySQL


Este es el Ejemplo #12.2 del Topic: Programación Gráfica en Java, que viene a formar parte del Topic #12 Código Java – Establecer Conexión a Base de Datos con JDBC

Como he explicado en el Topic #12, para realizar las conexiones necesitaremos los drivers respectivos, de acuerdo al motor de base de datos al cual deseemos conectarnos. En este ejemplo estableceremos una conexión con MySQL, para el cual es necesario contar con la respectiva librería como la que se muestra a continuación:

MySQL JDBC Driver - mysql-conector-java-5.1.3-bin.jar

Ustedes deberán conseguir la librería de acuerdo a la versión de MySQL al cual deseen conectarse y establecer los parámetros de conexión como se muestra en el código siguiente:

package beastieux.gui;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
/**
 *
 * @author beastieux
 */
public class Ejm12_2_ConectarMySQL {

    public CachedRowSet Function(String sql)
    {

            try
            {
                    Class.forName("org.gjt.mm.mysql.Driver");

                    String url = "jdbc:mysql://127.0.0.1:3306/mysql";
                    Connection con = DriverManager.getConnection(url, "usuario","contraseña");
                    Statement s = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                      ResultSet.CONCUR_READ_ONLY);

                    ResultSet rs= s.executeQuery(sql);

                    CachedRowSet crs = new CachedRowSetImpl();
                    crs.populate(rs);

                    rs.close();
                    s.close();
                    con.close();

                    return crs;

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }

            return null;
    }

    public void StoreProcedure(String sql)
    {

            try
            {
                    Class.forName("org.gjt.mm.mysql.Driver");

                    String url = "jdbc:mysql://127.0.0.1:3306/mysql";
                    Connection con = DriverManager.getConnection(url, "usuario","contraseña");
                    Statement s = con.createStatement();

                    s.execute(sql);

                    s.close();
                    con.close();

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }
    }
}

Código Java – Conexión a Base de Datos PostgreSQL


Este es el Ejemplo #12.1 del Topic: Programación Gráfica en Java, que viene a formar parte del Topic #12 Código Java – Establecer Conexión a Base de Datos con JDBC

Como he explicado en el Topic #12, para realizar las conexiones necesitaremos los drivers respectivos, de acuerdo al motor de base de datos al cual deseemos conectarnos. En este ejemplo estableceremos una conexión con PostgreSQL 8.3, para el cual es necesario contar con la respectiva librería como la que se muestra a continuación:

postgresql-8.3-603.jdbc3.jar

Ustedes deberán conseguir la librería de acuerdo a la versión de PostgreSQL al cual deseen conectarse y establecer los parámetros de conexión como se muestra en el código siguiente:


package beastieux.gui;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
/**
 *
 * @author beastieux
 */
public class Ejm12_1_ConectarPostgreSQL {

    public CachedRowSet Function(String sql)
    {
            try
            {
                    Class.forName("org.postgresql.Driver");

                    String url = "jdbc:postgresql://127.0.0.1:5432/postgres";
                    Connection con = DriverManager.getConnection(url, "usuario","contraseña");
                    Statement s = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                      ResultSet.CONCUR_READ_ONLY);

                    ResultSet rs= s.executeQuery(sql);

                    CachedRowSet crs = new CachedRowSetImpl();
                    crs.populate(rs);

                    rs.close();
                    s.close();
                    con.close();

                    return crs;

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }

            return null;
    }

    public void StoreProcedure(String sql)
    {

            try
            {
                    Class.forName("org.postgresql.Driver");

                    String url = "jdbc:postgresql://127.0.0.1:5432/postgres";
                    Connection con = DriverManager.getConnection(url, "usuario","contraseña");
                    Statement s = con.createStatement();

                    s.execute(sql);

                    s.close();
                    con.close();

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }
    }
}

Código Java – Establecer Conexión a Base de Datos con JDBC


Por fin he preparado el Ejemplo #12 del Topic: Programación Gráfica en Java, en el cual explicaré sobre cómo conectarnos a una base de datos cualquiera desde Java, manteniendo una misma estructura.

Para realizar la conexión a base de datos desde java necesitamos hacer uso de JDBC. Las bases de datos que deseemos conectar deberán proveernos el driver JDBC en un empaquetado JAR para añadirlo a las librerías del proyecto.

Deberemos conseguir la librería de acuerdo a la versión de la Base de Datos al cual deseemos conectarnos. Es posible que su IDE reconozca la existencia del driver si la base de datos ha sido instalada en el mismo ordenador junto con sus librerías, solo haría falta añadirlo a la lista de librerías que se usarán en el proyecto, por ejemplo en NetBeans se podría ir al directorio Libraries del Proyecto, hacer clic derecho sobre el y elegir Add Library y en la lista podría encontrase la que necesitemos, o si queremos agregarla manualmente Add JAR/Folder y seleccionar desde la dirección donde lo tenemos almacenado.

Add Library:

Add JAR/Folder:

Una vez agregada la librería, vamos a realizar el código de conexión, el cual nos debe presentar una clase con 2 métodos que a mi parecer no deberían faltar. Debería existir una función(Las funciones retornan datos) que nos retorne un CachedRowSet que es algo similar al ResultSet que no podemos retornar mientras el Statement esté sin cerrar, pero es obvio que por seguridad deberemos tener todas las conexiones cerradas, por eso no retornamos directamente el ResultSet y hacerlo sin cerrar las conexiones sería de muy mala práctica. En cambio, el CachedRowSet almacena todos los registros y podemos manipularla con las conexiones cerradas, cosa que no podemos hacer con los ResultSets, ya que éstos necesitan al Statement Abierto, y el Statement a su vez necesita la conexión abierta. Por otro lado deberíamos tener un procedimiento(No retorna ningún dato), no retorna nada ya que se encargará de realizar operaciones unidireccionales.

En conclusión, usamos la Función cuando usemos Sentencias DML SELECT incluyendo las Funciones y usar el Procedimiento cuando usemos INSERT, DELETE O UPDATE, incluyendo los StoreProcedures(Procedimientos Almacenados); aunque podemos conocer algunas bases de datos que permitan retornar datos desde StoreProcedures, lo ideal seria hacerlo desde funciones, manteniendo cada uno para su propósito. Del mismo modo, habrán podido darse cuenta que ambos métodos reciben una variable String como parámetro, ésta es nada menos que la Sentencia DML que deseamos ejecutar.

package beastieux.gui;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
/**
 *
 * @author beastieux
 */
public class Ejm12_ConectarDataBase {

    public CachedRowSet Function(String sql)
    {
            try
            {
                    Class.forName("Driver");

                    String url = "jdbc:motor:servidor:puerto/basededatos";
                    Connection con = DriverManager.getConnection(url, "usuario","contraseña");
                    Statement s = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                      ResultSet.CONCUR_READ_ONLY);

                    ResultSet rs= s.executeQuery(sql);

                    CachedRowSet crs = new CachedRowSetImpl();
                    crs.populate(rs);

                    rs.close();
                    s.close();
                    con.close();

                    return crs;

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }

            return null;
    }

    public void StoreProcedure(String sql)
    {

            try
            {
                    Class.forName("Driver");

                    String url = "jdbc:motor:servidor:puerto/basededatos";
                    Connection con = DriverManager.getConnection(url, "usuario","contraseña");
                    Statement s = con.createStatement();

                    s.execute(sql);

                    s.close();
                    con.close();

            }
            catch(Exception e)
            {
                   System.out.println(e.getMessage());
            }
    }
}

Como habrán podido apreciar en el código, el manejo de excepciones es relativamente sencilla, lo ideal sería especificar las excepciones por cada conexion, statement y resultset para de esa manera asegurarnos que permanezcan cerradas al finalizar la ejecución o aun cuando existieran errores; de igual manera sería muy útil obligar a cerrar las conexiones desde dentro de una clausula finally anexada al try – catch.

Por último la url de conexión “jdbc:motor:servidor:puerto/basededatos”, variará a continuación de jdbc, según el motor de base de datos al que deseemos conectarnos (PostgreSQL, MySQL, Oracle, Derby, etc) , la dirección IP del servidor, el puerto y finalmente el nombre de la base de datos al que queramos acceder.

En los próximos posts se presentará las conexiones a las diversas bases de datos y la explicación de como usar la clase creada.

Código Java – Conexión a Base de Datos PostgreSQL
Código Java – Conexión a Base de Datos MySQL
Código Java – Conexión a Base de Datos Apache Derby (Embebida y Cliente – Servidor)

Instalación y Ejecución de Apache Derby en Linux


En este post tocaremos rápidamente la instalación de la Base de Datos Apache Derby en Linux, específicamente en Debian para la cual deberemos tener los repositorios actualizados para obtener la versión más reciente.

Para probar la conexión de Apache Derby requeriremos de JVM (Máquina Virtual de Java), por ello deberemos tener ambos instalados:

#aptitude install sun-java6-jdk sun-java6-javadb

Luego de la instalación, podremos acceder al directorio ubicado en: /usr/lib/jvm/java-6-sun/db/ donde se ubican una base de datos de ejemplo, pero antes debemos exportar el CLASSPATH actualizado para poder acceder a la administración de Derby desde el terminal:

$export JAVA_HOME=/usr/lib/jvm/java-6-sun/
$export PATH=$JAVA_HOME/bin:$PATH
$export DERBY_HOME=/usr/lib/jvm/java-6-sun/db
$export CLASSPATH=$DERBY_HOME/lib/derby.jar:$DERBY_HOME/lib/derbytools.jar:.

Ahora accederemos a ver la base de datos ejemplo llamada toursdb que se encuentra en la siguiente ruta:
/usr/lib/jvm/java-6-sun/db/demo/databases/toursdb

Ingresar al terminal e ingresar las siguientes instrucciones:

$java org.apache.derby.tools.ij

No olvidarse de los punto y coma al final de cada instrucción:

ij>connect 'jdbc:derby:/usr/lib/jvm/java-6-sun/db/demo/databases/toursdb';
ij>SELECT * FROM countries;
ij>exit;

Si todo se ha hecho como se ha indicado no habrá problema y la sentencia responderá correctamente.

Ahora probaremos creando nuestra propia base de datos.
Primero deberemos ir la directorio donde se creará la base de datos:

$cd $HOME
$java org.apache.derby.tools.ij
ij>connect 'jdbc:derby:dbtest;create=true';
ij>create table usuario(nombre varchar(15), password varchar(30), rol varchar(50));
ij>insert into usuario values('beastieux','zeroo','administrador');
ij>insert into usuario values('apache','derby','sysadmin');
ij>select * from usuario;
NOMBRE         |PASSWORD                      |ROL
--------------------------------------------------------------------------------
beastieux      |zeroo                         |administrador
apache         |derby                         |sysadmin
ij>disconnect;
ij>exit;

Todo lo demás es así de sencillo, las sentencias SQL guardan los estándares, como se mencionan en DB-Derby-wiki.
Para ver la ubicación de la base de datos recién creada, solo fijarse en el directorio desde donde se lanzó la orden de conexión, en mi caso lo hice desde mi $HOME, donde se creó el directorio dbtest, que es el nombre que se puso a la base de datos. Esta podría ser copiada al proyecto desde donde se crea la aplicación en la que podría ser embebida.Así de Fácil.

A %d blogueros les gusta esto: