Mostrando las entradas con la etiqueta perl. Mostrar todas las entradas
Mostrando las entradas con la etiqueta perl. Mostrar todas las entradas

miércoles, 5 de febrero de 2014

Como listar archivos con filtrado en Perl

En esta ocasion vamos a aprender como listar los archivos de un directorio con filtrado de extension,por ejemplo listar los .txt,los .png,etc.

En perl las cosas se pueden hacer de muchas maneras,así que vamos a ver algunas(no todas),pero las que me gustan o conozco:

En todos los ejemplos,el array @archivos contendrá los archivos filtrados,este sera el que pueden usar para lo que necesiten.


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
use feature 'switch'; # Usamos switch

my $dir = "."; # . hace referencia al directorio actual

my @archivos;

 opendir(my $recorrer, $dir) || die "Error :( $! \n";  # recorrer es el filehandle
    while(readdir $recorrer){  # Leemos el directorio
        if (-f $dir . "/" . $_) { # Vemos si es un fichero
            given ($_) { 
                when (/.*jpg/) { # Elegimos la extension
                     push (@archivos, $_); # Añadimos al array el archivo
                }
                when (/.*jpeg/) { # Elegimos otra(si queremos)
                    push (@archivos, $_);
                }
            }
        } 
    }
    closedir $recorrer;  # Cerramos el directorio

Bien ese es que yo uso mas,es un poco a lo Java,pero me gusta que se vea mucho codigo,aunque luego me dicen que mientra menos mejor,y en perl eso es muy simple.

Bien ahora una forma mas sencilla,usando glob al estilo python,glob es similar a los pipes de Unix:

my @arr = glob("*.jpg");

Así de sencillo,aquí el problema es para añadir mas,podemos hacer esto si quisieramos tambien los .jpeg.


1
2
3
4
foreach (glob("*.jpeg")) 
{
   push (@archivos, $_);
}

Bien,ahora una manera aun mas sencilla:

my @arr = <*.jpg>;
De igual manera si queremos añadir mas:


1
2
3
4
foreach (<*.jpeg>)) 
{
   push (@archivos, $_);
}

Si queremos usar un directorio en especifico lo especificamos antes:

my @archivos = ;

Ahora por ejemplo para mostrar en pantalla:


1
2
3
4
5
6
7
use feature 'say';

my @archivos = <*.pl>;

foreach (@archivos) {    
    say $_;
}


Eso es todo.
Leer más...

lunes, 3 de febrero de 2014

[Shell] Spam comentarios wordpress

Seguimos hablando de pentest y aquí otra cosa que se ve mucho y que molesta,el spam,el spam son esos comentarios que no dejan nada y que son masivos.

A mi no me ha tocado mucho spam en blogger como dicen que sucede en wordpress,me han llovido anuncios,mentadas de madre,y otras ridiculeces pero bueno,es lo que pasa en la web hay todo tipo de gente hay muchas personas que comentan aportan y hay otras que,que bueno...

Pero bueno lo que sea de cada quien no se que sistema usen pero hace un tiempo pasaron mi capcha y comentaron 40 veces seguidas al mismo tiempo :O,hay que reconocer que saben lo que hacen.

En esta ocasión vamos a aprender a crear un spamer para los  comentarios de wordpress.

Esto no es para que anden spameando ya que es una tontería mas si el webmaster del sitio tiene las ip's(o simplemente wordpress nos manda la ip del comentario),es para que vean como se podría spamear y como defenderse,si quieren spamear haganlo bajo su propio riesgo yo solo les aviso de la hulla de Internet.

Bien vamos a usar Perl para este ejercicio,primero que nada instalamos lo necesario:

Abrimos una shell:
sudo cpan WWW::Mechanize
sudo cpan WWW::Mechanize::GZip
sudo cpan Data::Dumper
Bien ahora debemos por ejemplo:

Ver los imput del sitio en donde queremos "comentar",para esto podriamos usar regex y pipes Unix,pero vamos a hacerlo desde perl:

Aqui un sencillo script que ubica todos los input:

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
use strict;
use WWW::Mechanize;
use HTML::Form;
use LWP::UserAgent;
use Data::Dumper;

my $url = "http://url";

my $mech = WWW::Mechanize->new(autocheck => 1);

$mech->get( $url ) or die("No es posible conectarse a $url");

my $ua = LWP::UserAgent->new;

my $response = $ua->($url);

my @forms = HTML::Form->parse($response);

foreach (@forms) {
    print Dumper($_);
}

Ejecutamos y vemos todos los input,en wordpress es una tontería esto ya que están a fuego:


Ahora tenemos los fields:

comment
email
author 
url 



