lsb_release -a

Te mostrará una salida parecida a la siguiente:

No LSB modules are available.
Distributor ID:Ubuntu
Description:Ubuntu 14.04.1 LTS
Release:14.04
Codename:trusty

¿Que versión de Ubuntu estoy usando? publicado en BajoLinux.

Además de ser una librería sencillamente fantástica, jQuery tiene una extensa documentación que merece la pena visitar.

A continuación os dejo 5 páginas de documentación donde encontrar funciones de las mas usadas en el día a día de un programador de jQuery.

Núcleo de jQuery

Información sobre funciones avanzadas, incluyendo la función jQuery. Esta es la función principal.

Puede que no la hayas visto nunca, pues esta función suele representarse simplemente como $. Las siguientes sentencias son exactamente iguales:

$(document).ready();
jQuery(document).ready();

http://api.jquery.com/category/core/

Selectores

Aqui encontramos algunas de las funciones de selección mas útiles.

Información de uso de selectores como :focus, :lt, :checked o :disabled.

http://api.jquery.com/category/selectors/

Atributos

De lo mas usado. Siempre será necesario añadir o eliminar una clase a un elemento, o comprobar si contiene un atributo determinado.

Las funciones que encontrarás en este apartado son tan conocidas como:

• .addClass()
• .attr()
• .hasClass()
• .html()
• .prop()
• .removeAttr()
• .removeClass()
• .removeProp()
• .toggleClass()
• .val()

http://api.jquery.com/category/attributes/

Recorrido y búsqueda de elementos

Una de las características por las que nos encanta jQuery es la de permitir recorrer el DOM y buscar elementos de una forma sencilla.

En esta sección encontrarás la información necesaria para manejar funciones tan útiles como .find() o .each().

http://api.jquery.com/category/traversing/

Manipulación del Dom

Bien, ya hemos visto como recorrer el modelo de objetos del documento (DOM). Ahora lo que queremos es modificarlo. En esta sección encontraras

funciones para modificar el DOM.

.insertAfter(), .insertBefore(), .html() o .clone() son algunas de las funciones indispensables que detallata esta sección.

http://api.jquery.com/category/manipulation/

5 elementos que debes conocer para programar en jQuery publicado en BajoLinux.

Una de las posibilidades de esta herramienta es la de auditar una aplicación web para descubrir vulnerabilidades relacionadas con inyección SQL que podamos sufrir. Recordar que otro uso que le demos no es precisamente legal.

Características

• Soporte para MySQL, Postgres, Oracle y SQL Server
• Interfaz de línea de comandos.
• Autocompletado en comandos, argumentos de comandos y tablas y nombres de columnas en bases de datos.
• Inyección SQL automática e inyección SQL ciega. Utiliza la técnica de unión o técnicas booleanas.
• Inyección SQL en GET, POST y COOKIES.
• Soporte para filtros para eludir reglas IPS/IDS utilizando filtros genéricos.
• Posibilidad de crear nuevos filtros.

Descargar The Mole

Windows 32 Bit, Tarball-gzip

Tutorial de The Mole

Inyección SQL automatizada desde la línea de comandos con The Mole publicado en BajoLinux.

Por eso es importante para los administradores estar al tanto de las vulnerabilidades que puedan afectar al sistema para poner solución lo mas pronto posible.

TimThumb

Si tu tema o plugins utilizan el script TimThumb estas expuesto a un vulnerabilidad del tipo Remote File Inclusion. Por tanto, permitiría la inclusión de ficheros en tu servidor. Bastante chungo.

Hasta que una actualización arregle el problema, se recomienda buscar en el fichero timthumb.php la siguiente linea:

define (‘WEBSHOT_ENABLED’, true);

Y sustituir su valor a ‘false’.

define (‘WEBSHOT_ENABLED’, false);

MailPoet

El plugin para la gestión de newsletter presenta una grave vulneralibidad de la que aun no tenemos demasiada información, así que mientras se arregla es aconsejable no usarlo si no es estrictamente necesario.

MailPoet realizó su actualización el 1 de julio.

Vulnerabilidad WordPress en TimThumb y MailPoet publicado en BajoLinux.

El dataTable

Lo primero que necesitamos es crear la tabla. Para este ejemplo vamos a usar un dataTable creado directamente en html, para una mayor claridad en nuestro ejemplo.

¿Que necesitamos?

Básicamente, incluir en nuestra página los script necesarios, que son:

• jQuery
• jQuery dataTables
• jquery dataTables Column Filter (necesario para crear el filtrado)

Todos estos script junto a css, etc, están en el ejemplo de descarga al final de este artículo.

Una vez tenemos estos script, vamos a crear una página Html con el siguiente código:

<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8">
<title>Bajolinux - Ejemplo datatables</title>
<meta name="description" content="bajolinux - ejemplo datatables">
<meta name="author" content="http://bajolinux.com">
<link rel="stylesheet" href="css/styles.css">
<link rel="stylesheet" href="css/demo_table.css">
<!--[if lt IE 9]>
<script src="http://html5shiv.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
</head>
<body>
<table id="example" class="display" cellspacing="0" width="100%">
<thead>
<tr>
<th>Name</th>
<th>Position</th>
<th>Office</th>
<th>Age</th>
<th>Start date</th>
<th>Salary</th>
</tr>
</thead>
 
<tfoot>
<tr>
<th>Name</th>
<th>Position</th>
<th>Office</th>
<th>Age</th>
<th>Start date</th>
<th>Salary</th>
</tr>
</tfoot>
 
<tbody>
<tr>
<td>Tiger Nixon</td>
<td>System Architect</td>
<td>Edinburgh</td>
<td>61</td>
<td>2011/04/25</td>
<td>320</td>
</tr>
<tr>
<td>Garrett Winters</td>
<td>Accountant</td>
<td>Tokyo</td>
<td>63</td>
<td>2011/07/25</td>
<td>170</td>
</tr>
<tr>
<td>Ashton Cox</td>
<td>Junior Technical Author</td>
<td>San Francisco</td>
<td>66</td>
<td>2009/01/12</td>
<td>860</td>
</tr>
<tr>
<td>Cedric Kelly</td>
<td>Senior Javascript Developer</td>
<td>Edinburgh</td>
<td>22</td>
<td>2012/03/29</td>
<td>433</td>
</tr>
<tr>
<td>Charde Marshall</td>
<td>Regional Director</td>
<td>San Francisco</td>
<td>36</td>
<td>2008/10/16</td>
<td>470</td>
</tr>
</tbody>
</table>
 
<script src="js/jquery-1.4.4.min.js"></script>
<script src="js/jquery.dataTables.js"></script>
<script src="js/jquery.dataTables.columnFilter.js"></script>
<script src="js/script.js"></script>
</body>
</html>

Entre los archivos incluidos está el javascript script.js.

Este archivo contiene el código que usaremos para crear el filtrado de columnas.

Para crear un filtrado por columna que añada al final de nuestro dataTable las cajas de texto necesarias para realizar el filtrado, el archivo script.js tendrá el siguiente contenido:

$(document).ready(function() {
$('#example').dataTable().columnFilter();
} );

Tan sencillo como añadir .columnFilter() al crear nuestro dataTable.

Esta opción es la más sencilla. Se encargará de crear las entradas de texto necesarias para realizar el filtrado al final del dataTable.

Crea tus propias entradas para filtrar

Para personalizar estas opciones puedes crear tu propias entradas de texto.

En el código de ejemplo a continuación creamos nuestras propias entradas para filtrar por nombre, edad y salario.

Para ello, añade el siguiente código al html, justo después de crear la tabla y antes de incluir los script.

<div id="boxFilter">
 <div id="labelFilter">Filtrar por : </div>
 <div id="nameFilter"></div>
 <div id="ageFilter"></div> 
 <div id="salaryFilter"></div> 
</div>

Y ahora, modificamos el contenido de script.js por el siguiente:

$(document).ready(function() {
    $('#example').dataTable().columnFilter(
 {aoColumns:[
{ sSelector: "#nameFilter", type:"select"  },
{ }, null, 
{ sSelector: "#ageFilter", type:"select", values : ["33", "66", "59"] },
null, 
{ sSelector: "#salaryFilter", type:"number-range"}
 ]}
 );
});

Añadimos al método columnFilter los siguientes valores.

• sSelector: “#nameFilter”, type:”select”
• sSelector: “#ageFilter”, type:”select”, values : [“33″, “66”, “59”]
• sSelector: “#salaryFiter”, type:”number-range”

Fijate que añadimos los valores en la posición que representa a la columna que queremos tratar.

El resto de columnas las incluimos con {} o null para cada una de ellas.

La diferencia entre usar {} o null está en que al usar el valor null no se creará ninguna caja para el filtrado al final del tabla data. Mientras que al usar {} si se creará. Depende de lo que prefieras.

Con esto, el script de dataTables column filter se encargará de crear las entradas de texto para realizar el filtrado.

Todos los archivos necesarios puedes descargarlos a continuación.

Filtrar columnas en jQuery DataTables publicado en BajoLinux.

El comando “df” nos informa en su salida estandar de:

• Sistema de ficheros o unidad de disco
• Tamaño del disco
• Cantidad de espacio usados
• Cantidad de espacio disponible
• % de espacio de uso
• Punto de montaje

El comando “df”

pi@raspberrypi ~ $ df
S.ficheros     1K−bloques    Usados Disponibles Uso% Montado en
rootfs            7574088   2889120     4331928  41% /
/dev/root         7574088   2889120     4331928  41% /
devtmpfs           219832         0      219832   0% /dev
tmpfs               44800       244       44556   1% /run
tmpfs                5120         0        5120   0% /run/lock
tmpfs               89580         0       89580   0% /run/shm
/dev/mmcblk0p1      57288      9656       47632  17% /boot
/dev/sda1       488384508 198319828   290064680  41% /home/pi/DATA

El comando “df -h”

La opción -h nos mostrará la información de forma un poco mas entendible, en MB o GB.

pi@raspberrypi ~ $ df −h
S.ficheros     Tamaño Usados  Disp Uso% Montado en
rootfs           7,3G   2,8G  4,2G  41% /
/dev/root        7,3G   2,8G  4,2G  41% /
devtmpfs         215M      0  215M   0% /dev
tmpfs             44M   244K   44M   1% /run
tmpfs            5,0M      0  5,0M   0% /run/lock
tmpfs             88M      0   88M   0% /run/shm
/dev/mmcblk0p1    56M   9,5M   47M  17% /boot
/dev/sda1        466G   190G  277G  41% /home/pi/DATA

El comando “df -h /”

Y si añadimos un sistema de ficheros, solo nos informará de ese disco.

pi@raspberrypi ~ $ df −h /
S.ficheros     Tamaño Usados  Disp Uso% Montado en
/dev/root        7,3G   2,8G  4,2G  41% /

pi@raspberrypi ~ $ df −h /dev/sda1
S.ficheros     Tamaño Usados  Disp Uso% Montado en
/dev/sda1        466G   190G  277G  41% /home/pi/DATA

Espacio de disco desde la consola en linux publicado en BajoLinux.

En este ejemplo vamos a ver como realizar la carga dinámica de archivos javascript con jQuery.

Basta con usar la función getScript tal como se muestra en el siguiente ejemplo:

<!DOCTYPE HTML>
<html>
    <head>
        <title>Bajolinux - Ejemplo de carga dinámica de javascsript</title>
        <meta http-equiv="content-type" content="text/html; charset=utf-8" />
        <meta name="description" content="" />
        <meta name="keywords" content="" />
        <script src="jquery-1.11.1.min.js"></script>
    </head>
    <body>
        <div id="wrapper"><button id='boton'>pulsame</boton></div>
        <div id="result"></div>
    </body>
    <script>
    $(document).ready(function(){
        $('#boton').click( function(){
            $.getScript('my-script.js', function(data, textStatus){
                $('#result').append( getTexto() );
            });
        });
    });
    </script>
</html>

En la línea 17 cargamos el archivo externo, en este caso my-script.js.

En la linea 18 hacemos uso de la función getTexto(), incluida en my-script.js.

Carga dinámica de javascript con jQuery publicado en BajoLinux.

Organización de un sistema de ficheros

En una instalación típica de Linux, encontraremos varios directorios y un gran número de archivos. Los principales directorios y su contenido son los siguientes:

/bin

Contiene archivos ejecutables, conocidos como binarios. Estos programas son esenciales para el correcto funcionamiento del sistema.

/sbin

También contiene archivos binarios, la mayoría con fines administrativos para el sistema.

/etc

Muy importante. Contiene archivos de configuración del sistema. Aquí encontramos archivos de contraseñas, sistemas de archivos que se montan al inicio o fstab, y archivos de comandos de inicio.

/lib

Bibliotecas compartidas que utilizan los programas. Con el uso de bibliotecas compartidas muchos programas pueden utilizar el mismo código, con el consiguiente ahorro de espacio

/dev

Contiene archivos especiales conocidos como archivos de dispositivo. Se utilizan para acceder a los distintos tipos de hardware del sistema.

Algunos dispositivos típicos del directorio /dev son los siguientes:

• /dev/console, hace referencia a la consola del sistema
• /dev/sd, interfaz de dispositivo para discos SCSI
• /dev/tty, distintas consolas para las entradas de usuario
• /dev/null, un dispositivo especial, un pozo sin fondo. Todos los datos que se escriben aquí se pierden para siempre. Útil cuando al ejecutar un comando no se necesitan ni la salida estándar ni los errores.

/proc

Contiene información sobre los procesos de la memoria.

/tmp

Almacén de archivos temporales que crean los programas al ejecutarse. Si un programa crea archivos temporales muy grandes, es buena idea montarlo como sistema de archivos separado, para evitar que el sistema de archivos / se pueda llenar.

