Buscando un DNS más rápido (Linux Manjaro [Archlinux] - Ubuntu)

Últimamente el DNS de mi proveedor de Internet falla o es demasiado lento al navegar, y recordé una utilidad que ayuda a buscar un DNS más rápido realizando diferentes tipos de pruebas, y al final te da un resultado con los DNS más rápidos.

Esta es una herramienta multiplataforma, pueden usarla en Linux, Mac Os y Windows.
La herramienta es Namebench

Para instalar en ubuntu, la pueden encontrar en los repositorios:

$ sudo apt-get install namebench

Y para Manjaro podemos encontrarlo en el repositorio de AUR

$ yaourt -S namebench

y si queremos usar la interfaz gráfica instalamos "tk", el paquete la muestra como dependencia opcional.

$ sudo pacman -S tk

Y listo lo podemos ejecutar desde la terminal y que haga su magia y si instalaron tk para la interfaz gráfica al ejecutarlo esta se mostrará y con un clic comenzará a trabajar. Pueden dejar los parámetros tal y como están al momento de ejecutarse, si son usuarios mas experimentados pueden modificar las opciones a su gusto.

 Aquí unas imágenes de namebench trabajando:

Resultados en terminal

Imagen de la interfaz gráfica de namebench

Una vez con los resultados, solo es cuestión de cambiar los DNS en la configuración de red, esto ya dependerá de nuestro sistema y escritorio que usemos (GNOME, KDE, LXDE, XFCE etc). 

Build Authz 1.1.2 - Ayuda visual para construir el archivo "authz" [Actualizado]

Hoy liberé la nueva versión (1.1.2rv18) de esta herramienta que ayuda a construir el archivo "authz" para repositorios Subversion.  Referencia

En las novedades de la aplicación están:

• La opción de verificar el formato del archivo authz (mediante la herramienta de subversion "svnauthz-validate").
• Cargar usuarios desde un archivo "passwd".
• Guardar y cargar, la vista previa de los permisos que vamos configurando.

Y algunas correcciones de bugs.

pueden descargar los binarios para:

Windows

Linux

OsX

http://code.google.com/p/build-authz/downloads/list

Insync (Cliente Google Drive) - Sincronizando nuestros directorios en Ubuntu y Windows

Actualmente hay una gran variedad de servicios como Dropbox que nos ofrecen almacenamiento gratuito en la nube, ejemplo de esto lo tenemos en Ubuntu, con su servicio Ubuntu One que nos ofrece 5gb gratuitos, ademas de tener clientes multiplataforma, un servicio relativamente nuevo, es el liberado por Google, su servicio "Google drive". En lo personal, uso varios de estos servicios, entre ellos:

Ubuntu one
Google Drive
DropBox
Box

Google tardó un poco en liberar su API para este servicio (nada nuevo...), pero ya tenemos un cliente de escritorio para este servicio, y es Insync, es un cliente multiplataforma, entre sus características se integra con el administrador de archivos, y permite manejar cuentas múltiples.

Para instalarlo en Ubuntu/Mint, podemos agregar su ppa con los siguientes comandos: 

Para Ubuntu: 

$ echo "deb http://apt.insynchq.com/ubuntu $(lsb_release -cs) non-free" | sudo tee /etc/apt/sources.list.d/insync.list

Para Mint:

$ echo "deb http://apt.insynchq.com/mint $(lsb_release -cs) non-free" | sudo tee /etc/apt/sources.list.d/insync.list

Y después para cualquiera que sea, importamos las llaves:

$ wget -O - https://d2t3ff60b2tol4.cloudfront.net/services@insynchq.com.gpg.key | sudo apt-key add - sudo apt-get update

e instalamos:

Ubuntu (Soporte para Unity):

$ sudo apt-get install insync-beta-ubuntu

Mint (Soporte para Cinnamon):

$ sudo apt-get install insync-beta-cinnamon

