Al principio me sorprendió que uno de los consejos fuera que el directorio /usr tendría que estar en una partición separada y montada como sólo lectura. Pero el objetivo es que /usr pueda ser compartido entre distintos servidores por red. A mi personalmente me parece más interesante pensando en aspectos de seguridad:  ¿quién es el guapo que mete un rootkit en los ejecutables de un sistema de sólo lectura?

Así que decidí montar en mi sistema el directorio /usr como read-only. Esta es la entrada correspondiente en el fichero /etc/fstab, en mi caso la partición correspondiente a /usr es /dev/sda6.

/dev/sda6    /usr    ext4    ro    0    1

Pero esto supone un problema, ¿cómo actualizo el sistema sin permiso de escritura en /usr? Fácil, el sistema puede remontarse (no hace falta desmontar y volver a montar, con el riesgo que esto supondría para la estabilidad), podemos usar mount con el parámetro remount para aplicar cambios en un sistema de ficheros montado. Ejemplos:

# mount /dev/sda6 /usr -o remount,ro
# mount /dev/sda6 /usr -o remount,rw

Lo que yo hice para facilitar las cosas fué añadir estas dos entradas de alias en /root/.bashrc

alias usrro='mount /dev/sda6 /usr -o remount,ro && mount | grep sda6'
alias usrrw='mount /dev/sda6 /usr -o remount,rw && mount | grep sda6'

Ahora puedo usar los comandos usrrw y usrro antes y después de actualizar el sistema. En estos comandos de alias, la parte que hay a partir de && es puramente informativa, así podemos asegurarnos que los cambios se han aplicado correctamente.

Si se diera el caso de que somos unos paranoicos de la seguridad, no estaría nada mal aplicar el mismo cuento a los directorios /bin y /sbin, aunque hacer particiones expresamente para directorios que ocupan tan poco puede parecer un poco ridículo. Quizás la solución sería que estos dos directorios, donde encontramos los comandos básicos del sistema, no estuviesen montados en una partición sinó en un fichero con la opción loop, aunque hay que tener claro que esto es peligroso, si se corrompiera dicho fichero nos quedaríamos con un sistema inusable.

Se aceptan ideas.

Solución para BSD, GNU/Linux y otros UNIX

Descargamos la aplicación fdupes, que se autodefine como un programa para identificar o eliminar archivos duplicados que residen en los directorios especificados. Podemos compilarlo nosotros mismos o, como siempre, descargarlo de los repositorios de software de nuestro sistema operativo. El uso es así de simple:

$ fdupes <directorio>

Este comando compara el tamaño de cada archivo, su MD5 y finalmente hace una comparación byte a byte. Podemos añadir el parámetro -d para que nos vaya peguntando si queremos eliminar los repetidos. También tenemos opciones para seguir los directorios symlink e incluso para tratar archivos con hardlink.

Solución para MS Windows

Descargamos la aplicación findrepe, la descomprimimos en el directorio Archivos de Programa y luego, desde línea de comandos ejecutamos:

C:\Archivos de Programa> java -jar findrepe-0.5.1/FindRepe.jar --install

Ahora tenemos instalado el ejecutable findrepe.bat en el directorio de nuestro sistema, esto es sólo un script que llama a la aplicación Java pasándole los parámetros que nosotros deseemos, por esto es importante no eliminar los archivos descomprimidos al finalizar el paso anterior.

Ahora ya podemos usar el programa del siguiente modo:

C:\> findrepe c:\<directorio>

…y nos devolverá una lista de todos los archivos repetidos en dicho directorio. Además podemos pasarle más de un directorio o unidad como parámetros.

¡Pero puede usarse incluso como editor de texto! Creamos un archivo desde cero:

$ cat > /ruta/archivo.txt << "EOF"
Escribimos el texto <enter>
de tantas líneas como <enter>
queramos, y finalmente... <enter>
EOF

Ahora podemos comprobar si ha funcionado:

$ cat /ruta/archivo.txt
Escribimos el texto
de tantas líneas como
queramos, y finalmente...

Vemos que ha funcionado, hemos creado un archivo sin usar un editor de texto. Como aclaración, la palabra EOF significa End Of File, y podríamos usar cualquier otro indicador de fin de archivo, por ejemplo FIN o un punto.

Supongamos que estamos delante de una terminal y queremos enviar un mensaje a usuario@dominio.com, la forma más simple es la siguiente, ejecutamos

$ mail usuario@domunio.com

Ahora nos sale lo siguiente:

Subject: Título del mensaje <enter>
Empieza el texto del mensaje, y <enter>
sigue el texto hasta que <enter>
finalmente terminamos y <enter>
escribimos un punto <enter>
. <enter>
Cc: <enter>

Y el mensaje ya se ha enviado a usuario@dominio.com con el título indicado y el mensaje que hemos escrito. Como véis podemos añadir destinatarios adicionales en el campo Cc (Carbon Copy).

Pero, ¿y si queremos mandar un correo sin tener que interactuar en tiempo de envío, por ejemplo para mandar correos desde nuestros propios scripts? Pues todo lo que hemos visto se puede hacer por parámetros:

$ mail -s "Título del mensaje" usuario@dominio.com < /ruta/archivodetexto.txt

En el caso que hemos visto, el texto del mensaje lo recuperamos de un archivo de texto plano ASCII que se llama archivodetexto.txt y se encuentra en /ruta/, pero también podríamos incluir el propio cuerpo del correo en el comando si usamos una tubería:

$ echo "contenido del mensaje" | mail -s "Título del mensaje" usuario@dominio.com usuario4@dominio.com

Además vemos que podemos enviar el mensaje a distintos destinatarios. Pero ¿y si queremos enviar documentos adjuntos? El comando mail, que yo sepa, no puede hacerlo. Para ello podemos recurrir a mutt, un cliente de correo electrónico muy capaz y que posee una interface TUI (Text User Interface). Sin aprofundir en las capacidades de mutt, que son muchas, en este caso podríamos hacer lo siguiente:

$ mutt -s "Título del mensaje" -a /ruta/documento.pdf usuario@dominio.com < /ruta/archivodetexto.txt

En este caso, el usuario que posee el correo electrónico usuario@dominio.com recibirá un correo titulado “Título del mensaje”, el texto de este correo será el contenido de archivodetexto.txt, y se incluirá un PDF, documendo.pdf como archivo adjunto.

Voilà.

El comando watch ejecuta repetidamente el comando que le pasemos por parámetro, mostrando su salida en pantalla (salida estándar).

Esta mañana he estado moviendo archivos entre servidores, hablamos de mucha información, gigas y gigas. El servidor origen se ha quedado obsoleto y con el disco lleno, el servidor destino tiene 4 discos de 300 GB. Pero al pasar información, puedes llenar un disco sin darte cuenta, por lo que yo estaba ejecutando repetidamente

$ df -h

o más bien [flecha arriba + intro] hasta que watch se ha crucado en mi camino. Entonces he descubiertoque escribiendo

$ watch df -h

se nos muestra esta información (la salida de df -h) por pantalla:

Every 2,0s: df -h             Mon Jan  5 11:21:06 2009

S.ficheros          Tamao Usado  Disp Uso% Montado en
/dev/hda1              15G  2,8G   11G  21% /
/dev/hda3             274G  104G  156G  40% /mnt/disc1
/dev/hdb1             294G  191M  279G   1% /mnt/disc2
/dev/hdc1             294G  191M  279G   1% /mnt/disc3
/dev/hdd1             294G  191M  279G   1% /mnt/disc4
tmpfs                 379M     0  379M   0% /dev/shm

Por defecto se ejecuta cada 2 segundos, pero esto puede modificarse con el parámetro -n:

$ watch -n <número de segundos> <comando a ejecutar>

Otro parámetro curioso es -d, que remarca visualmente las modificaciones (con negrita o color de fondo) para que el seguimiento sea mas fácil.

No escribiré aquí como comprimir y descomprimir en *.tar.gz o en *.tar.bz2 (aunque tampoco tiene mucho secreto). Supongamos que tenemos esta estructura de directorios y archivos:

