[ Shell ] Buscar archivos desde terminal con find

En esta ocasión aprenderemos como buscar archivos desde la terminal,algo muy básico ya que es de lo mas común que se hace en un sistema,buscar archivos.

Tal vez en el futuro veamos tutoriales de seguridad informática y les aseguro que solo vamos a usar este tipo de comandos.

Para empezar para que queremos usar este buscador si el explorador cuenta con uno propio?

Find es un programa tipo consola un backend para buscar archivos,y no solo encuentra lo que le digamos sino que podemos ejecutar una accion basado en eso,como borrar,reproducir,copiar,mover,etc.

El filtrado es muy poderoso y la respuesta tambien(el tiempo que tarda en buscar).

La sintaxis mas básica del programa es la siguiente:

find ruta -name nombre

En donde ruta es la ruta,como hemos visto en Unix:

. => Directorio actual

../ => Un direcotorio para atras

~ => Nuestro home

/ => Raiz

etc.

-name => Va seguido de un argumento que es el nombre.

Para el nombre podemos hacer algo muy exacto como:

-name "archivo123.txt"

Y busca el archivo123.txt en la ruta que le indicamos,o podemos hacer un filtrado con regex de Unix:

-name 'archivo???.txt'

-name 'arc*.txt'

etc.

En el caso de una regex de comodines como los anteriores podemos usar esta sintaxis:

-name \arc*.txt

Ya que no hay problema de espacios,en otro caso usar la regex entre comillas simples,o incluso el parámetro -regex.

Podemos hacer uso del parámetro -user para encontrar solo archivos pertenecientes a un usuario en especial,por ejemplo buscar archivos de root que esten en nuestro home:

find ~ -name \* -user root

Podemos hacer uso del parámetro -group para buscar un archivo que pertenezca ha ese grupo:

find ~ -name \* -group 100

El parámetro es numérico,100 es el grupo users(para mas info googlear groups id unix)

Tenemos algunas opciones para enlaces simbólicos:

-P => Nunca seguir

-L => Seguir

Podemos buscar ejecutables(archivos con permisos de ejecucion) con el parametro -executable,por ejemplo buscar script's en shell ejecutables en nuestro home:

find ~ -name \*.sh -executable -user $LOGNAME

También podemos listar los detalles de los archivos encontrados,con el parámetro -ls:

find . -name \*.sh -executable -ls

El cual nos muestra: El usuario,el grupo al que pertenece,los permisos,la fecha del ultimo

Puede que halla archivos y directorios con el mismo nombre,así que podemos evitar encontrar archivos y directorios,mostrando solo lo que queramos con el argumento -type{d para directorios,f para archivos}:

find ~ -name \*py* -type d # Directorios de python(por ejemplo)

find ~ -name \*py* -type f # Ficheros de python(por ejemplo)

Otros argumentos,l link,p FIFO,s socket.

Podemos buscar archivos basados en permisos con el parámetro -perm,por ejemplo buscar todos los script's en shell con permisos 775:

find . -name \*.sh -perm \755

Por ultimo tenemos el parametro -exec que nos permite ejecutar un programa y pasale el resultado de la búsqueda como argumentos:

Por ejemplo buscar todas las fotos .png y verlas con feh:

find ~ -name \*.png exec `which feh` {} +

Se recomienda poner toda la ruta del ejecutable,pero si no sabemos donde esta podemos buscarla con el comando which seguido del nombre del programa encerrado en esas comillas que no recuerdo como se llaman :P.

Eso es todo,no es todo,pero es lo que me parece mas importante para uso basico,para mas info,en terminal:

man find

Ultimo ejemplo del poder de find:

Buscar todos los videos,mp4 y reproducirlos con totem:

find ~ -user $LOGNAME -name \*.mp4 -exec `which totem` {} +

Eso es todo :D.

Leer más...

Abrir y escribir en archivos con lua (IO Library)

Los dos tutoriales anteriores han sido sobre lua,y van a ser muchos mas,en estos momentos ya se aprendio sobre tipos de datos y condicionales con estructuras de seleccion y de repeticion,asi que ya se puede entender perfectamente como abrir un archivo de texto y leerlo,modificarlo o crear uno y escribir en el.

