Continuar leyendo »]]> Como todos sabéis ya, a partir de la versión 4.0+ de Android, éste quitó el soporte de almacenamiento masivo en nuestros dispositivos haciéndonos la vida más difícil a los usuarios de Linux.

A partir de esa versión Android da soporte para MTP (Media Transfer Protocol), que es un conjunto de extensiones a PTP (Picture Transfer Protocol) creado por Microsoft, para permitir al protocolo su uso con otros dispositivos además de cámaras digitales, como por ejemplo reproductores de audio digitales, y otros dispositivos digitales portátiles.

Bien, a partir de la versión de Ubuntu 13.04 Raring Ringtail este soporte de MTP ya viene activado, pero para los usuarios anteriores de Ubuntu…. ¿Cómo lo hacemos?

Si tienes Ubuntu 12.10 o 12.04 sólo que actualizar la versión de GVFS a una más nueva (port de raring). Para ello seguiremos éstos pasos:

sudo add-apt-repository ppa:langdalepl/gvfs-mtp
sudo apt-get update
sudo apt-get upgrade

Una vez efectuada la actualización reiniciamos el equipo y conectamos nuestro dispositivo Android.

Ubuntu 12.04 con soporte MTP

Y listo!!! a disfrutar como antes!

Continuar leyendo »]]> Vamos a aprender cómo extraer una partición de un fichero “img” que contiene un dump de un disco duro físico completo.

En primer lugar informar que podéis hacer una copia de un disco físico entero de esta forma:

# dd if=/dev/sda of=fichero.img

Para extraer una de las particiones, vamos a ver primero el contenido del disco con sfdisk:

# sfdisk -l -uS fichero.img

El resultado que a mi me da es:

Disco fichero.img: 966 cilindros, 255 cabezas, 63 sectores/pista
Unidades = sectores de 512 bytes, contando desde 0

Disp. Inicio Principio Fin Nº sect. Id Sistema
fichero.img1 2048 22527 20480 c W95 FAT32 (LBA)
fichero.img2 22528 63487 40960 83 Linux
fichero.img3 63488 13946879 13883392 83 Linux
fichero.img4 13946880 15523839 1576960 c W95 FAT32 (LBA)

Como vemos que tiene 4 particiones, imaginemos que queremos extraer la partición 3 (fichero.img3) a un archivo:

# dd if=fichero.img of=particion3.img skip=63488 count=13883392

Se hace un dd desde la posición 63488 hasta la posición 13883392 (que es el espacio que ocupa esa en el disco)

Por último ya podríamos montar esa partición para ver su contenido y modificarla:

# mount -o loop particion3.img /mnt/

Si lo que queríamos era sólo montar la partición para modificarla pero sin extraerla de fichero.img, se puede hacer con el comando mount:

Examinamos la partición con el comando parted y nos fijamos cual es el inicio de la partición para pasarselo como offset a mount:

# parted fichero.img

GNU Parted 2.3
Usando fichero.img
¡Bienvenido/a a GNU Parted! Teclee «help» para ver la lista de órdenes.
(parted) unit 
¿Unidad? [compact]? B 
(parted) print 
Modelo: (file)
Disco fichero.img: 7948206080B
Tamaño de sector (lógico/físico): 512B/512B
Tabla de particiones. msdos

Numero Inicio Fin Tamaño Tipo Sistema de archivos Banderas
 1 1048576B 11534335B 10485760B primary fat16 lba
 2 11534336B 32505855B 20971520B primary ext3
 3 32505856B 7140802559B 7108296704B primary ext4
 4 7140802560B 7948206079B 807403520B primary lba

(parted) quit

# mount -o loop,ro,offset=32505856 fichero.img /mnt/

o para escritura:

# mount -o loop,rw,offset=32505856 fichero.img /mnt/

Continuar leyendo »]]> Vamos a crear un sistema GNU/Linux ARM Ubuntu precise para poder ejecutar binarios de armhf o poder osarlo como kit de desarrollo para esta plataforma.