Y con esto tendremos instalado este cliente para manejar nuestras cuentas de google drive, cuando lo ejecutemos nos pedirá ligarlo a alguna cuenta que tengamos de google, una vez hecho esto, en nuestro directorio HOME creará los directorios de nuestras diferentes cuentas y en estos tendremos los archivos y directorios que queramos sincronizar.

Para windows, solo hay que descargar el instalador y seguir las instrucciones.

A pesar de ser muy buen cliente, falta una que a mi parecer es una opción muy buena, y es la de elegir otros directorios para compartir y que estos no se encuentren dentro de los directorios que crea el cliente. Por ejemplo esta opción si la tiene Ubuntu One, permite seleccionar cualquier directorio de nuestro sistema y sincronizarlo con nuestra cuenta. 

Pues muy simple! Podemos crear enlaces simbólicos de archivos o directorios que queramos tener sincronizados.

Desde la terminal tecleamos: 

$ ln -s  /ruta/de/directorio/que/quieras-sincronizar  /home/tuusuario/Insync/tusuario@gmail.com/

Y listo, tendremos sincronizados los directorios o archivos, y simple! Ojo: si borramos los archivos desde nuestro directorio de Insync se borrarán de nuestro google drive pero no de nuestro pc.

Build Authz 1.0 - Ayuda visual para construir el archivo "authz"

Este es el primer release de esta pequeña aplicación que nació para facilitar la configuración y creación del archivo "authz" para los repositorios de Subversion. Esta desarrollada en Lazarus 1.0.2.

Para recordar ver el post

SVN - Control de acceso con Authz

Esta aplicación es liberada bajo licencia GPL, es Software Libre y pueden descargar el código fuente desde el siguiente repositorio:

http://code.google.com/p/build-authz/

para modificarlo, leerlo y compilarlo a su gusto.

O pueden descargar los binarios precompilados para las diferentes plataformas:

• Windows
• Linux/Gtk
• OsX

http://code.google.com/p/build-authz/downloads/list

La documentación y manual se encuentra en la lista de descarga.

Llenando un Treeview desde un directorio en lazarus (Linux/Windows)

Bueno vengo a poner un ejemplo sencillo de como llenar un Treeview desde un directorio en Lazarus, algo curioso que note al portarlo a Linux y OsX es que el valor que la constante "faDirectory" en Windows toma un valor de "16" y en SO "Unix" toma el valor de "48" por ese detalle al principio no me listaba los directorios, después de ir viendo paso por paso los valores que tomaban me di cuenta de eso, solo agregamos una validación que identifique el SO en el que se esta ejecutando y ajustar ese valor.

En el ejemplo agregamos al evento OnClick de un botón el siguiente código:

procedure TfrmMain.btnAgregaMarcadorClick(Sender: TObject);
var
    lcSearch: TSearchRec;
    lcFileAttr: integer;
    lcFatherNode: TTreeNode;
    lcChildNode: TTreeNode;
    lcPath: String;
begin
    {$IFDEF UNIX}
        lcFileAttr:= 48;
    {$ELSE}
        lcFileAttr:= faDirectory;
    {$ENDIF}
    SelectDirectoryDialog1.Execute;
    lcPath:=SelectDirectoryDialog1.FileName;
    if Length(lcPath) > 0 then begin
        lcFatherNode:= TTreeNode.Create(TreeView1.Items);
        lcFatherNode:= TreeView1.Items.AddChild(TreeNodeRoot,lcPath);
        lcFatherNode.ImageIndex:=0;
        lcFatherNode.SelectedIndex:=0;
        lcFatherNode.Expanded:=True;
    end;
    lcPath:=lcPath+PathDelim;
    If FindFirst(lcPath+'*',faDirectory,lcSearch)=0 then begin
        repeat
            if lcSearch.Attr = lcFileAttr then begin
                if (lcSearch.Name = '.') or (lcSearch.Name = '..') then continue;
                lcChildNode:= TreeView1.Items.AddChild(lcFatherNode,lcSearch.Name);
                lcChildNode.ImageIndex:=0;
                lcChildNode.SelectedIndex:=0;
                AddDirectorios(lcChildNode,lcPath+lcSearch.Name);
            end;
        until FindNext(lcSearch) <> 0;
        FindClose(lcSearch);
    end;
   TreeView1.Refresh;