Bien vamos a crear un script para un comentario simple:






1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/usr/bin/env perl

use warnings;
use strict;
use WWW::Mechanize::GZip;

my $url = "http://url";

my $mech = WWW::Mechanize::GZip->new();

$mech->agent_alias("Linux Mozilla");

$mech->get($url) || die $!;

my $respuesta = $mech->submit_form(
       fields => {
       comment => "Este es un spam",
       email => 'email@gmail.com',
       author => "unknow",
       url => "direccion.com",
    }
);
print "Listo";
}

Con eso podemos comentar de manera común,ahora que convierte un comentario en spam:

El numero de envíos,así que vamos a enviar mas comentarios con un bucle:

Pero primer problema,wordpress verifica los comentarios en su base de datos,si son iguales redirigue la pagina y ya podríamos comentar.

Solución añadir un contador al comentario,con añadir un numero al principio o al final basta,esto en el mail o en el comentario.

'email@gmail.com'.$i

Otro problema,wordpress checa el tiempo en el que enviamos los mensajes,esto se solucion esperando un tiempo por ejemplo:

sleep 10;

Esperar 10 segundos en cada envió,si somos un poco ingeniosos incluso podemos usar una ip diferente para cada comentario,pero eso se los dejo de tarea.

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env perl

use warnings;
use strict;
use WWW::Mechanize::GZip;

my $url = "http://url";

my $mech = WWW::Mechanize::GZip->new();

$mech->agent_alias("Linux Mozilla");

$mech->get($url) || die $!;

for (1..10) {
my $respuesta = $mech->submit_form(
       fields => {
       comment => "Este es un spam".$_,
       email => 'mail'.$_.'@gmail.com',
       author => "unknow".$_,
       url => "direccion.com",
    }
);
print $respuesta->content(); # Nos muestra la respuesta del sitio.
sleep 10;
}

De esa manera podríamos spamear un sitio con comentarios,de igual forma lo podemos hacer en formularios de contacto,pero bueno.



Ahora como defenderse de esto:

1. Wordpress automáticamente no publica estos comentarios,pero de por si ya tenerlos en la bandeja es molesto así que si los publica automáticamente deben cambiar a moderar.

2. Si tienen los registros del servidor se podría hacer un filtrado de ip basado en tiempo esto lo hace wordpress automáticamente,pero no esta de mas usarlo a nivel de servidor,solo que si se usa una ip diferente podría evadirse este sistema.

3. Dejárselo a los profesionales hay filtros contra el spam(si tenemos wordpress en nuestro host),hay plugins para evitar esto,los instalamos y listo.

Pero cuidado ya que aqui esta la trampa:

Metemos un plugin pensando que nos soluciona esto,pero ese es el anzuelo de los spamers,por ejemplo Akismet,en una version(no se si ahora),mostraba nuestro full path disclosure(lo veremos en su momento) que seria un problema mas grande y que se abria logrado gracias al spam.

Bien eso es todo :D.

Un comunicado de este sitio:

Ya no voy a dejar comentar a personas anonimas,solo a las de google y personas registradas,son los que dejan mejores comentarios y si me mientan la madre(como lo han hecho últimamente) por lo menos den la cara y cuerpo,o mejor dicho el nick y el avatar :P.

Es enserio ya tengo bastante con la delincuencia de este país, uno no se siente seguro en la calle como para que en el sitio donde me distraigo un rato también fomenten la violencia,así que si quieren comentar háganlo con su cuenta,también serán moderados los comentarios.

Leer más...

sábado, 4 de enero de 2014

Programacion Orientada a Objetos con Perl parte 2

Continuamos con los tutoriales de OOP de Perl,en esta ocasión vamos a tocar otro tema importante de la OOP,la herencia.

En perl la herencia se puede hacer igual que en los otros lenguajes de programación,perl maneja las clases como paquetes y para que estos hereden de otros paquetes tienes que estar relacionados entre si,las clases padre se guardan en la variable isa de UNIVERSAL,UNIVERSAL es de donde heredan todas las clases de Perl implícitamente.

Para que una clase herede de otra debemos añadirla al array ISA,pero no es necesario en estos tiempos,lo que haremos sera facilitarnos el trabajo con parent:

En perl existen muchas pero muchas formas de hacer lo mismo ya que incluso lleva el lema There's more than one way to do it,voy a intentar hacerlo de la manera mas simple posible.

Vamos a usar de ejemplo una mascota virtual,(también lo veremos en Java),creamos un archivo llamado Mascota.pm:

vim Mascota.pm

Ahora vamos a crear la clase como vimos en el tutorial pasado.

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package Mascota;

use feature 'say';