directorio/
|-- subdirectorio-1
|   |-- archivo-11.txt
|   `-- archivo-12.dat
|-- subdirectorio-2
|   `-- archivo-20.ogg
`-- subdirectorio-3

Hemos creado un archivo TAR que contiene este árbol, y lo hemos guardado con el nombre directorio.tar, Posteriormente queremos mostrar el contenido de ese archivo *.tar, lo hacemos de la siguiente forma:

$ tar tvf directorio.tar
drwxr-xr-x usuario/grupo   0 2008-12-05 16:51 directorio/
drwxr-xr-x usuario/grupo   0 2008-12-05 16:51 directorio/subdirectorio-3/
drwxr-xr-x usuario/grupo   0 2008-12-05 16:52 directorio/subdirectorio-1/
-rw-r--r-- usuario/grupo   0 2008-12-05 16:51 directorio/subdirectorio-1/archivo-11.txt
-rw-r--r-- usuario/grupo   0 2008-12-05 16:51 directorio/subdirectorio-1/archivo-12.dat
drwxr-xr-x usuario/grupo   0 2008-12-05 16:52 directorio/subdirectorio-2/
-rw-r--r-- usuario/grupo   0 2008-12-05 16:52 directorio/subdirectorio-2/archivo-20.ogg

Y finalmente, si lo que queremos realmente es extraer sólo uno de los subdirectorios, haremos lo siguiente:

$ tar xvf directorio.tar directorio/subdirectorio-1
directorio/subdirectorio-1/
directorio/subdirectorio-1/archivo-11.txt
directorio/subdirectorio-1/archivo-12.dat

En este caso hemos extraido un subdirectorio entero, pero podemos extraer archivos concretos, además podemos usar wildcards como * o ? en el comando.

¿Y que pasa con los archivos comprimidos con Gzip o con Bzip2? Pues los comandos son prácticamente los mismos, sólo tenemos que añadir la letra z en caso de *.tar.gz o la letra j en el caso de *.tar.bz2.

Ejemplo de uso, buscamos el archivo sshd_config en todo el sistema de ficheros:

$ locate sshd_config

/etc/ssh/sshd_config

/usr/man/man5/sshd_config.5.gz

LOCATE

El comando locate se usa para buscar archivos en el disco duro. A diferencia del comando find, que es increíblemente potente, locate sólo puede hacer búsquedas simples por nombre de archivo. A cambio de sus limitadas posibilidades, locate es rápido, muy rápido. El truco está en que no busca a lo largo del disco duro como hace find, sinó que busca en una base de datos propia. Esta base de datos es actualizada por el programa updatedb.

Cuando ejecutamos updatedb, esta base de datos se actualiza. Si hacemos cualquier cambio en los archivos (crear, borrar, mover, etc) y después buscamos algo con locate, este va a buscar en una base de datos que no se corresponde exactamente al estado actual del disco. Es por esto que la mayoría de distribuciones de GNU/Linux ejecutan updatedb de forma automatizada (usando cron) de forma periódica, pero la búsqueda puede no ser perfecta a no ser que usemos el comando updatedb justo antes de usar el comando locate.

El primer problema que tiene locate es que updatedb tarda bastante en recorrer el disco duro. El segundo, mucho más grave, es que si existe una base de datos de todos los archivos del disco y esta puede ser consultada por los usuarios, estos pueden conocer el contenido de los directorios a los que no tienen acceso.

Los comandos locate, updatedb y find (entre otros) són parte del paquete findutils de GNU.

SLOCATE

Ya hemos visto los problemas de seguridad que nos encontramos al guardar una base de datos de los archivos en disco si esta puede ser libremente consultada. Slocate (o Secure Locate) viene a solucionar este problema. La gracia está en que cuando se ejecuta updatedb, la base de datos no guarda sólo el nombre de los archivos, sinó que añade los permisos (propietario, grupo, etc). De esta forma, slocate sólo muestra al usuario la información adecuada, la de los archivos a los que tiene acceso.

MLOCATE

En slocate vemos que el problema de seguridad está solucionado, ahora vamos a conocer mlocate (o Merging Locate) que además de implementar la misma solución (está basado en slocate), soluciona el grave problema de velocidad del comando updatedb. Lo que hace mlocate cuando ejecutamos updatedb no es crear una base de datos entera de todos nuestros archivos, sinó guardar sólo las diferencias a la base de datos original, por lo que updatedb es mucho más rápido si han habido pocos cambios.

RLOCATE

Aquí vamos a dejar de lado la tradicional idea de ejecuto updatedb, luego busco. Pero también dejamos de lado la simpleza de los programas anteriores. Rlocate consta, además, de un módulo para el kernel y de un daemon, todos bajo el mismo nombre. Estos son necesaros para que la base de datos se actualize sóla y no necesitemos usar updatedb. A medida que vamos creando/eliminando archivos en el sistema, rlocate crea bases de dafos diferenciales en tiempo real. Sólo vamos a usar updatedb para optimizar la base de datos. Parece ser la mejor solución, el único problema es el propio hecho de estar cargando un módulo y un daemon sólo para poder buscar archivos, la mayoría de la gente prefiere la simpleza de usar slocate o mlocate.

Una vez analizados los cuatro, está muy claro que ganan mlocate y rlocate, el uso de uno u otro dependerá de las ganas de complicarse preparando el sistema para que funcione rlocate (que tampoco hay para tanto) o si preferimos la simpleza de instalar y usar. Aunque en realidad lo normal es no molestarse mucho con el tema y usar lo que incluya nuestra distribución, que con toda probabilidad va a ser slocate o mlocate.

• Unir distintos PDFs en uno solo
• Dividir un PDF para extraer sus páginas
• Rellenar formularios PDF
• Extraer los metadatos
• Extraer los archivos adjuntos de un documento PDF
• Reparar PDFs corruptos cuando es posible
• Cifrar/descifrar documentos mediante contraseña
• Aplicar una marca de agua al fondo del documento
• etc

Este programa funciona en línea de comandos (hay una GUI que no es oficial y que yo no he probado). Lo que viene a continuación son algunos ejemplos prácticos de las opciones que yo he probado, que són las más básicas, lo demás lo probaré el dia que lo necesite:

Unir distontos documentos PDF en un documento PDF final:

$ pdftk doc1.pdf doc2.pdf doc3.pdf cat output doc-unido.pdf

También podríamos usar comodines (*, ?, [a-z], etc), este es el ejemplo más sencillo:

$ pdftk doc?.pdf cat output doc-unido.pdf

Incluso podemos usar variables, esto es tremendamente útil si lo usamos en scripts o si el comando se vuelve realmente largo. Además nos permite seleccionar páginas concretas de cada documento. En el siguiente ejemplo crearemos un documento combinado que contendrá las 3 primeras páginas de doc1.pdf, las 2 primeras de doc2.pdf y la cuarta de doc3.pdf:

$ pdftk  A=doc1.pdf B=doc2.pdf C=doc3.pdf cat A1-3 B1-2 C4 output doc-combinado.pdf

Podemos usar este sistema para invertir las páginas de un documento, en este caso supondremos que doc1.pdf tiene 5 páginas:

$ pdftk A=doc1.pdf cat A5-1 output doc1-inverso.pdf

Incluso podemos extraer por separado todas las páginas de un PDF. Este comando crea archivos con nombres pg_01.pdf, pg_02.pdf, etc… y otro archivo llamado doc_data.txt con los metadatos del PDF en nuestro directorio actual.

$ pdftk doc1.pdf burst

Si sólo queremos extraer los metadatos del documento, como por ejemplo el programa que se usó para crear el PDF, la fecha de creación, autor, número de páginas, etc podemos usar el parámetro dump_data:

$ pdftk doc1.pdf dump_data output metadatos.txt

Esto sólo es el principio, no olvidéis consultar la página man para más información, podéis ojearla online. Espero que os haya sido de utilidad.

Copiar un archivo de nuestro ordenador a un ordenador remoto:

$  scp archivo.tgz usuario@host_remoto:/ruta/remota/

Se nos pedirá la contraseña de ‘usurio’ en ‘host_remoto’ y se procederá a la transferencia del archivo hacia ‘/ruta/remota/’ si es que ‘usuario’ tiene permisos de escritura en esa ruta.

Copiar un archivo de un ordenador remoto a nuestro ordenador:

$ scp usuario@host_remoto:/ruta/remota/archivo.tgz /ruta/local/

También se nos pedirá la contraseña de ‘usuario’ en ‘host_remoto’ y se procederá a la transferencia del archivo hacia ‘/ruta/local’ si es que nuestro usuario tiene permisos de escritura en esta ruta.

En cualquiera de los dos casos, si el puerto TCP del servidor SSH no es el 22 (por defecto siempre es el 22) tendremos que especificarlo con el parámetro -p <número_de_puerto>.

Muchas veces al ejecutar comandos importantes para el sistema es necesario estar atento a la pantalla por si salen mensajes de alerta que nos pueden ser de ayuda, pero es evidente que no podemos estar atentos al 100% con tareas de este tipo. Una solución cutre sería redireccionar el STDOUT (>) a un fichero, usaremos el comando find sólo como ejemplo, por poner algo:

# find / -name *.conf > salida

En este caso, salida contiene toda la salida que hubiese hecho por pantalla el comando en concreto, pero… ¿y si queremos ver la salida en tiempo real, y al mismo tiempo almacenarla en un fichero? Muy facil, vamos a usar tee:

# find / -name *.conf | tee salida

tee envía lo que recibe por el pipe hacia la salida standard STDOUT (la pantalla) y al mismo tiempo lo envia al fichero que le pasemos por parámetro… ¡voilà! Pero supongamos que no queremos escribir de cero el fichero salida como lo haríamos con > sinó añadir esos datos al final como haríamos con >>. En este caso tenemos que usar el parámetro -a (append):

# find / -name *.conf | tee -a salida

Hasta aquí esta mini-explicación de un comando muy útil pero muchas veces desconocido, olvidado o simplemente poco usado.