Para comenzar necesitamos crear un sistema de ficheros inicial (root filesystem) y compilar un Kernelcon las herramientas de crosscompiler para arm, lo cual es muy sencillo en un sistema Debian/Ubuntu.

¿Qué haremos?
0.- prerequisitos

sudo apt-get install debootstrap qemu-user-static qemu-system git gcc-arm-linux-gnueabihf

1.- creamos el rootfs
# creamos el fichero de disco duro

fallocate -l 2GiB ubuntu-armhf.ext3
mkfs.ext3 ubuntu-armhf.ext3

# montamos el disco duro

mkdir mnt
sudo mount -o loop ubuntu-armhf.ext3 mnt

# creamos un initial rootfs usando debootstrap

HOSTNAME=ubuntu-armhf sudo debootstrap --variant=minbase --foreign --arch armhf precise ./mnt

# copiamos el fichero binario linkado estáticamente de QEMU dentro del rootfs

sudo cp /usr/bin/qemu-arm-static mnt/usr/bin/

# hacemos chroot dentro del rootfs e iniciamos un shell usando qemu-arm-static

LANG=C sudo chroot mnt /usr/bin/qemu-arm-static -cpu cortex-a9 /bin/sh

# ejecutamos debootstrap second stage desde el chroot:

/debootstrap/debootstrap --second-stage

# creamos el fichero sources.list para apt:

echo "deb http://ports.ubuntu.com precise main restricted universe
deb-src http://ports.ubuntu.com precise main restricted universe" > /etc/apt/sources.list

echo "deb http://ddebs.ubuntu.com precise main restricted universe multiverse" > /etc/apt/sources.list.d/ddebs.list

apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 428D7C01

# instalamos algunos paquetes fundamentales

apt-get update
apt-get install sudo apt-utils dialog less wget nano net-tools isc-dhcp-client

# creamos un fichero de configuracion para la consola serie

cp /etc/init/tty1.conf /etc/init/ttyAMA0.conf

sed -i "s/tty1/ttyAMA0/" /etc/init/ttyAMA0.conf

# añadimos un usuario

adduser mi_usuario

# añadimos el usuario al grupo sudo

usermod -aG sudo mi_usuario

# salimos del entorno chroot

exit

# desmontamos el rootfs

sudo umount mnt
rmdir mnt

2.- cross compilacion del Kernel
# nos descargamos las fuentes del Kernel

git clone -depth=1 git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
mkdir linux-build
cd linux

# creamos un .config basado en la configuración por defecto

make ARCH=arm O=../linux-build vexpress_defconfig

# compiamos el Kernel

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- O=../linux-build -j`getconf _NPROCESSORS_ONLN` zImage
cd ..

3.- arracamos la imagen usando QEMU

qemu-system-arm \
 -M vexpress-a9 -m 1024 \
 -serial stdio -no-reboot \
 -kernel linux-build/arch/arm/boot/zImage \
 -drive file=ubuntu-armhf.ext3,if=sd,cache=writeback \
 --append "rw console=ttyAMA0,38400n8 console=tty root=/dev/mmcblk0"

Continuar leyendo »]]> Normalmente es posible instalar un Mail Transport Agent (MTA) como postfix o exim para que sirva como servidor de correo en cualquier computadora conectada a internet con una dirección IP pública asignada. Sin embargo, debido al problema del SPAM, muchos de los servidores de correo de Internet bloquean el correo no autenticado proveniente de direcciones IP dinámicas, que son las habituales en las conexiones domésticas.

Una de las soluciones existentes es instalar un servidor de correo que no envíe directamente el correo al servidor destino, sino que utilice Google Mail (GMail) para que retrasmita los mensajes.

Para poder enviar correo utilizando el servidor SMTP de GMail (smtp.gmail.com) la conexión tiene que estar cifrada con TLS. Para ello necesitaremos tres elementos:

1. Un certificado autenticado por autoridad certificadora válida para GMail.
2. Una cuenta de correo GMail.
3. Un MTA local.

INSTALACIÓN

Primeramente instalamos Postfix, un MTA bastante completo y configurable. Abrimos una terminal de root (Aplicaciones > Accesorios > Terminal de Root) y escribimos el siguiente comando:

aptitude install postfix

Nota: Postfix tiene conflictos con Exim, pero es seguro remover exim en favor de postfix.

La instalación nos hará algunas preguntas:

1. Tipo de configuración: acá responderemos “Sitio de Internet”.
2. Nombre del sistema de correo: acá pondremos el nombre de dominio de nuestro servidor de correo local. Para nuestro caso, podemos poner el mismo nombre de dominio de nuestra PC. e.g. “micasa”.

Listo, la instalación debe haber finalizado existosamente.

CONFIGURACIÓN

Luego tenemos que editar el fichero /etc/postfix/main.cf y añadir las siguientes líneas al final del archivo:

relayhost = [smtp.gmail.com]:587
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl/passwd
smtp_sasl_security_options = noanonymous
smtp_use_tls = yes
smtp_tls_CAfile = /etc/postfix/cacert.pem

En resumen, acá le estamos diciendo a postfix que utilice relayhost para conectarse al servidor de Gmail, que utilice smtp_sasl_password_maps para extraer los datos de conexión SASL y que utilice smtp_tls_CAfile como certificado para la conexión segura.

AUTENTICACIÓN

Debemos crear el archivo /etc/postfix/sasl/passwd con el siguiente contenido:

[smtp.gmail.com]:587    [CUENTA]@gmail.com:[CONTRASEÑA]

Por ejemplo:

echo "[smtp.gmail.com]:587    luis@gmail.com:123456" > /etc/postfix/sasl/passwd

Y lo protegemos adecuadamente con:

chmod 600 /etc/postfix/sasl/passwd

Seguidamente, hay que transformar el archivo a un fichero indexado de tipo hash mediante la instrucción:

postmap /etc/postfix/sasl/passwd

Lo que creará el fichero /etc/postfix/sasl/passwd.db

CERTIFICACIÓN

Debemos tener instalados los certificados SSL de las autoridades certificadoras para poder realizar éste paso. Los podemos instalar así:

aptitude install ca-certificates

Para añadir la autoridad certificadora Equifax (la que certifica correos de Gmail) al fichero de certificados que utilizará postfix, ejecutamos el siguiente comando en una consola de root:

cat /etc/ssl/certs/Equifax_Secure_CA.pem > /etc/postfix/cacert.pem

PUESTA EN FUNCIONAMIENTO

Finalmente, reiniciamos postfix para aplicar los cambios, así:

/etc/init.d/postfix restart

Podemos comprobar el funcionamiento abriendo dos consolas. En una ejecutaremos el siguiente comando para monitorear el comportamiento del correo (como root):

tail -f /var/log/mail.log

Y en la otra enviaremos un correo:

echo "Éste es un correo de prueba" | mail prueba@gmail.com

Espero que les sea de utilidad

Continuar leyendo »]]> ¿Buscando una forma fácil y rápida de cortar (cut) un video? Se puede utilizar la excelente herramienta ffmpeg, tanto en su versión para Windows como para Linux:

ffmpeg -sameq -ss [inicio_en_formato_hh:mm:ss] -t [duracion_segundos] -i [archivo_original] [archivo_salida]

Vale decir que el parámetro -t [duracion_segundos] es opcional; si no se especifica ffmpeg toma por defecto la duración total del video.
También se puede especificar el corte final en el formato hh:mm:ss utilizando el mismo parámetro -t

Continuar leyendo »]]> ¿Alguna vez te ha pasado que te has quedado corto con la asignación de swap para tu Linux?

