29 de nov. 2009

Canon scann F915000 Driver

Atención a este dato, el scanner lleva la informacion de que es el modelo F915000 pero el respectivo cd de sus drivers no pone el mismo modelo , sino que corresponde al canonscan N340p/n640p
, supongo que seran los compatibles.

Un saludo a todos los que estais buscando este dichoso drivers y una patada en el culo a los de canon.


26 de nov. 2009

Insatalar codecs de video reproducir en fedora, linux rmp fusion


With the proliferation of music services and downloads, it’s easy to forget that many Linux distributions don’t provide support for MP3 and other restrictive codecs. These file types are generally encumbered by patents or non-free licenses and, because of this, a number of distributions will not ship these packages. As a result, users end up being unable to do things that they could otherwise do on Windows or Mac OS X. For those “in the know,” they turn to alternative third-party repositories.

For Fedora, RPM Fusion is one such third-party repository. This repository supplies packages that provide support for listening to MP3 files and watching DVDs or other video types: programs such as MPlayer, Xine, and others. It also includes closed source drivers for NVidia and ATI video cards.

RPM Fusion provides two repositories: free and non-free. The free repository contains open source software that cannot be included in Fedora due to potential patent issues. The non-free repository contains non-free software: software that is closed source or has publicly available source code with “no commercial use” and similar restrictions.

To set up these two repositories, install the appropriate RPM packages from rpmfusion.org:

# rpm -ivh http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm

Retrieving http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm

Preparing... ########################################### [100%]

1:rpmfusion-free-release ########################################### [100%]

# rpm -ivh http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm

Retrieving http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm

Preparing... ########################################### [100%]

1:rpmfusion-nonfree-relea########################################### [100%]

# yum update

You may notice warnings of unknown GPG signatures on these packages. For now it is safe to ignore them as they will be imported later.

When you run yum update, you will be prompted to install new versions of the package that are specific to your Fedora version (in this case version 10-1). It will also import the required GPG keys for each repository, which are used to verify the authenticity of packages that are subsequently downloaded from the repositories.

Once this is done, you can begin installing packages using yum. A GUI tool would make it easier to browse the packages, but you can do the same with yum:

# yum list | grep rpmfusion-free

This will list all packages known to yum in every repository, and filter on those with the name “rpmfusion-free.” Once you know the package name you are interested in, install it like you would any official package:

# yum install mplayer

Setting up RPM Fusion may sound like a hassle, but it can be done in minutes, and once it is set up, you can install a number of packages that give you proprietary graphics drivers, DVD and MP3 players and codecs, and even some games (such as various game emulators). RPM Fusion doesn’t provide a ridiculous number of packages as Fedora is quite complete, but it definitely complements what you get out of a Fedora install quite nicely.

Linux Backups , basico y facil backups de documentos en linux



Backup script for Linux using tar and find

Every Linux distribution provides a range of utilities that you can use to make backups of your files. Here is the how I get the job done with crontab and a shell script using tar and find

I wanted to secure all the data-files on my system on a regular basis. Regular for me implies on an automated basis. I've tried doing a manual backup every week or so but that caused too much hassle, so effectively I stopped making backups....
Further, I wanted to have an up-to-date backup of the most essential configuration settings on my system. This would help me in case I accidentally lost some datafiles or setting on my system. In case of losing everything I would need to reinstall my Linux distribution (plus extra installed software) and restore data files and settings. I decided that a full backup of the whole system wouldn't be worth the effort (and resources!).
Choice of hardware

Say "backup" and most Unix people think "tapedrive". However, nowadays harddrives come that cheap that I chose to add an extra harddrive to my AMD 400 machine. This cheap option has the advantage that a harddrive can be mounted automatically, no need for manually inserting tapes. A disadvantage is that the backup resides in the same physical unit as the very data it is supposed to secure. However, since I do have a CD-writer om my local network I still have the option to copy a backup to a CD once in a while.
My main HD is 6Mb. The backup HD has 10Mb.

After adding the drive to my machine I wrote a little shell script (for bash) that basically does the following:

* it mounts my backupdrive
* it checks the date
* every sunday it makes a full backup of some datafiles and some configuration settings, older incremental backups are removed. other days it backups files that have been accessed the last day
* it dumps all the contents of a mysql database to the backup drive and zips the file
* it unmounts the backup drive

This script (I've stored it in /root/scripts) is called every night at 3:01 AM by cron. The crontab file looks like:

1 3 * * * /root/scripts/daily_backup

Add this line using contab -e when root.


Here's the actual code:

# creates backups of essential files
DATA="/home /root /usr/local/httpd"
CONFIG="/etc /var/lib /var/named"
mount /mnt/backup
set $(date)
if test "$1" = "Sun" ; then
# weekly a full backup of all data and config. settings:
tar cfz "/mnt/backup/data/data_full_$6-$2-$3.tgz" $DATA
rm -f /mnt/backup/data/data_diff*
tar cfz "/mnt/backup/config/config_full_$6-$2-$3.tgz" $CONFIG
rm -f /mnt/backup/config/config_diff*
# incremental backup:
find $DATA -depth -type f \( -ctime -1 -o -mtime -1 \) -print > $LIST
tar cfzT "/mnt/backup/data/data_diff_$6-$2-$3.tgz" "$LIST"
rm -f "$LIST"
find $CONFIG -depth -type f \( -ctime -1 -o -mtime -1 \) -print > $LIST
tar cfzT "/mnt/backup/config/config_diff_$6-$2-$3.tgz" "$LIST"
rm -f "$LIST"
# create sql dump of databases:
mysqldump -u root --password=mypass --opt mydb > "/mnt/backup/database/mydb_$6-$2-$3.sql"
gzip "/mnt/backup/database/mydb_$6-$2-$3.sql"
umount /mnt/backup


data files:
All my data files are in /root, /home or /usr/local/httpd.

I chose to backup all the setting in /etc (where most essential settings are stored), /var/named (nameserver settings) and /var/lib (not sure about the importance of this one...). I might need to add more to the list but I still far from being a Unix-guru ;-). All suggestions are welcome!

tar versus cpio
The first version of this script used cpio to create backups iso tar. However, I found the cpio format not very handy for restoring single files so I chang ed it to tar. A disadvantage of using tar is that you can't (as far as I know) simply pipe the output of a find to it.
Using a construct like tar cvfz archive.tgz `find /home -ctime -1 -depth -print` caused errors for files that contained a space " " character. This problem was solved by wring the output of find to a file first (and using tar with the -T option).


Tipos de copia de seguridad
En función de la cantidad de archivos que se salvaguardan a la hora de realizar la copia de seguridad, podemos distinguir tres tipos de copia:

* Copia de seguridad total o íntegra
* Copia de seguridad incremental
* Copia de seguridad diferencial

Copia normal o copia total

Una copia de seguridad normal, es una copia de seguridad total de todos los archivos y directorios seleccionados.
Copia incremental

En un proceso de copia de seguridad incremental, se hace una copia de seguridad sólo de los archivos que han cambiado desde la última copia de seguridad realizada. Ejemplo, si hacemos copia de seguridad total el día 1 de cada mes y copia de seguridad incremental el resto de los días, cada copia incremental solo guardará los archivos que se hayan modificado ese día. Si tenemos que realizar la restauración de archivos ante un desastre, debemos disponer de la copia total y de todas las copias incrementales que hayamos realizado desde la copia total.

Copia diferencial

Una copia de seguridad diferencial es una copia de todos los archivos que han cambiado desde la última copia de seguridad total que hayamos hecho. Ejemplo, si hacemos copia de seguridad total el día 1 de cada mes y copia de seguridad diferencial el resto de los días, cada copia diferencial guardará los archivos que se hayan modificado desde el día 1. La ventaja es que se requiere menos espacio que la copia total y que en el proceso de restauración únicamente necesitaremos la última copia total y la última copia diferencial. Una copia diferencial anula a la copia diferencial anterior. Por el contrario, se consume más tiempo en realizar la copia y también más espacio que en el caso de copia incremental.

Recomendación sobre el tipo de copia a efectuar
Si el volumen de datos de nuestra copia de seguridad no es muy elevado (menos de 100 MB), lo más práctico es realizar siempre copias totales ya que en caso de desastre, tan solo debemos recuperar la última copia.

Si el volumen de datos de nuestra copia de seguridad es muy elevado (varios GB) pero el volumen de datos que se modifican no es elevado (menos de 500 MB), lo más práctico es realizar una primera copia total y posteriormente realizar siempre copias diferenciales. Así, en caso de desastre, tan solo debemos recuperar la copia total y la última diferencial. Periódicamente debemos realizar una copia total y así empezar de nuevo.