sub new 
{
    my $class = shift;
    my $self = { 
        'Hambre' => 1, 
    };
    bless $self,$class;
    return $self;
}

sub tienesHambre 
{
    my $self = shift;
    if (int($self->{Hambre}) == 1) 
    {
        say "Tengo hambre";
    } 
    else 
    {
        say "No tengo hambre";    
    }
}
sub darDeComer
{
    my $self = shift;
    $self->{Hambre} = 0;
}
1;


Como ven añadí dos funciones una por si tiene hambre y otra para quitarle el hambre(sobra explicarlo).

Ahora vamos a crear un Perro que herede esas funciones de la clase Mascota,creamos un archivo Perro.pm:

vim Perro.pm

Primero definimos el paquete:

package Perro; # Suponiendo que esta en el mismo directorio

Luego usamos Mascota como clase padre:

use parent 'Mascota';

Eso nos ahorra mucho trabajo,ya que verifica las cosas mas importantes como añadir ha isa,verificar autoherencia,etc.

Eso es todo para que un archivo heredara de otro las funciones.

Ahora lo mas importante,el constructor de la clase Perro,para que la clase Perro herede las funciones y las variables de Mascota tenemos que inicializar el constructor de Mascota,para eso creamos una clase new para perro y definimos que el self sea el self de mascota usando la palabra SUPER:


1
2
3
4
5
sub new {
    my $class = shift;
    my $self = $class->SUPER::new();
    return $self;
}

De esa manera ya estan construidos las dos clases,asi queda la clase Perro añadiendo una funcion propia de los perros:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package Perro;
use feature 'say';
use parent 'Mascota';

sub new {
    my $class = shift;
    my $self = $class->SUPER::new();
    return $self;
}

sub ladra {
    say 'woww';
}
1;


Ahora en el principal podemos llamar a la clase Perro y usar las funciones de mascota y de perro:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#!/usr/bin/env perl

use strict;
use warnings;

use Perro;

my $perro = Perro->new(); # Creamos un Perro

$perro->tienesHambre(); # Le preguntamos si tiene hambre

$perro->darDeComer(); # Le damos de comer

$perro->tienesHambre(); # Le preguntamos de nuevo

$perro->ladra(); # Y ladra

Eso prueba la herencia de un archivo,veamos la herencia en otro,para eso vamos a crear la clase Gato,toda la clase sera igual solo con sus funciones únicas de un Gato:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package Gato;
use feature 'say';
use parent 'Mascota';

sub new 
{
    my $class = shift;
    my $self = $class->SUPER::new();
    return $self;
}

sub maulla 
{
    say 'miau';
}
1;


Ahora en el programa principal podemos hacer esto:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env perl

use feature 'say';
use Perro;
use Gato;

my $perro = Perro->new();

$perro->tienesHambre();

$perro->darDeComer();

$perro->tienesHambre();

$perro->ladra();

my $gato = Gato->new();

$gato->maulla();

$gato->tienesHambre();



Como ven el Gato hereda las funciones y variables de Mascota,al igual que el Perro.  Tambien podemos poner todo en un mismo archivo.

Como dije en Perl se pueden hacer las cosas de muchas formas esto es un ejemplo de otra forma de herencia en Perl:

Enlace 

Mas informacion :  perldoc.perl.org
Leer más...

domingo, 29 de diciembre de 2013

Programacion Orientada a Objetos con Perl parte 1

La programación orientada a objetos en perl es un poco rara(para los que no conocen bien este lenguaje),he visto que dicen que no existe,la OOP(de ahora en adelante) en Perl es como en Lua,estamos usando tipos de datos de distintas formas en conjunto para crear un objeto,de hecho en Perl la OOP es lo mas básico que hay porque de no ser así no existirían tantos módulos de CPAN(pureperl) y vamos que CPAN es famoso por sus miles de módulos :D.

Bien,en Perl para definir una clase la podemos definir en un archivo .pm o en el mismo archivo .pl(u otra extensión),en este caso vamos a usar un archivo .pm.

Perl busca los módulos al igual que otros lenguajes,como Python,Ruby,etc primero en su PATH y luego en el directorio actual(cual sea el principio),para tener una clase que cree un objeto,vamos a crearlo en la misma carpeta:

En este caso vamos a usar dos,el principal:

vim principal.pl

Y una clase que se llame persona:

vim persona.pm

Si la clase persona.pm estuviera en un subdirectorio,por ejemplo que hiciéramos dos módulos uno para test y otro "oficial" seria así:



Bien en el modulo principal estas serian las lineas principales de siempre:


1
2
3
4
#!/usr/bin/env perl

use strict;
use warnings;

Y la clase lo añadimos asi:

use persona;

Si estuviera en test tendrías que usar cuatro puntos,ya que así es como perl ve los directorios:

use test::persona;

Bien,en la clase persona vamos a usar un constructor de clase llamado new,no necesariamente debe ser llamado new,puede ser otro nombre que no sea una palabra reservada del lenguaje,pero usare new ya que es lo que dice perldoc:

Primero que nada todo aquí son subrutinas,metodos,los cuales reciben parámetros que manipulamos con las variables especiales:

$_ y @_ o sus funciones shift,unshift

El argumento que recibiremos en la creacion de la clase sera la clase misma:

my $class = shift;

En este caso $class contendrá el nombre de persona,esto es para que sepa a que clase pertenece,ahora lo que tenemos que hacer es crear un hash para trabajar con los datos miembro:

my $self = {};

Luego debemos asociarlos de alguna manera,bless se encarga de eso:

bless $self,$class;

Ya lista la asociación devolvemos $self para que el objeto creado haga referencia a el:

return $self;

Así queda nuestro constructor:


1
2
3
4
5
6
7
sub new
{
   my $class = shift;
   my $self = {};
   bless $self,$class;
   return $self;
}

Algo muy importante es que al crear una clase nueva siempre lo primero que deben escribir es :


1
2
3
package nombre;
 # Aqui toda la clase
1;


En package tenemos que poner el nombre de la clase o paquete,debe ser el mismo del archivo(respetando mayúsculas y minúsculas) solo que sin la extensión:

1;

Es un retorno a true,que necesitan los paquetes para que funcionen,vamos a ver un poco de lo que serian set y get:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
sub setName
{
    my $self = shift;
    $self->{NOMBRE} = shift;
}

sub getName
{
    my $self = shift;
    if ($self->{NOMBRE})
    {
        return $self->{NOMBRE};
    }
    else
    {
        return "Sin sombre";
    }
}

Cuando llamamos una función el parámetro que se nos pasa primero es el self,la referencia del hash que estamos usando,y lo demás puede ser cualquier cosa,por ejemplo en setName podemos hacer también esto:


1
2
my ($self,$n) = @_;
$self->{NOMBRE} = $n;


Bien ahora en el archivo principal vamos a crear un objeto persona:

Asi queda todo el codigo de ejemplo:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#!/usr/bin/env perl

use warnings;
use strict;
use feature 'say';
use test::persona; # ./test/persona.pm

my $atheyus_tux = persona->new();

say $atheyus_tux->getName();

$atheyus_tux->setName("Atheyus");

say $atheyus_tux->getName();



Bien como vemos es muy sencillo,ahora vamos a ver como usar metodos internos desde la misma clase:

Gracias a bless $self esta a referencia con $class que a la vez es un shift que contiene el nombre del paquete en el ejemplo mas sencillo,pues gracias a esto $self puede usar funciones internas simplemente con llamarlas:

Por ejemplo una función que no permite  mostrar el nombre:


1
2
3
4
5
6
7
sub borraNombre {
    my $self = shift;
    if ($self->{NOMBRE}) # Si existe el nombre
    {
        $self->{NOMBRE} = "Borre el nombre"; # Cambiamos el valor
    }
}


Ahora lo podemos usar en la función getName:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
sub getName {
    my $self = shift;
    $self->borraNombre(); # Lo llamamos
    if ($self->{NOMBRE}) {
        return $self->{NOMBRE};
    } else
    {
        return "Sin sombre";
    }
}


Tambien podemos crear un destructor para que destrulla las variables asociaciadas al hash:


1
2
3
4
5
sub destruye
{
   my $self=shift; #El primer parámetro de un metodo es la  clase
   delete ($self->{NOMBRE});
}


Hasta aquí la primera parte en la siguiente hablaremos de herencia,pero de momento es todo,como vemos es un ejemplo sencillo pero no se trata de eso si no de que así como es de simple el ejemplo así de simple se entienda.


Codigo completo: principal.pl

Codigo completo: persona.pm

Leer más...

miércoles, 9 de octubre de 2013

Juego de ahorcado en multijugador Perl

Pues reinvente la rueda :P,ya la había reinventado en la primera versión de todos modos,pero bueno el hecho es que tengo cierta temática sobre eso de reinventar la rueda porque una cosa en no aportar nada y otra cosa es saber como funcionan las cosas.