Primero que nada vamos a usar las librerias del moudlo io de lua,Input,Output,entrada y salida,normalmente podriamos hacer un require para llamarlo,pero no es necesario en lua a menos que queramos cambiar el nombre del modulo,pero bueno,para no confundirnos de que modulo estamos usando podemos poner en la cabecera del archivo los require:

require 'io'

O entre comentarios,por si hacemos un programa grande y no recordamos que modulos usamos.

Primero que nada Lua es muy similar a C,ya que la función que vamos a usar se parece a fopen,de C solo que un poco diferente,creamos un objeto desde el momento que abrimos un archivo,y en C creamos un puntero,bueno de todas formas vamos a ver como se hace:

Primero que nada definimos una variable con el nombre del archivo,en lua se recomienda que las variables las comencemos con local,ya que si no es así tendrían ámbito en todo el programa,esta es la forma de privatizar variables,funciones,etc:

local filename = "Arechivo.txt"

Ahora debemos crear un objeto que abra el archivo o lo cree en dado caso,con la funcion(io.open):

file = io.open(filename,modo)

En donde dice filename,es el nombre del archivo,desde una variable o crudo(una string),en modo es el modo de apertura:

w : Abre o crea un archivo en modo escritura(borra el contenido si existe)

r : Abre el archivo en modo lectura

a : Abre el archivo en modo adición(no borra el contenido si existe)

Hay mas.

Ahora debemos hacer lo que queramos:

Para leer un archivo linea por linea debemos iterar con un bucle for,hasta que termine de leer el archivo:

Para leer todo un archivo:

Primero que nada debemos saber que no necesariamente debemos crear un objeto,para trabajar con el,podemos abrilo simplemente pasandole el nombre del archivo:

for line in io.lines(filename) do  print (line) end

Vamos como enumerar las lineas de un archivo

n = 1

for line in io.lines(filename) do 

  io.write(n) 

  print (line)

  n = n + 1 

end

Para escribir en un archivo se pude desviar el STDOUT(salida estandar),ya que normalmente es en el prompt(terminal,consola),podemos desviarlo a un archivo,así:

io.output(io.open(filename,"w"))

Ahora si escribimos durante todo el programa,la orden de io,write,que es con el que escribe en la consola,ahora escribira en el archivo:

io.write("Hola este es un ejemplo\n")

io.write("Desde io.write\n")

Cuando terminemos cerramos el io:

io.close()

De esa manera se puden leer y escribir en archivos,pero no es la mejor manera,la mejor manera es usar un objeto:

file = io.open(filename,modo)

Y luego usar sus funciones de clase,para empezar lua usa notacion de dos puntos(:),para las clases,para recorrer un archivo linea por linea se usa esta sintaxis:

file = io.open(filename,"r")

for line in file:lines() do print(line) end

Para escribir en un archivo de texto se usa esta sintaxis:

file = io.open(filename,"w")

file:write("Texto\n")

Y en ambos casos se debe cerrar el archivo,cuando se termine de hacer lo que se tiene que hacer:

file:close()

Veamos un programa mas complejo:

 #!/usr/bin/env lua  
 repeat   
  io.write("Nombre del archivo: ")  
  filename = io.read()  
 until filename ~= ""  
 n = 1  
 file = io.open(filename,"w")  
 print ("Escribe EOF para salir...")  
 while true do  
  io.write("Linea "..n.." : ")  
  local response = io.read()  
  if response == "EOF" then break end  
  file:write(response.."\n")  
  n = n + 1  
 end  
 io.close()  

Eso es todo :D

Leer más...

Tutorial lua en linux (condicionales)

En esta parte de los tutoriales de Lua aprenderemos a usar condicionales o como aprendí a decirles,estructuras selectivas las cuales deciden que "camino" elegir para un programa,y decidir que ejecutar basado en esta elección.

Tenemos de ejemplo esto:

Voy a usar mi pc con Internet,primero debo ver si tengo electricidad,si tengo la prendo,si no la conecto o no la prendo,luego si la prendo necesito Internet,si hay lo uso,si no hay me conecto a wifi,etc.