Si el volumen de datos de nuestra copia de seguridad es muy elevado (varios GB) y el volumen de datos que se modifican también lo es, las copias diferenciales ocuparán mucho espacio, por lo tanto en este caso lo más práctico será realizar una primera copia total y posteriormente realizar siempre copias incrementales ya que son las que menos espacio ocupan. El problema es que en caso de desastre debemos recuperar la última copia total y todas las incrementales realizadas desde que se hizo la última copia total. En estos casos, conviene hacer copias totales más a menudo para no tener que mantener un número muy elevado de copias incrementales.

En grandes compañías donde la realización de copias de seguridad está perfectamente planificada, se suelen utilizar sistemas mixtos. Por ejemplo en un caso típico se realizarían las siguientes tareas:

* Todos los días 1 de cada més, a las 23:00 horas: copia de seguridad total
* Todos los viernes a las 23:00 horas: copia de seguridad diferencial desde la copia de día 1
* Todos los días (excepto los viernes y el día 1) a las 23:00 horas: copia de seguridad incremental desde la copia del día anterior.

Con ésta planificación nos aseguramos disponer de copia de seguridad diaria. En caso de desastre deberíamos recuperar la copia total, la última diferencial y todas las incrementales desde la última diferencial.

En una política de este tipo se pueden utilizar por ejemplo 5 juegos diferentes de cintas de forma que se almacenen las copias de seguridad diarias de los últimos 3 meses. Luego se van reutilizando pero no más de 20 veces ya que las cintas se deterioran y la fiabilidad disminuye.
Creación de copias de seguridad
Elección de las carpetas a salvaguardar
Lo primero que debemos determinar son las carpetas que queremos salvaguardar en nuestro proceso de copias de seguridad.

En un sistema informático que da servicio a usuarios, la información más importante es precisamente la información de los usuarios, por lo tanto, la carpeta /home es una de las carpetas que debemos salvaguardar.

El objetivo de la realización de copias de seguridad es el reestablecimiento del servicio en el mínimo tiempo posible, por eso es conveniente realizar una copia de seguridad de los archivos de configuración del servidor, los cuales se encuentran en la carpeta /etc.

Otras carpetas de cierta importancia que se pueden salvaguardar son la carpeta /root y la carpeta /var/log. La primera es la carpeta personal del usuario root y la segunda es la carpeta donde se almacenan las incidencias del sistema (archivos de log del sistema). Resumiendo, deberíamos salvaguardar las siguientes carpetas:

* /home (Carpetas personales de los usuarios)
* /etc (Archivos de configuración del sistema)
* /root (Carpeta personal del usuario root)
* /var/log (Carpeta de logs del sistema)
* /var/www (Web de la intranet)

Por qué se debe comprimir la copia de seguridad
Cuando realizamos copias de seguridad, los datos deben comprimirse siempre por tres razones:

* La copia se realiza más rápidamente
* El tamaño de la copia es menor
* La compresión garantiza la integridad de los datos

Al quedar los datos reducidos, la cantidad de datos a copiar en el soporte de almacenamiento es mucho menor que lo que ocupan los datos descomprimidos; eso unido al hecho de que los datos estén compactados en un único archivo, hace que el tiempo en trasmitir los datos desde el servidor al soporte, sea menor que si no se comprime.

La integridad de los datos queda garantizada porque el algoritmo de compresión añade un código de redundancia cíclica (CRC) que se consulta a la hora de descomprimir los datos de forma que tenemos seguridad si están correctos o no lo están.

El proceso de creación de copias de seguridad debe ser un proceso automático que no requiera la intervención del usuario para realizarse ya que un olvido o dejadez del usuario podría ocasionar que el día que necesitemos la copia de seguridad, no se haya hecho.

Para lanzar la realización automática de copias utilizaremos cron. Cron es un servicio que nos permite lanzar comandos autom�ticamente los días y a las horas que deseemos. Cada usuario tiene su propio cron en el que puede configurar sus tareas programadas mediante el comando 'crontab -e' o con la aplicación gráfica kcron. En nuestro caso, como realizamos copia de seguridad de carpetas que solamente tiene acceso el usuario root, debemos programar la copia mediante el cron de root.

Supongamos que deseamos crear una copia de seguridad total los días 1 de cada mes y una copia de seguridad diferencial el resto de días en la carpeta /tmp (temporal), de las carpetas /home y /etc. El comando que ejecutaremos el día 1 de cada mes será:

// Comando a ejecutar los días 1 de cada mes

tar -jcvf /tmp/CopiaTotal_etc-home_`date +%d%b%y`.tar.bz2 /home /etc

Como puede verse, utilizamos `date %d%b%y` que si hoy es 1 de febrero de 2009 se sustituira por 1feb09. De ésta forma nos sirve el mismo comando para todos los meses.

El comando que ejecutaremos todos los días para realizar la copia diferencial, será:

// Comando a ejecutar los días para hacer copia diferencial respecto al día 1

tar -jcvf /tmp/CopiaDiferencial_etc-home_01`date +%b%y`-`date +%d%b%y`.tar.bz2 /home /etc -N 01`date +%b%y`

Como puede verse, utilizamos 01`date %b%y`-`date %d%b%y` que si hoy es 13 de febrero de 2009 se sustituira por 01feb09-13feb09. También en la opción -N ponemos 01`date +%b%y` para que añada únicamente los archivos más nuevos que el día 1 del mes actual. De ésta forma nos sirve el mismo comando para todos los días.

Si deseamos programar para que automáticamente se ejecute la copia total el día 1 de cada més y la copia diferencial todos los días, debemos añadirlo en el cron del usuario root lo cual se puede realizar ejecutando el comando 'crontab -e' o bien utilizando una aplicación como 'kcron':

Al final nuestro archivo cron para que se ejecuten automáticamente los comandos que realizan las copias de seguridad quedará como el de la figura:

De ésta forma, los días 1 de cada mes a las 02:30 horas se realizará la copia total de las carpetas /etc y /home y todos los días a las 03:30 horas se realizará la copia diferencial respecto de la copia del día 1 del mes.

Las copias de seguridad se realizarán sobre la carpeta /tmp, pero lo recomendable es realizar la copia de seguridad sobre un dispositivo extraible como cintas, cds, dvds o un pendrive. Habrá que sustituir /tmp por la carpeta donde esté montado el dispositivo. Ejemplo, si se trata de un pendrive USB, lo más normal es que el dispositivo esté montado en la carpeta /mnt/sda1 o algo parecido ya que se monta como un dispositivo SCSI, lo que quiere decir que en lugar de poner /tmp en el comando tendríamos que poner /mnt/sda1.

Copias de seguridad en servidores remotos
Lo comentado anteriormente permite realizar copias de seguridad en un disco duro local. Una mejora añadida sería la creación de la copia en una carpeta remota. Al igual que se automatiza la creación de la copia, se podría ejecutar automáticamente un comando que, vía ftp o ssh, vuelque los archivos en un servidor remoto para mayor seguridad. También existen herramientas para realizar directamente copias de seguridad remotas:

* rsync: permite realizar copias en carpetas remotas
* unison: permite mantener sincronizadas dos carpetas remotas

Aplicaciones para la realización de copias de seguridad
Existen aplicaciones tanto libres como de pago que facilitan la tarea de realización de copias de seguridad. Entre las aplicaciones libres destacamos:

* BackupPC: Herramienta para hacer copias de seguridad de PCs de la red
* Amanda: Herramienta para hacer copias de seguridad de PCs de la red
* afbackup: Herramienta para hacer copias de seguridad de PCs de la red
* sbackup: Simple Backup.
* pybackpack: copias de seguridad locales y remotas vía ssh.

Estas aplicaciones tienen la ventaja de ser muy completas ya que disponen de un sinfín de posibilidades, pero son más complejas de manejar.



Página del isftic

* Curso Redes de Área Local. Aplicaciones y servicios en Linux. del isftic: http://www.isftic.mepsyd.es/formacion/materiales/85/cd/REDES_LINUX/indice.htm

* http://ubuntu.teoriza.net/como-crear-copias-de-seguridad-facil-e-intuitivamente-con-sbackup.php
* http://www.alejandrox.com/2007/05/copias-de-seguridad-en-ubuntu-con-pybackpack/

24 de nov. 2009

contactos de outlook 2003 a outlook express


Lo primero teopoulus, yo no he nacido sabiendo como tu dices (ya me gustaría). Me paso muchas horas delante del ordenador aprendiendo y buscándome la vida para solucionar los problemas. No soy de esas personas que ni siquiera investigan un poco, por ejemplo por google y que se ponen a escriben un mensaje en los foros esperando a que alguien les haga todo el trabajo. Tampoco digo que tu seas uno de ellos porque no te conozco.

