HOW-TO: Copiar archivos por la red

Ala pues!

Muchas veces nos pasa que necesitamos enviar información de un pc a otro, pero por los motivos que sean, las soluciones "convencionales" no nos solucionan el problema. Imaginemos que queremos enviar el contenido completo de un disco duro o simplemente queremos enviar "información suelta" para comunicación entre programas, pero no deseamos estar leyendo archivos en carpetas compartidas, o queremos hacer un programa de comunicación...

Pues bien, podemos usar sockets para enviar ésta información. En Linux, tenemos la herramienta "nc" (hay abundante información en internet) La herramienta nc es la que nos va a permitir crear sockets para todo lo que se nos ocurra.

Vamos a repasar el concepto de socket. Socket es un método de comunicación por el cuál se comunican dos entes, los cuáles pueden adquirir el rol de cliente o servidor.

Hacer un socket es muy fácil, en un "cliente" con ip 192.168.1.10 escribid:

nc -l -p 6000

En un "servidor" escribid:

nc 192.168.1.10 6000

Observad que, todo lo que escribís en el servidor aparece en la consola del cliente. En éste caso, cliente y servidor pueden ser dos consolas en un mismo equipo. Pulsad control+c para terminar la sesión.


Consultad "man nc" para ver qué es cada parámetro. Ahora vamos a enviar un archivo:

PC (o consola) Receptor: nc -l 6000 | dd of=nombrefichero
PC (o consola) Emisor: dd if=archivo_origen | nc 192.168.1.10 6000

Observad que, aunque el archivo se ha recibido, la conexión no se cierra hasta que pulsemos control+c en el emisor (si lo hacemos en el receptor, puede ser que no recibamos toda la información) Fijaos también que, la transmisión se cierra siempre que el cliente pulse control+c, hay que tenerlo siempre presente.

Ahora supongamos que tenemos un archivo muy grande y somos tan listos que decidimos enviarlo comprimido, pero es tan grande que, no se puede comprimir sin ocupar todo lo que queda de disco. Bueno, podemos comprimirlo "al vuelo"

PC 192.168.1.10 Receptor: nc -l 6000 | tar xvvzpf -
PC 192.168.1.11 Emisor: tar cvvzpf - archivo | nc 192.168.1.10

Ésto comprimiría el archivo pero no lo almacenaría en el disco local, si no que lo envía a la salida estándar (Parámetro "f -") Allí, es direccionado a nc y enviado al 192.168.1.10

Mientras tanto, el receptor direcciona todo lo que le llega por la red a la salida estándar y allí es direccionado a tar para ser descomprimido en el mismo lugar.

Los beneficios, obviamente son, mejor aprovechamiento del ancho de banda ya que la información va comprimida.

Observad que, la transmisión no se cierra hasta que el emisor pulsa control+c en su consola.

Imaginaos la potencia de ésto: se pueden hacer, scripts de comunicación, copias de seguridad "al vuelo" protocolos de comunicación y todo lo que se os ocurra.

Vamos a liar más la perdiz y a darle otra vuelta de rosca. Vamos a hacer un programa teórico de comunicación.

PC 1: 192.168.1.10

En una consola 1:
nc -l -u -p 6000

En otra consola 2:
nc -u 192.168.1.11 -p 7000

PC 2: 192.168.1.11

En una consola 1:
nc -l -u -p 7000

En otra consola 2:
nc -u 192.168.1.10 6000

Ahí está: todo lo que escribamos en la consola 2 será enviado a la consola 1 del otro equipo, y todo lo que el otro equipo escriba en su consola 2 será enviado a la consola 1 del nuestro.

Observad el parámetro "-u". Ésto significa que usaremos el protocolo "UDP" (envío sin confirmación de recepción) Es decir, que si el otro pulsa control+c en su consola, no romperá nuestra consola, de hecho, no sabremos si está ahí.

De aquí en adelante, todo vuestro, todo lo que se os ocurra.

Linux power!!!

Reparación: Recuperar Contraseña de Root

Y otra vez. Se conoce que hay gente que, después de instalar ubuntu, se "olvida" de la contraseña de root y no puede acceder al sistema.

GNU/Linux es un sistema muy seguro para trabajo en red, pero, al contrario que otros sistemas, asume que el usuario es inteligente y no está completamente protegido contra ciertas acciones sobre el equipo físico. Hoy vamos a explotar una de esas puertas traseras que tiene Linux para cambiar la password de root.

Sólo necesitamos un LiveCD de Ubuntu. Bien, al tajo:

1-Iniciad con el LiveCD

2-Abrid una consola

3-Montad La unidad principal de vuestro Linux (ver aquí, sección 2)

En nuestro caso, /dev/sda5 es la unidad principal:

sudo mount /dev/sda5

4- Haced un chroot en /mnt

sudo chroot /mnt

5- Cambiad la contraseña como si tal cosa:

passwd

6- Terminad y reiniciad el ordenador.

exit
sudo reboot

Disfrutad;

Reparación: Recuperar Grub después de instalar Windows

Son muchos los usuarios que migran de plataforma Windows a Linux, y mayoritariamente a Ubuntu. Hace tiempo que ayudo en ubuntu-es.org y ante la ingente cantidad de veces que he tenido que repetir ésto, he decidido crear una entrada sólo para ésto. Éso sí, aquí lo voy a explicar con pelos y señales.

El problema: Teníamos ubuntu instalado y después (bien por reparación o por planificación) instalamos Windows. Pasa que windows está muy acostumbrado a campar en solitario por nuestro disco duro, más aún por su MBR, y lo pisotea inevitablemente cada vez que una instalación se pasea por ésos lares. Cosas de la vida.