end;

El siguiente procedimiento lo agregamos nosotros, este será llamado desde nuestro anterior proceso cuando encuentre un directorio, y será llamado recursivamente desde él mismo agregando los nodos hijos con el nombre de los directorios encontrados.

procedure TfrmMain.AddDirectorios(elNodo: TTreeNode; cPath: String);
var
    sr: TSearchRec;
    lcFileAttr: Integer;
    theNewNode : tTreeNode;
begin
    {$IFDEF UNIX}
        lcFileAttr:= 48;
    {$ELSE}
        lcFileAttr:= faDirectory;
    {$ENDIF}

    if FindFirst(cPath+PathDelim+'*', faDirectory, sr) = 0 then begin
        repeat
            if sr.Attr = lcFileAttr then begin
                if (sr.Name = '.') or (sr.Name = '..') then continue;
                    theNewNode := TreeView1.Items.AddChild(elNodo,sr.name);
                    theNewNode.ImageIndex:=0;
                    theNewNode.SelectedIndex:=0;
                    AddDirectorios(theNewNode,cPath+PathDelim+sr.Name);
            end;
        until FindNext(sr) <> 0;
        FindClose(sr);
    end;
end;

Desarrollo multiplataforma con Lazarus (Clon de Delphi)

¿Que es Lazarus?

Bueno en su página podemos encontrar lo siguiente:

Lazarus es el conjunto de bibliotecas de clases para el compilador Free Pascal que emula a Delphi. Free Pascal es un compilador de licencia GPL que trabaja sobre Linux, Windows, OsX, OS/2, 68k y más.

Lo interesante de esto es que podemos crear nuestro proyecto en cualquier plataforma y solo tendremos que compilarla en otras para mudarla. Como ejemplo, creamos un proyecto en Windows con componentes normales de este, para migrarlo a Linux solo tenemos que mover el proyecto al equipo con Linux y Lazarus instalado, seleccionar que conjunto de widgets queremos utilizar (GTK o Qt para Linux) y compilarlo, Lazarus se encargará de todo, no tenemos que reescribir nuestro código.

A diferencia de Java que es "compilalo una vez ejecútalo donde sea", con Lazarus lo escribimos una vez y lo compilamos donde queramos".

En cuanto al lenguaje, como se menciono es un clon de Delphi, entonces para los que usaron esta herramienta, será muy familiar para ellos.

A finales del mes pasado (Agosto) acaban de liberar la versión 1.0 de esta herramienta.

Podemos ver las notas de cambios aqui:  http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes 

Acá unas imágenes de como se ve trabajando en Linux 

Y acá imágenes del mismo proyecto compilado en Windows:

La herramienta esta muy completa, se encarga de hacer los bindings para la interfaz, tiene soporte nativo para bases de datos, MySQL, PostgreSQL, SQL Sever y más, y es multiplataforma, así que vale la pena probarlo. 

Para Ubuntu/Mint no esta en los repositorios oficiales y desafortunadamente no cuenta con un ppa, pero en la página de descargas ofrecen los paquetes DEB con los que podemos instalarlos fácilmente.

Sitio de descarga: http://sourceforge.net/projects/lazarus/files/

Sitio principal de Lazarus: http://www.lazarus.freepascal.org/

SVN - Control de acceso con Authz

Actualmente utilizamos en la empresa SVN como sistema de control de versiones para nuestros proyectos, es práctico y nos ha servido bastante bien, hasta ahora hemos utilizado el método del archivo "passwd" para dar acceso a los repositorios de los proyectos, no habíamos necesitado de nada más.