Vamos a ver un ejemplo y después lo explico:

 #!/usr/bin/env lua  
   
 -- Vemos si tiene energia la pc  
   
 t = {"Si","No"}  
   
 math.randomseed(os.time())  
   
 num = math.random(1,2)  
   
 -- ^ Funciones para elegir un numero al azar y asociarlo a una respuesta  
   
 res = t[num] -- Asociamos respuesta  
   
 function enciende()  
     repeat  
       io.write("Encender? (S/N):")  
       response = io.read()  
     until response == "S" or response == "N"  
     if response == "S" then  
       print("Encendida :D")  
       while true do  
         io.write("Ejemplo terminado\nEscribe exit para salir: ")  
         local response = io.read()  
         if response == "exit" then  
           break  
         end  
       end  
       os.exit(0)  
     else  
       print ("No encendida")  
       print ("Hasta luego")  
       os.exit(0)  
     end  
 end  
   
 while true do  
   if res == "Si" then  
     print ("Tienes energia")  
     enciende()  
   else  
     print("No tienes energia")  
     repeat  
       io.write("Conectar a la luz? (S/N):")  
       response = io.read()  
     until response == "S" or response == "N"  
     if response == "S" then  
       res = t[1]  
     end  
     if response == "N" then  
       print ("No conectada,hasta luego.")  
       os.exit(0)  
     end  
   end  
 end  
   

Ahora lo ejecutan y podrán ver lo practicas que son las selecciones:

En este caso vimos las palabras especiales:

if,else,while,repeat,until,end

Primero que nada debemos saber que una estructura selectiva siempre decide basado en una condición verdadera,aunque esta sea falsa a simple vista:

Me explico,cuando un lenguaje de programación elige una acción se basa en una decisión verdadera,lógica booleana,verdadero o falso,en este caso en lua solo admite,false o true:

Vamos a ver unos ejemplos:

1 es igual a 1 -- Es verdadero

2 es igual a 1 -- Es falso

1 no es igual a 2 -- Es falso

1 es menor a 10 -- Verdadero

1 es mayor a 10 -- Falso


Para usar esto en lua se usan los simbolos de asociacion:

== -- Igual a

=~ -- No igual a

< -- Menor a

> -- Mayor a

<= -- Menor o igual a

>= -- Mayor o igual a

Ahora vemos los ejemplos de arriba con simbolos

1 == 1 -- Es verdadero

2 == 1 -- Es falso

1 ~= 2 -- Es verdadero

1 < 10 -- Verdadero

1 > 10 -- Falso

Bien sabiendo eso podemos usar las elecciones de control:

Las cuales son:

Si..
Si no..
No

La sintaxis es:

if condicion then -- Condición principal

elseif condicion then -- Segunda condición(opcional)

else -- Error en condicionales anteriores(opcional,es para manejo de errores)

end

Vamos a ver un ejemplo:

 uno = 1  
   
 if 1 == 1 then  
   print ("Es verdadero")  
 elseif 2 == 1 then  
   print("Es falso")  
 elseif 1 ~= 2 then  
   print ("Es verdadero")  
 elseif 1 < 10 then  
   print ("Verdadero")  
 elseif 1 > 10 then  
  print("Falso")  
 else  
   print("Otro valor")  
 end  

Si ejecutamos ese codigo obiamente no veremos la palabra es falso,ya que al ser falso no entra en la condicion,de hecho no pasa a las siguientes estructuras si encuentra una verdadera primero.

Si queremos probar todas las posibles concidencias verdaderas tendriamos que usar solo if's:

 if 1 == 1 then  
   print ("1 == 1 : Es verdadero")  
 end  
 if 2 == 1 then  
   print("2 == 1 : Es falso")  
 end  
 if 1 ~= 2 then  
   print ("1 ~= 2 : Es verdadero")  
 end  
 if 1 < 10 then  
   print ("1 < 10: Verdadero")  
 end  
 if 1 > 10 then  
   print("1 > 10 : Falso")  
 end  
   

Algo muy importante de lua es que no necesita identacion ni punto y coma,como es el caso de python en identacion(sangria) y perl(punto y coma),lua usa el estilo shell scripting o el de ruby,usa llaves de terminación,en el caso de if,else,elseif usa:

then -> end

o mas adelante veremos:

do -> end

Por ejemplo podemos hacer una if en una linea:

if 1 ~= 2 then print ("1 ~= 2 : Es verdadero") end

Pero como siempre hay reglas de una buena programación y es bueno identar,comentar,usar varias lineas,usar varios espacios de linea,etc.