¿Qué ha pasado con nuestro Ubuntu (o GNU/Linux)? Pues no os asustéis, porque no ha pasado nada de nada, es decir, sigue intacto (allá donde esté...)

Solución: Reinstalar Grub en el MBR del disco duro.

Necesitamos: Un Live CD de Ubuntu.

1 - Introducid el LiveCD de Ubuntu en el lector, encended vuestra máquina y arrancad desde el LiveCD, dejad que todo fluya tranquilamente hasta que veáis el clásico escritorio de un Ubuntu impoluto.


2- Abrid una Consola


Teoría:

Antes de teclear nada en la consola debemos entender como organiza GNU/Linux las unidades y las particiones.

Cada unidad usb o sata que detecta, es puesta en el directorio de dispositivos "/dev". Bajo el nombre de "sd" + Una letra. La letra corresponde al número de unidad, "a" para la primera, "b" para la segunda... etc.

Además, a lo anterior se le asigna un número para cada partición detectada en la unidad, de forma que, la primera partición del primer disco será: "sda1" La segunda partición del primer disco será 2 (sda2) La segunda partición del segundo disco será "sdb2". Imagino que ya os imagináis por donde van los tiros.

Y todos éstos ficheros de unidades se situan en "/dev".


3- Identificar donde está instalado Ubuntu:

Escribid en consola: sudo fdisk -l Deberíais tener algo parecido a ésto: (tranquilos, en vuestra máquina tendréis dos o tres líneas, alo sumo)



Muy bien ¿cómo sabemos qué dispositivo es nuestro disco de ubuntu? Fácil, el primero cuyo sistema de ficheros sea Linux. En éste caso será /dev/sda5. En el vuestro será 1 o 2 o 3, depende.

En consola escribid: sudo mount /dev/sda5 /mnt (No devuelve nada)

4- Restaurando Grub

En la misma consola escribid: sudo grub-install --root-directory=/mnt /dev/sda


Y todo listo, no tiene más historia, reiniciad vuestro ordenador y disfrutad de GNU!

Scripts Avanzados: Un script para manejar básicamente iptables

Y otra vez, hemos vuelto. Ésta vez, os mostraré un script para manejar funcionalidades básicas de IPTABLES. El objetivo de éste script, aparte de manejar IPTABLES, es el de enseñar el su uso, dado que cada vez que lo usemos, hará una traducción de lo que escribimos a lo que hace iptables, de modo que poco a poco nos iremos quedando con el funcionamiento de IPTABLES.

También se puede usar para aprender a hacer scripts en consola, ya que en él aparecen prácticamente todos los mandatos de la consola.

Aunque claro está, también puede usarse para no tener que aprender IPTABLES ;)

Script:


#!/bin/bash
# ########################
# IAL Script versión 2.5
# Daniel Perella
# ########################
complete_rule=iptables
part_rule=

function _aplicar
{
echo -e "Aplicar $part_rule a $complete_rule? (s/n)"
read a
if [[ $a = "s" ]]
then
complete_rule=$(echo $complete_rule $part_rule)
echo regla:$complete_rule
else
echo regla:$complete_rule
fi
}

function asistente # asistente: Ejecuta un asistente guiado para añadir una regla
{

echo "añadir o quitar norma?"
echo "añadir | quitar [INPUT|OUTPUT|FORWARD]"
echo -e "que hacer)\c"
read aa
$aa

echo "protocolos admitidos: tcp udp icmp all"
echo -e "protocolo)\c"
read pro
protocolo "$pro"

echo "seleccione política"
echo "acciones: aceptar | rechazar | ignorar "
echo -e "accion)\c"
read ac
$ac

echo "direccion: origen | destino [IP o host]"
echo -e "direccion)\c"
read di
$di

if test $pro = "tcp" -o $pro = "udp"
then
echo "puerto al que aplicar la norma"
echo -e "puerto)\c"
read pu
puerto $pu
fi

echo "Puede Aplicar la norma ahora o añadir"
echo "más propiedades en éste mismo CLI"
echo -e "Aplicar la norma ahora (s/n)?\c"
read ap
if [[ $ap = "s" ]]
then
aa=$(echo $aa | cut -d " " -f 1)
if [[ $aa = "añadir" ]]
then
ejecutar
else
echo -e "Desea borrar ésta norma?? (s/n)?\c"
read bbb
if [[ $bbb = "s" ]]
then
ejecutar
else
echo "No Borrada"
fi
fi
else
echo "Use la ayuda para ver que propiedades"
echo "tiene disponibles"
echo " "
fi

}

function añadir # añadir [INPUT|OUTPUT|FORWARD]: Añade al tipo de Norma
{
echo "-A"
part_rule="-A $1"
_aplicar
}

function quitar # quitar [INPUT|OUTPUT|FORWARD]
{
echo "-D"
part_rule="-D $1"
_aplicar
}

function protocolo # protocolo [tcp|udp|icmp|all]: Añade un tipo de protocolo
{
echo "-p $1"
part_rule="-p $1"
_aplicar
}

function puerto # puerto [n]: Define el puerto de la norma
{
echo Puerto: $1
part_rule="--dport $1"
_aplicar
}

function aceptar # aceptar: Aplica la norma ACCEPT a los paquetes
{
echo "-j ACCEPT"
part_rule="-j ACCEPT"
_aplicar
}

function rechazar # rechazar: Aplica la norma REJECT a los paquetes
{
echo "-j REJECT"
part_rule="-j REJECT"
_aplicar
}

function ignorar # ignorar: Aplica la norma DROP a los paquetes
{
echo "-j DROP"
part_rule="-j DROP"
_aplicar
}

function interfaz # interfaz [ethn] Define el interfaz para la norma
{
echo "-i $1"
part_rule="-i $1"
_aplicar
}