Actualmente ha surgido la necesidad de buscar una manera de crear un repositorio común para toda la organización pero con acceso limitado por carpetas para los diferentes usuarios.
Leyendo un poco acerca de las diferentes formas de control de acceso para SVN encontré que usando  svnserve, y configurando el archivo "authz" se puede configurar el acceso a directorios, en base a usuario o grupos de usuarios.

En este caso lo mejor es crear el árbol de directorios que se usará para que en base a ese árbol configuremos el archivo "authz", aunque siempre se puede modificar si se agregan mas directorios y se quiere mantener el acceso restringido a estos.

NOTA es importante definir bien la estructura del directorio, desde los niveles mas bajos a los mas altos.

Primero creamos un repositorio, lo llamaremos "Proyectos", editamos el archivo svnserve.conf que se crea, buscamos y descomentamos las siguientes lineas:


#    anon-access = read #    auth-access = write .
.
.
#   password-db = passwd

para que queden sin la almoadilla "#"

anon-access = read

auth-access = write
.
.
.
password-db = passwd

Y añadimos los usuarios que vayan a utilizar el repositorio en el archivo "passwd"

para este ejemplo agregaré 4 usuarios:

[users]
admin = adminssecret
devchief = chiefssecret
developer1 = devs1secret
developer2 = devs2secret
developer3 = devs3secret

Después creamos la estructura de directorios:

Voy a poner un ejemplo simple de estructura de directorios:

Directorio Raiz: --Proyectos
                              --Web
                                 --PERL
                                 --PHP
                                 --RUBY

importamos a nuestro repositorio el directorio raiz con los subdirectorios:
ya sea que lo hagan con un cliente gráfico como VCSRabbit o Tortoise
o desde la terminal, que sería así:

$ svn import -m "estructura" --username admin --password adminssecret Proyectos/  svn://tuserver/Proyectos 

Así queda creada la estructura de directorios base en el repositorio.

Ahora si! es hora de configurar el archivo "authz"
Abrimos el archivo authz que se encuentra en el directorio de nuestro repositorio y buscamos la sección [groups] que es donde configuraremos los grupos con los usuarios que definimos en el archivo "passwd"

deberá quedar algo así:


[groups]
Admins = admin, devchief
Developersphp = developer1, developer3
Developersperl = developer2
Developersruby = developer2, developer3

después de esta sección vamos a configurar el acceso a los directorios de la siguiente manera:

primero tenemos que dar acceso a todos los usuario a la raíz del repositorio, pero solo daremos permiso de escritura al grupo de administradores. No se le puede otorgar un permiso de escritura a un usuario/grupo si no tiene acceso de lectura al directorio padre.

[/]
@Admins = rw   #con esto damos acceso de lectura y escritura a el grupo Admins
* = r    #con esto damos acceso a todos acceso de lectura

[/Web] #Ahora configuramos los accesos para el siguiente nivel, que es el directorio "Web"
* = r    #con esto damos acceso a todos acceso de lectura
@Admins = rw   #con esto damos acceso de lectura y escritura a el grupo Admins

[/Web/PHP]  #Ahora configuramos los accesos para el siguiente sub-nivel,  de Web, que es el directorio "PHP"
@Developersphp = rw   #con esto damos acceso de lectura y escritura a el grupo Developersphp, entonces SOLO el usuario developer1, developer3 podrán ver y escribir este directorio
@Admins = rw #con esto damos acceso de lectura y escritura a el grupo Admins
* =   #Con esto se asegura que nadie mas tenga ningún tipo de acceso al directorio

[/Web/PERL] #Ahora configuramos los accesos para el siguiente sub-nivel,  de Web, que es el directorio "PERL"
@Developersperl = rw #con esto damos acceso de lectura y escritura a el grupo Developersperl, entonces SOLO el usuario developer2 podrá ver y escribir este directorio
@Admins = rw
* =