Por ejemplo cuando las personas se dedican al pentesting o hacking,por así decirlo muchos les dicen que son lammers o script kiddies por usar programas de los demás,pero puede ser lo mismo usar programas hechos por otros o reinventar la rueda programando esos programas nosotros mismos,la verdad es que pocos son los inventores en el mundo y lo digo por las muchas alternativas que hay de algo en vez de algo nuevo,pero esta el otro lado de la moneda, programar algo que ya esta hecho solamente para saber como funciona y ese es mi caso yo si programo algo que ya existe no es porque me digan script kiddie o lammer es para saber como funciona,aunque con los diagramas de algoritmos bastaría ya que algunos los entregan como es el caso de arpon .

Así que aquí otra versión de este popular juego.

Bueno vamos a ver el juego:

Le añadí la opción de dos jugadores,el cual consta de que un jugador escriba la palabra que tiene que descifrar el otro,ademas de que añadí un marcador de puntos basado en el calculo de las palabras,sea de manera individual o multijugador:







El juego lo pueden descargar en el enlace siguiente:

Enlace

Lo descomprimen y abren una terminal donde se descomprimió,luego ejecutan:

perl ahorcado.pl

Espero que les sirva el juego para que se diviertan o para que estudien los algoritmos que usa y como vemos se pueden programar juegos sin SDL ni imágenes como con pygame,Lua,C,etc(bueno ahí salio una imagen de un juego pero es el fondo de la terminal),solo usando la consola :D.
Leer más...

miércoles, 4 de septiembre de 2013

[ Shell ] Acceder a formularios web desde terminal

Esto mas bien es de perl,pero entra en los tutoriales de shell por si necesitan esto y no conocen perl.

Bien,primero que nada voy a explicar de que se trata esto:

De lo que se trata esto de la posibilidad de poder rellenar formularios web desde la misma terminal,ya se solo por probar una url,o por otros propósitos.

Bien pondré de ejemplo mi sitio que tengo en mi localhost que se llama:

mi_blog_de_ejemplo.net/
El sitio esta en wordpress,así que el login se lleva a cabo en el url(wp-login.php):

http://mi_blog_de_ejemplo.php

Ahora como me puede logear desde la consola?

Bien,es un ejemplo esto,podemos usar esto con formularios como el de blogger,o como el search de esta pagina que esta arriba a la derecha:

Primero que nada vamos a instalar/actualizar los módulos perl necesarios:

sudo cpan WWW::Mechanize::GZip
sudo cpan  LWP::UserAgent
Terminados de instalar,podemos comenzar a escribir el script:

#!/usr/bin/env perl

use warnings;
use strict;
use WWW::Mechanize::GZip;

Vamos a definir una variable con el url del sitio:

my $url = "http://mi_blog_de_ejemplo.php";

Ahora vamos a crear un objeto de Mechanize:

my $mech = WWW::Mechanize::GZip->new();

Vamos a llamar la url:

$mech->get($url) || die $!;

Y por ultimo vamos a pasar los parametros:

Los fields y el nombre del form,como sabemos o si no saben wordpress usa los fields,pwd y log en la form loginform:

Así que :

my $respuesta = $mech->submit_form(
        form_id => "loginform",
        fields => {
        log => "user",
        pwd => "password"
});

Y listo imprimimos la respuesta:

print $respuesta->content();
Esto nos imprime en la pantalla el contenido html de la pagina,sea o no sea el usuario y la contraseña,lo que hace es exactamente como si lo hiciéramos a clic desde el navegador.

También cuenta con opciones de cookies,user agent,y si por ejemplo no hay id del formulario podemos acceder a ellos con el numero que tendrían ordenándolos:



Por ejemplo :

#!/usr/bin/env perl
#
use warnings;
use strict;
use WWW::Mechanize::GZip;

my $url = "http://desdelinux.net";

my $mech = WWW::Mechanize::GZip->new();

$mech->agent_alias("Linux Mozilla");

$mech->get($url) || die $!;

my $respuesta = $mech->submit_form(
   form_number => 1,
   fields => {
              s => "archlinux"
   }
);


print $respuesta->content();


Y si por ejemplo metieron el script en un archivo llamado script.pl pueden probar este comando:

perl script.pl > pagina.html && xdg-open pagina.html

Les dejo un script un poco mas detallado:

Enlace
Para mas información,en terminal :

perldoc WWW::Mechanize::GZip

Leer más...

martes, 27 de agosto de 2013

[Shell] Juego de ahorcado en Perl

Bueno,estaba un poco aburrido hace unos días y me programe este juego de ahorcado en perl,sirve sin módulos,solamente lenguaje perl,ya que no tenia Internet en ese momento para instalar algún modulo que le ayudara a verse mejor.

Para jugar bajan el paquete zip:

Enlace
Versión 2:

Enlace

Y lo descomprimen.

Luego entran a la la carpeta desde terminal,o con nautilus/dolphin y le dan abrir en terminal y escriben:

perl ahorcado.pl

Y eligen una categoría,por defecto esta una categoría de programación con nombres de lenguajes de programación,pero si quieren añadir mas solo entran a la carpeta categorías y crean un archivo con el nombre de la categoría con extensión .txt y adentro de este meten las palabras para jugar de esa categoría.


Las letras se ven rojas por la configuración de mi $PS1,eso es todo,luego le pongo modulos para mejorar la función clear que no me gusto nada usarla,o un modo multijugador en modo online local,etc.

Leer más...

sábado, 20 de julio de 2013

Como usar MongoDB con Perl

Tutorial Perl MongoDB scripting


Como prometí en un comentario,aquí un tutorial de como usar MongoDB desde un script en Perl,el cual luego podemos usar en GUI,Diseño Web,etc en otra ocasión lo haré en python pero de momento en Perl.

Primero que nada se supone que ya debemos tener instalado MongoDB,si no es así consulta lo documentación o busca si ya esta en tu distribución de Linux(Si usas Linux):

Por ejemplo en Ubuntu/Debian:

aptitude search mongo

Gentoo:

emerge –search mongo
Y luego lo instalamos :

sudo apt-get install mongodb

etc


Bueno,también necesitamos el modulo MongoDB de Perl,así que lo instalamos desde CPAN:

En terminal:

sudo cpan install MongoDB


SI usan Windows,pueden instalar desde la GUI que traen las versiones de Perl,dependiendo cual usen,con el nombre MongoDB.

Ahora vamos a crear el script para Shell:

Con su editor favorito:

vim mongo.pl

Y metemos:

 #!/usr/bin/env perl # <-Hashbang  
   
 use MongoDB; # <- Modulo  
 use MongoDB::Database; <- Submodulo  
 use strict;  
   
 use warnings; # <- Para desarrollo  
   
 # Definimos algunas variable para conectarnos a la Base de Datos  
 # Como el nombre de la base de datos   
 # El puerto,etc  
   
 my $database = "test";  
   
 my $puerto = 27017;  
   
 my $host = "localhost";  
   
 # Iniciamos la conexion  
   
 $host = sprintf("%s:%s",$host,$puerto);  
   
 my $cliente = MongoDB::MongoClient->new("host" => $host );  
   
 # Nos conectamos a la base de datos  
   
 my $base_datos = $cliente->get_database( $database );  

Esa es la plantilla basica de conexion,ahora vamos a ver algunas cosas que se pueden hacer:

Listar las collections:

Para ello usamos un array

 my @collections = $base_datos->collection_names;  
   
 for (my $i = 0; $i < scalar(@collections); $i++)  
 {  
   print $collections[$i],"\n";  
 }  

Definir una collection:

 my $collections = {};  
   
 my @collections = $base_datos->collection_names;  
   
 for (my $i = 0; $i < scalar(@collections); $i++)  
 {  
   print $i,":",$collections[$i],"\n";  
 }  
   
 my $coll = {};  
   
 print "Elige una base de datos : ";  
   
 my $R_c = <STDIN>;  
   
 chop($R_c);  
   
 $coll->{$collections[$R_c]} = $base_datos->get_collection($collections[$R_c]);  



Eso se hace mas simple pero yo use una referencia para acceder a barias collections,ahora ya estamos en una collection adentro de la referencia:

$coll;

También podemos hacer algo mas simple manualmente como;

 my $coll = $base_datos->get_collection('collection');

Buscar un objeto:

Para buscar un objeto solo basta con asignar una variable al objeto,ya que solo es uno:

Pero aunque nos devuelva un solo valor covertira la variable a un hashref,ya que al usar formato estilo JSON debemos iterar sobre un valor de tipo diccionario,si usan,usaban MySQL no hay problema se hace lo mismo para recorrer los valores:

 my $object = $coll->{$collections[$R_c]}->find_one();  
   
 foreach my $keys(keys $object)  
  # Con un foreach basta  
 {  
   print $object->{$keys},"\n";  
 }  

Buscar todos los datos de una collection:

Si no queremos buscar uno y queremos ver todos los datos podemos usar un bucle foreach anidado en un while desde la funcion find del modulo MongoDB:

 my $all = $coll->{$collections[$R_c]}->find;  
   
 while (my $doc = $all->next) {  
   foreach my $keys (keys $doc)  
   {  
     print $doc->{$keys}," ";  
   }  
   print "\n";  
 }  

Insertar datos:

Para insertar datos debemos estar en la collection,así que el código iría debajo del anterior o en vez:

 $coll->{$collections[$R_c]}->insert({  
     "_id" => 2,  
     "value" => "Hola Mundo desde Perl y MongoDB"  
   });  