Lo segundo, en tu segunda respuesta al post parecia como si ni siquiera hubieras leido el post del amigo torogt porque de haberlo leido con atención verías que pone Te muestra una lista de tus carpetas de Outlook seleccionas la carpeta contactos. Pero eso no es todo, sino que como nadie te habia contestado, tu malhumorado preguntaste en este mismo foro si habia oro foro de ofimatica mejor que te solucionaran los problemas (http://www.forosdelweb.com/f90/alguien-conoce-foro-mas-potente-ofimatica-que-este-409689/).

Pero bueno, la diferencia de este foro con respecto a otros es que cuando se puede échamos una mano si es posible y eso es lo que voy a hacer porque investigando un poco al parecer desde la versión 5 del outlook express, ese método no vá del todo bien. Asi que os voy a explicar como se pasan contactos por ejemplo desde outlook xp a outlook express beta 6 que es lo que tengo en mi ordenador y con lo que he estando haciendo pruebas.

Primero tenemos que generar una nueva libreta de direcciones para Outlook. Para eso tenemos que ir a Panel de control - Correo - Cuentas de correo electronico. Seleccionamos Agregar una nueva libreta de direcciones, Luego la opcion libretas de direcciones adicionales, y por ultimo libreta personal de direcciones. Nos aparece una nueva ventana donde pondremos el nombre de la libreta, la ruta donde la vamos a guardar y seleccionamos que muestre los nombres por apellidos.

Buenos ya tenemos la libreta creada, abrimos el outlook y vamos a herramientas - Libreta de direcciones. Una vez abierta vamos a herramientas - opciones y aqui es donde viene el paso mas importante.

* Donde pone, mostrar primero esta lista de direcciones, seleccionamos si es que no está puesta Contactos que cuelga de la libreta de direcciones de outlook.
* Donde pone, guardar direcciones personales ahí tenems que seleccionar la libreta de direcciones que hemos creado nueva.

Vale, una vez hecho volvemos a la pantalla principal de la libreta de direcciones, ala derecha hay un selector que pone Mostrar los nombres que figuran en: seleccionamos Contactos. Nos tienen que aparecer los contactos que tenemos en outlook, los seleccionamos todos pinchando en el primero y con la tecla Shift Mayusculas sin dejar de pulsarla, seleccionamos el ultimo de todos. Una vez los tenemos todos seleccionados vamos al menú archivo y elegimos la opcion Agregar a la libreta de direcciones.

Ya queda poco, cerramos el outlook y abrimos el outlook express. Menu archivo - Importar - Otra libreta de direcciones y elegimos Libreta presonal de direcciones de Microsoft exchange y bualá, tiene que pasarnos los contactos.

Una vez que todo esté correcto hay que entrar de nuevo en outlook, abrir la libreta de direcciones. Entramos en el menú herramientas - opciones y cambiamos la opcion guardar direcciones personales y ponemso de nuevo outlook, para que los nuevos contactos que generes se guarden ahí ;D.

Por ultimo, entramos otra vez en panel de control - correo - cuentas de correo electronico y eliminamos la libreta de direcciones que hemos creado para poder pasar los contactos y listo.

Ya sé que es un poco de lio pero funciona. Espero que os funcione a ambos y si teneis algun problema ó duda ya sabeis donde postearlo que gustosamente intentaré ayudaros.

Un saludo.

Raid 1 en Linux


Siguiendo el artículo anterior del servidor NAS para casa, aquí cuento todo lo que hice para configurar y probar el raid 1 en debian y las conclusiones finales a las que llegué. Este pequeño tutorial lo he hecho en una máquina virtual VMware por lo cómodo que es probar e instalar todo. El disco de sistema es hda con una única partición y los discos con los que se creará el raid 1 serán hdb y hdc. Muestro en rojo lo que he introducido en los diferentes menús.
# Particionar los dos discos duros. El sistema de archivos debe ser Linux raid auto.

shian:~# fdisk /dev/hdb
Command (m for help): p

Disk /dev/hdb: 1073 MB, 1073741824 bytes
16 heads, 63 sectors/track, 2080 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

Device Boot Start End Blocks Id System

Command (m for help): n
Command action
e extended
p primary partition (1-4)
Partition number (1-4): 1
First cylinder (1-2080, default 1):INTRO
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-2080, default 2080):INTRO
Using default value 2080

Command (m for help): t
Selected partition 1
Hex code (type L to list codes): fd
Changed system type of partition 1 to fd (Linux raid autodetect)

Command (m for help): p

Disk /dev/hdb: 1073 MB, 1073741824 bytes
16 heads, 63 sectors/track, 2080 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

Device Boot Start End Blocks Id System
/dev/hdb1 1 2080 1048288+ fd Linux raid autodetect

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

# Repetimos los pasos para /dev/hdc.
# Creamos el raid 1 con las dos particiones que acabamos de crear. En las opciones indicamos que el tipo de raid será 1 (mirror), que deseamos utilizar dos discos y que el nuevo dispositivo raid será /dev/md0.

shian:~# mdadm --create /dev/md0 --verbose --level=1 --raid-devices=2 /dev/hdb1 /dev/hdc1
mdadm: size set to 1048192K
mdadm: array /dev/md0 started.

NOTA: Si ya hemos usado el disco anteriormente para otro raid, es necesario reiniciar el superbloque para que se borre la información existente, puesto que sino, la creación puede fallar:

shian:~# mdadm --zero-superblock /dev/sdXX

# El raid 1 se está creando en segundo plano. En función del tamaño de los discos tardará más o menos. Se puede ver el estado en el archivo /proc/mdstat:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus1/target0/lun0/part1[1] ide/host0/bus0/target1/lun0/part1[0]
1048192 blocks [2/2] [UU]
[===========>.........] resync = 58.2% (611196/1048192) finish=0.0min speed=101866K/sec
unused devices:

# El porcentaje va subiendo hasta que finalmente el dispositivo está listo:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus1/target0/lun0/part1[1] ide/host0/bus0/target1/lun0/part1[0]
1048192 blocks [2/2] [UU]

unused devices:

# A partir de este momento para cualquier manipulación que deseemos hacer del raid debemos utilizar /dev/md0 y no /dev/hdb1 ni /dev/hdc1.
# Formateamos el raid

shian:~# mkfs.ext3 /dev/md0
mke2fs 1.37 (21-Mar-2005)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
131072 inodes, 262048 blocks
13102 blocks (5.00%) reserved for the super user
First data block=0
8 block groups
32768 blocks per group, 32768 fragments per group
16384 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376

Writing inode tables: done
Creating journal (4096 blocks): done
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 22 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.

# Creamos el punto de montaje, añadimos la entrada correspondiente para que el raid se monte cuando se arranca la máquina y lo montamos:

shian:~# mkdir /mnt/raid

shian:~# echo "/dev/md0 /mnt/raid ext3 defaults 0 1" >> /etc/fstab

shian:~# mount /mnt/raid

shian:~# df -h /dev/md0
Filesystem Size Used Avail Use% Mounted on
/dev/md0 1008M 17M 941M 2% /mnt/raid

# Aquí ya habríamos terminado la instalación del raid y podríamos utilizarlo, aunque tal y como está configurado y montado sólo tendría permisos el usuario root.

A partir de aquí, lo que yo hice inicialmente fue simular que un disco duro se estropeaba y al arrancar la máquina quería montar el raid sólo con el otro disco y utilizarlo normalmente. Además, después de simular con la máquina virtual que añadía un nuevo disco duro, quería añadirlo al raid para volver a tener de nuevo la redundancia. Después de leer muchos tutoriales y foros no había manera de que funcionase. Si reiniciaba la máquina sin un disco del raid, éste no se montaba y no podía acceder a los datos. Además, el dispositivo /dev/md0 no era reconocido, por lo que era como si el raid no existiese!. Finalmente, encontré en un pequeño tutorial la solución a mis problemas.

# Es necesario indicarle al sistema operativo cómo acceder a ese dispositivo raid para que sea capaz de utilizarlo. Esto que puede parecer tan obvio no venía en ningún tutorial ni en ninguna ayuda de las que consulté.

shian:/# cd /etc/mdadm
shian:/etc/mdadm# cp mdadm.conf mdadm.conf.`date +%y%m%d`
shian:/etc/mdadm# echo "DEVICE partitions" > mdadm.conf
shian:/etc/mdadm# mdadm --detail --scan >> mdadm.conf
shian:/etc/mdadm# cat mdadm.conf
DEVICE partitions
ARRAY /dev/md0 level=raid1 num-devices=2 UUID=a48e6816:ea6e7f37:6cc50cdb:6fead399