Esas son las estructuras de elección,básica ahora vamos a ver las estructuras de repetición,también de elección ya que deciden igual basado en una respuesta booleana.

El primero es while,el cual repite el código hasta que su condición inicial termine,la sintaxis es:

while condicion do
    -- codigo a ejecutar
end

Con while podemos crear repeticiones infinitas (bucles infinitos),solo basta con crear una condicion infinita,una condición que no cambiara,por ejemplo:

while true do print("Bucle infinito") end

Si no tenemos una variable bandera o una terminación no esperada no terminara,a menos que cerremos el proceso del sistema.

Terminación inesperada con break:

while true do
    print ("Bucle no infinito)
    break
end

Terminación con variable bandera:

uno = 1

while uno == 1 do
    print ("Cambiamos el valor de uno,la variable que controla while")
    uno = 2
end

Bucle de repetición for,el bucle for se usa basado en una variable o variables banderas que hasta que terminen de recorrer su valor no se detendrá,la sintaxis es:

for var = inicio,final,argumento do
    -- codigo a ejecutar
end

Veamos un ejemplo de una cuenta hasta diez desde uno:

for var = 1,10 do
    print(var)
end

Una cuenta de 10 a uno:

for var = 10,1,-1 do
    print(var)
end

Una cuenta de 0 a 100 de 5 en 5:

for var = 0,100,5 do
    print(var)
end

Con un bluce while eso se puede escribir así:

var = 0
while var < 105 do
    print(var)
    var = var + 5
end

Normalmente lo que se puede hacer con un bucle se puede hacer con otro,otro ejemplo es el bucle repeat/until,solo que este es inverso al bucle while,el bucle while se rompe cuando la condición sea falsa y este se rompe cuando la condición sea verdadera:

var = 5
repeat
    print(var)
    var = var + 5
until var == 105

Pues eso es lo mas importante de las estructuras selectivas en lua,existen mas cosas como la iteracion,pero lo veremos cuando hable de funciones y tablas mas a fondo.

Leer más...

Tutorial lua en linux (variables,tipos)

Esta un poco muerto el sitio y como lo he dicho antes esto se debe a que no hay mucho de que hablar en linux,ya que mucha información que necesitemos esta a un simple comando:

man algo

Y es un poco aburrido hacer un tutorial de algo que nadie va a usar.

Lua es un buen lenguaje que se usa de diversas formas y aquí vamos a usarlo como script,como lo hacemos con Python,Perl y Bash.

Así que hola Lua :D y espero que les funcionen estos tutoriales.

Bien antes que nada vamos a instalar:

En ubuntu y derivados basta con:

sudo apt-get install lua5.2

Y es la versión que usaremos la 5.2,para otros sistemas solo usen los comandos que usan normalmente,por ejemplo:

En gentoo buscamos:

eix lua

Y luego instalamos el paquete.

Bien todo esto lo haremos desde la consola así que primero que nada vamos a crear una carpeta donde trabajar:

mkdir ~/Documentos/lua

Por ejemplo.

Y nos cambiamos a ese directorio:

cd ~/Documentos/lua

Ahora vamos a escribir el primer programa:

Con nuestro editor favorito(de consola) creamos un archivo llamado hola.lua:

Los archivos lua regularmente tienen la extensión .lua.

La primera linea del script puede ser el hashbang ya que podemos ejecutar el script como un ejecutable,así que es recomendable:

# : hash

! : bang

/usr/bin/env : Ruta del programa env que busca a lua

lua : Y el nombre del ejecutable que usa como parametro env

#!/usr/bin/env lua

Con eso ya podemos darle permisos de ejecución a nuestros scripts y los podremos correr sin llamar el lenguaje nosotros mismos,por ejemplo:

Con hashbang un programa se puede ejecutar así:

chmod +x /ruta/script.lua

y

/ruta/script.lua

o así:

lua /ruta/script.lua

Y sin el hashbang solo se puede ejecutar así:

lua /ruta/script.lua

Ahora la segunda linea puede ser un comentario los cuales inician con un doble guion medio,por ejemplo :

-- Este es mi primer script en lua5

Normalmente esas lineas son necesarias en todos los scripts aunque son opcionales,aunque menos opcionales que los módulos.

Así que todos nuestros script tendrán el hashbang y uno o mas comentarios.

El programa Hola mundo es un programa que se muestra por el stdout(standart ouput[Salida estándar]).

El cual podemos llevar a cabo con la función print de lua o con la función io.write:

print ("Mi primer programa en Lua :D")
io.write("Hola Mundo!!!\n")

Bien esa es la bienvenida,ahora vamos a ver algunos tipos de datos:

Primero que nada tenemos que almacenar nuestro valor en una variable:

Los cuales son string(cadenas de texto),encerradas en comillas o comillas dobles:

cadena = "Una cadena de texto"

Numeros (sin tipo,nada de flotante y entero,etc):

Por ejemplo:

num_f = 3.14

num_d = 10

Booleanos que son solo true y false(nada de 0 y 1),lua solo ve booleanos con las palabras especiales true o false.

bool = true

Funciones,como las que nosotros mismos crearemos en futuros tutoriales y las que trae programadas,como print.

Y nil que es un valor único el que se otorga a la nada(por así decirlo).

Si no me creen ejecuten este programa:

#!/usr/bin/env lua
-- Este es mi segundo script en lua5

cadena = "Una cadena de texto"
num_f = 3.14
num_d = 10
bool = true

print ("Variable cadena es : "..type(cadena))
print("Variable num_f es : "..type(num_f))
print("Variable num_d es : "..type(num_d))
print("Variable bool es : "..type(bool))
print("Print es :"..type(print))

Eso pudo haber salido mejor:

#!/usr/bin/env lua
-- Este es mi segundo script en lua5
--
cadena = "Una cadena de texto"
num_f = 3.14
num_d = 10
bool = true

vars = {cadena,num_f,num_d,bool}
tipos = {"Variable cadena","Variable num_f","Variable num_d","Variable bool"}

for i = 1,#tipos do
    print (tipos[i].." es : "..type(vars[i]))
end


Y aun mejor,pero es lo que aprenderán en estos tutoriales,pero eso me recuerda que están también los tipos de datos table,que antes usamos para crear un menú para awesome:

El cual se define de esta manera:

tabla = {"Hola","Mundo"}

print (type(tabla))

Esa es una tabla básica de una dimensión,a la cual podemos acceder a sus elementos usando corchetes indicando su valor comenzando desde uno.

print(tabla[1].." "..tabla[2])

Aunque el valor 0 esta definido (como nil),podemos cambiarlo,por ejemplo por el nombre de la tabla,pero por defecto se comienza a contar desde 1:

tabla[0] = "tabla"

print(tabla[0])

O también podemos hacer algo como esto:

tabla = {[0] = "Hola","Mundo"}

Pero eso lo veremos en una entrada dedicada,a las tablas por ultimo veremos paso de argumentos y leer valor desde el teclado:

Para pasar un parámetro se usa la tabla especial arg,con el valor que queramos usar comenzando desde el cero:

#!/usr/bin/env lua
-- Mi tercer programa con lua5

print("Nombre del programa: "..arg[0])

for i = 1,#arg do -- El # quiere decir el numero de valores de la tabla
    print(i..": Argumento => "..arg[i])
end

Podemos ejecutar nuestro script como esta en la imagen:

Otro ejemplo clásico:

#!/usr/bin/env lua
-- Mi cuarto programa en lua
--

if #arg > 0 then
    print("Hola : "..arg[1])
else
    print("Uso: "..arg[0].." <nombre>")     
end

También cabe aclarar que los argumentos comienzan con el 0,pero también cuenta lo que esta antes del nombre,por ejemplo si ejecutamos de esta manera:

lua script.lua uno

Estos serian los argumentos:

lua = arg[-1]

script.lua = arg[0]

uno = arg[1]

Bien ahora vamos a ver como se haría esto fácilmente desde la lectura del teclado(stdin[Standart input]):

#!/usr/bin/env lua
-- Mi quinto programa en lua
--

print("exit para salir")

while true do
    io.write("Escribe tu nombre: ")
    nombre = io.read() -- Funcion que usamos para stdin
    if nombre == "exit" then
        print("Hola : "..nombre.." :P")
        break
    else
        print("Hola : "..nombre)
    end
end

Como ven lua es sencillo y podríamos usarlo en administración del sistema o muchas cosas ya que cuenta con modulos desde JSON,hasta MVC Web,pero aquí termina el primer tutorial.

Leer más...

[ 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...