function numero # numero [n]: Define el número de norma (útil para borrar)
{
echo "-I $1"
part_rule="-I $1"
_aplicar
}

function origen # origen [IP o HOST]: Define el origen del paquete para la norma
{
echo "-s $1"
part_rule="-s $1"
_aplicar
}

function destino # destino [IP o HOST] Define el destino del pquete de la norma
{
echo "-d $1"
part_rule="-d $1"
_aplicar
}

function normas # normas: Hace un listado de las normas existentes
{
echo "Norma que está siendo editada"
echo $complete_rule
echo "Ultima parte aplicada o no a la norma"
echo $part_rule
echo " "
echo " "
i=$(whoami)
if [[ $i != "root" ]]
then
echo "No eres root, no se puede hacer iptables"
else
iptables -n -L
fi

}

function nueva # nueva: Empieza a hacer una norma nueva
{
complete_rule="iptables"
part_rule=""
echo "Nueva norma iniciada"
}


function ejecutar # ejecutar: Aplica la norma
{
echo "Aplicando norma: $complete_rule"
$complete_rule
echo "Hecho"
}

function guardar # guardar Volca en un archivo las normas
{
echo "Guardar normas en fichero"
if test -n $1
then
nom=$1
else
echo -e "nombre del fichero)\c"
read nom
fi
iptables-save > $nom
echo "Guardado como $nom"
}

function cargar # cargar Lee un fichero de normas y lo aplica
{
echo "Cargar Normas IPTABLES"
if test -n $1
then
nom=$1
else
echo -e "nombre del fichero)\c"
read nom
fi
cat $nom | grep "-" | grep -v "#" | while read lin
do
echo -e "Cargando: $lin\r\c"
complete_rule=$(echo $complete_rule $lin)
ejecutar
nueva
done;
}

function vaciar # vaciar [INPUT|OUTPUT|FORWARD] Vacia del todo un juego de normas
{
if test -n $1
then
iptables -F $1
echo Normas de $1 Limpio
else
echo "Vaciar Normas de: INPUT OUTPUT FORWARD"
echo -e "normas)\c"
read nor
iptables -F $nor
echo Normas de $nor Limpio
fi
}

function _backup
{
guardar backup_normas
}

function _restore
{
cargar backup_normas
}
# exit 0 : sale del script

case $1 in

--directo|-d)
$2 $3 $4 $5 $6 $7 $8 $9
;;
--backup|-b)
_backup
;;
--restore-backup|-r)
_restore
;;
*)
while [[ $? ]]
do
i=$(whoami)
if [[ $i != "root" ]]
then
echo "No eres root, no se aplicará ningún cambio"
fi
echo "Use: ayuda"
echo -e "root)\c"
read rul
if [[ $rul = "ayuda" ]]
then
cat blacklist.sh | grep "#" | grep -v "grep" | grep -v "_" | grep -v "bash" | cut -d "#" -f 2

else
$rul
fi
done;
;;
esac

_backup


Uso:

Ejecutaremos el script con permisos de root y accederemos a su consola. Podemos usar la orden "ayuda" para obtener ayuda acerca de las funciones que podemos usar.

La idea es ir completando una variable con las posibles opciones que podemos usar en iptables, claro está, el script nos dice en cada momento lo que podemos introducir. Después ésa variable se le pasa a IPTABLES y es aplicada.

Para empezar, podemos usar la órden "asistente" y cuando cojamos soltura iremos probando las funciones sueltas.

Si tenéis dudas, ya sabéis donde estamos!

Suerte

HOW TO: Incompatibilidad Hotmail Live, Office Live,.. + Firefox Ubuntu (Actualizado)

El Problema
Como muchos usuarios de Ubuntu habreis notado, siempre que intentemos acceder a cualquiera de los servicios Live! de Microsoft desde Firefox con Ubuntu, nos encontramos con mensajes del estilo:

OFFICE LIVE (http://www.officelive.com):


HOTMAIL (http://www.hotmail.com):

En dicho momento las alarmas propietarias se activan y piensas... ¿Sera posible que Microsoft haya utilizado tenologias propietarias para sus portales, dejando asi de lado a los usuarios de linux?

La respuesta es, en parti si, y en parte no. Para poder usar "Office Live" al completo si que necesitaremos instalar ciertos programas (plugins) exclusivamente para Windows, sin los cuales el uso de Office Live se ve limitado a la lectura de documentos. Por lo que la emocion inicial de no tener que volver a Windows o usar el Office a traves de Wine, para editar los documentos de word, excel, etc.. fue disipada muy rapidamente. Y ademas como anotacion al lector, todos sabemos que OpenOffice, puede leer documentos de Word, Excel, etc..pero la mayoria de las veces los documentos adaptados no son 100% fieles al original, pues el caso de "Office Live" es de los mas encandaloso que he visto jamas, dado que al abrir documentos originales en el nuevo portal de Microsoft, estos son mostrados peor que con OpenOffice.

Reseñas aparte, para poder llegar a ver documentos y/o ver nuestro correo de Hotmail, necesitamos un paso previo, engañar los portales de Hotmail y Office Live haciendoles creer que navegamos en Firefox (pero desde Windows).
Voy a obviar el tema de lo triste que es para una empresa como Microsoft bloquear sistematicamente a los usuarios de Linux, por el simple hecho de usar ese sistema operativo, dado que los portales son completamente funcionales cambiando simplemente el user agent
La Solucion
Para navegar como si estuvieramos usando el sistema operativo Windows (Cualquiera de sus versiones nos vale) nos valemos de una simple herramienta llamada UserAgentSwitcher con el que podremos hacer creer al navegador en cuestion de segundos que estamos navegando con diferentes sistemas operativos y navegadores, con un gesto tan simple como el que veis en la imagen.Por defecto esta herramienta viene con las opciones Internet Explorer 7, Netscape 4.8 y Opera 9.25 (Windows Vista), pero la mas interesante para nosotros es Firefox para Windows, dado que queremos que Hotmail, siga cargando su interfaz para el navegador de Mozilla, pero saltandonos el cansino mensaje y asegurandonos la maxima compatibilidad con nuestro navegador al igual que en Windows.
  1. Instalamos la extension de firefox disponible aqui.
  2. Abrimos las opciones de la extension y hacemos click en "User Agents -> Import" (Podeis hacer una copia de seguridad de las actuales haciendo click en Export")
  3. Ahora solo teneis que importar el siguiente fichero xml: Firefox_Win32_UserAgent
  4. Y listo! Ya deberiais tener en vuestra lista de user agents, la version: "Firefox (Windows XP)"
Ya podeis entrar en vuestro correo de Hotmail y en Office Live, siempre y cuando activeis previamente, con el UserAgentSwitcher, la version de "Firefox (Windows XP)".

Que lo disfruteis.

Corrección: Parece que desde Redmond se han dado cuenta de la importacia y la importante cuota de mercado que pueden ganar ofreciendo esta version de Office Live para todas las plataformas, anunciando que para finales de este año estara disponible para Windows, Linux y Mac (La posibilidad de gestionar documentos de Office en cualquier plataforma asegura que los usuarios de Linux dependeremos cada vez menos del sistema operativo de Redmond, es una gran noticia para el mundo linux)
Fuente: The Inquirer ES

Script de Instalación Para nuestra Distribución

Que parte del equipo de ubuntu Linux estaba trabajando en una metadistribución de Ubuntu no es nada nuevo.

Pues bien, hemos dado un paso más. Se ha creado el instalador de la Distribución. Sé que estamos lejos de tener una distribución propia, pero andar es andar y, aunque sea despacio, siempre se acorta el camino.

Os acordaréis de una entrada que hicimos sobre cómo haceros vuestra propia distribución de Ubuntu, para Netbooks, ahora os enseñaré como hacer un instalador para ella.

Necesitamos (entrando ya en materia) dos scripts. El primero, generará una imágen de la distribución que se esté ejecutando, el segundo, habrá que incluirlo en el CD de instalación de Ubuntu Mini.

Script de Generación:

#!/bin/bash
me=$(whoami)
echo "Obteniendo Listado de Paquetes...."
dpkg-query -W -f='${Package}\n' > packages.txt
echo "Listado de paquetes obtenido"
echo "Obteniendo Configuración de Usuario"
cd /home/$me
cp /etc/apt/sources.list .
tar -cvvf installer/home.tar . --exclude=installer --exclude=.ssh --exclude=*.mozilla --exclude=.aptitude

Éste script obtiene la lista de paquetes instalados y los archivos de configuración del home del usuario actual. Los tres archivos que genera (home.tar, packages.txt y sources.list) Habrá que ponerlos en la misma ruta del instalador, en el CD de instalación.

Script de Instalación:

#!/bin/bash
me=$(whoami)

if [[ $me = "root" ]]
then
echo "Comprobando Lista de Paquetes"
if test -e packages.txt
then
echo "Lista de Paquetes encontrada, empezando la Instalación..."
cat packages.txt | while read package
do
echo aptitude --assume-yes install $package
done
echo "Paquetes Instalados, Empezando configuración de Usuario"
echo "Escriba un Nombre de usuario en minúsculas y sin acentos:"
echo -e "Nombre de usuario: \c"
read user
adduser $user
adduser $user admin

tar -xvvf home.tar -C /home/$user
cp /home/$user/sources.list /etc/apt/sources.list
chown -R $user.$user /home/$user

else
echo "No se ha encontrado la lista de paquetes, no se instala"
fi
else
echo "No Eres root, no se hace nada"
fi


Y éso es todo. Es decir, de momento, lo que hay que hacer es, bajarse el ubuntu mini, instalarlo y ejecutar el script "install.sh"

Me dejo para otra entrada como hacer el CD de instalación.

Cuidaros!

Opinión: Ubuntu Linux, el día a día, futuro o Moda

Hoy vamos a hacer una entrada distinta. No es que nos falten entradas técnicas, es que a veces, también me gusta reflexionar sobre lo que hacemos.

Haciendo un poco de memoria, no me cuesta recordar la primera vez que oí hablar de Ubuntu. Por aquél entonces era estudiante y ni siquiera estaba en la rama de informática, era el año 2004. Un amigo me trajo unos CD's en una envoltura de cartón y me dijo que era una nueva distribución de Linux que acababa de salir.

Obviamente mi primera impresión fue lamentable. Poca documentación, soporte pésimo, etc, etc. Nunca imaginé la proyección que alcanzaría aquella "versión recortada de Debian"

Hoy, Ubuntu se ha convertido, casi sin duda, en la distribución más famosa (y mediática) de la informática, tirando del carro de Linux. Vayas por donde vayas, hace días que se habla de Ubuntu. Cada vez que alguien dice que le ha entrado un virus por el messenger, no muy lejos, alguien sonríe de forma condescendiente.

No deja de ser curioso que ésto, hasta hace poco era al revés. Linux era un programa que usaban los hackers informáticos para robar información, a cualquiera que se le hablase de éste sistema operativo se le dibujaba una sonrisa paternal y condescendiente en la cara y asistía sin el menor interés a las explicaciones que se le diesen. Pero mira, cada vez somos más, y ahora los que sonríen son los usuarios que cada vez que entran en internet, lo hacen de forma más segura, sin tener que comprar un equipo nuevo cada dos años ni pagar licencias de software.

Desde éste punto de vista, se ha mejorado la vida de mucha gente. Lo que era inpensable hace unos años, hoy puede ser una realidad. por ejemplo, Aquí, en el laboratorio de Ubuntu Linux a Fondo, como en tantos otros, se gestan ideas para que ésto sea una realidad. Instalar Linux en máquinas antiguas, o personalizar un sistema operativo para hacer que sea un SO prácticamente bajo demanda son algunos de los ejemplos que ya tenemos, otros que vendrán, como por ejemplo instalar un escritorio libre sobre Darwin (la distribución que lleva OS X por debajo)

Pero todo no puede ser bueno y siempre hay gente que intenta hacer de lo famoso, algo lucrativo.

Actualmente, las empresas se están volcando con el código abierto y todas (las que quieren aprovechar la buena publicidad) sacan productos basados en soluciones de código abierto. Se empeñan en ofertar servicios adicionales para rentabilizar un fenónemo que viene de atrás pero que ahora se ha puesto de moda.

Mucho se ha hablado sobre la aportación de Ubuntu al código abierto y al fenómeno Linux en general, se ha especulado sobre si el tirón actual viene de la mano de ciertas distribuciones o era una consecuencia absolutamente inevitable.

Lo que sí es cierto (y puede que me crucifiquen por ésto) es que Canonical (Por nombrar la que nos ataña, aunque otras distros también tienen soporte privado) es una empresa y en el fondo, sigue la filosofía de una empresa.

Si bien es cierto que probablemente una comunidad de desarrolladores "a ratos libres" no lograse soportar un número significativo de distribuciones, es cierto que lograse mantener al menos un par de ellas.

Lo que queda por ver es cómo terminará todo ésto, quiero decir ¿Acabaremos pagando por Ubuntu?

Ahí queda.

HOW-TO: Script + Hotkey para activar/desactivar Touchpad

Hace ya tiempo que uso ubuntu, y poco a poco, te vas dando cuenta de alguno detalles que le faltan. Pero a la vez te das cuenta de que no es tan dificil ponerte manos a la obra y arreglar tu mismo esos pequeños detalles, que hacen que tu dia a dia sea mas agradable.

Hoy nos concierne un problema que tengo desde hace tiempo, y que se ha acentuado mas desde que he empezado a jugar a juegos con Wine bajo Ubuntu 8.04, el touchpad. Cuando usaba windows podia desactivar el touchpad con el HotKey asociado, pero esta tecla no funciona en mi Ubuntu desde hace ya tiempo.

Como supongo que habra muchos de vosotros en la misma sitiacion, he decidido crear este pequeño HOW-TO para hacer la vida un poco mas facil a los usuarios de ubuntu.

[ Manos a la obra ]

PASO 1, Activar SHMConfig
Investigando un poco nos damos cuenta de lo sencillo que es habilitar/deshabilitar el touchpad. Simplemente tenemos que ejecutar un comando con el valor 0 o 1. Pero antes de eso necesitamos habilitar una opcion del touchpad. Empezamos:
  1. Editar el archivo xorg.conf con el comando:
    sudo gedit /etc/X11/xorg.conf

  2. Ahora tenemos que buscar la seccion del Touchpad Synaptics, que deberia parecerse a esto:

    En esta seccion debemos añadir => Option "SHMConfig"
    de forma que se parezca a:

  3. Resetear el servidor X (Ctrl + Alt + Bcksp) o en su defecto el propio Ubuntu.

  4. Ya podemos habilitar/deshabilitar el touchpad por linea de commandos usando:
    synclient TouchpadOff=1  // Deshabilitado
    synclient TouchpadOff=0 // Habilitado
PASO 2, Activar HotKey + Script
Hasta aqui todo muy bien, pero realmente queremos abrir una consola cada vez que querramos desactivar el touchpad?? Ciertamente no, asi que ahora vamos a pasar a asignar esta accion a una HotKey, de forma que podamos hacerlo con un simple gesto de teclado. Para ellos nos hara falta convertir esto en un script, que cambie el estado de esa variable automaticamente. Asi que me he montado el siguiente script que consulta dicho valor y lo cambia. Tan facil como esto:
#!/bin/bash

state=`synclient -l | grep TouchpadOff | tail -c 2`

if [[ $state == "0" ]]
then
# Change value to 1
synclient TouchpadOff=1
else
# Change value to 0
synclient TouchpadOff=0
fi
Descargar script: aqui
  1. Guardar el script en una carpeta de tu home, por ejemplo:
    /home/username/Scripts

  2. Le damos permisos de ejecucion:
    sudo chmod u+x /home/username/Scripts/touchpad.sh

  3. Ahora para asignar este script a una combinacion de teclas hacemos los siguiente:

    Usando el Gnome Configuration Editor (gconf-editor)


    1. Ejecutad el programa gconf-editor

    2. Navegad hasta => apps \ metacity \ keybinding_commands

    3. Editad la primera clave libre que tengais (por ejemplo 'command_1')

    4. Despues navegad hasta: apps \ metacity \ global_keybindings

    5. Asignad la combinacion deseada a la correspondiente clave 'run_commandoanterior' en nuestro caso 'run_command_1'

    6. LISTO !! Ya podeis activar y desactivar el touchpad con la combinacion elegida.

Saludos y happy binding!

Scripts Avanzados: Un script que parsea un fichero de opciones

Una de scripts. Irá haciendo entradas sobre scripts, unas introductorias y otras más avanzadas. Hoy vamos a ver cómo hacer que nuestros scripts puedan configurar sus variables desde ficheros externos.

Ésto es especialmente útil cuando actualizamos nuestros scripts en distintas máquinas y no queremos alterar la configuración de cada uno.

Una práctica (extendida, pero no adecuada) Era hacer algo así:

copy.sh

#!/bin/bash
ruta_origen=/home/juanjo
ruta_destino=/mnt

function copiar{
cp -vr $ruta_origen $ruta_destino
}

Con lo que si cambiamos el script de ordenador, puede que /home/junajo no exista. Vamos a hacerlo bien. Crearos un fichero de propiedades, por ejemplo

copy.sh.properties

Y dentro colocad:
# Fichero de Propiedades de copy.sh
# propiedad=valor
origen=/home/juanjo
destino=/mnt

Ahora, en el fichero copy.sh añadid la funcion propiedad:

#!/bin/bash

function propiedad {
if test -r $0.properties
then
cat $0.properties | grep -v "#" |grep -i "$1" | cut -d "=" -f 2
else
echo "ERROR: Fichero de Propiedades no encontrado o no legible"
echo "Se sale del script."
exit 0
fi
}

ruta_origen=$(propiedad origen)
ruta_destino=$(propiedad destino)

function copiar{
cp -vr $ruta_origen $ruta_destino
}


De ésta forma, podemos cambiar los scripts conservando las configuraciones de cada equipo. Dejo para otro post (de scripts básicos) la explicación de cada línea.

A cuidarse!

Debate: Yo vs el Resto

Tras cuatro años de compartir vivencias, clases, prácticas y demás con mi PowerBook G4 de 12 pulgadas llegó la hora de tener más potencia. Tenia muy claro que mi próxima adquisición iba a ser un MacBook Pro, pero casualidades de la vida cuando lo fui a comprar salio el nuevo MacBook Pro (teclado negro) y este evento hizo que me pensase que modelo adquirir: El viejo MacBook Pro o el nuevo.

Todo esto hizo que se generase un debate en la oficina y que se formasen dos bandos al mas puro estilo Guerra Fría. Por una parte llamemoslos señor "X" y señor "Z", y por otra parte el señor "P" y por último yo.



Al señor "X" y el señor "Z" estaban escandalizados de que gastase 1749 en un portátil, argumentado que por ese precio tenia productos PC con mejores prestaciones en los cuales podría llegar incluso a instalar Leopard. Respecto a esto no tengo nada que decir, puesto que estoy de acuerdo con ellos. Otro de los argumentos que exponian era el famoso tema de los juegos para Mac. Que si los drivers gráficos están cerrados. Que si no podré jugar al Counter que si tal que si cual. Sobre este tema discrepabamos tanto el señor "P" como yo. Puesto que ambos no nos compramos un Mac para jugar (el señor "P" tambien tiene un MacBook Pro). Y aquí podemos abrir el siguiente debate: ¿Qué utilidad vas a darle a tu portátil?. Al final estos señores ("X" y "Z"), usuarios de ubuntu, tienen que recurrir a un emulador de aplicaciones para poder jugar en su ubuntu, al igual que yo en mi mac.

Mientras tanto en la otra parte de la oficina el señor "P" insistía en que comprase el MacBook Pro viejo, puesto que el nuevo dejaba de tener la esencia Apple añadiendo un teclado negro, borde de pantalla negro, pantalla de brillo "Glossy" y demás. Ciertamente, el señor "P" tenia razón. Otro de los argumente fue la poca innovación tecnología del producto (dos tarjetas gráficas, track pad sin botones, DDR3).

Finalmente tras una larga deliberacion con mi chica, la señora "A", y mucha paciencia por su parte, nos decidimos a comprar el MacBook Pro viejo, a lo que añadimos que tuvo un gran descuento por la salida del nuevo modelo y se quedaba en 1399€, este precio seguía siendo escandaloso para "X" y "Z".

El principal tema de discusión de todo esto para mi es el diseño, el diseño por parte de los ingenieros de Apple que intentan cuidar el mas mínimo detalle de cada producto, y ciertamente lo han conseguido hasta ahora. Sabemos que Apple no incluye toda la tecnología que existe en el mercado, prefiere centrarse en que ese producto sea ligero, pequeño, duradero, robusto, bonito, autónomo.

Yo esto lo comparo con los coches, por que se comprán coches mas caros que otros que tienen mejores prestaciones, pues por el diseño, exclusividad, belleza, detalles .....



Tampoco estamos descubriendo nada nuevo, esto en economía se llama Ventaja Estrategica (Si, señor "P" aquella economía que suspendiamos en la carrera ;)), en la que una empresa puede basarse en la diferenciacion (Apple) o en ser lider en costes. Después esta el comprador que es el que decide qué comprar. Quizás si compras algo de una empresa basada en la diferenciación no solo compres el producto, sino que formas parte de una filosofía que dichas empresas se encargan de construir a base de publicidad o a lo largo de la historia mediante las decisiones que han tomado.

Después de esta retahíla filosófica he de decir que la compra ha sido perfecta y que muchas gracias a todos los integrantes de esta historia en especial a mi chica, la señora "A".

Investigación: Instalar Debian etch en Pentium II con 64 Mb de RAM

Y ya estamos otra vez!

¿Cuántos de nosotros no tenemos por casa un equipo viejo? Algo así como un PII con 64Mb de RAM del que no supimos deshacernos a tiempo y ahora sólo ocupa espacio... ¿Lo tirásteis a la basura? lástima, de haber leído ésto antes, quizás no lo hubiérais hecho.

Pues si, hoy veremos como reciclar nuestro viejo Pentium, para, por ejemplo, convertirlo en un media center.

Necesitamos una imágen de Debian etch 4.0 netboot, descargadla de Aquí. Tostadla en un CD e ir a vuestro viejo Pentium, iniciad desde el CD y tal.

Empezad la instalación como en una Debian Normal. No voy a poner los pasos obvios, sólo los que pueden ser críticos.

Elegid el diseño del teclado y vuestra localización:



Dejad un esquema de particiones parecido a éste:



Asumimos que el equipo tiene muy poquito disco duro, unos 4 Gb, así que podemos ponerlo todo en una partición. Una vez escritas las particiones en el disco y configuradas la red, los usuarios etc, debemos elegir un mirror del que descargarnos los paquetes.


Elegid es que mejor os vaya. Después, seleccionaremos los paquetes que queremos instalar, es decir, excepto el sistema estándar, ninguno. Hay que ahorrar espacio y... ¡memoria! No queremos que haya procesos siempre correteando por nuestra escasa RAM.


Una vez seleccionado sólo "standard system" se descargarán e instalarán los paquetes, por cierto, bastante rápido. Después nos pedirá que seleccionemos las resoluciones de pantalla, pero podemos dejarlo por defecto.


Se reinicia. Aparece:



Para la prueba, yo cree un usuario llamado debian con contraseña debian y puse como contraseña de root "debian" Así que ahora podré hacer login en mi nuevo sistema Debian :)

Lo primero que haremos será:

su root
aptitude install x-window-system-core fluxbox

Éso nos instalará el sistema x y el escritorio fluxbox. Fluxbox es un escritorio muy ligero y bastante potente, perfecto para un media center basado en un Pentium conectado a una tele y un ratón.

Para iniciar el entorno gráfico:

startx

Ahora, si queremos que el entorno gráfico inicie cuando se inicie el sistema, podemos editar el archivo /etc/init.d/rc.local:

Debajo de la línea "do_start" añadid:

startx

Ahora, podemos instalar los paquetes que creamos oportunos, por ejemplo:

Navegador web:

iceweasel


Explorador de Archivos:

thunar

Reproductor de audio y video:

gstreamer-plugins-ugly
gstreamer-plugins-bad
mplayer

Editor de documentos:

abiword

Gestor de paquetes:

synaptic


Y así, hasta lo que necesitéis. Ciertamente la lista puede ser larga.

A cuidarse!

Mapa interactivo: el kernel de Linux

Mapa-Interactivo-Linux

Interactive map of Linux kernel, un mapa detallado de «cómo funciona Linux por dentro», ideal para quienes están aprendiendo. Se puede navegar con el ratón (rueda = zoom) o mediante los controles de la ventana; los diferentes detalles están convenientemente hiperenlazados.

No es precisamente una entrada relacionada con la técnica, sino más bien con la teoría (aunque es de la que para programar para Linux es básica) pero es lo suficientemente interesante como para no desperdiciarlo.

Extraído de este enlace a Microsiervos:

http://www.microsiervos.com/archivo/ordenadores/mapa-interactivo-kernel-linux.html

Editar los scripts en el initrd

Y otra más!

Hoy vamos a ver cómo editar el initrd. Supongo que a vosotros se os ocurrirá alguna aplicación práctica para ésto. Bueno, ahí va:

Copiad el fichero initrd a una carpeta y:

Si es un gz:

sudo gunzip initrd.gz

Si lo que tenemos es un inird.img, haremos primero:

gunzip -S .img initrd-2.6.X.img


Y Después

sudo cpio -imdF initrd

Y listo, ya tenéis descomprido el initrd.

Volcar una Imágen de Qemu en una partición

Ya estamos otra vez

Hoy vamos a ver como volcar una imágen de qemu en una partición o directorio del equipo Host. Nos encontramos muchas veces con que, hemos hecho una imágen de qemu y queremos migrarla a un equipo de verdad, sin embargo, ésto se convierte en una tarea ardua cuando se trata de imágenes qcow o raw.

Hoy lo vamos a enfocar desde un punto de vista fácil, sencillo e independiente de los tipos de imágenes y sistemas de ficheros.

Vamos a imaginar que tenemos qemu cargado en su imágen raw o qcow y que está funcionando con linux.

Primero, montaríamos nuestra partición de destino, en el equipo host, por ejemplo en /mnt

sudo mount /dev/sdxx /mnt

Después, en el equipo host, con permisos de root, escribiríamos:

nc -l -p 6000 | tar xvf - -C /mnt

Es decir, abrimos un socket en el puerto 6000 y lo que entre, lo descomprimiremos y enviaremos a /mnt.

Ahora, se deja a la espera y pasamos al equipo Guest (qemu) y con permisos de root ejecutaríamos:

tar cvp --same-owner --exclude=/home/error.log --exclude=/proc/* --exclude=/mnt/* --exclude=/sys/* --exclude=/tmp/* --exclude=/var/run/* --exclude=/var/run/* --exclude=/var/lock/* --exclude=/dev/* / | nc IP_DEL_EQUIPO_HOST 6000

De ésta forma, lo que hacemos es comprimir todo el sistema (excepto lo que excluímos, que cambia en cada máquina) y lo canalizamos, en lugar de a un archivo a la salida estándar, de ahí lo pasamos al socket que tenemos abierto hacia nuestra propia máquina.

No se ha probado, pero es muy posible que ésto funcione también para otras máquinas en la red, es decir, volcar nuestro qemu en otra máquina en red ¿genial no?

Os dejo un pantallazo de la copia en acción... a cuidarse!


Basado en
http://linuxclues.blogspot.com/2007/07/backup-your-system-using-tar.html

Investigación: Haciendo Nuestro Propio Netbook en Ubuntu 8.04 con KDE 4.1

Hola! Hemos vuelto!

Lo que vamos a hacer hoy es montar nuestra propia distro para Netbook, naturalmente estará basada en ubuntu 8.04 Hardy.

Después de ver el trabajo de los chicos de ubuntu con su netbook-remix, por lo menos a mi, se me ocurren otros caminos para éstos pequeños portátiles. El ume-launcher parece una aplicación maximizada que se queda detrás de las aplicaciones que vamos lanzando, pero hay (desde mi punto de vista) un problema. El ume-launcher es muy grande y el panel (que por cierto, no se puede quitar) muy pequeño, además del consumo de memoria adicional.

Entonces pensé que el menú kickoff de KDE 4.1, maximizado, quizás sería una alternativa más "económica" y visualmente más atractiva.

Después de ver el Limpus Linux y la manera que tiene de organizar el contenido, KDE no parece una idea tan descabellada.

Bien, basta de palabrería, lo primero nos bajamos la imágen mínima de ubuntu aquí.

Haced una partición de 3,8 Gb con 256 Mb de SWAP, bien en una imágen de qemu o bien en vuestro disco duro.

Una vez hecha la partición, instalad ubuntu con la opción "cli" en el boot de la imágen, de ésta forma instalaremos sólo lo que vamos a necesitar.

Cuando termine de instalar, añadiremos los siguientes repositorios:

deb http://ppa.launchpad.net/netbook-remix-team/ubuntu hardy main

deb http://ppa.launchpad.net/kubuntu-members-kde4/ubuntu hardy main

Instalaremos KDE 4.1:

sudo aptitude install kde4-core

Daremos permisos al usuario. Si no hacemos éste paso, KDE no arrancará.

sudo chown -R usuario /home/usuario
sudo chgrp -R usuario /home/usuario

Ya podemos reiniciar para ver nuestro KDE funcionando. Para obtener una sensación parecida a la de un Netbook, quizás debiéramos maximizar el menú de Kde.

Si queremos que se parezca a un netbook, podemos instalar el paquete "maximus", de forma que cada vez se abra una aplicación, por defecto aparecerá maximizada.

Para que se abra por defecto en KDE, id al menú Máquina, Preferencias del Sistema, Autoarranque y añadid el programa "maximus" pero no hagáis que se ejecute en terminal.

Os dejo algunos pantallazos de cómo lo he dejado, cuidaros!








Activar protocolos XDMCP y VNC en Cliente de Terminal Server Ubuntu

El cliente de terminal server que trae ubuntu tiene soporte para varios protocolos, entre ellos el XDMCP y VNC, pero no está activados por defecto.

Para poder activar y usar éstos dos protocolos, tenemos que instalar los siguientes paquetes:

xnest
xtightvncviewer

Poned ésto en la consola:

sudo aptitude install xnest xtightvncviewer






Listar un directorio con colores a través del paginador less

Post movido a: Listar un directorio con colores a través del paginador less

Crear o Modificar Mi Propio Live CD de Ubuntu

Ésta va a ser la primera entrada, vamos a crear una versión del live cd de ubuntu.

Cuántas veces no nos hemos encontrado en que queremos enseñar un live cd y no tiene internet para descargar códecs de audio, o bien queremos rescatar un sistema y no tenemos ésa herramienta que siempre instalamos en nuestro ubuntu, por citar algunos ejemplos.

Ahora, con éste sencillo método podremos fardar, o bien rescatar en, o cualquier sistema. Bien, necesitaremos una iso de nuestra versión favorita de ubuntu, y un par de paquetes: squashfs-tools y mkisofs (que ahora se llama genisoimage)

Por cierto, estoy dando por hecho que conocéis bien la consola y sabéis lo que es un chroot, por que si no es así, éste artículo podría costaros un poco de entender.


Sin más dilación, yo concretamente voy a modificar la ubuntu 8.04.1. Ala pues, al tajo:

sudo apt-get install mkisofs squashfs-tools

Para tener las cosas claras y ordenadas, vamos a crear una estructura de directorios para trabajar tranquilos.

El proceso siguiente descibe lo siguiente:

-Montar la imágen del cdrom
-Montar el filesystem.squashfs en un directorio
-Copiar el contenido del filesystem.squashfs a otro directorio para poder modificarlo
-Copiar el resolv.conf del equipo host (principal, el nuestro) para poder acceder a internet
-Chrotearnos en el filesystem.squashfs para poder modificar el sistema de ficheros de forma nativa.

Bueno, ahí va:


mkdir ubuntu8
cd ubuntu8
cp ../ubuntu8.iso .
mkdir image
mkdir squash
mkdir mysquash
sudo mount -t iso9660 -o loop ubuntu8.iso ./image
sudo mount -t squashfs -o loop ./image/casper/filesystem.squashfs ./squash
cp -vr ./squash/* ./mysquash
sudo cp /etc/resolv.conf ./mysquash/etc
sudo chroot ./mysquash

Ahora, en nuestra consola, será como si estuviéramos en el root de un linux normal, es decir, podremos hacer los apt-get install o apt-get remove que queramos, modificando unicamente el squash.

Hacemos los apts necesarios. En mi caso me he quitado todo el tema de ofimática y juegos, he quitado el escritorio gnome y he puesto xfce. Como ya he dicho antes, doy por hecho que ésto lo sabéis hacer, así que no voy a ponerlo aquí (Quizás otro día haga un artículo de introducción a bash)

Ahora hay que empaquetar los cambios del directorio mysquash y generar un filesystem.

mksquashfs ./mysquash filesystem.squashfs

Éso tarda bastante rato, aunque la imágen que generemos sea pequeña. Ahora deberíamos copiar la imágen del live que montamos antes en otro directorio, como por ejemplo: imagen_nueva

Luego ponemos el filesystem.squashfs en el casper de la imágen nueva

sudo cp filesystem.squash ./imagen_nueva/casper

Después hacemos una imágen iso:

mkisofs -J -R -o ubuntu-my-live.iso -no-emul-boot -boot-info-table -b isolinux/isolinux.bin ./imagen_nueva

Ahora ya está, la podemos probar por ejemplo, con qemu.