# Ahora ya podemos reiniciar la máquina y el raid arrancará y se montará automáticamente en el arranque.
# Podemos probar a parar el dispositivo y a levantarlo de nuevo:

shian:/etc/mdadm# umount /mnt/raid
shian:/etc/mdadm# mdadm --stop /dev/md0
shian:/etc/mdadm# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
unused devices:

shian:/etc/mdadm# mdadm --assemble /dev/md0 /dev/hdb1 /dev/hdc1
mdadm: /dev/md0 has been started with 2 drives.
shian:/etc/mdadm# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus0/target1/lun0/part1[0] ide/host0/bus1/target0/lun0/part1[1]
1048192 blocks [2/2] [UU]

unused devices:

Ahora sí, vamos a probar si realmente el podemos recuperar la información y el sistema funciona correctamente en caso de caída de un dispositivo. Además, veremos cómo reemplazar el disco defectuoso y recuperar de nuevo el raid 1 con los dos discos.
# Creamos un archivo aleatorio de 25MB en el raid montando previamente de nuevo el raid:

shian:/# mount /dev/md0 /mnt/raid
shian:/# dd if=/dev/urandom of=/mnt/raid/random1 count=51200
51200+0 records in
51200+0 records out
26214400 bytes transferred in 7.829523 seconds (3348148 bytes/sec)

# Calculamos su CRC y lo apuntamos. Posteriormente nos servirá para comprobar que todo es correcto:

shian:/# cksum /mnt/raid/random1
1652310020 26214400 /mnt/raid/random1

# Vamos a simular un fallo en uno de los dispositivos. Para ello apagamos el sistema, desconectamos uno de los discos duros (en este caso /dev/hdb) y arrancamos de nuevo.
# Una vez arrancado de nuevo el sistema, si examinamos con detalle los mensajes de arranque encontraremos algo como lo siguiente. Como se puede ver el sistema ha detectado un disco falla y al no haber un disco de repuesto (spare) levanta el raid en modo degradado con un sólo disco. Podremos seguir utilizando el raid con total normalidad pero si este disco también fallase, perderíamos irremediablemente todos los datos.

md: bind
md: ide/host0/bus1/target0/lun0/part1's event counter: 00000006
md0: former device hdb1 is unavailable, removing from array!
md: raid1 personality registered as nr 3
md0: max total readahead window set to 124k
md0: 1 data-disks, max readahead per data-disk: 124k
raid1: device ide/host0/bus1/target0/lun0/part1 operational as mirror 1
raid1: md0, not all disks are operational -- trying to recover array
raid1: raid set md0 active with 1 out of 2 mirrors
md: updating md0 RAID superblock on device
md: ide/host0/bus1/target0/lun0/part1 [events: 00000007]<6>(write) ide/host0/bus1/target0/lun0/part1's sb offset: 1048192
md: recovery thread got woken up ...
md0: no spare disk to reconstruct array! -- continuing in degraded mode
md: recovery thread finished ...

# En el archivo /proc/mdstat podemos ver el estado del raid. Ahora mismo se encuentra funcionando sólo con un dispositivo de dos posibles y nos indica que el que ha fallado es el primero de ellos:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus1/target0/lun0/part1[1]
1048192 blocks [2/1] [_U]

unused devices:

# No obstante el raid está montado y el filesystem es accesible:

shian:~# df -h /dev/md0
Filesystem Size Used Avail Use% Mounted on
/dev/md0 1008M 42M 916M 5% /mnt/raid

# Ahora marcamos el disco /dev/hdb1 como fallo para proceder a cambiarlo:

shian:~# mdadm --manage /dev/md0 --fail /dev/hdb1
mdadm: set /dev/hdb1 faulty in /dev/md0

Apagamos la máquina y cambiamos el disco duro defectuoso por uno nuevo. En el caso de VMware basta con crear un nuevo dispositivo de tipo disco duro. Además, este disco duro nuevo que añadimos va a ser de mayor tamaño que el anterior. Idealmente en un raid 1 los dos discos duros deben tener el mismo tamaño, pero linux nos proporciona la suficiente flexibilidad para que esto no sea así.

# En el arranque de la máquina vemos que el raid sigue arrancando pero en modo degradado. Lo que vamos a hacer es crear la tabla de particiones del nuevo disco duro exáctamente igual que la del disco duro que aún funciona y que forma parte del raid:

shian:~# sfdisk -d /dev/hdc | sfdisk /dev/hdb
Checking that no-one is using this disk right now ...

Disk /dev/hdb: 4161 cylinders, 16 heads, 63 sectors/track

sfdisk: ERROR: sector 0 does not have an msdos signature
/dev/hdb: unrecognized partition table type
Old situation:
No partitions found
New situation:
Units = sectors of 512 bytes, counting from 0

Device Boot Start End #sectors Id System
/dev/hdb1 63 2096639 2096577 fd Linux raid autodetect
/dev/hdb2 0 - 0 0 Empty
/dev/hdb3 0 - 0 0 Empty
/dev/hdb4 0 - 0 0 Empty
Warning: no primary partition is marked bootable (active)
This does not matter for LILO, but the DOS MBR will not boot this disk.
Successfully wrote the new partition table

Re-reading the partition table ...

If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)
to zero the first 512 bytes: dd if=/dev/zero of=/dev/foo7 bs=512 count=1
(See fdisk(8).)

# Como este nuevo disco duro es mayor que el anterior, podemos crear una partición /dev/hdb2 y formatearla para utilizarla sin problemas.

shian:~# fdisk /dev/hdb

The number of cylinders for this disk is set to 4161.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of LILO)
2) booting and partitioning software from other OSs

Command (m for help): n
Command action
e extended
p primary partition (1-4)
Partition number (1-4): 2
First cylinder (2081-4161, default 2081):INTRO
Using default value 2081
Last cylinder or +size or +sizeM or +sizeK (2081-4161, default 4161):INTRO
Using default value 4161

Command (m for help): p

Disk /dev/hdb: 2147 MB, 2147483648 bytes
16 heads, 63 sectors/track, 4161 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

Device Boot Start End Blocks Id System
/dev/hdb1 1 2080 1048288+ fd Linux raid autodetect
/dev/hdb2 2081 4161 1048824 83 Linux

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.

shian:~# mkfs.ext3 /dev/hdb2
mke2fs 1.37 (21-Mar-2005)
warning: 62 blocks unused.

Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
131328 inodes, 262144 blocks
13110 blocks (5.00%) reserved for the super user
First data block=0
8 block groups
32768 blocks per group, 32768 fragments per group
16416 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376

Writing inode tables: done
Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 30 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.

shian:~# mkdir /mnt/tmp

shian:~# mount /dev/hdb2 /mnt/tmp

# Ahora vamos a reconstruir el raid:

shian:~# mdadm --manage /dev/md0 --add /dev/hdb1
mdadm: hot added /dev/hdb1

# En este instante el raid 1 se está reconstruyendo. Toda la información del disco existente (/dev/hdc1) se está escribiendo en el nuevo disco (/dev/hdb1) para reconstruir el mirror y tener de nuevo la redundancia. Podemos comprobar el estado en el archivo /proc/mdstat:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus0/target1/lun0/part1[2] ide/host0/bus1/target0/lun0/part1[1]
1048192 blocks [2/1] [_U]
[=======>.............] recovery = 39.5% (415488/1048192) finish=0.1min speed=69248K/sec
unused devices:

# Finalmente, después de un tiempo tenemos el raid recuperado:

shian:~# cat /proc/mdstat
Personalities : [raid1]
read_ahead 1024 sectors
md0 : active raid1 ide/host0/bus0/target1/lun0/part1[0] ide/host0/bus1/target0/lun0/part1[1]
1048192 blocks [2/2] [UU]

unused devices:

# Si no nos fiamos de que todo esté correcto (yo tengo que verlo para creerlo), podemos hacer lo siguiente para comprobar que la recuperación se ha realizado satisfactoriamente. Lo que vamos a hacer es desmontar el raid, montar únicamente el nuevo dispositivo /dev/hdb1 y comprobar el CRC del archivo que generamos anteriormente para comprobar que la recuperación ha sido correcta.

shian:~# umount /mnt/raid
shian:~# mount /dev/hdb1 /mnt/raid
shian:~# cksum /mnt/raid/random1
1652310020 26214400 /mnt/raid/random1

# Y listo!. El raid se ha recuperado correctamente y toda nuestra información está a salvo. Es importante dejarlo todo como estaba antes de utilizarlo puesto que ahora mismo en /mnt/raid se encuentra montado de manera temporal sólo un dispositivo del raid y no éste completo. Si ahora hiciéramos algún cambio, creásemos archivos,... perderíamos todos esos datos en cuanto montásemos de nuevo el raid. Mejor lo dejamos todo como estaba:

shian:~# umount /mnt/raid/
shian:~# mount /mnt/raid/
shian:~# df -h /mnt/raid/
Filesystem Size Used Avail Use% Mounted on
/dev/md0 1008M 42M 916M 5% /mnt/raid

# Si ahora reiniciamos la máquina vemos que el raid arranca correctamente con los dos discos de nuevo:

md: ide/host0/bus0/target1/lun0/part1's event counter: 0000000c
md: ide/host0/bus1/target0/lun0/part1's event counter: 0000000c
md: raid1 personality registered as nr 3
md0: max total readahead window set to 124k
md0: 1 data-disks, max readahead per data-disk: 124k
raid1: device ide/host0/bus0/target1/lun0/part1 operational as mirror 0
raid1: device ide/host0/bus1/target0/lun0/part1 operational as mirror 1
raid1: raid set md0 active with 2 out of 2 mirrors
md: updating md0 RAID superblock on device
md: ide/host0/bus0/target1/lun0/part1 [events: 0000000d]<6>(write) ide/host0/bus0/target1/lun0/part1's sb offset: 1048192
md: ide/host0/bus1/target0/lun0/part1 [events: 0000000d]<6>(write) ide/host0/bus1/target0/lun0/part1's sb offset: 1048192

Hemos visto una manera bastante sencilla y fiable de tener nuestros datos importantes a buen recaudo. No obstante este sistema raid no sirve de nada sin una buena política de backups, puesto que no protege del borrado accidental de archivos.

Después de haber probado FreeNAS y el Raid en Debian puedo sacar en claro lo siguiente:
# FreeNAS es mucho más sencillo y fácil de configurar, pero no ofrece toda la flexibilidad que linux. Por ejemplo, con FreeNAS no es posible crear un raid con dos discos de distinto tamaño y aprovechar el espacio restante. En linux eso no supone ningún problema. Simplemente hay que tener claro que los datos de esa nueva partición no tendrán respaldo, por lo que no se debe utilizar para almacenar información importante.
# FreeNAS todavía es una versión beta y aunque parece muy robusta y hay mucha gente que la está utilizando (sólo hay que echar un vistazo a sus foros), los desarrolladores indican que no se debería utilizar en entornos de producción. Por contra, el raid por software en linux se lleva utilizando desde hace bastante tiempo.
# Si tengo algún problema con FreeNAS será más complicado encontrar soporte. Sólo tendría el foro para preguntar. Si tengo un problema con linux tengo a mano a Alex que seguro está encantado de echarme una mano ;-)
# Al utilizar un sistema linux "estandar" podemos montar un apache, scripts de monitorización del raid, avisos por correo electrónico,... cualquier cosa que se nos ocurra. Con FreeNAS esto sería muy complicado de hacer.

Ahora ya sólo me queda cambiar mi actual Duron 1200Mhz (algo que voy a hacer en las próximas semanas) puesto que ya está algo viejo y cada vez lo noto más lento y utilizarlo como servidor NAS-Debian en casa.

El siguiente capítulo será la configuración de Samba para compartir los nuevos dispositivos creados con una máquina windows así como la gestión de los distintos permisos de usuario.

18 de nov. 2009

Error vmware en Kernel 2.6.31, error: conflicting types for ‘poll_initwait’ , ‘poll_initwait’ , solucionado

Error vmware en Kernel 2.6.31, error: conflicting types for ‘poll_initwait’ , ‘poll_initwait’

Todos estos problemas causados por el nuevo kernel, no han tenido otra solucion para mi que reinstalar vmware, primero desintalando y siguiendo esta muy buena guía lo pude solucionar sin problemas.


primero de todo desintalamos con "vmware-uninstall.pl"

y ahora seguimos esta guía.

VMware Server es un producto de virtualización gratuito para servidores Windows y Linux con soporte de clase empresarial y la gestión de VirtualCenter. VMware Server es un robusto y fácil de usar productos de virtualización de servidores y se basa en la tecnología de virtualización, que ha sido utilizado por miles de clientes durante muchos años.

En primer lugar es necesario descargar 2.0.x del servidor del sitio web de VMware VMware y obtener la clave de instalación del servidor de VMware

Actualmente tenemos un problema al compilar vmware server bajo la versión del kernel 2.6.31 por lo que este tutorial se explica cómo instalar 2.0.x del servidor VMware en Ubuntu 9.10

Ahora una vez que tengamos el VMware-server-2.0.2-203138.i386.tar.gz archivo para descomprimir este archivo:

tar -zvxf VMware-server-2.0.2-203138.i386.tar.gz

y vamos al directorio vmware-server-distrib:

cd vmware-server-distrib
Corremos el script vmware-install.pl utilizando el siguiente comando: ./vmware-install.pl
Ahora puede que recibas mensajes de error de compilación por lo que es necesario descargar archivos de la revisión necesaria en el directorio vmware-server-distrib del foro de vmware .Puedes utilizar el siguiente comando para descargar los parches: wget http://www.ubuntugeek.com/images/vmware-server.2.0.1_x64-modules-
Después de la descarga extrae el archivo: vmware-server.2.0.1_x64-modules-
tar xvzf vmware-server.2.0.1_x64-modules-
Y ahora corre el script del parche usando el siguiente comando: (Nota: Este script funciona con las versiones de kernel 2.6.30 y 2.6.31)
sh vmware-server.2.0.1_x64-modules-
Después de que se completen cada una de las instalaciones de la revisión deberías ver mensajes similares a los siguientes:
Después de completar la instalación de la revisión que usted necesita para eliminar / usr / lib / vmware / modules / binaria ya que el original de los directorios de módulos de VMware se encuentra todavía en la ruta, así que esto confunde VMware es por eso que vamos a eliminar este directorio:

rm -rf /usr/lib/vmware/modules/binary
Ahora ejecuta el script vmware-config.pl: vmware-config.pl (Esto debe completar la instalación del servidor de VMware.)
Ahora abre tu navegador https: / / PC-direccionip: 8333,

15 de nov. 2009

error: sys/eventfd.h: No such file or directory , compilar kernel debian 2.6.31


Nos puede pasar al finalizar de compilar el kernel version 2.6.31.x nos salga el siguiente error:

cc -m32 -Wall -Wmissing-declarations -Wmissing-prototypes -O3 -I../../include -I../../arch/x86/include -U_FORTIFY_SOURCE lguest.c -o lguest
lguest.c:21:25: error: sys/eventfd.h: No such file or directory
lguest.c: In function ‘create_thread’:
lguest.c:1021: warning: implicit declaration of function ‘eventfd’
make: *** [lguest] Error 1


Editamos el archivo Documentation/lguest/Makefile, y cambiamos el valor siguiente:

all: lguest

… borramos lguest, quedando la línea así:


Al parecer es un problema de la versión de libc, por el momento, lo solucionamos de ésta manera.

13 de nov. 2009

Convertir pdf a excell

The pharmaceutical industry uses a lot of data. Consequently, we see a lot of tabular data converted to PDF documents. It is common to see lab instrument data, database reports and enterprise systems data output as PDF.

So, there you are, alone in your office staring at a PDF document wishing you had access to the original data. What do you do?

Fortunately, Acrobat 9.1 offers a couple of different ways to export to Excel.

1. Select table and open in Excel
This allows you to select a portion of a page and open it in Excel.

2. Export as Tables in Excel
This method uses some artificial intelligence to convert multiple page PDF documents to multiple worksheets in an XML-based spreadsheet file. It works best on files which were converted directly from Excel to PDF.

To open the XML-based file output generated using method 2 above, you'll need either:

* Office 2007
* The free Microsoft Office Compatibility Pack for Word, Excel, and PowerPoint 2007 File Formats for earlier versions of Office.

Acrobat generally will usually do a pretty good job converting the text, but formatting and column widths will look different than the original. Acrobat only copies over the text. Formulas will not convert. Do not expect 100% fidelity.

In the full article, you'll receive my usual step-by-step instructions.
Converting to Excel from PDF: Copy Table as Spreadsheet

I've had better luck using this method for scanned documents and documents which were not originally spreadsheets.

How to use it:

1. Open a PDF and OCR if it was originally scanned
Document—> OCR Text Recognition
2. Select the Select Text tool (cursor)
Acrobat cursor tool
3. Hold down the ALT (CMD on the Mac) key to make a rectangular selection over a table in the document.
Your cursor will change shape to:
Acrobat area selection tool
4. With the text still selected, right-click and choose “Open Table in Spreadsheet”
Copy Tables as Spreadsheet
5. The table data will open in Excel

What are the other options?
Copy as Table will copy the data to the clipboard. From there, you can paste it into Excel or another document. Save as Table will allow you to name the data and save it as a Comma Separated Value (CSV) file.