Les dejo un script con todo lo que hicimos:

Enlace

Bueno y eso es lo básico,conexión,consulta y insertar,para mas información visiten el tutorial de CPAN:

http://search.cpan.org/~friedo/MongoDB-0.701.4/lib/MongoDB/Tutorial.pod
Leer más...

domingo, 7 de julio de 2013

Tutorial Perl MySQL Consulta

Bueno,es raro que hable de MySQL en este blog pero en fin,vamos a ver como usarlo en perl,se suponer que debes saber algo de MySQL y de Perl para entender este tutorial,pero aun así lo haré un poco didáctico:

Primero que nada necesitamos instalar el modulo DBI de perl,lo mas seguro es que ya lo tengas,pero si no es así lo instalamos desde terminal con :

sudo cpan DBI 

Bien,ahora vamos a usar un script para ver su funcionamiento,el script se usa desde la terminal,recuerden que la terminal sirve para muchas cosas,entre ellas probar los algoritmos antes de usar GUI o Diseño Web.

Iniciamos(lo que esta en morado iremos escribiendo en el script):

Definimos el hashbang y llamamos a DBI:

#!/usr/bin/env perl

use DBI;

Ahora definimos los datos de acceso:

El usuario:

my $user = "usuario";

La base de datos:

my $db = "base_de_datos";

El host:

my $host = "mi_host";

El puerto(regularmente es el 3306 a menos que tu mismo o el administrador lo hayan cambiado):

my $port = "3306";

Si no sabes cual es y tienes nmap,puedes averiguarlo con:

nmap host | grep --color sql
También vamos a guardar una tabla:

my $table = "tabla"; 

Y el password:

my $pass = "password";

Si no quieres guardarlo a fuego(adentro del script),puedes usar STDIN desde la shell:

print "Password : ";

my $pass = <STDIN>;

chop($pass);

O incluso hacer invisible la shell,o usar un shasum,etc.

Ahora vamos a crear un variable de información para MySQL:

my $info="DBI:mysql:database=$db;$host:$port";

Vamos a crear una variable tipo referencia para guardar la conexión:

my $dbh = DBI->connect($info,$user,$pass);

Por ultimo vamos a preparar un query para consulta:

my $query = "Select * from $table"; # Orden MySQL

Ahora preparamos la query:


my $sth = $dbh->prepare($query); 

Y ejecutamos:

$sth->execute();

Con eso ya establecimos nuestra conexion MySQL,ahora para ver los valores de la tabla,solo hace falta ver en ellos:

Creamos una referencia:

my $referencia = $sth->fetchrow_hashref()

Y podemos recorrer sus valores con un foreach:

foreach my $keys (keys $referencia)
  {
        print  " $keys => $referencia->{$keys}";
  }

Eso en el caso de ser solo una linea si es mas de una se recomienda usar un buble while asi:

my $referencia;
my $n = 0; # Creamos un numero para guardar el nombre de los valores
while($referencia = $sth->fetchrow_hashref())
 # Llenamos el valor de la referencia con nuevos valores
{
if ($n == 0)
{
    foreach my $keys (keys $referencia)
    {
        print  " $keys"; # Imprimimos las columnas
    }
}
print "\n";

foreach my $keys (keys $referencia)
  {
        print  " $referencia->{$keys}"; # Imprimimos las columnas
  }
$n++;
}
print "\n";

Con eso simulamos la impresion de MySQL,tendriamos que ponerle una barras tipo exel,pero con eso nos manda la impresión tabla columna de MySQL.

El script completo queda así:

Enlace
Eso es todo,no lo explico mas porque no tengo tiempo,pero si tienen dudas comenten.

Como ven es un uso de shell,pero así se inicia todo,esto se podría hacer un tipo phpmyadmin en programación web o programa en Gtk/Qt/etc para sistemas operativos:





Eso es todo :D.

Mas información.



Leer más...

domingo, 23 de junio de 2013

Saber el numero mayor de un array Perl

En ocasiones necesitamos saber cual es valor mas alto numéricamente hablando,de un array o de un hash,en esta ocasion veremos los array,el algoritmo es simple:

1.Definir un valor a 0

2.Recorrer el array y comparar el valor de cada elemento con el de 0.

3.Como es obvio esperar un valor mayor a 0 cambiamos el valor de 0 al valor del elemento del array.

4.Regresamos al paso 2