[/Web/RUBY] #Ahora configuramos los accesos para el siguiente sub-nivel,  de Web, que es el directorio "RUBY"
@Developersruby = rw #con esto damos acceso de lectura y escritura a el grupo Developersruby, entonces SOLO los usuarios developer2 y developer3 podrán ver y escribir este directorio
@Admins = rw
* =


 #Nota si se desea puede darse acceso a usuarios por separado de a siguiente forma:
#[/Web/PERL] 
#developer2 = rw
#devchief  = r
#* =

Guardamos y cerramos el archivo.
Ahora hay que descomentar una linea más en el archivo "svnserve.conf"
Buscamos la siguiente linea:

# authz-db = authz

lo descomentamos y lo dejamos así:


authz-db = authz

Guardamos y cerramos el archivo, y reiniciamos el demonio o servicio de svnserve.

Ahora cuando el usuario "admin" haga un checkout del repositorio podrá ver y escribir en todos los directorios. Y cuando el usuario developer1 solo podrá ver y escribir en el directorio "PHP" y así para cada uno de los diferentes usuarios que configuramos en el archivo authz.

Lighttpd + PHP en Windos parte 2 + Dokuwiki

Continuando con el tema de Lighttpd + PHP en Windows, veremos como instalar y configurar PHP para lighttpd.

Primero descargamos PHP desde su sitio http://windows.php.net/download/ yo descargue la ultima versión al momento PHP 5.4 (5.4.6), descargue el .zip.

Una vez descargado, lo descomprimo en el directorio de Lighttpd y creo un directorio "PHP", en mi caso C:\Lighttpd\PHP

Una vez hecho esto, buscamos en el directorio php el archivo "php.ini-development" lo renombramos a "php.ini" lo abrimos y buscamos la siguiente linea:

;cgi.fix_pathinfo=1

Y descomentamos la linea, borrando el punto y coma del inicio.

 cgi.fix_pathinfo=1

Guardamos y cerramos el archivo.

Ahora en el archivo "lighttpd.conf" en el directorio "conf" lo editamos y buscamos la siguiente linea y descomentamos
#### fastcgi module
.
.
.
#fastcgi.server             = ( ".php" =>
#                              ( "localhost" =>
#                                 (
#                                  "host" => "127.0.0.1",
#                                   "port" => 9000
#                                 )
#                               )
#                             )

para dejarlo de la siguiente forma:


fastcgi.server             = ( ".php" =>
                              ( "localhost" =>
                                 (
                                  "host" => "127.0.0.1",
                                   "port" => 521
                                 )
                               )
                             )

y guardamos y cerramos el archivo.

Ahora necesitamos ejecutar "Lighttpd" y "php-cgi"
Para esto podemos hacer un script que inicie ambos ejecutables:

@ECHO OFF
START /B PHP/php-cgi.exe -b 127.0.0.1:521
ECHO LightTPD
ECHO.
ECHO Presiona 'INTRO' para salir.
ECHO.
ECHO LightTPD:
ECHO ---------
START /B lighttpd.exe -f conf/lighttpd.conf -m modules -D
PAUSE > NUL
TASKKILL /F /IM php-cgi.exe
TASKKILL /F /IM lighttpd.exe
EXIT

Lo guardamos con extensión ".BAT" y lo ejecutamos.

Entramos desde el navegador a: http://localhost:81/index.php

y nos deberá mostrar la página de información de PHP. Podemos agregar para que se ejecute al inicio el script que inicia Lighttpd y PHP.

Una vez hecho esto solo tenemos que descargar "DokuWiki" desde su sitio http://www.splitbrain.org/projects/dokuwiki

Descomprimimos el archivo en el directorio "htdocs" de Lighttpd, en mi caso renombre solo por "dokuwiki" el directorio y desde el navegador entramos a:

http://localhost:81/dokuwiki/install.php

y seguimos las instrucciones de configuración para nuestra wiki. 