Mac Users: Only Copy as Table and Save as Table are available.

Converting to Excel from PDF: Save As Tables in Excel Spreadsheet

This method allows you export a multiple page PDF to multiple Tables in an Excel file. It seems to work best on documents which were:

1. Converted directly to PDF from Excel
2. Converted using Acrobat (rather than a clone)

Save as Tables works better in Acrobat 9.1
Adobe greatly improved the capability to export to Excel using this method in Acrobat 9.1. Acrobat 9.0 sometimes exported XML tables that Excel could not open. Make sure you update.

How to use it:

1. Open the PDF you want to convert
2. OCR the document if it was originally scanned.
Choose Document—> OCR Text Recognition
3. Choose File—> Save As
4. From the Type list at the bottom of the window, choose Tables in Excel Spreadsheet
Adjust the file type pop-up
5. Click Save

How do I open the file in Excel?
Depending on your file associations, you may not be able to double-click the resulting XML file to open it in Excel. You’ll need to open Excel and choose File—> Open

Where are all the pages?
Each page in the PDF is converted to a different worksheet in the Excel file. Look at the tabs at the bottom of the screen.
Choose the tabs

Batch Converting PDF to Excel

Have a lot of PDFs you want to convert to Excel? No problem! This works in any version of Acrobat 9.

1. Choose File—> Export—> Export Multiple Files
2. Click the Add Files button at the top of the window and locate your source PDFs
Export Multiple Files Window
3. The Output Options window appears:
Output Options window
A) Click Browse to select a folder for the Excel output
B) If desired, add a prefix or suffix to the filename
C) Change Export to “Tables in Excel”
4. Click OK

Cómo convertir una puta imagen de disco .nrg de Nero a .iso para grabar en Debian/Ubuntu GNU/Linux con un grabador libre


Cómo convertir una puta imagen de disco .nrg de Nero a .iso para grabar en Debian/Ubuntu GNU/Linux con un grabador libre
By pragmart



1. Abro un Terminal de root en Aplicaciones>Accesorios>Terminal de root o escribiendo gksu gnome-terminal en el cuadro que aparece al utilizar la combinación Atl+F2

2. Instalo nrg2iso con el siguiente comando

apt-get update && apt-get install -y nrg2iso


sudo apt-get update && sudo apt-get install -y nrg2iso

3. Para usarlo desde terminal con el siguiente comando (previamente situado en la carpeta que contiene la imagen con el comando cd)

nrg2iso imagendedisco.nrg imagendedisco.iso

Donde, obviamente, imagendedisco.nrg imagendedisco.iso son los nombres de origen y destino de la imagen que quiera cambiar de formato

Y pista.
Fuente: La casa de Tux

Comando fine , buscar en debian


El comando find:

Este comando nos permite buscar archivos indicando un punto de inicio de la búsqueda (path) y una expresión a buscar. Es uno de los comandos más utilizados. Por ejemplo si queremos buscar cualquier archivo que empiece por “syslog” en todo el árbol de directorios lo procesaríamos de la siguiente manera:

find / -name syslog*

*nota: si no ejecutas este comando como root, recibirás un mensaje de error cada vez que find intente acceder a un directorio para el que no tengas permiso. En este caso es recomendable dirigir los errores al dispositivo null, es decir, purgarlos: find / -name syslog* 2>/dev/null

Algunos otros modificadores útiles de find son:

-size +/-n[bkMG] donde n es el número de unidades de espacio que serán especificadas por b,k,M o G, es decir, bytes, kilobytes, Megabytes o Gigabytes respectivamente (hay más opciones). Veamos un ejemplo:

find /var/log/ -size +1M -size -20M buscará todos los archivos dentro de /var/log/ que tengan entre 1 y 20 Megabytes.

Para buscar a partir del directorio actual usaremos por ejemplo:

find . -name nombrearchivo el punto después de find indica que queremos buscar a partir de la ruta en la que nos encontramos.Aquí podemos usar otras opciones, incluso utilizar variables del sistema, como por ejemplo $HOME que corresponde a la ruta del directorio del usuario actual.

find $HOME -name nombrearchivo

Find busca de forma recursiva por defecto. Si queremos limitar la búsqueda al nivel de direcorio actual podemos usar el modificador -maxdepth 1, si quisieramos descender un nivel más en la estructura de directorios -maxdepth 2 y así sucesivamente.

También podemos especificar determinados tipos y así ignorar otros que no nos interesan; imaginemos que sólo necestamos buscar directorios:

find / -name log* -type d

En type podemos especificar varias opciones. las más comunes: d (directorios) , f (archivos normales) o l (links simbólicos).

Con -perm podemos encontrar archivos que tengan unos permisos determinados, bastante útil para securizar nuestro linux. Si lo combinamos con -user podemos localizar archivos que puedan ser modificados por un usuario determinado:

find /var/log/ -perm /222 -user usuario1

Si el resultado es muy amplio lo podemos redireccionar a un archivo para su análisis y añadir el modificador -ls, que nos listará ademas información ampliada sobre cada archivo:

find /var/log/ -perm /222 -user usuario1 -ls >> datos.txt

Otro modificador muy útil es el modificador por tiempo de acceso o modificación:

-mtime n Encontrará los ficheros que hayan sido modificados hace n*24 horas. Ignora las fracciones así que su uso no es tan evidente como el de -mmin. Si indicamos -mtime +1 buscará archivos modificados hace al menos 48 horas. Incluyo algunos ejemplos de uso más abajo, sino queda muy claro, consultad el man find.

-mmin n Encontrará los ficheros que hayan sido modificados hace n minutos.

Para ver los accesos sólo tenemos que cambiar la primera m por una a , es decir:

-atime n y -amin n

Por ejemplo

find / -mmin 1 encontrará todos los archivos que han sido modificados en el último minuto. Muy útil cuando queremos saber donde hemos dejado ese archivo que estábamos modificando hace un rato y que ahora no encontramos o qué archivos ha modificado alguna herramienta que hemos utilizado.

find . -atime 0 encontrará archivos que han sido accedidos en las últimas 24 horas.

find . -mtime 1 encontrará archivos que han sido modificados entre las últimas 24 y 48 horas.

find . -mtime +1 encontrará archivos que han sido modificados hace más de 48 horas.

find . -mtime +2 -mtime -5 encontrará archivos que han sido modificados hace más de 48 horas y menos de 5 dias.

12 de nov. 2009

Recuperar pestaña cerrada


Con FireFox existe una forma de poder recuperar la última pestaña cerrada y eso es mediante el atajo de teclas Ctrl-Shift-T (en Windows) o Cmd-Shift-T (en Mac).

Compilar el kernel de linux


debian way http://www.esdebian.org/articulos/23843/compilar-kernel-estilo-debian

Molt bo ---->http://www.espaciolinux.com/2008/08/como-compilar-un-kernel-para-principiantes/

10 de nov. 2009

Introducción a la creación de shell scripts con bash


Una de las cosas con la que trabajamos mucho los administradores linux es la programación de shell scripts, dado que éstos nos dan la posibilidad de preparar tareas que simplifican nuestro trabajo diario.

Veamos a continuación un pequeño guión introductorio sobre programación de shell scripts.

Para escribir un shell script necesitamos un editor de texto plano, como por ejemplo: nano o gedit. En realidad nos vale cualquier editor de texto, siempre y cuando el archivo lo guardemos como text/plain.

1. Cómo se crea un script

Vamos a crear un fichero al que llamaremos script.sh. Para ello, abrimos nano, gedit o cualquier otro editor de texto y escribimos:

echo Este es mi primer script en bash!

Podemos ejecutarlo haciendo una llamada al shell y pasando como parámetro el nombre del script:

$ sh script.sh

También podemos hacerlo ejecutable dándole permisos de ejecución:

$ chmod +x script.sh

Una vez añadido el permiso de ejecución, ya podemos ejecutarlo directamente:

$ ./script.sh

Pero si lo que queremos es poder llamarlo desde cualquier lugar, lo copiaremos a un directorio de ficheros ejecutables, como por ejemplo: /usr/bin o /usr/local/bin.

Si observamos el código fuente de nuestro pequeño script, veremos que consta de dos líneas:


En la primera se indica el shell que se va a usar como intérprete para este script: #!/bin/sh. Esta siempre debe ser la primera línea de un shell script.

La segunda línea contiene el comando echo, que muestra un mensaje por pantalla.

2. Variables

Una variable es un contenedor que almacena un valor. Utilizamos variables para guardar valores que necesitaremos en nuestro script. Un detalle que debemos indicar es que las variables en shell script no tienen tipos asociados.