/home

Es el directorio base para los directorios de usuarios. Se puede montar como sistema de archivos separado para mantener la información y el tamaño controlados.

/var

Archivos que suelen cambiar de tamaño con el tiempo, como registros de sistema, mensajes o noticias.

/usr

Muy importante para el funcionamiento del sistema. Contiene los grandes paquetes de software que se instalan. También se puede montar como un sistema de archivos por separado.

Algunos de los directorios típicos de /usr son los siguientes:

/usr/bin

Programas ejecutables instalados.

/usr/etc

Archivos de configuración.

/usr/lib

Bibliotecas para uso de los programas.

/usr/man

Páginas del comando ‘man’ para la documentación.

/usr/src

Código fuente de los programas.

/usr/local

Para personalizar localmente el sistema. Una forma de definirlo es tener un /usr/local/bin, un /usr/local/lib, etc.

Organización de un sistema de ficheros en Linux publicado en BajoLinux.

Un sistema de ficheros representa la organización lógica que se plasma en los discos o soportes de memorias para colocar información y datos en ellos.

Cuando se escribe información en un disco, no se hace de cualquier manera, sino que se organiza para colocar de una forma determinada la información relativa a los ficheros y los datos. Esta organización está definida por el sistema de ficheros.

En Linux no existe un único tipo de sistema de ficheros, sino varios. Aunque los fundamentos para organizar la información suelen ser muy parecidos en los distintos sistemas de ficheros soportados por Linux, estos pueden variar dependiendo de la distribución elegida.

El principio básico que rige en los sistemas de ficheros es asociar un nombre de fichero con su contenido y autoriza acceso, creación, modificación, lectura, etc…

Por tanto, los sistemas de archivos o ficheros son la base de todos los datos, programas, bibliotecas, archivos de sistema y usuario. De aquí la importancia de administrar correctamente el sistema de ficheros para ejecutar Linux correctamente.

Los metadatos o inodos

Antes de pasar a la representación y organización de los sistemas de ficheros comentar que las propiedades de un fichero se denominan metadatos o inodos. Los metadatos o inodo de un fichero se representan con un número único para el fichero al que se refieren dentro del sistemas de ficheros.

Esta información se almacena internamente en un lugar especial del soporte de almacenamiento, y aunque pueden variar ligeramente de un sistema a otro, en general encontramos los siguientes:

• Permisos del fichero
• Últimas fechas se acceso y modificación
• Propietario y grupo del fichero
• El tamaño
• Número de bloques utilizados
• El tipo de fichero
• Contador de vínculos

Representación de un sistema de ficheros

El sistema de ficheros en Linux se organiza en forma de árbol de directorios y subdirectorios desde una raíz común. Cada directorio forma parte de una organización y tiene una jerarquía ordenada.

Por tanto, el sistema de archivos que resulta visible tras una instalación se basa en una estructura en árbol, con la raíz en la parte superior, y los directorios y subdirectorios se ramifican desde la raíz. El directorio superior o / se conoce como directorio raíz. Una representación típica puede ser la siguiente:

sistema de archivos en linux

Los directorios y su estructura pueden encontrarse en la misma partición o en una partición separada. Si está separada, se anexa al árbol en directorio conocido como punto de montaje.

Sistemas de ficheros en linux publicado en BajoLinux.

Basta con crear un sencillo script como el siguiente.

#!/bin/bash
for i in ./tif/*.tif
do
  echo convirtiendo $i to ./jpeg/$(basename $i .tif).jpg
  convert $i ./jpeg/$(basename $i .tif).jpg
done

Las imágenes en formato tif deberán estar en una carpeta llamada tif.

Las imágenes en formato jpeg las dejará en una carpeta llamada jpeg.

Luego le damos permiso de ejecución y ejecutamos nuestro script:

chmod +x convertir.sh

Y lo ejecutamos.

./convertir.sh

Y eso es todo, dejará las imágenes en formato jpeg en la carpeta mencionada.

Pero recuerda que esto es linux, si las imágenes están nombradas en mayúsculas tendrás que cambiar .tif por .TIF para que funcione.

Luego, en la carpeta jpeg puedes ejecutar el siguiente comando para reducir el tamaño de las imágenes:

mogrify −resize 20% −path resized/ *.jpg

Con esto las reducirá a un tamaño menor si son demasiado grandes y pesadas para la web, dejándo las imágenes reducidas en la carpeta resized.

Saludos linuxeros.

Photo credit: *Luana* via photopin cc

Ubuntu, convertir imágenes de formato tif a jpg con imagemagick publicado en BajoLinux.