Eso en Perl luce asi:



 #!/usr/bin/env perl  
 my @prueba = ( 8,1,2,2,6881);  
 print num_mayor(@prueba),"\n";  
 sub num_mayor  
 {  
   my @array = @_;  
   my ($n,$mayor) = (0,0); # Definimos dos numeros para trabajar el bucle  
   while ($n < scalar(@array)) # Recorremos el array  
   {  
     if ($mayor >= $array[$n]) # Vemos si es mayor o igual  
     {  
       $mayor = $mayor; # Si es asi sigue teniendo su valor  
     }  
     else # Si no es asi  
     {  
       $mayor = $array[$n]; # Obviamente es menor y le ponemos un nuevo valor  
     }  
     $n+=1; # Interaccion  
   }  
   return $mayor if ($mayor != 0); # Regresamos valor si no es 0  
 }  


Es simple el algoritmo,y podemos hacerlo en C,PHP,Lua,Javascript,etc,por ejemplo en ruby:


O en python me gusta usar un "truco",voltear la lista y imprimir el primer valor que debería ser el numero mayor:

 #!/usr/bin/env python3  
 prueba = [2,4,3,222,12]  
 def num_mayor(x):  
   mayor = sorted(x)  
   mayor = mayor[::-1]  
   return mayor[0]  
 print (num_mayor(prueba))  

En perl no se si existen estas funciones,porque hemos hablado de pop,shift,etc pero trabajan diferente,de todas formas me gusta parsear,para ver como funcionan las funciones del lenguaje de programación :D.

Espero que les sirva.
Leer más...

martes, 28 de mayo de 2013

Abrir directorio con Perl Linux

Muchas veces necesitamos abrir un directorio desde Perl para un script o un programa,esto lo podemos hacer desde las funciones de perl con los comandos opendir,readdir y closedir.

Bien,primero que nada para abrir un archivo necesitamos decir la carpeta que vamos a usar,en este caso vamos a definir el usuario así:

my $user = getlogin();

Ahora el Directorio,por ejemplo nuestro Home:

my $dir = "/home/" . $user;

Ahora vamos a abrir el directorio con la función opendir:

Definimos una variable que usaremos para leer el directorio,en este caso $recorrer:

opendir(my $recorrer, $dir) || die "Error :( $! \n";  

Ahora iniciamos un bucle while para que recorra el directorio,usando la variable que creamos al abrir el directorio:

 while(readdir $recorrer) {  
 # Codigo  
 }  

Cuando terminemos de recorrer y usar el directorio lo cerramos con el comando:

closedir $recorrer;

Eso es todo,al recorrer con un bucle while los archivos del directorio los guarda en su recorrido en la variable especial $_ ,veamos un ejemplo de como guardar los datos de un directorio en dos arrays:

#!/usr/bin/env perl  
my $user = getlogin();  
my $dir = "/home/" . $user;  
my (@archivos,@dirs) = ((),()); # Creamos dos arrays vacios  
opendir(my $recorrer, $dir) || die "Error :( $! \n";  
while(readdir $recorrer)  
 {  
   if (-d $dir . "/" . $_) { # Vemos si es un directorio  
     push (@dirs,$_); # Si es asi llenamos el array de directorios  
   }  
   if (-f $dir . "/" . $_) { # Hacemos lo mismo con los archivos  
     push (@archivos,$_);  
   }  
 }  
=pod  
 Aclaraciones  
 $dir . "/" . $_ # concatenamos los archivos del directorio para poder saber de que archivo trata  
 -d # Es para saber si es un directorio  
 -f # Es para saber si es un archivo  
 push # Añade un valor a un array  
=cut  
closedir $recorrer;  
foreach my $files(@archivos) { # Recorremos los arrays  
   print "Archivos : $files\n";  
}  
foreach my $directorios(@dirs) {  
   print "Directorios : $directorios\n";  
} # O hacemos lo que queramos con ellos  



Otra forma de hacer esto es con el modulo DirHandle,veamos:

#!/usr/bin/perl  
use DirHandle;  
my $user = getlogin();  
my (@archivos,@dirs) = ((),()); # Creamos dos arrays vacíos  
my $dir = "/home/" . $user;  
$directorio = DirHandle->new("$dir"); # Definimos directorio  
while ($_ = $directorio->read) { # Lo leemos  
   if (-d $dir . "/" . $_) {  
     push (@dirs,$_);  
   }  
   if (-f $dir . "/" . $_) {  
     push (@archivos,$_);  
   }  
 }  
undef $directorio; # Indefinidos el valor para cerrar el archivo  
foreach my $files(@archivos) {  
   print "Archivos : $files\n";  
}  
foreach my $directorios(@dirs) {  
   print "Directorios : $directorios\n";  
}  

Bien,eso es todo,use foreach para recorrer el array,pero podemos usar for,while ademas de que podemos usar las funciones de array,pop,push,sort,etc.

Eso es todo :D
Leer más...