Veamos a continuación cómo se asigna un valor a una variable:


# Asignamos el valor 1 a i

# Asignamos Bienvenidos a la programación de shell scripts! a la variable cadena
cadena="Bienvenidos a la programación de shell scripts!"

Una cuestión importante: No podemos dejar espacios entre la variable y el igual o el igual y el valor, porque el shell lo interpretará como un comando y nos dará error.

Veamos ahora como podemos obtener el valor de una variable.

Para acceder al contenido de una variable empleamos $ delante de su identificador:


$ i=4
# Mostramos el valor de la variable i por pantalla
echo $i

echo "El valor asignado a i es $i"

3. Uso de parámetros en scripts

Podemos usar parámetros en nuestros scripts. Dichos parámetros nos permitirán pasar valores externos que utilizaremos dentro:

$0 contiene el nombre nombre de nuestro script

$# contiene el número de parámetros con los que se ha invocado al shell

$n contiene los parámetros, con n de 1 a 9 (a $#)

{$n} cuando n > 9, tenemos qu especificar los parámetros entre llaves

$$ contiene el PID de nuestro proceso

$* todos los parámetros menos $0

4. La salida de los programas

Cuando se ejecuta un programa, un comando UNIX es un programa, podemos, a parte de redirigir su entrada y su salida, recoger el resultado de su ejecución y su salida.

El resultado es un valor numérico, por lo general cero si todo ha ido bien, y distinto de cero si ha habido alguna clase de error.
- Para obtener el resultado de la ejecución del último comando, utilizamos $?


mkdir /home/alumnos/$idalumno > /dev/null ; echo $?

if [ $?=0 ]; then
echo "El directorio $idalumno se ha creado sin problemas"

- Para obtener la salida de un comando, utilizamos $(comando) o comillas invertidas: `comando`


$ directorioactual=`pwd`
$ echo $directorioactual

- Para devolver el resultado de ejecución de un script, utilizamos exit valor, donde valor debe ser un numéro entero.


exit 0 # Termina el programa y devuelve cero como valor de salida

5. Operadores aritméticos
Si queremos que el shell evalúe una operación aritmética y no la tome como argumentos de un comando, escribiremos la expresión observando la siguiente sintaxis: $((expresion))

Al escribir la expresión de este modo, el shell la evalúa y la reemplaza por su valor.


$ echo $((1+1))

Algunos de los operadores aritméticos soportados son:

+ la suma
* la mutiplicación
- la resta
/ la división entera
% el resto de la división entera
( ) los paréntesis nos sirven para agrupar operaciones

6. Operadores de comparación
Podemos hacer comprobaciones sobre ficheros utilizando el comando test.

El comando test evalúa una expresión y retorna un valor que será cero si la expresión es verdadera o distinto de cero si la expresión es falsa.

Este comando tiene la siguiente sintaxis:

test expresion
[ expresion ]

donde EXPRESION puede ser una evaluación: de cadenas de caracteres, números enteros, archivos (evaluamos permisos y existencia del archivo) u operadores lógicos que permiten realizar una combinación de varias evaluaciones.

- Utilización abreviada del comando test.

En vez de escribir test EXPRESION, podemos escribir la EXPRESION entre corchetes( [ ] ) y el resultado será exactamente el mismo.


$ str="abc"
$ [ "$str" = "abc" ]
$ echo $?

Habitualmente el comando test se utiliza en conjunto con la sentencia if para evaluar distintos tipos de expresiones que veremos a continuación.

6.1. Operadores sobre ficheros

-d fichero cierto si fichero existe y es un directorio
-e fichero cierto si fichero existe, independientemente del tipo que sea
-f fichero cierto si fichero existe y es un fichero normal
-r fichero cierto si fichero existe y se puede leer
-s fichero cierto si fichero existe y tiene tamaño mayor que cero
-w fichero cierto si fichero existe y es se puede escribir sobre él
-x fichero cierto si fichero existe y es ejecutable

6.2. Operadores lógicos

! expresion cierto si expresion es falsa (negación)
expresion1 -a expresion2 cierto si expresion1 y expresion2 son ciertas
expresion1 -o expresion2 cierto si expresion1 o expresion2 son ciertas

6.3. Operadores de comparación de números enteros

n1 -eq n2 cierto si los enteros n1 y n2 son iguales
n1 -ne n2 cierto si los enteros n1 y n2 no son iguales
n1 -gt n2 cierto si el enteros n1 es mayor que n2
n1 -ge n2 cierto si los enteros n1 y n2 son iguales o n1 es mayor que n2
n1 -lt n2 cierto si el enteros n1 es menor que n2
n1 -le n2 cierto si los enteros n1 y n2 son iguales o n1 es menor que n2

6.4. Operadores de comparación de cadenas

s1 = s2 cierto si las cadenas de texto s1 y s2 son idénticas
s1 != s2 cierto si las cadenas de texto s1 y s2 no son idénticas
s1 <> s2 cierto si la cadena de texto s1 es mayor que s2
-n cadena cierto si la longitud de la cadena de texto es distinta de cero

6.5. Operadores lógicos && y ||

Además de los anteriores, existen los operadores lógicos && (AND, multiplicación lógica) y || (OR, suma lógica), que se puede aplicar al valor de salida de los programas:

$ true && true ; echo $?
$ true && false ; echo $?
$ false && true ; echo $?
$ false && false ; echo $?

$ true || true ; echo $?
$ true || false ; echo $?
$ false || true ; echo $?
$ false || false ; echo $?

7. Sentencias de comparación
7.1. Sentencia if

Esta sentencia nos permitirá ejecutar un bloque de código, o u otro, dependiendo de como se evalue una condición.

La forma más simple tiene la siguiente sintaxis:

if CONDICION; then
bloque de comandos

En este primer caso el bloque de comandos se ejecutará solo si la condición es evaluada a cierto.

Una segunda posibilidad es utilizar else:

if CONDICION; then
bloque de comandos b1
bloque de comandos b2

En este segundo caso el bloque de comandos b1 se ejecutará si la condición es cierta. Si la condición fuera falsa, se ejecutará el bloque de comandos b2.

La condición puede ser, por ejemplo, una llamada al comando test o una operación lógica entre los valores de salida de diferentes comandos.


read numero
# comparamos cadenas de texto, así que usamos comillas
if [ $numero -eq 5 ]; then
echo Acerté tu número. Es el 5.

7.2. Sentencia case

Se utiliza cuando el valor de una variable ha de ser contrastado con varios valores. Su sintaxis es la siguiente:

case variable in
patron1) comando1
patron2) comando3

Comprueba si variable coincide con algunos de los patrones (patron1, patron2,...) y ejecuta los comandos asociados con la primera coincidencia que tiene lugar.

Sólo se ejecuta un único grupo de comandos.

El ";;" es el delimitador de los comandos que se ejecutaran para un determinado patrón y "esac" es el fin de la sentencia case.

Un ejemplo clásico de uso de la sentencia case es la creación de un menú:

# Genera un menú de opciones #
echo "[1] Listar archivos"
echo "[2] Ver directorio de trabajo"
echo "[3] Crear directorio"
echo "[4] Crear usuario"
read -p "Ingrese una opción: " OPCION
case $OPCION in
1) ls;;
2) pwd;;
3) read -p "Ingrese nombre del directorio a crear: " DIRECTORIO
4) if id | grep uid=0
read -p "Ingrese el nombre del usuario a crear: " NOMBREUSUARIO
echo "Se necesitan permisos de root"
*) echo "Opción ingresada no valida, intentelo de nuevo"
exit 1;;

8. Bucles

El shell nos aporta mecanismos para realizar tareas repetitivas mediante el empleo de estructuras que permiten repetir un bloque de comandos.
8.1. El bucle for

Esta estructura permite repetir un bloque de comandos asignando valores de una serie a una variable en cada iteración.

bloque de comandos

En cada iteración la variable VARIABLE toma un valor de SERIE, que en caso de no contener elementos hará que no se ejecute nada y se devuelva un valor 0.

En caso de que se ejecuten comandos, el resultado devuelto tras el bucle es el del último comando ejecutado.

Podemos especificar los valores de la serie de dos formas:

* Nombrando todos los elementos de la serie:for i in 1 2 3 4 5; do
* Utilizando la sentencia seq:for i in seq 1 5; do


for i in 1 2 3 4 5; do
echo $i

for i in seq 1 5; do
echo $i

# con cadenas de texto
for palabra in uno dos tres cuatro cinco; do
echo $palabra

8.2. El bucle while

Es otra estructura de bucle que permite ejecutar un bloque de comandos mientras se evalúe una condición a cierto:

while CONDICION; do
bloque de comandos