Lighttpd + PHP en Windows

Hoy toca ver una alternativa ligera para un servidor web, esta es "Lighttpd"
Según Wikipedia:
Lighttpd es software libre y se distribuye bajo la licencia BSD. Funciona en GNU/Linux y UNIX de forma oficial. Para Microsoft Windows actualmente hay una distribución conocida como Lighttpd For Windows mantenida por Kevin Worthington.

Esto ya no es así, ahora la versión para Windows es mantenida y desarrollada por un grupo húngaro, el proyecto se llama WLMP, que es el acrónimo para Windows / LightTPD / MySQL / PHP. Esta versión de windows esta bajo una licencia GNU/General Public License.

http://en.wlmp-project.net/

Bueno el caso es que decidimos usar una Wiki para hacer un tipo de repositorio de conocimiento para la empresa, todo lo que aprendamos y pongamos en práctica, poder documentarlo y compartirlo con los demás, al final decidimos por DokuWiki.
Esta wiki es muy liviana, rápida y no necesitas hacer uso de base de datos para instalarla y manejarla, aunque  siempre puedes usarla, ya sea mysql o postgres.

Para probar y aprender decidí ponerla en otro servidor, y no el Apache que usamos para desarrollo y trabajo, aquí. Así decidí probar lighttpd.

Primero descargamos ya sea el instalador o el archivo .zip desde el sitio de descargas http://en.wlmp-project.net/downloads.php?cat=lighty

yo descargue el .zip y lo descomprimí directo en "C:\"

Abrimos el directorio que descomprimimos y vamos al directorio "conf". Ahí encontraremos el archivo "lighttpd.conf" que es el archivo de configuración del servidor.

Buscamos al principio del archivo las siguientes lineas:
#                                "mod_fastcgi",
#                                "mod_rewrite",

y borramos las "almoadillas" # para descomentar los módulos que serán los que usemos para PHP:

                             "mod_fastcgi",
                             "mod_rewrite",

¿Por que usar el módulo fastcgi y no cgi? Bueno se mencionan algunas ventajas como rapidez, independencia de lenguaje (perl, php, .net, c++) entre otras.

Una vez hecho esto buscamos las siguientes lineas:

## bind to port (default: 80)

#server.port                = 81     

y descomentamos la linea de "server.port", en mi caso tengo un server Apache en el puerto 80, así que lo ponemos en el puerto 81.

server.port                = 81  

Podemos poner un archivo "index.html" en el directorio "htdocs" del directorio "LightTPD" para probar que funciona, podemos ver que hay un "index.php" pero todavía no tenemos instalado y configurado PHP así que lo mas probable es que nos tire un error.

En el próximo post veremos como instalar y configurar PHP para Lighttpd e instalar la Dokuwiki.

Enviando Correos con PERL usando SMTP de Gmail (Windows & LINUX)

Dejando un poco de lado a Twitter, buscábamos agregar un modulo para un proyecto para enviar correos, ya tenemos uno, pero al utilizarlo para conectarse al servidor SMTP de gmail, simplemente no funcionaba. Tan fácil como buscar en google, hay muchas bibliotecas para hacerlo, el problema es que para el servidor que se va a utilizar la versión de PERL es la 5.8 o 5.10, y para estas versiones las bibliotecas de ActivePerl para windows solo soportan las versiones 5.14 >
Por eso este post menciona la forma de hacerlo en Windows con un PERL 5.8 y con LINUX usando PERL 5.14.

Vamos con la primera forma de hacerlo con LINUX:

Para esto podemos usar la biblioteca Email::Send::Gmail
en su página de CPAN podemos encontrar un ejemplo de como usarlo.

=======================================================================

#!/usr/bin/perl

use strict;
use Email::Simple;
use Email::Simple::Creator;
use Email::Send;
use Email::Send::Gmail;

send_mail();
print "mensaje enviado";