La solución sería volver a redimensionar el disco para dar más espacio a la partición swap… un auténtico caos, os propongo una solución mejor:

Crear un fichero swap y asignarlo a tu Linux:

Creamos un fichero vacío de 2 GB por ejemplo:

sudo dd if=/dev/zero of=/var/swapfile bs=1M count=2048

Establecemos permisos:

sudo chmod 600 /var/swapfile 

Creamos el sistems de ficheros swap:

sudo mkswap /var/swapfile 

Creamos la entrada en el fstab para que se ejecute al inicio:

echo /var/swapfile none swap defaults 0 0 | sudo tee -a /etc/fstab

y activamos los cambios ahora!

sudo swapon -a

Listo! Ya tenemos nuestro sistema de ficheros swap en un archivo!

Continuar leyendo »]]> El programa dd es una utilidad que resulta muy apropiada para la creación de imágenes, discos de prueba, eliminación de rastros, clonado de discos, entre otras muchas funciones. Un gran inconveniente de dd es que no nos va indicando el progreso de las operaciones, por lo que no podemos saber ni la velocidad a la que avanza ni si queda mucho para finalizar.

Si tenemos ejecutado por ejemplo una copia del disco sdb a sdc en un terminal:

$ dd if=/dev/sdb of=/dev/sdc

Para saber el progreso sólo tenemos que ejecutar desde otro terminal:

$ pkill -SIGUSR1 dd

En la otra terminal (la primera) aparecerán el estado del dd en ese instante:

$ dd if=/dev/zero of=/dev/zero 
22707933+0 records in
22707932+0 records out
11626461184 bytes (12 GB) copied, 10.8072 seconds, 1.1 GB/s

Continuar leyendo »]]> Uso mucho VirtualBox. En mi ordenador el sistema operativo es Ubuntu, pero gracias a VirtualBox dispongo en cualquier momento de una máquina virtual con otras distros de Linux para desarrollo de software. El otro día pensé si sería posible montar en Ubuntu el disco duro virtual de mi máquina virtual de VirtualBox.

1. Antes de nada, apaga tu máquina virtual. No puedes montarla en Ubuntu si la tienes abierta en VirtualBox
2. Abre el terminal. Todo lo que viene a continuación es a través de terminal.
3. Instala qemu-kvm

   $ sudo apt-get install qemu kvm

4. Carga el módulo network block device.

   $ sudo modprobe nbd

5. Ejecuta qemu-nbd. No olvides sustituir <vdi-file> por el nombre —ruta completa— de tu imagen de disco .vdi)

   $ sudo qemu-nbd -c /dev/nbd0 <vdi-file>

6. Con esto tendrás cargado el disco completo en /dev/nbd0. Cada una de sus particiones se identifica añadiendo p y el número de partición. Por ejemplo, la primera partición sería /dev/nbd0p1.
7. Y ya está! Ahora puedes montar la primera partición del disco virtual escribiendo por ejemplo:

   $ sudo mount /dev/nbd0p1 /mnt/

8. Ya puedes copiar archivos o lo que necesites.
9. Cuando hayas terminado y quieras desmontar la partición y apagar el servicio qemu-nbd (para poder cargarla de nuevo con VirtualBox, por ejemplo) sólo has de escribir lo siguiente:

   $ sudo umount /mnt/ $ sudo qemu-nbd -d /dev/nbd0

Continuar leyendo »]]> Para cambiar el hostname de un servidor basado en Debian solo tienes que editar el archivo de hostname.

vim /etc/hostname

No es necesario reiniciar el servidor para que el cambio tenga efecto, solo correr un script.

/etc/init.d/hostname.sh start

Usualmente el prompt por default trae el hostname incluido, pero también puedes revisarlo con el comando hostname, y con una opción te da el dominio completo.

hostname --fqd

También puedes cambiar el hostname actual con el mismo comando, pero los cambios no son permanentes.