Cada iteración se evalua la condición y en el momento que no sea cierta, el bucle termina.

Ejemplos de bucles:

# equivalente a seq 1 5
while [ $i -le 10 ]; do
echo $i

# leemos de stdin hasta que se introduzca la palabra 'salir'
read linea

while [ $linea != "salir" ]; do
read linea

8.3. Rompiendo la ejecución del bucle: break

Podemos interrumpir un bucle en cualquier momento mediante el uso de la sentencia break, de forma que tras ser ejecutado ese comando el control pasa al siguiente comando después del done.

Ejemplo de uso de break:

for elemento in *; do
echo Primer elemento $elemento


echo Esto nunca se llega a ejecutar

echo Seguimos con el programa

9. Funciones

Una función o subrutina es una agrupación de comandos bajo un mismo nombre. Lo que nos permitirá dividir el programa en bloques y programar cada bloque por separado, o agrupar una serie de comandos que se ejecutan a menudo bajo un mismo nombre.
Veamos cuál es la sintaxis de una función:


Luego, para ejecutar la función debemos llamarla por su nombre, igual que un comando:


Eso sí, debemos tener en cuenta que es necesario definir cada función antes de utilizarla. Veamos un ejemplo:

mostrar_menu ()
echo -e "\n"
echo "[1] Crear usuario"
echo -e "[2] Salir\n"
read -p "Elija una opción: " OPCION

crear_usuario ()
if [ id | grep uid=0 ]; then
read -p "Nombre del usuario a crear: " NOMBREUSUARIO
echo '*****************************'
echo "Se necesitan permisos de root"
echo '*****************************'
############# Programa principal #################
while true; do
case $OPCION in
1) crear_usuario ;;
2) echo "Abandonando el programa..."
*) echo '********************************************'
echo "Opción ingresada no valida, intente de nuevo"
echo '********************************************';;

9 de nov. 2009

configurando ipcop


8 de nov. 2009

Linux, añadir unidad de red windows


La red que hay montada en mi lugar de trabajo es una red Windows. Actualmente estoy intentando utilizar lo más posible la distributción Ubuntu que tengo instalada para realizar mi trabajo diario. Una de las necesidades que me surgen es el acceso a unidades compartidas de red de otros equipos Windows.

Aunque el administrador de archivos Nautilus que tiene el Gnome me permite navegar por unidades compartidad de Windows, muchas de las aplicaciones existentes no “entienden” el protocolo “smb” y por tanto no pueden acceder a los archivos que se encuentran en dichas unidades.

Para solucionar este inconveniente, lo mejor es “montar” las unidades compartidas en nuestro arbol de directorio para que todas las aplicaciones vean las unidades como si de un directorio más se tratasen.

Antes de nada, lo primero que necesitamos es añadir el soporte para samba (así se conoce el sistema de compartición de carpetas de Windows) a nuestro GNU/Linux. En Ubuntu, basta con instalar los paquetes “smbfs”, “samba”, “samba-common” y “smbclient”.

A continuación crearemos la carpeta en la que “montaremos” la unidad compartida:

$ sudo mkdir /mnt/compartida

Una vez que nuestro sistema tiene instalado todo lo necesario, ya “entenderá” el protocolo de Samba y podemos “montar” la unidad compartida con el comando:

$ sudo mount -t smbfs -o username='usuario',password='clave',workgroup=grupowin //equipowin/compartida /mnt/compartida

Con lo que conseguimos que la carpeta compartida “compartida” del equipo “equipo.red” esté accesible en el directorio “/mnt/compartida” de nuestro equipo, como si de un directorio local se tratase.

Si lo deseamos, también podemos editar el fichero “/etc/fstab” para añadir una línea que defina cómo se montará esta unidad de red. Antes de ello hacemos una copia de seguridad por si acaso mediante la orden:

$ sudo cp /etc/fstab /etc/fstab_backup

Y después lo editamos mediante:

$ sudo gedit /etc/fstab

Añade lo siguiente al final del fichero:

//equipowin/compartida /mnt/compartida smbfs username=usuario,password=clave,workgroup=grupowin,user,owner,noauto 0 0

Tendrás que personalizar esta línea para cambiar:

* equipowin por el nombre de la máquina Windows a la que te estás conectando
* compartida por el nombre de la carpeta compartida
* /mnt/compartida por el nombre del directorio donde lo quieras montar
* la ip de la máquina Windows a la que te conectas
* username, poner el del usuario en Windows
* password, poner la clave del usuario en Windows
* grupowin por el nombre del grupo de trabajo o dominio en Windows

Sólo hace falta ejecutar:

$ sudo chmod +s /usr/bin/smbmnt

para hacer que un usuario “normal” pueda montar la unidad.

Ahora abre tu equipo mediante Lugares -> Equipo y verás un nuevo icono representando a la carpeta compartida. Mediante un doble clic en ella, se montará la unidad. También puedes montarla con la orden:

$ mount /mnt/compartida

Para desmontarla, hay que ser root, por lo que no puedes desmontarla más que ejecutando:

$ sudo umount /mnt/compartida

Opcones más comunes de mount
La cuarta columna del fichero fstab lista todas las opciones de montaje para el dispositivo o partición. Hay muchas opciones disponibles, pero estas son las más comunes:

* credentials: Permite tener el usuario y contraseña en un fichero en vez de proporcionarlo como parámetro en el comando. El contenido del fichero será similar a esto:


Y generalmente se le asignará permiso de escritura y lectura solamente para el propietario (chmod 600)
* auto y noauto: Con auto (opción por defecto) el dispositivo se montará automaticamente.
* user y nouser: La opción user permite que usuarios normales monten el dispositivo mientras que nouser (valor por defecto) solamente lo permite para root.
* exec y noexec: exec (valor por defecto) permite ejecutar binarios de la partición, mientras que noexec no lo permite.
* ro y rw: ro monta el sistema de archivos en modo solo lectura mientras que rw (valor por defecto) lo monta en modo lectura/escritura.
* sync y async: Indica cómo se realizará la entrada y salida del sistema de archivos. sync significa que se hará de forma síncrona (al ejecutar un comando, se escribe físicamente en el dispositivo el resultado) mientras que con async (valor por defecto) se realiza asíncronamente (el sistema de archivos se sincroniza antes de desmontar la unidad).
* defaults: Utiliza las opciones por defecto que son rw, suid, dev, exec, auto, nouser, y async.

Opciones de smbmount

* username=: nombre de usuario SMB
* password=: contraseña SMB
* netbiosname=: nombre NetBIOS origen
* uid=: usuario que será propietario de la unidad montada
* gid=: grupo que será propietario de la unidad montada
* port=: número puerto remoto SMB
* fmask=: máscara de permisos asignados a los ficheros de la unidad montada
* dmask=: máscara de permisos asignados a los directorios de la unidad montada
* debug=: nivel de depuraciñon
* ip=: nombre host o dir. IP destino
* workgroup=: dominio/grupo NetBios destino
* sockopt=: opciones socket TCP
* scope=: NetBIOS scope
* guest: invitado, sin contraseña
* ro: montar solo-lectura
* rw: montar lectura-escritura

Solución de problemas

Problema:Al montar una unida con:

$ sudo mount -t smbfs -o username=user,password=pass //IP/recurso /mnt/tmp

Nos monta la unidad pero nos dice esto:

20389: session request to IP failed (Called name not present)
20389: session request to 192 failed (Called name not present)

esto se soluciona buscando el nombre NetBios de la máquina a la que se le requiere el servicio:

nmblookup -A IP

por ejemplo:

nmblookup -A

y una vez obtenido (si lo sabemos de memorio no hace falta, claro), procedemos al montaje de la unidad mediante:

$ sudo mount -t smbfs -o username=user,password=pass //NOMBRE_NETBIOS/recurso /mnt/tmp

Hecho esto no nos debe a aparecer ninguna alerta al respecto.

7 de nov. 2009

Instalar Machintosh Leopard 10.5 sobre windows con vmware


6 de nov. 2009

descarga de archivos de servidores como Rapidshare.com o Megaupload.com

Es una plataforma de código abierto escrita completamente en Java, diseñado para simplificar la descarga de archivos de servidores como Rapidshare.com o Megaupload.com, no solo para usuarios con cuenta Premium sino también para los de cuenta gratuita.
JD ofrece descargas múltiples paralelas, reconocimiento de captcha, extracción automática de archivos, administración de contraseñas y mucho más. Adicionalmente, soporta muchos sitios de “encriptación de enlaces”, así que solo tendrá que pegar los enlaces “encriptados” y JD hará el resto. JD puede importar archivos DLC, CCF y RSDF.
Por supuesto, JD es gratuito.

Limpiar espacio en linux


5 de nov. 2009