sub send_mail {

my $usuario = 'tucorreo@gmail.com';
my $password = 'tupassword';

#Creamos el correo, a quien va dirigido, de quien, el asunto y el mensaje
my $email = Email::Simple->create(
    header => [
        To => 'JuanPerez@gmail.com',
        From => $usuario,
        Subject => 'Probando 123',
        ],
    body => "Prueba desde LINUX",
    );

#Aquí especificamos que usara a Gmail como servidor SMTP
my $sender = Email::Send->new(
{    mailer => 'Gmail',
    mailer_args =>[
        username => $usuario,
        password => $password,
        ]
}
);
$sender->send($email);


}

=========================================================================

Hasta aquí todo bien, pero en windows usando PERL 5.8 no está la biblioteca, entonces hurgando un poco en su código, podemos ver como funciona esta, nos podemos dar cuenta que usa la biblioteca Net::SMTP::SSL, y esta si la podemos encontrar para PERL 5.8.

y así quedaría el código para enviarlo en windows:

#!/usr/bin/perl

use strict;
use Net::SMTP::SSL;
  
send_mail('juanPerez@gmail.com','Prueba desde windows', 'probando el correo desde windows ;D');  
print "mensaje enviado";
    
sub send_mail {
  
  my $username = 'tucorreo@gmail.com';
  my $password = '123456';
  my $dest = shift; #'destinatario@algomail.com'
  my $asunto = shift;  
  my $body_mail = shift;

  #creamos la conexión con el servidor SMTP de Gmail
  my $smtp = Net::SMTP::SSL->new(
       'smtp.gmail.com',
       Port  => 465,
       Debug => 0,
       )
        || print 'Email::Send::Gmail: error connecting to server smtp.gmail.com';
    #se realiza al autentificación 
    $smtp->auth( $username, $password )
        or
        print "Email::Send::Gmail: error authenticating username $username";
        
  $smtp->mail($username);        
  $smtp->to($dest);
  #Se envía el correo
  $smtp->data();
  $smtp->datasend("From: ". $username );
  $smtp->datasend("\n");
  $smtp->datasend("To: ". $dest );
  $smtp->datasend("\n");
  $smtp->datasend("Subject: ". $asunto. "\n");
  $smtp->datasend("\n");
  $smtp->datasend($body_mail ."\n");
  
  $smtp->dataend();
  $smtp->quit();
  
  
}

Y así podemos enviar correos usando nuestras cuentas de Gmail a traves de PERL en LINUX y Windows.

Ejecutando aplicaciones de Windows con WINE

Como es bien sabido, WINE permite ejecutar ciertas aplicaciones nativas de Windows en Linux, mi problema se presentó cuando al tratar de ejecutar una aplicación, para ser mas exacto un juego, el emulador NeoRage para Windows, si no me encontraba en el directorio donde se encuentra el programa, no puede leer los archivos necesarios para ejecutarse, pero en cambio si desde la terminal me posicionaba en el directorio y ejecutaba el programa se ejecutaba sin problemas.

$ cd /home/jaxnet/NeoGeo

$ wine neorage.exe

-funciona bien-

pero si el caso es que desde mi directorio "home" lo ejecuto no lee los archivos.

Entonces leyendo en la wiki de WINE di con la solución:

si ejecutamos desde un lanzador creado por nosotros en el escritorio o desde otro directorio diferente a donde este el programa, hay que usar:

$ wine start /Unix "/home/jaxnet/NeoGeo/neorage.exe" 

con esto WINE define el directorio de trabajo para el programa

O si tenemos el programa en otro WINEPREFIX 

$ WINEPREFIX="$HOME/NeoGeo" wine start "C:\\NeoGeo\\neorage.exe" 

en la próxima entrada escribiré como crear  un "WINEPREFIX" para aplicaciones, esto permite un mejor manejo a la hora de instalar y configurar programas.

Aquí una imagen del lanzador que hice para la aplicación