La Línea de Comandos de Linux
La Línea de Comandos de Linux
No, no es la historia de cómo, en 1991, Linus Torvalds escribió la primera versión del kernel
de Linux. Puedes leer esa historia en montones de libros sobre Linux. Tampoco voy a
contarte la historia de cómo, algunos años antes, Richard Stallman comenzó el Proyecto
GNU para crear un sistema operativo libre parecido a Linux, Esa también es una historia
importante, pero la mayoría de los libros de Linux también la incluyen.
Hoy, el mundo es muy diferente. Los ordenadores están en todas partes, desde pequeños
relojes de pulsera a gigantescos centros de datos. Además de ordenadores repartidos por
todas partes también tenemos redes conectándolos. Ésto ha creado una maravillosa nueva
era de empoderamiento personal y libertad creativa, pero en las dos últimas décadas algo
más ha sucedido. Algunas grandes corporaciones han impuesto su control sobre la mayoría
de ordenadores del mundo y han decidido lo que puedes o no puedes hacer con ellos.
Afortunadamente, gente de todo el mundo está haciendo algo al respecto. Están luchando
por mantener el control de sus ordenadores escribiendo su propio software. Están
construyendo Linux.
Mucha gente habla de "libertad" con respecto a Linux, pero no creo que la mayoría de la
gente sepa que significa esta libertad en realidad. Libertad es el poder de decidir lo que tu
ordenador hace, y la única forma de tener esta libertad es saber que está haciendo tu
ordenador. La libertad es un ordenador que no tiene secretos, en el que todo puede saberse
si te interesa averiguarlo.
La mayoría de los usuarios de ordenadores de hoy sólo están familiarizados con la interfaz
gráfica de usuario o GUI (del inglés graphical user interface) y los vendedores y los
expertos les han enseñado que la interfaz de línea de comandos o CLI (del inglés command
line interface) es una cosa espantosa del pasado. Es una pena, porque una buena interfaz
de línea de comandos es una maravillosa y expresiva forma de comunicarse con el
ordenador, muy parecida a lo que el lenguaje escrito es para los seres humanos. Se ha
dicho que "las interfaces gráficas de usuario hacen fáciles las tareas fáciles, mientras que
las interfaces de línea de comandos hacen posibles las tareas difíciles" y eso es muy cierto
aún hoy.
Desde que Linux fue desarrollado desde la familia de sistemas operativos Unix, comparte la
misma rica herencia de herramientas de línea de comandos que Unix. Unix saltó a la fama
en los primeros años ochenta (aunque fue desarrollado una década antes), antes de que se
extendiera la adopción de las interfaces gráficas de usuario, y por eso, se desarrolló una
amplia interfaz de línea de comandos
en su lugar.
Este libro está muy centrado en Linux. Muchos otros libros tratan de ser más atractivos
incluyendo otras plataformas como Unix genérico y OS X. Al hacerlo, se convierten en una
presentación de tópicos generales. Este libro, por otra parte, sólo cubre distribuciones Linux
actuales. El noventa y cinco por ciento del contenido es útil para usuarios de otros sistemas
parecidos a Linux, pero este libro está muy enfocado a las interfaces de línea de comandos
de Linux modernas.
Dicho esto, no hay atajos para dominar Linux. Aprender la línea de comandos es un reto y
requiere un esfuerzo real. No es que sea muy duro, más bien es muy extenso. El sistema
Linux medio tiene literalmente miles de programas que puedes usar en la linea de
comandos. Considérate avisado; aprender la linea de comandos no es un esfuerzo puntual.
Otro objetivo es familiarizarte con la forma de pensar de Unix, que es distinta de la forma de
pensar de Windows. A lo largo de nuestro camino, tomaremos algunos desvíos para
ayudarte a comprender por qué algunas cosas funcionan de un modo concreto y por qué lo
hacen así. Linux no
es sólo una pieza de software, es también una pequeña parte de la gran cultura Unix, que
tiene su propio lenguaje e historia. Podría hacer alguna reflexión también.
Este libro está dividido en cuatro partes, cada una cubre un aspecto de la experiencia con la
línea de comandos:
Prerrequisitos Para usar este libro, todo lo que necesitas es una instalación de
Linux funcionando. Puedes conseguirlo de cualquiera de estas dos formas:
1. Instala Linux en un ordenador (no tiene que ser muy potente). No importa la
distribución que elijas, aunque la mayoría de las personas hoy en día empiezan con
Ubuntu, Fedora o OpenSuse. Si estás en duda, prueba primero Ubuntu. Instalando una
distribución de Linux moderna puede ser ridículamente fácil o ridículamente difícil
dependiendo de tu hardware. Recomiendo un ordenador de hace un par de años y que
tenga al menos 256 megabytes de RAM y 6 gigabytes libres de disco duro. Evita
portátiles y redes inalámbricas si es posible, ya que suelen ser más difíciles de hacerlas
funcionar. (Nota del traductor: estos requisitos se refieren a la fecha de edición del libro,
en la actualidad se necesita una hardware algo más potente.) 2. Utiliza un “Live CD”.
Una de las cosas interesantes que puedes hacer con muchas
distribuciones Linux es ejecutarlas directamente desde un CDROM (o una unidad
USB) sin instalar nada. Sólo entra en la configuración de tu BIOS y configura tu
ordenador para que “Arranque desde el CDROM”, introduce el Live CD, y reinicia.
Usar un Live CD es una gran forma de probar la compatibilidad de un ordenador antes
de instalarlo. La desventaja de usar un Live CD es que podrá ser mucho más lento
que un Linux instalado en el disco duro. Ubuntu y Fedora (además de otros) tienen
versiones en Live CD.
Cuando tengas una instalación funcionando, empieza leyendo y siguiendo el libro con tu
propio ordenador. La mayoría del material de este libro es “manos a la obra”, así que
¡siéntate y empieza a
teclear!
Richard Stallman, es el genio-filósofo que fundó el Free Software Movement (Movimiento por
el Software Libre), comenzó la Free Software Foundation (Fundación por el Software Libre),
formó el Proyecto GNU, escribió la primera versión del Compilador GNU C (GCC: GNU C
Compiler), creó la Licencia Pública General GNU (GPL: General Public License), etc., etc.,
etc. Él insiste en que se le llama “GNU/Linux” para reflejar apropiadamente las
contribuciones del Proyecto GNU. Mientras que el Proyecto GNU es anterior al kernel de
Linux, y las contribuciones hechas por el proyecto son muy dignas de reconocimiento,
colocarlo en el nombre es injusto para todos aquellos otros que hayan hecho contribuciones
significantes. Además, pienso que “Linux/GNU” sería más preciso técnicamente ya que el
kernel arranca primero y todo lo demás funciona sobre él.
Popularmente, “Linux” se refiere al kernel y todo el software libre y de código abierto que
viene en cualquier distribución de Linux; o sea, todo el ecosistema Linux, no solo los
componentes GNU. El mercado de sistemas operativos parece que prefieren nombres de
una sola palabra como DOS, Windows, Solaris, Irix, AIX. Yo he elegido usar el formato
popular. Si, de todas formas, prefieres utilizar “GNU/Linux”, por favor haz un “buscar y
reemplazar” mentalmente mientras lees este libro. No me importará.
Agradecimientos
Quiero dar las gracias a las siguientes personas, quienes me ayudaron a hacer posible
este libro:
Dmitri Popov escribió un artículo en Free Software Magazine titulado, “Creating a book
template with Writer,” que me inspiró a usar OpenOffice.org Writer para maquetar el texto.
Al final resultó que funcionó maravillosamente.
Jesse Becker, Tomasz Chrzczonowicz, Michael Levin, Spence Miner también leyeron y
revisaron partes del texto.
Karen M. Shotts contribuyó con muchas horas, puliendo mi supuesto Inglés, editando el
texto.
(Nota del traductor: para errores de traducción podéis utilizar los comentarios del blog,
gracias)
Agradecimiento especial para las siguientes personas que me hicieron valiosos comentarios
en la primera edición: Adrian Arpidez, Hu Bo, Heriberto Cantú, Joshua Escamilla, Bruce
Fowler, Ma Jun, Seth King, Mike O'Donnell, Parviz Rasoulipour, Gabriel Stutzman, and
Christian Wuethrich.
• Os dejo algunos artículos de Wikipedia sobre la gente famosa que aparecen en este
capítulo:
http://en.wikipedia.org/wiki/Linus_Torvalds
http://en.wikipedia.org/wiki/Richard_Stallman
http://en.wikipedia.org/wiki/Free_Software_Foundatio
n http://www.fsf.org http://www.gnu.org
http://www.gnu.org/gnu/why-gnu-linux.html
http://www.gnu.org/gnu/gnu-linux-faq.html#tools
Colofón
Este libro fue originalmente escrito utilizando OpenOffice.org Writer con las fuentes
Liberation Serif y Sans en un Dell Inspiron 530N, configurado de fábrica con Ubuntu 8.04. La
versión PDF de este texto fue generada directamente con OpenOffice.org Writer. The
Second Internet Edition fue producida en el mismo ordenador utilizando LibreOffice Writer
en Ubuntu 12.04.
¿Qué es el Shell?
Cuando hablamos de la línea de comandos, realmente nos estamos refiriendo al shell. El
s un programa que coge los comandos del teclado y los pasa al sistema operativo
shell e
para ejecutarlos. Casi
todas las distribuciones Linux contienen un programa shell del Proyecto GNU llamado
bash. El nombre “bash” es un acrónimo de “Bourne Again SHell”, una referencia al hecho
de que bash es un sustituto mejorado de sh, el programa Shell original de Unix escrito por
Steve Bourne.
Emuladores de Terminal
Cuando utilizamos una interfaz gráfica de usuario, necesitamos otro programa llamado
emulador de terminal p ara interactuar con el shell. Si buscamos en nuestros menús de
escritorio, probablemente encontraremos uno. KDE usa konsole y GNOME usa
gnome-terminal, aunque es probable que se llame simplemente “terminal” en nuestro
menú. Hay muchos otros emuladores de terminal disponibles para Linux, pero todos hacen
básicamente lo mismo; nos dan acceso al shell. Seguramente desarrollarás preferencia por
uno u otro según el número de “extras” que tenga.
Esto se llama shell prompt y aparecerá donde quiera que el shell esté listo para aceptar
entradas. Aunque puede variar algo en apariencia según la distribución, normalmente
incluirá tu nombredeusuario@nombredetumaquina, seguido del directorio de trabajo
actual (veremos esto dentro de un poco) y un signo de dólar.
Si el último carácter del prompt es un signo de libra (“#” ) en lugar de un signo de dólar, la
sesión de terminal tiene privilegios de superusuario. Esto significa que o hemos iniciado la
sesión como usuario root o hemos seleccionado un emulador de terminal que proporciona
privilegios (administrativos) de superusuario.
Asumiendo que todo va bien por ahora, intentemos teclear algo. Introduce letras sin
sentido en el prompt, como ésto:
[me@linuxbox ~]$ kaekfjaeifj
Como el comando no tiene sentido, el shell nos dirá que nos da otra
oportunidad:
bash: kaekfjaeifj: command not found
[me@linuxbox ~]$
Historial de Comandos
Si pulsamos la tecla de la flecha hacia arriba, veremos que el comando anterior “kaekfjaeifj”
reaparece tras el prompt. Esto se llama Historial de Comandos. La mayoría de
distribuciones Linux recuerdan los últimos 500 comandos por defecto. Pulsa la tecla de la
flecha hacia abajo y el comando anterior desaparece.
Nota: No trates de usar Ctrl-c y Ctrl-v para copiar y pegar en una ventana de
terminal. No funciona. Estos códigos de control tienen diferentes significados para el shell
y fueron asignados muchos años antes de Microsoft Windows.
Un comando relacionado es cal que, por defecto, muestra un calendario del mes
actual.
La consola tras el
telón
Aunque no tengamos ningún emulador de terminal funcionando, algunas sesiones de
terminal continúan funcionado detrás del escritorio gráfico. Llamados terminales virtuales o
consolas virtuales, podemos acceder a estas sesiones en la mayoría de las distribuciones
Linux pulsando Ctrl-Alt-F1 a Crtl-Alt-F6. Cuando accedemos a una sesión,
presenta un prompt de acceso en el que podemos introducir nuestro usuario y contraseña.
Para cambiar de una consola virtual a otra, presiona Alt y F1-F6. Para volver al escritorio
gráfico, pulsa Alt-F7.
Resumiendo
Para empezar nuestro viaje, hemos presentado el shell y hemos visto la línea de
comandos por primera vez y aprendido como empezar y terminar una sesión de terminal.
También hemos visto como enviar algunos comandos sencillos y realizar una pequeña
edición en la línea de comandos. No da tanto miedo ¿no?
Navegación
Lo primero que necesitamos aprender (además de teclear) es como navegar por el
sistema de archivos en nuestro sistema Linux. En este capítulo presentaremos los
siguientes comandos:
Nota que al contrario que Windows, que tiene un árbol del sistema de directorios separado
para cada dispositivo de almacenamiento, los sistemas como-Unix, como es Linux, siempre
tienen un único árbol de sistema, independientemente de cuantas unidades o dispositivos
de almacenamiento están conectados al ordenador. Los dispositivos de almacenamiento
están conectados (o más correctamente, montados) en varios puntos del árbol según la
voluntad del administrador del sistema, la persona (o personas) responsables del
mantenimiento del sistema.
Sin embargo, la línea de comandos no tiene imágenes, así que para navegar por el árbol del
sistema de ficheros tenemos que pensar de una forma diferente.
Imagina que el sistema de ficheros es como un laberinto con forma de árbol bocabajo y
que podemos estar dentro de él. En un momento dado, estamos dentro de un directorio
en concreto y podemos ver los archivos contenidos en él, y la ruta hacia el directorio que
está sobre nosotros (llamado directorio padre) y los subdirectorios debajo de nosotros.
Éste directorio, en el cual estamos, se llama directorio de trabajo actual. Para mostrar el
directorio de trabajo actual, utilizamos el comando pwd (print working directory):
[me@linuxbox ~]$ pwd
/home/me
La primera vez que accedemos al sistema (o abrimos una sesión del emulador de terminal)
nuestro directorio de trabajo actual es nuestro directorio home ( se podría traducir como
directorio hogar o directorio de usuario). Cada cuenta de usuario tiene su propio directorio
home y es el único lugar donde un usuario normal (sin privilegios) puede escribir archivos.
En realidad, podemos usar el comando ls para listar el contenido de cualquier directorio, no
sólo el directorio de trabajo actual, y hay muchas otras cosas curiosas que puede hacer
también. Pasaremos más tiempo con ls en el próximo capítulo.
Rutas Absolutas
Una ruta absoluta comienza con el directorio raíz y sigue rama tras rama hasta que la ruta al
directorio o archivo que queremos está completa. Por ejemplo, hay un directorio en nuestro
sistema en el que la mayoría de los programas de sistema están instalados. La ruta de
dicho directorio es /usr/bin. Ésto significa que en el directorio raíz (representado por la
barra inclinada en la ruta) hay un directorio llamado “usr” que contiene un directorio llamado
“bin”.
[me@linuxbox ~]$ cd /usr/bin
[me@linuxbox bin]$ pwd /usr/bin
[me@linuxbox bin]$ ls ...Listing of
many, many files ...
Ahora podemos ver que hemos cambiado el directorio de trabajo a /usr/bin y que está lleno
de archivos. ¿Ves como ha cambiado el prompt del shell? Por defecto, normalmente está
configurado para mostrar automáticamente el nombre del directorio de trabajo.
Rutas Relativas
Mientras que una ruta absoluta empieza desde el directorio raíz y sigue hasta su destino,
una ruta relativa comienza en el directorio de trabajo. Para hacer ésto, utiliza un par de
símbolos especiales que representan posiciones relativas en el árbol del sistema de
directorios. Estos símbolos son “.” (punto) y “..” (punto punto).
Ok, ahora le diremos que queremos cambiar el directorio de trabajo al padre de /usr/bin
que es /usr. Podríamos hacerlo de dos formas diferentes. Tanto con una ruta absoluta:
Dos métodos diferentes con idénticos resultados. ¿Cuál usamos? ¡El que requiera teclear
menos!
Igualmente, podemos cambiar el directorio de trabajo de /usr a /usr/bin de dos formas
distintas. O usando una ruta absoluta:
[me@linuxbox usr]$ cd /usr/bin
[me@linuxbox bin]$ p wd /usr/bin
Ahora, hay algo importante que debo señalar aquí. En la mayoría de los casos, puedes
omitir el “./”. Está implícito. Escribir:
[me@linuxbox usr]$ cd bin
Algunos atajos
útiles
En la Tabla 2-1 vemos algunas formas útiles para cambiar rápidamente el directorio de
trabajo actual.
Resumiendo
En este capítulo hemos visto como el shell trata la estructura de directorios del sistema.
Hemos aprendido sobre las rutas absolutas y relativas y los comandos básicos que se usan
para moverse por dicha estructura. En el próximo capítulo utilizaremos este conocimiento
para darnos una vuelta por un sistema Linux moderno.
Explorando el sistema
Ahora que sabemos como movernos por el sistema de archivos, es hora para un tour
guiado por nuestro sistema Linux. Antes de empezar sin embargo, vamos a aprender
algunos comandos más que serán útiles en nuestro viaje:
Además del directorio de trabajo actual, podemos especificar el directorio a listar, de esta
forma:
me@linuxbox ~]$ ls /usr bin games kerberos libexec
sbin src etc include lib local share tmp
También podemos cambiar el formato de la salida para que nos muestre más
detalles:
[me@linuxbox ~]$ ls -l total 56 drwxrwxr-x 2 me me
4096 2007-10-26 17:20 Desktop drwxrwxr-x 2 me me
4096 2007-10-26 17:20 Documents drwxrwxr-x 2 me me
4096 2007-10-26 17:20 Music drwxrwxr-x 2 me me 4096
2007-10-26 17:20 Pictures drwxrwxr-x 2 me me 4096
2007-10-26 17:20 Public drwxrwxr-x 2 me me 4096
2007-10-26 17:20 Templates drwxrwxr-x 2 me me 4096
2007-10-26 17:20 Videos
Opciones y
argumentos
Ésto nos ofrece un aspecto muy importante sobre como funcionan la mayoría de los
comandos. A los comandos, a menudo, le siguen una o más opciones que modifican su
comportamiento, y adicionalmente, por uno o más argumentos, los elementos sobre los que
el comando actúa. Así que la mayoría de los comandos aparecen como algo así:
comando -opciones
argumentos
La mayoría de los comandos usan opciones que consisten en un sólo carácter precedido
por un guión, por ejemplo, “-l”, pero muchos comandos, incluidos los del Proyecto GNU,
también soportan opciones largas, consistentes en una palabra precedida por dos guiones.
Además, muchos comandos permiten múltiples opciones cortas enlazadas. En este
ejemplo, al comando ls se le han dado dos opciones, la opción “l” para mostrar la salida
en formato largo, y la opción “t” para ordenar el resultado por la hora de modificación de los
archivos.
[me@linuxbox ~]$ ls -lt
Fíjate que las opciones de los comandos, como los nombres de archivo en Linux, son
sensibles a las mayúsculas.
El comando ls tiene un gran número de posibles opciones. Las más comunes están
listadas en la Tabla 3-1.
file
nombre_del_archivo
Cuando invocamos, el comando file mostrará una breve descripción del contenido del
archivo. Por ejemplo:
ile picture.jpg picture.jpg:
[me@linuxbox ~]$ f
JPEG image data, JFIF standard 1.01
Hay muchos tipos de archivos. De hecho, una de las ideas comunes en los sitemas
operativos como- Unix es que “todo es un archivo”. Según avancemos en nuestras lecciones,
veremos como de cierta es esta expresión.
Mientras que muchos de los archivos en tu sistema son familiares, por ejemplo MP3 y
JPEG, hay otros muchos que son un poco menos obvios y algunos que son un poco raros.
Viendo el contenido de un archivo con
less
El comando less es un programa para ver archivos de texto. En nuestro sistema Linux,
hay muchos archivos que contienen texto comprensible. El programa less proporciona
una forma adecuada para examinarlos.
¿Para qué querríamos examinar archivos de texto? Porque muchos de los archivos que
contienen la configuración del sistema (llamados archivos de configuración) está
almacenados en este formato, y ser capaces de leerlos nos permite ver como funciona el
sistema por dentro. Además, muchos de los programas que el sistema utiliza (llamados
scripts) están almacenados en este formato. En capítulos posteriores, aprenderemos como
editar archivos de texto para modificar configuraciones del sistema y escribiremos nuestros
propios scripts, pero por ahora sólo veremos su contenido.
less
nombre_del_archivo
Una vez ejecutado, el programa less nos permite desplazarnos arriba y abajo a
través de un
archivo de texto. Por ejemplo, para examinar el archivo que define todas las cuentas de
usuario del sistema, usamos el siguiente comando:
[me@linuxbox ~]$ less /etc/passwd
Una vez que el programa less arranca, podemos ver el contenido del archivo. Si el
archivo ocupa más de una página, podemos desplazarnos arriba y abajo. Para salir de
less, pulsamos la tecla “q”.
La siguiente tabla muestra los comandos de teclado más comunes que se usan con
less.
Comando Acción Re Pag o b
Se desplaza hacia atrás una página
Av Pag o espacio
Se desplaza hacia delante una página
Flecha hacia arriba
Se desplaza hacia arriba una línea
Flecha hacia abajo
Se desplaza hacia abajo una linea
G Se mueve al final del archivo de texto
A lo largo de un sistema Linux, muchos archivos están almacenados en formato texto y hay
muchas herramientas de Linux que trabajan con archivos de texto. Incluso Windows
reconoce la importancia de este formato. El famoso programa NOTEPAD.EXE es un editor
para archivos de texto plano ASCII.
less entra en la clase de programas llamados “paginadores”, que permiten ver fácilmente
documentos de texto largos en forma de páginas. Mientras que el programa more sólo
permitía avanzar páginas, el programa less permite avanzar y retroceder por las páginas y
cuenta también con otras características.
A continuación, vamos a dar un paseo por el sistema de archivos para darnos cuenta de lo
que hace nuestro sistema linux. Ésto nos dará la oportunidad de practicar nuestras
habilidades de navegación. Una de las cosas que descubriremos es que muchos de los
archivos interesantes están en texto plano legible. A medida que vamos avanzando en
nuestra visita guiada, prueba lo siguiente:
¡Recuerda el truco para copiar y pegar! Si utilizas ratón, puedes hacer doble clic en el
nombre de un archivo para copiar y clic con el botón central para pegarlo en los comandos.
A medida que avancemos, no tengas miedo de echar un vistazo. Los usuarios normales
tienen terminantemente prohibido desordenar cosas. ¡Es trabajo para los administradores de
sistema! Si un comando protesta sobre algo, pasa a otra cosa. Pasa algo de tiempo echando
un vistazo. El sistema es nuestro para explorarlo. Recuerda, en Linux, ¡no hay secretos!
La tabla 3-4 lista sólo algunos de los directorios que podemos explorar. ¡Eres libre de
probar con más!
binarios (programas) que tienen que estar presentes para que el sistema
arranque y funcione.
/boot
Contiene el kernel de Linux, la imagen del disco de RAM inicial (para controladores
necesarios en el momento del arranque), y el cargador de arranque.
• /boot/grub/grub.conf o menu.lst, que se utilizan para configurar el cargador
de arranque.
• /boot/vmlinuz, el kernel de Linux.
Éste es un directorio especial que contiene los nodos de dispositivo. “Todo es un
/dev
archivo” también se aplica a los dispositivos. Aquí es donde el kernel mantiene una lista
de todos los dispositivos que comprende.
/etc
El directorio /etc contiene todos los archivos de configuración del sistema. También
contiene una colección de scripts de shell que se ejecutan con cada servicio del
sistema en el arranque. Todo en este directorio debería ser texto legible. Archivos
interesantes: Como todo en /etc es interesante, os dejo algunos de mis favoritos de
siempre:
• /etc/crontab, un archivo que define cuando los trabajos automáticos se
ejecutarán.
• /etc/fstab, una tabla de los dispositivos de almacenamiento y sus puntos de
montaje asociados.
• /etc/passwd, una lista de las cuentas de usuario.
/home
En configuraciones normales, a cada usuario se le asigna un directorio en /home. Los
usuarios normales sólo pueden escribir archivos en sus directorios home. Esta
Contiene
limitación protege el sistema de actividades erróneas de los usuarios. /lib
archivos de librerías compartidas utilizadas por los programas del
/lost+f ound
Cada partición formateada o dispositivo que usa un sistema de archivos de Linux como
ext3, tendrá este directorio. Se usa en caso de una recuperación parcial causada por
un evento de corrupción del sistema de archivos. A menos que algo realmente malo
ocurra a tu sistema, este directorio debería permanecer vacío.
/media
En sistemas Linux modernos el directorio /media contendrá los puntos de montaje de
los dispositivos extraibles como unidades USB, CD-ROMs, etc. que se montan
El sistemas Linux antiguos, el directorio /mnt
automáticamente al introducirlos. /mnt
contiene los puntos de montaje
de los dispositivos extraíbles que han sido montados
manualmente.
/opt
El directorio /opt se usa para instalar software “opcional”. Principalmente se usa para
contener productos de software comercial que podrían ser instalados en tu sistema.
/proc
El directorio /proc es especial. No es un sistema de ficheros real en el sentido de
archivos almacenados en tu disco duro. En su lugar, es un sistema de archivos virtual
mantenido por el kernel de Linux. Los “archivos” que contienen son como mirillas
dentro del propio núcleo. Los archivos son legibles y os darán una imagen de como el
Este
kernel ve el ordenador. /root Es el directorio home para la cuenta root. /sbin
directorio contiene binarios de sistema. Son programas que realizan tareas
de sistema
vitales que generalmente están reservadas al superusuario.
El directorio /tmp está destinado a almacenamiento de temporales, ficheros /tmp
provisionales creados por varios programas. Algunas configuraciones hacen que este
directorio sea vaciado cada vez que el sistema se reinicia.
/usr
El árbol del directorio /usr es casi el más grande en un sistema Linux. Contiene todos
los programas y archivos de soporte utilizados por los usuarios normales. /usr/bi n
/usr/bin contiene los programas ejecutables instalados en tu distribución Linux. No
/usr/lo cal
El árbol /usr/local es donde están instalados los programas que no están incluidos
Contiene más
en tu distribución pero están destinados a un uso general. /usr/sb in
programas de administración de sistema.
/usr/sh are
/usr/share continiene todos los datos compartidos utilizados por los programas en
/usr/bin. Ésto incluye cosas como archivos de configuración por defecto, iconos,
fondos de pantalla, archivos de sonido, etc. /usr/sh are/do
c
La mayoría de los paquetes instalados en el sistema incluirán algún tipo de
documentación. En /usr/share/doc, encontraremos archivos de documentación
ordenados por paquete.
/var
Con la excepción de /tmp y /home, los directorios que hemos visto hasta ahora
permanecen relativamente estáticos, o sea, su contenido no cambia. El árbol del
directorio /var es donde los datos que es probable que cambien son almacenados.
Diferentes bases de datos, archivos de colas, correos de usuarios, etc. se encuentran
aquí.
/var/lo g
/var/log contiene archivos de registro de varias actividades del sistema. Son muy
importantes y deberían ser monitorizados de vez en cuando. El más útil es
/var/log/messages. Tenga en cuenta que, por razones de seguridad, en algunos
sistemas, tienes que ser superusuario para ver los archivos de registro.
Enlaces Simbólicos
Cuando miramos a nuestro alrededor, es probable que veamos un listado de directorio
con una entrada como esta:
lrwxrwxrwx 1 root root 11 2007-08-11 07:34 libc.so.6 ->
libc-2.6.so
¿Ves como la primera letra del listado es “l” y la entrada parece tener dos nombres de
archivo? Ésto es un tipo especial de archivo llamado enlace simbólico (también
conocido como enlace blando o sym-link. ) En la mayoría de los sistemas como-Unix es
posible tener un archivo referenciado por múltiples nombres. Aunque el sentido de ésto
no parezca obvio, es realmente una característica muy útil.
Imagina este escenario: Un programa requiere el uso de algún tipo de recurso
compartido contenido en un archivo llamado “foo”, pero “foo” tiene frecuentes cambios
de versión. Sería bueno incluir el número de versión en el nombre del archivo para que
el administrador u otras partes interesadas pudieran ver que versión de “foo” está
instalada. Ésto presenta un problema. Si
cambiamos el nombre del recurso compartido, tenemos que localizar cada programa que
pudiera usarlo y cambiarlo para que buscara un nuevo recurso cada vez que se instalara
una nueva versión del recurso. Esto no suena nada divertido.
Aquí es donde los enlaces simbólicos nos arreglan el día. Digamos que instalamos la versión
2.6 de “foo”, que tiene el nombre de archivo “foo-2.6” y entonces creamos un enlace
simbólico llamado simplemente “foo” que apunta a “foo-2.6”. Ahora todo el mundo está
contento. Los programas que utilizan “foo” pueden encontrarlo y nosotros aún podemos ver
que versión está instalada en realidad. Cuando llegue la hora de actualizar a “foo-2.7”, sólo
añadiremos el archivo a nuestro sistema, borraremos el enlace simbólico “foo” y crearemos
uno nuevo que apunte a la nueva versión. No sólo soluciona el problema del cambio de
versión, también nos permite guardar ambas versiones en nuestra máquina. Imagina que
“foo-2.7” tiene un bug (¡Condenados programadores!) y necesitamos recuperar la versión
antigua. De nuevo, sólo borramos el enlace simbólico que apunta a la nueva versión y
creamos un nuevo enlace simbólico apuntando a la versión antigua.
El directorio listado anteriormente (del directorio /lib de un sistema Fedora) muestra un
enlace simbólico llamado “libc.so.6” que apunta a un archivo de librería compartida llamado
“libc-2.6.so”. Ésto significa que los programas que busquen “libc.so.6” en realidad obtendrán
el archivo “libc- 2.6.so”. Aprenderemos como crear enlaces simbólicos en el próximo
capítulo.
Enlaces duros
Como estamos en el tema de los enlaces, tenemos que mencionar que hay un segundo tipo
de enlace llamado enlace duro. Los enlaces duros también permiten a los archivos tener
múltiples nombres, pero lo hacen de una forma distinta. Hablaremos más sobre las
diferencias entre enlaces simbólicos y duros en el próximo capítulo.
Resumiendo
Terminado nuestro tour, hemos aprendido un montón acerca de nuestro sistema. Hemos
visto varios archivos y directorios y sus contenidos. Una cosa que deberías haber sacado de
ésto es lo abierto que es el sistema. En Linux hay muchos archivos importantes que están
en texto plano y legible. Al contrario que muchos sistemas propietarios, Linux hace que todo
pueda ser examinado y estudiado.
http://www.pathname.com/fhs/
http://en.wikipedia.org/wiki/Unix_directory_structure
http://en.wikipedia.org/wiki/ASCII
Manipulando archivos y
directorios
Llegados a este punto, ¡estamos preparados para algo de trabajo real! En este
capítulo presentaremos los siguientes comandos:
Estos cinco comandos están entre los comandos de Linux usados más frecuentemente. Se
usan para manipular tanto archivos como directorios.
Aunque, para ser francos, algunas de las tareas que realizan estos comandos se hacen
más fácilmente con un gestor gráfico de archivos. Con un gestor de archivos, podemos
arrastrar y soltar un archivo de un directorio a otro, cortar y pegar archivos, borrar archivos,
etc. Entonces, ¿por qué utilizamos estos programas antiguos de línea de comandos?
Un enlace duro es indistinguible del fichero mismo. Al contrario que un enlace simbólico,
cuando listas el contenido de un directorio que contiene un enlace duro no veras ninguna
indicación especial para el enlace. Cuando un enlace duro se borra, el enlace se elimina
pero el contenido del fichero continua existiendo (o sea, su espacio no es liberado) hasta
que todos los enlaces al archivo son borrados.
Es importante ser conscientes de los enlaces duros porque los podrías encontrar de vez en
cuando, pero las prácticas modernas prefieren los enlaces simbólicos, que veremos a
continuación.
Enlaces
simbólicos
Los enlaces simbólicos se crearon para solucionar las limitaciones de los enlaces duros. Los
enlaces simbólicos funcionan creando un tipo especial de archivo que contiene un texto
apuntando al archivo o directorio enlazado. En este aspecto, funcionan de forma muy
parecida a los accesos directos de Windows, pero precedieron a esta característica de
Windows en muchos años ;-)
Un archivo enlazado por un enlace simbólico, y el propio enlace simbólico son casi
indistinguibles uno del otro. Por ejemplo, si escribes algo en el enlace simbólico, el archivo
enlazado será modificado también. De todas formas cuando borras un enlace simbólico, sólo
el enlace se borra, no el archivo. Si el archivo es borrado antes que el enlace simbólico, el
enlace continuará existiendo, pero no apuntará a nada. En este caso, el enlace se dice que
está roto. En muchas implementaciones, el comando ls mostrará los enlaces rotos en un
color distintivo, como rojo, para revelar su presencia.
El concepto de enlace puede parecer muy confuso, pero aguanta. Vamos a probar todo
ésto y, con suerte, quedará claro.
Construyamos un terreno de
juego
Como vamos a realizar manipulación real de archivos, construiremos un sitio seguro para
“jugar” con nuestros comandos de manipulación de archivos. Primero necesitamos un
directorio donde trabajar. Crearemos uno en nuestro directorio home y lo llamaremos
“playground”.
Creando directorios
El comando mkdir se usa para crear un directorio. Para crear nuestro terreno de juego
primero nos aseguraremos de que estamos en nuestro directorio home y luego
crearemos nuestro nuevo directorio:
Para hacer nuestro terreno de juego un poco más interesante, crearemos un par de
directorios dentro llamados “dir1” y “dir2”. Para hacerlo, cambiaremos nuestro directorio de
trabajo actual a playground y ejecutaremos otro mkdir:
[me@linuxbox ~]$ cd playground
Copiando archivos
A continuación, pongamos algunos datos en nuestro terreno de juego. Lo haremos
copiando un archivo. Utilizando el comando cp, copiaremos el archivo passwd del
directorio /etc al directorio de trabajo actual:
[me@linuxbox playground]$ cp /etc/passwd .
Fíjate cómo hemos usado la abreviatura para el directorio de trabajo actual, el punto que
inicia la ruta. Así que ahora si ejecutamos un ls, veremos nuestro archivo:
Ahora, sólo por divertirnos, repitamos la copia usando la opción “-v” (verbose) para ver que
hace:
[me@linuxbox playground]$ cp -v /etc/passwd .
`/etc/passwd' -> `./passwd'
El comando cp realiza la copia otra vez, pero esta vez muestra un mensaje conciso
indicando que operación estaba realizando. Fíjate que cp sobrescribe la primera copia sin
ningún aviso. De nuevo es un caso de cp asumiendo que sabes lo que estás haciendo. Para
tener un aviso, incluiremos la opción “-i” (interactive):
[me@linuxbox playground]$ cp -i /etc/passwd .
cp: overwrite `./passwd'?
Moviendo y renombrando
archivos
Bien, el nombre “passwd” no parece muy divertido y esto es un terreno de juego, así
que lo cambiaremos por otra cosa:
[me@linuxbox playground]$ mv passwd fun
Divirtámonos un poco más moviendo nuestro archivo renombrado a cada directorio y
volvamos atrás de nuevo:
[me@linuxbox playground]$ mv fun dir1
Fíjate que como dir2 ya existía, mv movió dir1 dentro de dir2. Si dir2 no hubiera
existido, mv habría renombrado dir1 a dir2. Finalmente, pondremos todo como estaba:
Creando enlaces
duros
Ahora intentaremos crear algunos enlaces. Primero los enlaces duros. Crearemos enlaces
a nuestro archivo de datos de la siguiente forma:
[me@linuxbox playground]$ ln fun fun-hard
[me@linuxbox playground]$ ln fun dir1/fun-hard
[me@linuxbox playground]$ l n fun dir2/fun-hard
Así que ahora tenemos cuatro instancias del archivo “fun”. Echemos un vistazo a nuestro
directorio playground:
[me@linuxbox playground]$ ls -l total 16 drwxrwxr-x
2 me me 4096 2008-01-14 16:17 dir1 drwxrwxr-x 2 me
me 4096 2008-01-14 16:17 dir2 -rw-r--r-- 4 me me
1650 2008-01-10 16:33 fun -rw-r--r-- 4 me me 1650
2008-01-10 16:33 fun-hard
Una cosa que notarás es que el segundo campo en el listado para fun y fun-hard
contiene en ambos un “4” que es el número de enlaces duros que existen ahora para el
archivo. Recordarás que un archivo tiene siempre al menos un enlace duro porque el
nombre del archivo se crea con un enlace. Entonces, ¿cómo sabemos que fun y
fun-hard son, en realidad, el mismo archivo? En este caso, ls no es muy útil. Aunque
podemos ver que fun y fun-hard tienen los dos el mismo tamaño (campo 5), nuestro
listado no nos ofrece una forma de estar seguro. Para solucionar el problema, vamos a
tener que cavar un poco más hondo.
Cuando pensamos en los enlaces duros, puede ayudarnos imaginar que los archivos está
compuestos de dos partes: la parte de datos que alberga el contenido del archivo y la parte
del nombre que contiene el nombre del archivo. Cuando creamos enlaces duros, realmente
estamos creando partes
de nombre adicionales que se refieren todos a la misma parte de datos. El sistema asigna
una cadena de sectores del disco llamada inodo, la cual es asociada con la parte del
nombre. Cada enlace duro por lo tanto se refiere a un inodo específico que alberga el
contenido del archivo.
El comando ls tiene una forma de revelar esta información. Se invoca con la
opción “-i”:
En esta versión de la lista, el primer campo es el número del inodo y, como podemos ver,
tanto fun como fun-hard comparten el mismo número de inodo, lo que confirma que son
el mismo archivo.
Creando enlaces
simbólicos
Los enlaces simbólicos fueron creados para superar las dos desventajas de los enlaces
duros: Los enlaces duros no pueden salir de su dispositivo físico y tampoco pueden enlazar
directorios, sólo archivos. Los enlaces simbólicos son un tipo especial de archivo que
contiene un texto apuntando al archivo o directorio de destino.
El primer ejemplo es muy sencillo, simplemente añadimos la opción “-s” para crear un
enlace simbólico en lugar de un enlace duro. Pero ¿qué pasa con los dos siguientes?
Recuerda, cuando creamos un enlace simbólico, estamos creando un texto describiendo
donde está el archivo de destino con respecto al enlace simbólico. Es más fácil verlo si
miramos el resultado de ls:
El listado para fun-sym en dir1 muestra que es un enlace simbólico con una “l” en el
primer carácter del primer campo y que apunta a “../fun”, lo cual es correcto. En cuanto a la
localización de fun-sym, fun está en el directorio superior. Ten en cuenta que, la longitud
del archivo enlace simbólico es 6, el número de caracteres de la cadena “../fun” en lugar de
la longitud del archivo al que está apuntando.
ln -s /home/me/playground/fun dir1/fun-sym
o rutas relativas, como hicimos en el anterior ejemplo. Usar rutas relativas es más
recomendable porque permite que un directorio que contiene enlaces simbólicos pueda
ser renombrado y/o movido sin romper los enlaces.
Además de archivos normales, los enlaces simbólicos también pueden enlazar
directorios:
[me@linuxbox playground]$ ln -s dir1 dir1-sym
[me@linuxbox playground]$ ls -l total 16 drwxrwxr-x 2 me
me 4096 2008-01-15 15:17 dir1 lrwxrwxrwx 1 me me 4
2008-01-16 14:45 dir1-sym -> dir1 drwxrwxr-x 2 me me
4096 2008-01-15 15:17 dir2 -rw-r--r-- 4 me me 1650
2008-01-10 16:33 fun -rw-r--r-- 4 me me 1650 2008-01-10
16:33 fun-hard lrwxrwxrwx 1 me me 3 2008-01-15 15:15
fun-sym -> fun
Eliminando archivos y
directorios
Como vimos anteriormente, el comando rm se usa para borrar archivos y directorios.
Vamos a usarlo para limpiar nuestro terreno de juego un poco. Primero, borraremos uno de
Escribe “y” en la consola y el archivo se borra. Pero miremos al mensaje de ls ahora. ¿Ves
lo que le ha pasado a fun-sym? Como era un enlace simbólico apuntando a un archivo que
ahora no existe, el enlace está roto:
[me@linuxbox playground]$ ls -l total 8 drwxrwxr-x 2 me
me 4096 2008-01-15 15:17 dir1 lrwxrwxrwx 1 me me 4
2008-01-16 14:45 dir1-sym -> dir1 drwxrwxr-x 2 me me
4096 2008-01-15 15:17 dir2 lrwxrwxrwx 1 me me 3
2008-01-15 15:15 fun-sym -> fun
La mayoría de las distribuciones Linux configuran ls para mostrar los enlaces rotos. En
Fedora, los enlaces rotos ¡se muestran en texto rojo parpadeante! La presencia de un
enlace roto no es, por sí misma peligrosa pero si indica un poco de desorden. Si
intentamos usar un enlace roto veremos ésto:
[me@linuxbox playground]$ less fun-sym
fun-sym: No such file or directory
Limpiemos un poco. Borraremos los enlaces
simbólicos:
[me@linuxbox playground]$ rm fun-sym dir1-sym
[me@linuxbox playground]$ ls -l total 8
drwxrwxr-x 2 me me 4096 2008-01-15 15:17 dir1
drwxrwxr-x 2 me me 4096 2008-01-15 15:17 dir2
Una cosa que hay que recordar sobre los enlaces simbólicos es que la mayoría de las
operaciones con archivos son realizadas en el archivo de destino, no en el propio enlace.
rm es una excepción. Cuando borras un enlace, es el enlace el que es eliminado, no el
archivo de destino.
Resumiendo
Hemos abarcado mucho terreno y no llevará algo de tiempo asentarlo complentamente.
Realiza el ejercicio del terreno de juego una y otra vez hasta que tenga sentido. Es
importante tener una buena comprensión de la manipulación básica de comandos y
comodines. Siéntete libre para ampliar el ejercicio del terreno de juego añadiendo más
archivos y directorios, usando comodines para archivos concretos para varias operaciones.
El concepto de enlace es un poco confuso al principio, pero tómate tiempo para aprender
como funcionan. Pueden ser un verdadero salvavidas.
Trabajando con
comandos
Llegados a este punto, hemos visto una serie de misteriosos comandos, cada uno con
sus misteriosas opciones y argumentos. En este capítulo, intentaremos resolver algunos
de estos misterios e incluso crear algunos comandos propios. Los comandos
comando
• which – Muestra que programa ejecutable será
ejecutado
• help – Ofrece ayuda para funciones del shell
• man – Muestra el manual de un comando
• apropos – Muestra una lista de comandos
apropiados
• info – Muestra información sobre un comando
• whatis – Muestra una descripción muy breve de un
comando
• alias – Crea un alias para un comando
¿Qué son exactamente los
comandos?
Un comando puede ser una de estas cuatro
cosas:
1. Un programa ejecutable como todos esos archivos que vimos en /usr/bin.
Dentro de
esta categoría, los programas pueden ser binarios compilados c omo programas escritos
en C y C++, o programas escritos en lenguajes de script como el shell, perl, python,
ruby, etc. 2. Un comando contenido en el propio shell. bash soporta gran número de
comandos
internos llamados shell builtins. El comando cd, por ejemplo, es un shell builtin. 3.
Una función del shell. Éstos son pequeños scripts de shell incorporados en el
entorno.
Veremos cómo configurar el entorno y cómo escribir funciones del shell en próximos
capítulos, pero por ahora, sólo ten en cuenta que existen. 4. Un alias. Comando
que podemos definir nosotros mismos, construidos a partir de otros
comandos.
Identificando
comandos
A menudo es útil saber exactamente cual de los cuatro tipos de comandos estamos usando
y Linux proporciona un par de formas de averiguarlo.
type comando
donde comando es el nombre del comando que quieres examinar. Aquí tienes algunos
ejemplos:
[me@linuxbox ~]$ type type type is
a shell builtin [me@linuxbox ~]$
type ls ls is aliased to `ls
--color=tty' [me@linuxbox ~]$ type
cp cp is /bin/cp
Aquí vemos los resultados para tres comandos diferentes. Fíjate en el de ls (realizado
sobre un sistema Fedora) y en cómo el comando ls es realmente un alias del comando
ls con la opción “--color=tty” añadida. ¡Ahora sabemos porqué la salida de ls se
muestra en color!
Obteniendo la documentación de un
comando
Ahora que sabemos qué es un comando, podemos buscar la documentación disponible
para cada tipo de comando.
Mientras que la salida de help para el comando cd es concisa y precisa, esto no significa
que sea un tutorial como podemos ver, también parece mencionar muchas cosas de las que
aún no hemos hablado. No te preocupes. Llegaremos a ello.
man programa
Las man pages varían algo en formato pero generalmente contienen un título, una sinopsis
de la sintaxis del comando, una descripción del propósito del comando, y una lista y
descripción de cada
opción del comando. Las man pages, de todas formas, no suelen incluir ejemplos, y están
pensadas como una referencia, no como un tutorial. Como ejemplo, probaremos a ver la
man page para el comando ls:
En la mayoría de los sistemas Linux, man usa less para mostrar la man page, así que
todos los comandos de less que nos son familiares funcionan cuando está mostrado la
página.
El “manual” que man muestra está dividido en secciones y no sólo cubre los comandos de
usuario sino también los comandos del administrador de sistema, interfaces de
programación, formatos de archivo y más. La tabla siguiente describe la estructura del
manual:
A veces necesitamos buscar en una sección específica del manual para encontrar lo que
estamos buscando. Esto es particularmente cierto si estamos buscando un formato de
archivo que también es el nombre de un comando. Sin especificar un número de sección,
siempre obtendremos el primer resultado, probablemente en la sección 1. Para especificar
un número de sección, usamos man así:
man sección término_buscado
Por ejemplo:
[me@linuxbox ~]$ man 5 passwd
El primer campo de cada línea es el nombre de la man page, el segundo campo muestra la
sección. Fíjate que el comando man con la opción “-k” ofrece exactamente la misma función
que apropos.
Por otra parte, es muy precisa y concisa, además de ser extremadamente completa. Así
que échale un vistazo si te atreves y imagínate el día en que puedas leerla y tenga sentido.
comando1; comando2;
comando3...
Como podemos ver, hemos combinado tres comandos en una línea. Primero hemos
cambiado el directorio a /usr luego hemos listado el directorio y finalmente hemos vuelto al
directorio original (usando 'cd -') con lo que hemos terminado donde empezamos. Ahora
convirtamos esta secuencia en un nuevo comando usando alias. La primera cosa que
tenemos que hacer es inventarnos un nombre para nuestro nuevo comando. Probemos
“test”. Antes de hacerlo, sería una buena idea averiguar si el nombre “test” ya está siendo
usado. Para averiguarlo, podemos usar el comando type de nuevo:
Tras el comando “alias” le damos a alias un nombre seguido inmediatamente (si espacio en
blanco) por un signo igual, seguido inmediatamente por una cadena entre comillas simples
conteniendo los comandos que se asignarán al nombre. Después de definir nuestro alias,
puede ser usado donde quiera que el shell acepte comandos. Probemos:
[me@linuxbox ~]$ foo bin games kerberos
lib64 local share tmp etc include lib
libexec sbin src /home/me [me@linuxbox ~]$
También podemos usar el comando type de nuevo para ver nuestro
alias:
Aunque evitamos a propósito nombrar nuestro alias con un nombre de comando existente,
no es raro que se haga. A menudo se hace para aplicar una opción que se utilice a
menudo en cada invocación de un comando común. Por ejemplo, vimos antes que el
comando ls a menudo es un alias con soporte para colores:
[me@linuxbox ~]$ type ls ls is
aliased to `ls –color=tty'
Para ver todos los alias definidos en nuestro entorno, utiliza el comando alias sin
argumentos. Aquí tienes algunos de los alias definidos por defecto en un sistema Fedora.
Pruébalo e imagina para que sirve cada uno:
[me@linuxbox ~]$ alias alias
l.='ls -d .* --color=tty' alias
ll='ls -l --color=tty' alias
ls='ls –color=tty'
Resumiendo
Ahora que hemos aprendido como encontrar documentación sobre los comandos, échale un
vistazo a la documentación de todos los comandos que hemos visto hasta ahora. Estudia
que opciones adicionales están disponibles y ¡prúebalas!
• El Manual de Referencia de Bash e s una guía de referencia del shell bash. Sigue
siendo sólo un trabajo de referencia pero contiene ejemplos y es más fácil de leer que
la man page de bash.
http://www.gnu.org/software/bash/manual/bashref.ht
ml
• El Bash FAQ contiene respuestas a preguntas frecuentes sobre bash. Esta lista está
dirigida usuarios de intermedios a avanzados, pero contiene un montón de buena
información.
http://mywiki.wooledge.org/BashFAQ
• El Proyecto GNU provee una extensa documentación para sus programas, los cuales
forman el corazón de la experiencia con la linea de comandos de Linux. Puedes ver una
lista completa aquí:
http://www.gnu.org/manual/manual.html
• Wikipedia tiene un interesante artículo sobre las man
pages:
http://en.wikipedia.org/wiki/Man_page
Redirección
En esta lección vamos a desvelar la que podría ser la mejor característica de la línea de
comandos. Se llama redirección I/O. I/O significa input/output y con esta aplicación puedes
redirigir la salida y entrada de los comandos hacia o desde archivos, así como conectar
múltiples comandos juntos en poderosos “conductos” o pipelines de comandos. Para mostrar
esta aplicación introduciremos los siguientes comandos:
Siguiendo con el tema Unix de “todo es un archivo”, programas como ls en realidad
mandan sus resultados a un archivo especial llamado standard output o salida estándar (a
menudo expresado como stdout) y sus mensajes de estado a otro archivo llamado standard
error estándar (stderr) . Por defecto, tanto la salida estándar como el error estándar
error o
están enlazados a la pantalla y no se guardan en un archivo en el disco.
Además muchos programas toman la entrada de una aplicación llamada standard input o
entrada estándar (stdin) que está, por defecto, asociada al teclado.
La redirección I/O nos permite cambiar donde va la salida y de donde viene la entrada.
Normalmente, la salida va a la pantalla y la entrada viene del teclado, pero con la
redirección I/O, podemos cambiarlo.
Redirigiendo la salida
estándar
La redirección I/O nos permite redefinir donde va la salida estándar. Para redirigir la salida
estándar a otro archivo en lugar de a la pantalla, usamos el operador de redirección “>”
seguido del nombre del archivo. ¿Para qué querríamos hacer ésto? A menudo es útil
almacenar la salida de un comando en un archivo. Por ejemplo, podríamos decirle al shell
que mande la salida del comando ls al archivo ls-output.txt en lugar de a la pantalla:
Bien, un bonito y largo archivo de texto. Si vemos el archivo con less, veremos que el
archivo ls-output.txt en efecto contiene el resultado del nuestro comando ls:
Ahora, repitamos nuestra prueba de redirección, pero esta vez con un giro. Cambiaremos el
nombre del directorio a uno que no exista:
[me@linuxbox ~]$ ls -l /bin/usr > ls-output.txt ls:
cannot access /bin/usr: No such file or directory
¡El archivo ahora tiene tamaño cero! Ésto es porque, cuando redirigimos la salida con el
operador de redirección “>”, el archivo de destino siempre se sobreescribe desde el
principio. Como nuestro comando ls no generó resultados y sólo un mensaje de error, la
operación de redirección comenzó a reescribir el archivo y paró a causa del error,
truncándose. De hecho, si alguna vez necesitamos realmente un archivo truncado (o crear
un archivo nuevo vacío) podemos usar un truco como éste:
[me@linuxbox ~]$ > ls-output.txt
Redirigiendo el error
estándar
Redirigir el error estándar carece de la facilidad de un operador de redirección dedicado.
Para redirigir el error estándar debemos referirnos a su descriptor de archivo (file descriptor).
Un programa puede producir salidas en una de varias cadenas de archivos numeradas.
Aunque nos hemos referido a las tres primeras de estas cadenas de archivos como entrada
estándar, salida estándar y error estándar, el shell se refiere a ellas internamente como los
descriptores de archivo 0, 1 y 2 respectivamente. El shell proporciona una notación para los
archivos redirigidos utilizando el número descriptor de archivo. Como el error estándar es el
mismo que el descriptor de archivo número 2, podemos redirigir el error estándar con esta
notación:
[me@linuxbox ~]$ ls -l /bin/usr 2> ls-error.txt
Fíjate que el orden de las redirecciones es fundamental. La redirección del error
estándar siempre debe ocurrir despúes de redirigir la salida estándar o no funcionará. En el
ejemplo anterior,
>ls-output.txt 2>&1
Eliminando salidas
innecesarias
Algunas veces “el silencio es oro”, y no queremos salida de un comando, sólo queremos
ignorarla.
Ésto se aplica particularmente a los mensajes de estado y de error. El sistema proporciona
una forma de hacerlo redireccionando la salida a un archivo especial llamado “dev/null”. Este
archivo es un dispositivo de sistema llamado un cubo de bits que acepta entradas y no hace
nada con ellas. Para suprimir los mensajes de error de un comando, hacemos esto:
[me@linuxbox ~]$ ls -l /bin/usr 2> /dev/null
Redireccionando la entrada
estándar
Hasta ahora, no hemos encontrado ningún comando que haga uso de la entrada estándar
(en realidad sí lo hemos hecho, pero revelaremos la sorpresa un poco más tarde), así que
necesitamos presentar uno.
cat – Concatenando
archivos
El comando cat lee uno o más archivos y los copia a la salida estándar de la siguiente
forma:
cat [file...]
En la mayoría de los casos, puedes pensar que cat es un análogo al comando TYPE
de DOS. Puedes usarlo para mostrar archivos sin paginar, por ejemplo:
[me@linuxbox ~]$ cat ls-output.txt
mostrará el contenido del archivo ls-output.txt. cat a menudo se usa para mostrar
archivos de texto cortos. Como cat puede aceptar más de un archivo como argumento,
puede ser usado también para unir archivos. Imagina que hemos descargado un gran
archivo que ha sido dividido en múltiples partes (los archivos multimedia a menudo está
divididos de esta forma en Usenet), y queremos unirlos de nuevo. Si los archivos se
llamaran:
movie.mpeg.001 movie.mpeg.002 ... movie.mpeg.099
Como los comodines siempre expanden sus resultados en orden alfabético, los
argumentos se distribuirán en el orden correcto.
Todo esto está muy bien, pero ¿qué tienen esto que ver con la entrada estándar? Nada
todavía, pero probemos algo más. Que pasa si usamos “cat” sin argumentos:
[me@linuxbox ~]$ cat
No ocurre nada, sólo se queda quieto como si se hubiera quedado colgado. Podría parecer
eso, pero realmente está haciendo lo que se supone que debe hacer.
Ahora, pulsa Ctrl-d (p.ej., pulsa la tecla Ctrl y luego pulsa “d”) para decirle a cat
que ha alcanzado el final del archivo ( EOF – end of file) en el salida estándar:
[me@linuxbox ~]$ cat The quick brown fox jumped
over the lazy dog. The quick brown fox jumped
over the lazy dog.
Escribe el comando seguido del texto que queremos colocar en el archivo. Recuerda pulsar
Ctrl- d al final. Usando la línea de comandos, ¡hemos implementado el procesador de
texto más tonto del mundo! Para ver nuestros resultados, podemos usar cat para copiar el
archivo a stdout de nuevo:
at lazy_dog.txt The quick
[me@linuxbox ~]$ c
brown fox jumped over the lazy dog.
Ahora que conocemos como cat acepta la entrada estándar, además de nombres de
archivo como argumentos, probemos redirigiendo la entrada estándar:
at < lazy_dog.txt The quick
[me@linuxbox ~]$ c
brown fox jumped over the lazy dog.
Usando el operador de redirección “<”, hemos cambiado el origen de la entrada estándar del
teclado al archivo lazy_dog.txt. Vemos que el resultado es el mismo que pasarle un
nombre de archivo como argumento, pero sirve para demostrar el uso de un archivo como
fuente de la entrada estándar. Otros comandos hacer un mejor uso de la entrada estándar,
como veremos pronto.
Antes de seguir, echa un vistazo a la man page de cat, ya que tiene varias opciones
interesantes.
Pipelines (Tuberías)
La capacidad de los comandos de leer datos de la entrada estándar y mandarlos a la salida
estándar la utiliza una función del shell llamada pipeline (tubería). Usando el operador pipe
(tubo) “|” (la barra vertical), la salida estándar de un comando puede ser canalizada hacia la
entrada estándar de otro:
comando2
comando1 |
Mucha gente intentará lo siguiente cuando están aprendiendo los pipelines, “sólo mira
Aquí tenemos un ejemplo real enviado por un lector que estaba administrando una
aplicación de servidor basada el Linux. Como superusuario, hizo ésto:
# cd /usr/bin #
ls > less
Filtros
Los pipelines a menudo se usan para realizar complejas operaciones con datos. Es posible
poner varios comandos juntos dentro de un pipeline. Frecuentemente, a los comandos
usados de esta forma se les llama filtros. Los filtros toman entradas, la cambian en algo y las
mandan a la salida. El primero que probaremos es sort. Imagina que queremos hacer una
lista combinada de todos los programas ejecutables en /bin y en /usr/bin, que los
ponga en orden y los veamos:
[me@linuxbox ~]$ ls /bin /usr/bin | sort | less
Como hemos especificado dos directorios (/bin y /usr/bin), la salida de ls debería
haber consistido en dos listas ordenadas, una para cada directorio. Pero incluyendo
sort, en nuestro pipeline, hemos cambiado los datos para producir una única lista
ordenada.
En este ejemplo, usamos uniq para eliminar duplicados de la salida del comando sort.
Si, en lugar de eso, queremos ver la lista de duplicados, añadiremos la opción “-d” a uniq
así:
[me@linuxbox ~]$ ls /bin /usr/bin | sort | uniq -d | less
Cuando grep encuentra un “patrón” en el archivo, muestra las líneas que lo contienen. El
patrón que grep puede encontrar puede ser muy complejo, pero por ahora nos
concentraremos en coincidencias simples de texto. Trataremos patrones avanzados,
n un capítulo posterior.
llamados expresiones regulares e
Digamos que queremos encontrar todos los archivos en nuestra lista de programas que
tengan la palabra “zip” incluida en el nombre. Una búsqueda así debería darnos una idea
que algunos de los programas en nuestro sistema que tienen algo que ver con la
compresión de archivos. Haríamos ésto:
[me@linuxbox ~]$ ls /bin /usr/bin | sort | uniq | grep zip
bunzip2 bzip2 gunzip gzip unzip zip zipcloak zipgrep zipinfo
zipnote zipsplit
Hay un par de opciones útiles para grep: “-i” que hace que grep ignore las mayúsculas
cuando haga la búsqueda (normalmente las búsquedas con sensibles a las mayúsculas) y
“-v” que le dice a grep que sólo muestre las lineas que no coincidan con el patrón.
head / tail – Muestra la primera/última parte de los
archivos
Algunas veces no quieres toda la salida de un comando. Podrías querer sólo las primeras o
las últimas líneas. El comando head muestra las primeras diez líneas de un archivo y el
comando tail muestras las diez últimas. Por defecto, ambos comandos muestran diez
líneas de texto, pero ésto puede ajustarse con la opción “-n”:
[me@linuxbox ~]$ head -n 5 ls-output.txt total 343496
-rwxr-xr-x 1 root root 31316 2007-12-05 08:58 [ -rwxr-xr-x 1
root root 8240 2007-12-09 13:39 411toppm -rwxr-xr-x 1 root
root 111276 2007-11-26 14:27 a2p -rwxr-xr-x 1 root root 25368
2006-10-06 20:16 a52dec [me@linuxbox ~]$ tail -n 5
ls-output.txt -rwxr-xr-x 1 root root 5234 2007-06-27 10:56
znew -rwxr-xr-x 1 root root 691 2005-09-10 04:21
zonetab2pot.py -rw-r--r-- 1 root root 930 2007-11-01 12:23
zonetab2pot.pyc -rw-r--r-- 1 root root 930 2007-11-01 12:23
zonetab2pot.pyo lrwxrwxrwx 1 root root 6 2008-01-31 05:22
zsoelim -> soelim
tail tiene una opción que nos permite ver los archivos en tiempo real. Ésto es útil para ver
el progreso de los archivos de logs tal como se van escribiendo. En el siguiente ejemplo,
veremos el archivo messages en /var/log (o el archivo /var/log/syslog si
messages no existe). Se requieren privilegios de superusuario para hacerlo en algunas
distribuciones Linux, ya que el archivo /var/log/messages podría contener información
de seguridad:
Resumiendo
Como siempre, revisa la documentación de cada comando que hemos tratado en este
capítulo. Sólo hemos visto su uso más básico. Todos tienen numerosas opciones
interesantes. Según vayamos ganando experiencia con Linux, veremos que la función de
redirección de la línea de comandos es extremadamente útil para solucionar problemas
especializados. Hay muchos comandos que hacen uso de la entrada y salida estándar, y
casi todos los programas de la línea de comandos usan el error estándar para mostrar sus
mensajes informativos.
Windows es como una Game Boy. Vas a la tienda y compras una toda brillante y nueva en
su caja. La llevas a casa, la enciendes y juegas con ella. Bonitos gráficos, sonidos chulos.
Cuando pasa un rato, te cansas del juego que viene con ella y vuelves a la tienda a comprar
otro. Este ciclo se repite una y otra vez. Finalmente, vuelves a la tienda y le dices a la
persona que está tras el mostrador, “¡Quiero un juego que haga ésto!” sólo para que te
digan que ese tipo de juego no existe porque no hay “demanda” en el mercado. Entonces
dices, “¡Pero sólo necesito cambiar una cosa! La persona tras el mostrador te dice que no
puedes cambiarlo. Los juegos se venden en sus cartuchos. Descubres que tu juguete está
limitado a los juegos que otros han decidido que necesitas y ya está.
Linux, al contrario, es como el mecano más grande del mundo. Lo abres y sólo es una gran
colección de partes. Un montón de puntillas, tornillos, tuercas, engranajes, poleas, motores
todos de acero y algunas sugerencias sobre qué puedes construir. Así que empiezas a jugar
con él. Construyes una de las sugerencias y luego otra. Después de un rato descubres que
tienes tus propias ideas de qué construir. Nunca más tienes que volver a la tienda, ya que
tienes todo lo que necesitas. El mecano se adapta a tu imaginación. Hace lo que tú quieres.
Tu elección de juguetes es, por supuesto, algo personal, así que ¿qué juguete
encontrarías más satisfactorio?
Expansión
Cada vez que escribes un comando y presionas la tecla enter, bash realiza varios procesos
sobre el texto antes de llevar a cabo el comando. Hemos visto un par de casos de cómo una
simple secuencia de caracteres, por ejemplo “*”, puede tener mucho significado para el shell.
El proceso que hace que ésto ocurra se llama expansión. Con la expansión, introduces algo
y se expande en otra cosa antes de que el shell actúe sobre ello. Para demostrar qué
queremos decir con ésto, echemos un vistazo al comando echo. echo es una función del
shell que realiza una tarea muy simple. Muestra sus argumentos de texto en la salida
estándar:
[me@linuxbox ~]$ echo this is a test
this is a test
Es muy sencillo. Cualquier argumento que pasemos a echo se muestra. Probemos otro
ejemplo:
[me@linuxbox ~]$ echo * Desktop Documents ls-output.txt
Music Pictures Public Templates Videos
Pero, ¿qué ha pasado? ¿por qué echo no ha escrito “*”? Como recordarás de nuestro
trabajo con comodines, el carácter “*” significa coincidencia de caracteres en el nombre de
archivo, pero lo que no hemos visto en nuestra conversación original es como hace eso el
shell. La respuesta sencilla es que el shell expande el “*” en algo más (en este ejemplo, los
nombres de los archivos que se encuentran en el directorio de trabajo actual) antes de que el
comando echo se ejecute. Cuando presionamos la tecla enter, el shell automáticamente
expande todos los caracteres en la linea de comandos antes de que el comando sea
ejecutado, por lo que el comando echo no ve el “*”, sólo su resultado expandido. Sabiendo
ésto, podemos ver que echo se ha comportado como se esperaba.
Expansión de nombres de
archivo
El mecanismo según el cual trabajan los comodines se llama expansión de nombres de
archivo. Si probamos algunas de las técnicas que hemos empleado en nuestros capítulos
anteriores, veremos que son realmente expansiones. Tomemos un directorio home que
aparezca de la siguiente forma:
[me@linuxbox ~]$ ls Desktop ls-output.txt
Pictures Templates Documents Music Public
Videos
y:
[me@linuxbox ~]$ echo *s Documents
Pictures Templates Videos
o también:
[me@linuxbox ~]$ echo [[:upper:]]* Desktop Documents Music
Pictures Public Templates Videos
Podría parecer a primera vista que podríamos incluir archivos ocultos en una
expansión comenzando el patrón con un punto, así:
echo .*
Casi funciona. De todas formas, si examinamos los resultados atentamente, veremos que
los nombres “.” y “..” también aparecen en los resultados. Como estos nombres se refieren al
directorio actual y su directorio padre, usar este patrón probablemente producirá un
resultado incorrecto. Podemos verlo si probamos el comando:
ls -d .* | less
Para ejecutar mejor una expansión de nombres de archivo en esta situación, tenemos que
emplear un patrón más específico:
echo .[!.]*
Este patrón se expande en todos los nombres de archivo que empiecen con un punto, no
incluye un segundo punto, seguido de cualquier otro carácter. Ésto funcionará correctamente
con la mayoría de archivos ocultos (piensa que todavía no incluirá los nombres de archivo
con múltiples puntos al principio). El comando ls con la opción -A (“almost all” o “casi todo”)
proporcionará un listado correcto de los archivos ocultos:
ls -A
Expansión de la tilde de la
ñ
Como recordarás de nuestra introducción al comando cd, el carácter virgulilla, o tilde de la
ñ (“~” tiene un significado especial. Cuando se usa al principio de una palabra, se expande
en el nombre del directorio home del usuario nombrado, o si no se nombra a ningún
usuario, en el directorio home del usuario actual:
[me@linuxbox ~]$ echo ~
/home/me
Expansión aritmética
El shell permite realizar aritmética mediante la expansión. Ésto nos permite usar el prompt
del shell como una calculadora:
[me@linuxbox ~]$ echo $((2 + 2)) 4
La expansión aritmética sólo soporta enteros (números enteros sin decimales), pero puede
realizar un buen número de operaciones diferentes. Aquí hay unos pocos de los
operadores soportados:
Tabla 7-1: Operadores aritméticos
Operador Descripción
+ Suma - Resta
** Potencia
Los paréntesis sencillos pueden ser usados para agrupar subexpresiones. Con esta técnica,
podemos reescribir el ejemplo anterior y obtener el mismo resultado usando una única
expansión en lugar de dos:
[me@linuxbox ~]$ echo $(((5**2) * 3))
75
Aquí tenemos un ejemplo usando los operadores división y resto. Fíjate el efecto de la
$((5/2))
Five divided by two equals 2 [me@linuxbox ~]$
echo with $((5%2)) left over. with 1 left over.
Expansión con
llaves
Quizás la expansión más extraña es la llamada expansión con llaves. Con ella,
puedes crear múltiples cadenas de texto desde un patrón que contenga llaves. Aquí
tienes un ejemplo:
[me@linuxbox ~]$ echo Front-{A,B,C}-Back
Front-A-Back Front-B-Back Front-C-Back
Los patrones a expandir con llaves deben contener un prefijo llamado preámbulo y un sufijo
llamado postcript. La expresión entre llaves debe contener una lista de cadenas separadas
por comas o un rango de números enteros o caracteres individuales. El patrón no debe
contener espacios en blanco. Aquí hay un ejemplo usando un rango de números enteros:
[me@linuxbox ~]$ echo Number_{1..5} Number_1
Number_2 Number_3 Number_4 Number_5
¿Y para qué sirve ésto? La aplicación más común es hacer listas de archivos o directorios a
crear. Por ejemplo, si fuésemos fotógrafos con una gran colección de imágenes que
queremos organizar en años y meses, la primera cosa que deberíamos hacer es crear una
serie de directorios nombrados en formato numérico “Año-Mes”. De esta forma, los
directorios se ordenarán cronológicamente. Podríamos escribir la lista completa de
directorios, pero sería un montón de trabajo y sería muy fácil equivocarnos. En lugar de eso,
podríamos hacer esto:
[me@linuxbox ~]$ mkdir Photos [me@linuxbox ~]$ cd
Photos [me@linuxbox Photos]$ mkdir
{2007..2009}-{01..12} [me@linuxbox Photos]$ ls
2007-01 2007-07 2008-01 2008-07 2009-01 2009-07
2007-02 2007-08 2008-02 2008-08 2009-02 2009-08
2007-03 2007-09 2008-03 2008-09 2009-03 2009-09
2007-04 2007-10 2008-04 2008-10 2009-04 2009-10
2007-05 2007-11 2008-05 2008-11 2009-05 2009-11
2007-06 2007-12 2008-06 2008-12 2009-06 2009-12
¡Muy astuto!
Expansión con
parámetros
Sólo vamos a tratar brevemente la expansión con parámetros en este capítulo, pero lo
trataremos más extensamente más tarde. Es una función que es más útil en scripts de shell
que directamente en la línea de comandos. Muchas de sus capacidades tienen que ver con
la capacidad del sistema de almacenar pequeños trozos de datos y dar a cada trozo un
nombre. Muchos de esos trozos, mejor llamados variables, están disponibles para que los
examines. Por ejemplo, la variable llamada “USER” contiene tu nombre de usuario. Para
invocar la expansión con parámetros y revelar el contenido de USER deberías hacer ésto:
Habrás notado que con otros tipos de expansión, si escribes mal un patrón, la expansión no
se lleva a cabo y el comando echo simplemente mostrará el patrón que has escrito mal.
Con la expansión con parámetros, si escribes mal el nombre de la variable, la expansión se
realizará, pero dando como resultado una cadena vacía:
[me@linuxbox ~]$ echo $SUER
[me@linuxbox ~]$
Sustitución de
comandos
La sustitución de comandos nos permite usar la salida de un comando como una
expansión:
[me@linuxbox ~]$ echo $(ls) Desktop Documents
ls-output.txt Music Pictures Public Templates Videos
Aquí hemos pasado el resultado de which cp como un argumento para el comando ls,
de esta forma tenemos el listado del programa cp sin tener que saber su ruta completa.
No estamos limitados a comandos simples sólo. Pipelines completas pueden ser usadas
(sólo se muestra una salida parcial):
[me@linuxbox ~]$ file $(ls -d /usr/bin/* | grep zip)
/usr/bin/bunzip2: symbolic link to `bzip2' /usr/bin/bzip2:
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV),
dynamically linked (uses shared libs), for
GNU/Linux 2.6.9, stripped /usr/bin/bzip2recover: ELF
32-bit LSB executable, Intel 80386, version 1 (SYSV),
dynamically linked (uses shared libs), for GNU/Linux
2.6.9, stripped /usr/bin/funzip: ELF 32-bit LSB
executable, Intel 80386, version 1 (SYSV), dynamically
linked (uses shared libs), for GNU/Linux 2.6.9, stripped
/usr/bin/gpg-zip: Bourne shell script text executable
/usr/bin/gunzip: symbolic link to `../../bin/gunzip'
/usr/bin/gzip: symbolic link to `../../bin/gzip'
/usr/bin/mzip: symbolic link to `mtools'
En éste ejemplo, el resultado del pipeline se convierte en la lista de argumentos del comando
file.
o:
[me@linuxbox ~]$ echo The total is $100.00
The total is 00.00
Comillas dobles
El primer tipo de citas que vamos a ver son las comillas dobles. Si colocas un texto dentro de
comillas dobles, todos los caracteres especiales utilizados por el shell perderán su
significado especial y serán tratados como caracteres ordinarios. Las excepciones son “$”, “\”
(barra invertida), y “`” (tilde invertida). Esto significa que la división por palabras, expansión
de nombres de archivo, expansión de la tilde de la ñ y la expansión con llaves están
suprimidas, pero la expansión con parámetros, la expansión aritmética y la sustitución de
comandos sí que funcionarán. Usando comillas dobles, podemos manejar nombres de
archivo que contengan espacios en blanco. Digamos que somos la desafortunada víctima de
un archivo llamado two words.txt. Si tratáramos de usarlo en la línea de comandos, la
separación de palabras haría que fuera tratado como dos
argumentos separados en lugar del único argumento que
queremos:
[me@linuxbox ~]$ ls -l two words.txt ls: cannot access
two: No such file or directory ls: cannot access
words.txt: No such file or directory
¡Ahí lo tienes! Ahora no tenemos que seguir escribiendo esas malditas comillas dobles.
Recuerda, la expansión con parámetros, la expansión aritmética y la sustitución de
comandos siguen funcionando dentro de las comillas dobles:
[me@linuxbox ~]$ echo "$USER $((2+2)) $(cal)"
me 4 February 2008 Su Mo Tu We Th Fr Sa 1 2 3 4
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
22 23 24 25 26 27 28 29
El hecho de que las líneas nuevas sean consideradas como separadores por el
mecanismo de separación de palabras provoca un interesante, aunque sutil, efecto en la
sustitución de comandos. Considera lo siguiente:
[me@linuxbox ~]$ echo $(cal) February 2008 Su Mo Tu We Th Fr
Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
23 24 25 26 27 28 29 [me@linuxbox ~]$ echo "$(cal)" February
2008
Su Mo Tu We Th Fr Sa 1
2 3 4 5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29
Comillas simples
Si necesitamos suprimir todas las expansiones, usamos comillas simples. A continuación
vemos una comparación entre sin comillas, comillas dobles y comillas simples:
[me@linuxbox ~]$ echo text ~/*.txt {a,b} $(echo foo) $
((2+2)) $USER text /home/me/ls-output.txt a b foo 4 me
[me@linuxbox ~]$ echo "text ~/*.txt {a,b} $(echo foo) $
((2+2)) $USER" text ~/*.txt {a,b} foo 4 me [me@linuxbox
~]$ echo 'text ~/*.txt {a,b} $(echo foo) $ ((2+2)) $USER'
text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER
Caracteres de
escape
Algunas veces sólo queremos entrecomillar un único carácter. Para hacerlo, podemos
preceder un carácter con una barra invertida, que en este contexto se llama carácter de
escape. A menudo se hace dentro de las comillas dobles para prevenir selectivamente una
expansión:
[me@linuxbox ~]$ echo "The balance for user $USER is: \
$5.00" The balance for user me is: $5.00
También es común usar caracteres de escape para eliminar el significado especial de un
carácter en un nombre de archivo. Por ejemplo, es posible usar caracteres en nombres de
archivo que normalmente tienen un significado especial para el shell. Ésto incluye “$”, “!”,
“&”, “ “, y otros. Para incluir un carácter especial en un nombre de archivo puedes hacer
ésto:
[me@linuxbox ~]$ mv bad\&filename good_filename
Para permitir que la barra invertida aparezca, la “escapamos” escribiendo “\\”. Fíjate que
dentro de las comillas simples, la barra invertida pierde su significado especial y se trata
como un carácter ordinario.
La tabla anterior lista algunos de las secuencias de caracteres de escape más comunes. La
idea detrás de esta representación usando la barra invertida se originó en la programación
en lenguaje C y ha sido adoptada por otros muchos, incluido el shell.
Resumiendo
A medida que avancemos en el uso del shell, encontraremos que las expansiones y
entrecomillados se usarán con mayor frecuencia, así que cobra sentido tener un buen
entendimiento de la forma en que funcionan. De hecho, se podría decir que son el aspecto
más importante a aprender sobre el shell. Sin un entendimiento adecuado de la expansión,
el shell siempre será una fuente de misterio y confusión, y perderemos mucho de su
potencial.
Edición de la línea de
comandos
bash usa una librería (una colección compartida de rutinas que pueden utilizar diferentes
programas) llamada Readline para implementar la edición de la línea de comandos. Ya
hemos visto algo de ésto. Sabemos, por ejemplo, que las teclas de las flechas mueven el
cursor, pero hay muchas más características. Piensa en ello como herramientas adicionales
que podemos emplear en nuestro trabajo. No es importante aprenderlo todo sobre ellas, pero
muchas son muy útiles. Cójelas y elígelas como quieras.
Modificando el texto
La tabla 8 – 2 lista los comandos de teclado que se usan para editar caracteres en la
línea de comandos.
Tabla 8 -2: Comandos de edición de
texto
Comando Acción Ctrl -k Kill (corta) el texto desde la localización del cursor al final
de la línea. Ctrl -u Kill (corta) el texto desde la localización del cursor hasta el
principio de
la línea. Alt -d Kill (corta) el texto desde la localización del curso hasta el final de
la
palabra actual. Alt -Retroceso Kill (corta) el texto desde la localización del cursor
hasta el principio de
la palabra actual. Si el cursor está al principio de una palabra, corta la palabra
anterior. Ctrl -y Yank (pega) texto del kill-ring y lo coloca en la localización del
cursor
La Meta tecla
Si te aventuras en la documentación Readline, que puedes encontrar en la sección
READLINE de la man page de bash, encontrarás el término “meta key”. En los teclados
modernos te dirige a la tecla Alt pero no siempre es así.
Volviendo a los tiempos oscuros (antes de los Pcs pero después de Unix) no todo el mundo
tenía su propio ordenador. Lo que podían tener era un dispositivo llamado terminal. Un
ra un dispositivo de comunicación que con contaba con una pantalla para mostrar
terminal e
texto y únicamente la electrónica suficiente dentro para mostrar los caracteres y mover el
cursor. Estaba conectado (normalmente con un cable serie) a una computadora mayor o a la
red de comunicación de una computadora mayor. Había muchas marcas diferentes de
terminales y todas tenían configuraciones de pantalla y teclado diferentes. Como todas
tendían al menos a entender ASCII, los desarrolladores de software querían escribir
aplicaciones portables reducidas al mínimo común denominador. Los sistemas Unix tienen
una forma muy elaborada de tratar con los terminales y sus pantallas. Como los
desarrolladores de Readline no podían estar seguros de la presencia de una tecla de control
extra, se inventaron una y la llamaron “meta”. Igual que la tecla Alt sirve como tecla meta en
los teclados modernos, puedes también pulsar y soltar la tecla Esc para tener el mismo
efecto que pulsando la tecla Alt si todavía estás usando un terminal (¡Lo que aún puedes
hacer en Linux!).
Completado
Otra forma en que el shell puede ayudarte es mediante un mecanismo llamado
completado. El completado ocurre cuando presionas la tecla tabulador mientras
escribes un comando. Veamos como funciona. Dado un directorio home que aparece
así:
[me@linuxbox ~]$ ls Desktop ls-output.txt
Pictures Templates Videos Documents Music Public
¿Ves como el shell completa la línea por tí? Probemos otra vez. De nuevo, no pulses
Enter:
Pulsa tab:
[me@linuxbox ~]$ ls D
No completa, sólo da un pitido. Esto ocurre porque “D” coincide con más de una
entrada en el directorio. Para que el completado funcione, el “indicio” que le des no
debe ser ambiguo. Si seguimos:
[me@linuxbox ~]$ ls Do
Y pulsamos tab:
[me@linuxbox ~]$ ls Documents
El completado funciona.
Aunque este ejemplo muestra el completado de nombres de archivo, que es su uso más
común, el completado también funciona con variables (si el principio de la palabra es un
“$”), nombres de usuario (si la palabra empieza con “~”), comandos (si la palabra es la
primera en la línea.) y nombres de equipo (si la palabra empieza con “@”). El completado
de nombres de equipo sólo funciona para los nombres de equipo listados en
/etc/hosts.
Hay un número de secuencias de meta teclas y teclas de control que están asociadas al
completado:
Hay algunos más que me parecen bastante extraños. Puedes ver una lista en la man page
de bash bajo “READLINE”.
Completado programable
Versiones recientes de bash tienen una característica llamada completado programable. El
completado programable te permite (o mejor dicho, el proveedor de tu distribución te permite)
añadir reglas de completado adicionales. Normalmente ésto se hace para añadir soporte
para aplicaciones específicas. Por ejemplo es posible añadir completados para la lista de
opciones de un comando o para buscar tipos de archivo en concreto que soporte una
aplicación. Ubuntu tiene una gran colección definida por defecto. El completado programable
se implementa mediante funciones de shell, un tipo de mini scripts de shell que veremos en
próximos capítulos. Si eres curioso, prueba:
set | less
y mira si puedes encontrarlos. No todas las distribuciones las incluyen por
defecto.
Usando el historial
Como descubrimos en el Capítulo 1, bash mantiene un historial de los comandos que
hemos introducido. Esta lista de comandos se guarda en nuestro directorio home en un
archivo llamado .bash_history. El historial es un recurso útil para reducir la cantidad de
pulsaciones que tenemos que hacer, especialmente cuando lo combinamos con la edición
en la línea de comandos.
Buscando en el
Historial
En cualquier momento, podemos ver el contenido del historial
así:
[me@linuxbox ~]$ history | less
Por defecto, bash almacena los últimos 500 comandos que has utilizado. Veremos como
ajustar este valor en un capítulo posterior. Digamos que queremos encontrar los comandos
que hemos usado para listar /usr/bin. Una de las formas en que podríamos hacerlo sería
así:
[me@linuxbox ~]$ history | grep /usr/bin
Y digamos que entre los resultados tenemos una línea que contiene un comando
interesante como éste:
88 ls -l /usr/bin > ls-output.txt
bash expandirá “!88!” en el contenido de la octogésimo octava línea del historial. Hay
otras formas de expandir el historial que veremos un poco más tarde.
(reverse-i-search)`':
Nuestro prompt de shell vuelve y nuestra línea de comandos está cargada y ¡lista para la
acción! La siguiente tabla lista alguna de los atajos de teclas usados para manipular el
historial:
Tabla 8-5: Comandos del historial T ecla Acción Ctrl-p Se mueve a la anterior entrada
del historial. Misma acción que la flecha hacia arriba Ctrl-n Se mueve al la siguiente
entrada del historial. Misma acción que la flecha hacia abajo Alt-< Se mueve al
principio (arriba) del historial. Alt-> Se mueve al final (abajo) del historial, p.ej., la
actual línea de comandos. Ctrl-r Búsqueda incremental inversa. Busca
incrementalmente desde el actual comando
hacia arriba en el historial. Alt-p Búsqueda inversa, no incremental.
Con esta combinación de teclas, escribes las
palabras a buscar y presionas enter antes de que la búsqueda se realice.
Alt-n Búsqueda hacia delante, no incremental. Ctrl-o Ejecuta el elemento actual
en el historial y avanza al siguiente. Ésto es práctico si
estás intentando reejecutar una secuencia de comandos del
historial.
Quisiera aconsejarte no usar las formas “!texto” y “!?texto!” a no ser que estés
completamente seguro del contenido de los elementos del historial.
Hay muchos más elementos disponibles en el mecanismo de expansión del historial, pero
es un asunto demasiado arcaico y nuestras cabezas podrían explotar si continuamos. La
sección HISTORY EXPANSION de la man page de bash ahonda en todos los detalles
macabros. ¡Eres libre de explorarlo!
script
Además de la función del historial de comandos en bash, la mayoría de las distribuciones
Linux
incluyen un programa llamado script que se puede utilizar para grabar una sesión
de shell completa y almacenarla en un archivo. La sintaxis básica del comando es:
script [archivo]
Resumiendo
En este capítulo hemos tratado algunos de los trucos de teclado que el shell ofrece para
ayudar a los duros pulsadores de teclas reducir su carga de trabajo. Sospecho que según
pase el tiempo y te familiarices más con la línea de comandos, volverás a este capítulo para
recoger más de estos trucos. Por ahora, considéralos opcionales y potencialmente útiles.
http://en.wikipedia.org/wiki/Computer_terminal
Permisos
Los sistemas operativos tradicionales de Unix difieren de los tradicionales de MS-DOS en
que no sólo son sistemas multitarea, sino que tembién son sistemas multiusuario.
¿Qué significa ésto exactamente? Significa que más de una persona puede estar usando el
ordenador al mismo tiempo. Aunque que un ordenador típico tendrá sólo un teclado y un
monitor, podrá ser usado por más de un usuario. Por ejemplo, si un ordenador está
conectado a una red o a Internet, los usuarios remotos pueden acceder via ssh (secure
shell) y utilizar el ordenador. De hecho, los usuarios remotos pueden ejecutar aplicaciones
gráficas y hacer que la salida gráfica aparezca en una pantalla remota. El Sistema X
Windows soporta ésto como una parte de su diseño básico.
Para hacer ésto práctico, el sistema tenía que ser ideado para proteger a los usuarios unos
de otros. Después de todo, las acciones que de un usuario no podían permitirle estropear el
ordenador, ni un usuario podía interferir en los archivos que pertenecía a otro usuario.
En este capítulo vamos a ver esta parte esencial de la seguridad del sistema y
presentaremos los siguientes comandos:
• id – Muestra la identidad del usuario
• chmod – Cambia el modo de un archivo
• umask – Establece los permisos por defecto
• su – Ejecuta un shell como otro usuario
• sudo – Ejecuta un comando como otro usuario
• chown – Cambia el propietario de un archivo
• chgrp – Cambia la propiedad de grupo de un
archivo
• passwd – Cambia la contraseña de un usuario
La razón de este mensaje de error es que, como usuarios normales, no tenemos permiso
para leer este archivo.
Veamos la salida. Cuando se crea una cuenta de usuario, al usuario se le asigna un número
llamado ID de usuario o uid que es, por el bien de los humanos, asignado a un nombre de
usuario. Al usuario se le asigna un ID de grupo primario o gid y puede pertenecer a grupos
adicionales. El ejemplo anterior es de un sistema Fedora. En otros sistemas, como Ubuntu,
la salida puede ser un poco diferente:
[me@linuxbox ~]$ id uid=1000(me) gid=1000(me)
groups=4(adm),20(dialout),24(cdrom),25(floppy),29(audio),30
(dip),44(v ideo),46(plugdev),108(lpadmin),114(admin),1000(me)
Como podemos ver, los números uid y gid son diferentes. Ésto simplemente es porque
Fedora empieza numerando las cuentas de los usuarios normales desde el 500, mientras
que Ubuntu empieza en el 1000. También podemos ver que el usuario de Ubuntu pertenece
a muchos más grupos. Ésto tiene que ver con la forma en que Ubuntu maneja los privilegios
para los dispositivos y servicios del sistema.
Pero ¿de dónde viene esta información? Como tantas otras muchas cosas en Linux, de un
par de archivos de texto. Las cuentas de usuario está definidas en el archivo /etc/passwd
y los grupos
están definidos en el archivo /etc/group. Cuando las cuentas y los grupos de usuarios son
creados, estos archivos son modificados junto con archivo /etc/shadow que guarda la
información de las contraseñas de los usuarios. Para cada cuenta de usuario, el archivo
/etc/passwd define el nombre de usuario (login), uid, gid, el nombre real de la cuenta, el
directorio home y el shell de login. Si examinas el contenido de /etc/passwd y
/etc/group, verás que además de las cuentas de los usuarios normales, hay cuentas para
el superusuario (uid 0) y varios otros usuarios del sistema.
En el próximo capítulo, veremos procesos, y verás que algunos de esos otros usuarios
están, de hecho, muy ocupados.
Mientras que muchos sistemas como-Unix asignan los usuarios normales a un grupo
común como “users”, la práctica en los Linux modernos es crear un único grupo, con un
único usuario y el mismo nombre que el usuario. Ésto hace más fácil asignar ciertos tipos
de permisos.
Los primeros diez caracteres de la lista son los atributos del archivo. El primero de éstos
caracteres es el tipo de archivo. Aquí tenemos los tipos de archivo que se ven más a
menudo (hay otros, menos comunes):
Tabla 9-1: Tipos de archivo Atributo Tipo de archivo - Archivo normal d Directorio l
Enlace simbólico. Fíjate que con los enlaces simbólicos, el resto de los atributos del
archivo son siempre “rwxrwxrwx” y que son valores de relleno. Los atributos reales son
los del archivo al que el enlace simbólico apunta. c Archivo de carácter especial. Este
tipo de archivo se refiere a un dispositivo que
soporta datos como una cadena de bytes, como un terminal o un modem. b Archivo de
bloque especial. Este tipo de archivo se refiere a un dispositivo que soporta
datos en bloques, como un disco duro o una unidad de
CD.
Los nueve caracteres restantes de los atributos del archivo, se llaman modo de archivo, y
representan los permisos de lectura, escritura y ejecución del propietario de archivo, del
grupo del propietario del archivo y del resto de usuarios:
Cuando establecemos los atributos de modo r, w y x tienen el siguiente efecto sobre los
archivos y directorios:
Tabla 9-2: Atributos de permisos Atributo Archivos Directorios r Permite que un
archivo sea abierto y
leido.
Permite que el contenido del directorio sea listado si el atributo de ejecución también
está configurado. w Permite que un archivo sea escrito o
truncado, sin embargo este atributo no permite renombrar o borrar los archivos. La
capacidad de borrar o renombrar archivos viene determinada por los atributos del
directorio.
Permite crear, borrar y renombrar archivos dentro de un directorio si el atributo de
ejecución también está establecido.
x Permite que un archivo sea tratado como
un programa y ejecutarlo. Los archivos de programas escritos en lenguajes de script
deben ser también configurados como legibles para ser ejecutados.
Permite entrar en el directorio, p.ej., cd directorio
Aquí tenemos algunos ejemplos de configuraciones de atributos de archivo:
Tabla 9-3: Ejemplos de atributos de permisos A tributos de archivo
Significado
-rwx------ Un archivo normal que se puede leer, escribir y ejecutar por el
propietario del
archivo. Nadie más tiene acceso. -rw------- Un archivo normal que se puede leer y
escribir por el propietario del archivo.
Nadie más tiene acceso. -rw-r—r-- Un archivo normal que se puede leer y escribir
por el propietario del archivo.
Los miembros del grupo del propietario del archivo puede leerlo. El archivo lo puede
leer todo el mundo. -rwxr-xr-x Un archivo normal que lo puede leer, escribir y
ejecutar el propietario del
archivo. El archivo puede ser leído y ejecutado por todos los demás. -rw-rw---- Un
archivo normal que lo puede leer y escribir el propietario del archivo y los
miembros de su grupo nada más. lrwxrwxrwx Un enlace simbólico. Todos los
enlaces simbólicos tienen permisos de relleno.
Los permisos reales se guardan en el archivo real al que apunta el enlace simbólico.
drwxrwx--- Un directorio. El propietario y los miembros de su grupo pueden entrar
en el
directorio y crear, renombrar y borrar archivos dentro del directorio. drwxr-x--- Un
directorio. El propietario puede entrar en el directorio y crear, renombrar y
borrar archivos dentro del directorio. Los miembros del grupo del propietario pueden
entrar en el directorio pero no pueden crear, borrar o renombrar archivos.
chmod – Cambiando el modo de archivo
Para cambiar el modo (los permisos) de un archivo o un directorio, se utiliza el
comando chmod.
Ten en cuenta que sólo el propietario del archivo o el superusuario pueden cambiar el
modo de un archivo o un directorio. chmod soporta dos formas distintas de especificar
los cambios de modo: representación en números octales o representación simbólica.
Veremos la representación en números octales primero.
Con la notación octal usamos números octales para especificar el patrón de los permisos
que queremos. Como cada dígito en un número octal representa tres dígitos binarios, esto
coincide muy bien con la forma de almacenar el modo de archivo. Esta tabla muestra lo que
queremos decir:
Usando tres dígitos octales, podemos establecer el modo de archivo para el propietario, el
grupo del propietario y el mundo:
[me@linuxbox ~]$ > foo.txt [me@linuxbox ~]$ ls
-l foo.txt -rw-rw-r-- 1 me me 0 2008-03-06
14:52 foo.txt [me@linuxbox ~]$ chmod 600
foo.txt [me@linuxbox ~]$ ls -l foo.txt
-rw------- 1 me me 0 2008-03-06 14:52 foo.txt
Pasándole el argumento “600”, podemos establecer los permisos del propietario para leer y
escribir mientras borramos todos los permisos para el grupo del propietario y el mundo.
Aunque recordar la correspondencia entre octal y binario puede parecer un inconveniente,
normalmente sólo tendrás que usar algunos muy comunes: 7(rwx), 6(rw-), 5(r-x),
4(r--), y 0(---).
chmod también soporta notación simbólica para especificar los modos de archivo. La
notación simbólica se divide en tres partes: a quien afecta el cambio, que operación se
realizarán, y que permisos se establecerán. Para especificar quien se ve afectado se usa
una combinación de los caracteres “u”, “g”, “o” y “a” de la siguiente manera:
Los permisos se especifican con los caracteres “r”, “w” y “x”. Aquí tenemos algunos ejemplos
de la notación simbólica:
Tabla 9-6 Ejemplos de notación simbólica de chmod N otación Significado u+x Añade
permisos de ejecución para el propietario u-x Elimina permisos de ejecución del
propietario +x Añade permisos de ejecución para el propietario, el grupo y el mundo.
Algunos prefieren usar la notación octal, otros prefieren la simbólica. La notación simbólica
ofrece la ventaja de permitirte establecer un atributo individual sin molestar a los otros.
Échale un vistazo a la man page de chmod para más detalles y una lista de opciones. Un
aviso de precaución acerca de la opción “--recursive”: actúa tanto en archivos como en
directorios, así que no es tan útil como uno esperaría, raras veces queremos que archivos
y directorios tengan los mismos permisos.
¿Qué diablos es un
octal?
Octal (base 8), y su primo, hexadecimal ( base 16) son sistemas numéricos que se utilizan a
menudo para expresar números en ordenadores. Nosotros los humanos, debido al hecho de
que (al menos la mayoría de nosotros) hemos nacido con diez dedos, contamos usando un
sistema numérico en base 10. Los ordenadores, por otra parte, han nacido sólo con un dedo
y por tanto todo lo cuentan en sistema binario (base 2). Su sistema numérico sólo tiene dos
numerales, 0 y 1. Así que contar en binario tiene esta pinta: 0, 1, 10, 11, 100, 101, 110, 111,
1000, 1001, 1010, 1011... En octal, se cuenta con los números de cero al siete, así: 0, 1, 2, 3,
4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21... Contar en hexadecimal usa los números de
cero a nueve más las letras "A" a "F": 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10, 11, 12,
13... Mientras que podemos ver el sentido del binario (ya que los ordenadores sólo tienen un
dedo), ¿para que sirven los octales y los hexadecimales? La respuesta tiene que ver con la
conveniencia humana. Muchas veces, pequeños trozos de datos se representan en los
ordenadores como patrones de bits. Tomemos como ejemplo un color RGB. En la mayoría
de las pantallas de ordenador, cada pixel se compone de tres componentes de color: ocho
bits para el rojo, ocho bits para el verde y ocho bits para el azul. Un bonito azul claro podría
ser un número de 24 dígitos: 010000110110111111001101 ¿Te gustaría leer y escribir este
tipo de números todos los días? Creo que no. Aquí es donde otro sistema numérico nos
puede ayudar. Cada dígito en hexadecimal representa cuatro dígitos en binario. En octal,
cada dígito representa tres dígitos binarios. Así que nuestro azul claro de 24 dígitos podría
reducirse a un número hexadecimal de seis dígitos: 436FCD Cómo los dígitos en el número
hexadecimal "se alinean" con los dígitos del número binario, podemos ver que el
componente rojo de nuestro color es 43, el verde 6F, y el azul CD.
Hoy en día, la notación hexadecimal (a menudo llamada "hex") es más común que la octal,
pero como veremos pronto, la capacidad de los octales para expresar tres bits de binario
será muy útil...
Primero hemos eliminado cualquier copia antigua de foo.txt para asegurarnos de que
empezamos de cero. A continuación, hemos ejecutado el comando umask sin argumentos
para ver el valor actual. Ha respondido con el valor 0002 (el valor 0022 es otro valor por
defecto muy común), que es la representación octal de nuestra máscara. Luego hemos
creado una nueva instancia de foo.txt y hemos observado sus permisos.
Podemos ver que tanto el propietario como el grupo tienen permisos de lectura y escritura,
mientras que los demás sólo tienen permisos de lectura. La razón por la que el mundo no
tiene permisos de escritura es por el valor de la máscara. Repitamos nuestro ejemplo, esta
vez estableciendo la máscara nosotros mismos:
[me@linuxbox ~]$ rm foo.txt [me@linuxbox ~]$
umask 0000 [me@linuxbox ~]$ > foo.txt
[me@linuxbox ~]$ ls -l foo.txt -rw-rw-rw- 1 me
me 0 2008-03-06 14:58 foo.txt
Olvida por el momento los ceros a la izquierda (volveremos a ellos en un minuto) y observa
que donde aparece el 1 en nuestra máscara, el atributo se elimina – en este caso, los
permisos de escritura del mundo. Ésto es lo que hace la máscara. Donde aparezca un 1 en
el valor binario de la máscara, un atributo es desactivado. Si miramos el valor de máscara
0022, podemos ver lo que hace:
original
Modo de
archivo
La mayoría de las veces no tendrás que cambiar la máscara; la que tu distribución trae por
defecto irá bien. En algunas situaciones de alta seguridad, sin embargo, querrás
controlarla.
Algunos permisos
especiales
Aunque a veces vemos la máscara octal de permisos expresada como un número de tres
dígitos, es más correcto técnicamente expresarla en cuatro dígitos ¿por qué? Porque,
además de permisos de lectura, escritura y ejecución, hay algunas otras configuraciones de
permisos menos usadas.
El segundo permiso menos usado es el setgid bit ( octal 2000) el cual, como el setuid bit,
cambia el ID efectivo de grupo d e el ID real de grupo a
l del propietario del archivo. Si el
setgid bit se aplica en un directorio, los nuevos archivos que se creen en el directorio
tendrán como grupo del propietario el del directorio en lugar del de creador del archivo.
Esto es útil en un directorio compartido cuando los miembros de un grupo común necesitan
acceso a todos los archivos del directorio, independientemente del grupo del propietario
primario del archivo.
El tercero se llama el sticky bit (octal 1000). Esto es una reliquia del antiguo Unix, donde era
posible marcar un archivo ejecutable como “no intercambiable”. En archivos, Linux ignora el
sticky bit, pero si se aplica a un directorio, previene que los usuarios borren o renombren
archivos a menos que el usuario sea el propietario del directorio, el propietario del archivo o
el superusuario. Esto, a menudo, se usa para controlar el acceso a un directorio compartido,
como /tmp.
Aquí hay algunos ejemplos de uso de chmod con notación simbólica para establecer estos
permisos especiales. Primero asignaremos setuid a un programa:
chmod u+s program
Cuando vemos la salida de ls, podemos determinar los permisos especiales. Aquí tenemos
algunos ejemplos, primero un programa que tiene setuid:
-rwsr-xr-x
Cambiar identidades
Muchas veces, encontraremos necesario tomar la identidad de otro usuario. A menudo
querremos ganar permisos de superusuario para manejar tareas administrativas, pero
también es posible “convertirse” en otro usuario normal para cosas como probar una
cuenta. Hay tres formas para tomar una identidad alternativa:
su [-[l]] [user]
Si se incluye la opción “-l”, la sesión shell resultante es un shell de login para el usuario
especificado. Ésto significa que el entorno del usuario se carga y el directorio de trabajo se
cambia al directorio home del usuario. Ésto es lo que queremos normalmente. Si no
especificamos el usuario, se asume el superusuario. Fíjate que (extrañamente) puede ser
abreviada como “-”, que es como se usa más a menudo. Para arrancar una shell para el
superusuario, haríamos esto:
[me@linuxbox ~]$ su -Password:[root@linuxbox ~]#
Usando esta forma, un única línea de comandos es pasada al nuevo shell para su
ejecución. Es importante incluir el comando entre comillas simples, ya que no
queremos que se realice una expansión en nuestro shell, ni tampoco en el nuevo shell:
[me@linuxbox ~]$ su -c 'ls -l /root/*'Password:-rw------- 1
root root 754 2007-08-11 03:19 /root/anaconda-
ks.cfg/root/Mail:total 0[me@linuxbox ~]$
Después de introducir el comando, somo preguntados por nuestra contraseña (no la del
superusuario) y una vez que la autenticación está completada, el comando especificado se
lleva a cabo. Una diferencia importante entre su y sudo es que sudo no abre una nueva
shell, ni carga el entorno de otro usuario. Esto significa que los comandos no necesitan ser
entrecomillados de forma diferente a la que lo estarían si lo ejecutáramos sin usar sudo.
Ten en cuenta que este comportamiento puede ser anulado especificando varias opciones.
Mira la man page de sudo para más detalles.
Para ver qué privilegios están aceptados por sudo, usa la opción “-l” para
listarlos:
udo -lUser me may run the following
[me@linuxbox ~]$ s
commands on this host:(ALL) ALL
Ubuntu y sudo
Uno de los problemas recurrentes para los usuarios normales es ejecutar ciertas tareas que
requieren privilegios de superusuario. Estas tareas incluyen instalar y actualizar software,
editar archivos de configuración del sistema, y acceder a dispositivos. En el mundo
Windows, se hace a menudo dando a los usuarios privilegios de administrador. Ésto permite
a los usuarios ejecutar estas tareas. Sin embargo, también permite que los programas
ejecutados por el usuario tengan las mismas capacidades. Esto no es deseable en la
mayoría de los casos, ya que permite al malware (sortware malicioso) como virus tener
dominio absoluto del ordenador. En el mundo Unix, siempre ha habido una gran división
entre los usuarios normales y los administradores, debido a la herencia multiusuario de Unix.
El enfoque tomado en Unix es proporcionar privilegios de superusuario sólo cuando se
necesite. Para hacer ésto, se usan comúnmente los comando su y sudo.
Hasta hace pocos años, la mayoría de las distribuciones Linux confiaban en su para éste
propósito. su no requiere la configuración que requiere sudo, y tener una cuenta root es
tradicional en Unix. Esto creaba un problema. Los usuarios tendían a operar como root
cuando no era necesario. De hecho, algunos usuarios operaban sus sistemas como root
exclusivamente, ya que eliminaban todos esos molestos mensajes de “permiso denegado”.
Así es como se reduce la seguridad de un sistema Linux a la de un sistema Windows. No es
una buena idea.
Cuando apareció Ubuntu, sus creadores tomaron un rumbo diferente. Por defecto, Ubuntu
desactiva el acceso a la cuenta root (impidiendo establecer una contraseña para la cuenta),
y en lugar utiliza sudo para proporcionar privilegios de superusuario. La cuenta de usuario
inicial tiene acceso a privilegios completos de superusuario vía sudo y pueden proporcionar
poderes similares a posteriores cuentas de usuario.
cambia el grupo del propietario del archivo al grupo users. :admins Cambia el grupo
del propietario al grupo admins. El propietario del archivo no cambia bob: Cambia el
Como podemos ver, el directorio tiene como propietarios al root y tiene permisos 755.
Para hacer este directorio compartible, bill necesita cambiar el grupo del propietario y
sus permisos para permitir la escritura:
[bill@linuxbox ~]$ sudo chown :music
/usr/local/share/Music[bill@linuxbox ~]$ sudo chmod 775
/usr/local/share/Music[bill@linuxbox ~]$ ls -ld
/usr/local/share/Musicdrwxrwxr-x 2 root music 4096 2008-03-
21 18:05 /usr/local/share/Music
¿Pero qué significa todo ésto? Significa que ahora tenemos un directorio,
/usr/local/share/Music cuyo propietario es root y permite acceso de lectura y
escritura al grupo music. El grupo music tiene como miembros al bill y karen, tanto
bill como karen pueden crear archivos en el directorio /usr/local/share/Music.
Otros usuarios pueden listar el contenido del directorio pero no pueden crear archivos
dentro.
Pero aún tenemos un problema. Con los permisos actuales, los archivos y directorios
creados en el directorio Music tendrán los permisos normales de los usuarios bill y
karen:
[bill@linuxbox ~]$ >
/usr/local/share/Music/test_file[bill@linuxbox ~]$ ls -l
/usr/local/share/Music-rw-r--r-- 1 bill bill 0 2008-03-24
20:03 test_file
Realmente tenemos dos problemas. Primero, la umask en este sistema es 0022 la cual
previene que
los miembros del grupo no puedan escribir archivos pertenecientes a otros miembros del
grupo. Ésto no sería un problema si el directorio compartido sólo contuviera archivos, pero
como este directorio contendrá música, y la música suele organizarse en una jerarquía de
artistas y álbumes, los miembros del grupo necesitarán la capacidad de crear archivos y
directorios dentro de los directorios creados por otros miembros. Necesitamos modificar la
umask utilizada por bill y karen a 0002.
Segundo, cada archivo y directorio creado por un miembro será adjudicado al grupo
primario del usuario en lugar de al grupo música. Ésto se puede arreglar estableciendo el
setgid bit en el directorio:
[bill@linuxbox ~]$ sudo chmod g+s
/usr/local/share/Music[bill@linuxbox ~]$ ls -ld
/usr/local/share/Musicdrwxrwsr-x 2 root music 4096 2008-03-
24 20:03 /usr/local/share/Music
Ahora probaremos a ver si los nuevos permisos arreglan el problema. bill establece su
umask a 0002, elimina el anterior archivo de prueba, y crea un nuevo archivo y directorio
de pruebas:
[bill@linuxbox ~]$ umask 0002[bill@linuxbox ~]$ rm
/usr/local/share/Music/test_file[bill@linuxbox ~]$ >
/usr/local/share/Music/test_file[bill@linuxbox ~]$ mkdir
/usr/local/share/Music/test_dir[bill@linuxbox ~]$ ls -l
/usr/local/share/Musicdrwxrwsr-x 2 bill music 4096 2008-03-
24 20:24 test_dir-rw-rw-r-- 1 bill music 0 2008-03-24 20:22
test_file[bill@linuxbox ~]$
Tanto archivos como directorios se crean ahora con los permisos correctos para permitir a
todos los miembros del grupo music crear archivos y directorios dentro del directorio
Music.
El único problema que queda es umask. La configuración necesaria sólo dura hasta el
final de la sesión y debe ser reconfigurada. En el Capítulo 11, veremos como hacer el
cambio de umask permanente.
Cambiando tu
contraseña
El último asunto que veremos en este capítulo es establecer contraseñas para tí mismo (y
para otros usuarios si tienes acceso a privilegios de superusuario). Para establecer o
cambiar una contraseña, se usa el comando passwd. La sintaxis del comando es así:
passwd [usuario]
El comando passwd tratará de obligarte a usar contraseñas “fuertes”. Ésto significa que
rechazará contraseñas que son muy cortas, muy parecidas a contraseñas anteriores,
palabras del diccionario, o muy fácilmente adivinables:
[me@linuxbox ~]$ passwd(current) UNIX password:New UNIX
password:BAD PASSWORD: is too similar to the old oneNew
UNIX password:BAD PASSWORD: it is WAY too shortNew UNIX
password:BAD PASSWORD: it is based on a dictionary word
Si tienes privilegios de superusuario, puedes especificar un nombre de usuario como
argumento en el comando passwd para establecer la contraseña de otro usuario. Hay otras
opciones disponibles para el superusuario como, el bloqueo de cuentas, caducidad de la
contraseña, etc. Mira la man page de passwd para más detalles.
Resumiendo
En este capítulo hemos visto como los sistemas como-Unix, por ejemplo Linux manejan los
permisos de usuario para permitirles acceso para leer, escribir y ejecutar archivos y
directorios. La idea básica de este sistema de permisos viene de los primeros días de Unix y
se han mantenido muy bien con el paso del tiempo. Pero el mecanismo nativo de permisos
en los sistemas Unix-like carecen de la granularidad precisa de sistemas más modernos.
Hay numerosos programas de línea de comandos para crear y mantener usuarios y grupos.
Para más información, mira las man pages de los siguientes comandos:
• adduser
• useradd
• groupadd
Procesos
Los sistemas operativos modernos son normalmente multitarea, lo que significa que crean la
ilusión de que hacen más de una cosa al mismo tiempo mediante un rápido cambio de un
programa en ejecución a otro. El kernel Linux gestiona ésto a través de el uso de procesos.
Los procesos son la forma en que Linux organiza los diferentes programas que esperan su
turno en la CPU.
Algunas veces un ordenador se vuelve lento o una aplicación deja de responder. En este
capítulo, veremos algunas de las herramientas disponibles en la línea de comandos que
nos permitirá examinar qué están haciendo los programas, y como terminar procesos que
están teniendo un mal comportamiento.
Éste capítulo presentará los siguientes
comandos:
El kernel mantiene información sobre cada proceso para ayudar a tener las cosas
organizadas. Por ejemplo, cada proceso tiene asignado un número llamado process ID o
PID. Los PIDs son asignados en orden creciente, con init siempre ocupando el PID1. El
kernel también guarda la ruta a la memoria asignada a cada proceso, así como la
disponibilidad de los procesos para reanudar la ejecución. Como los archivos, los procesos
también tiene propietarios y IDs de usuario, IDs efectivas de usuarios, etc.
Viendo los
procesos
El comando más comúnmente usado para ver procesos (hay varios) es ps. El programa ps
tiene un montón de opciones, pero en su forma más simple se usa así:
Si añadimos una opción, podemos tener una imagen más amplia de que está haciendo el
sistema:
[me@linuxbox ~]$ ps x PID TTY STAT TIME COMMAND 2799 ? Ssl 0:00
/usr/libexec/bonobo-activation-server –ac 2820 ? Sl 0:01
/usr/libexec/evolution-data-server-1.10 -- 15647 ? Ss 0:00
/bin/sh /usr/bin/startkde 15751 ? Ss 0:00 /usr/bin/ssh-agent
/usr/bin/dbus-launch -- 15754 ? S 0:00 /usr/bin/dbus-launch
--exit-with-session 15755 ? Ss 0:01 /bin/dbus-daemon --fork
--print-pid 4 –pr 15774 ? Ss 0:02 /usr/bin/gpg-agent -s –daemon
15793 ? S 0:00 start_kdeinit --new-startup +kcminit_start 15794
? Ss 0:00 kdeinit Running... 15797 ? S 0:00 dcopserver –nosid
and many more...
Añadiendo la opción “x” (fíjate que no lleva un guión delante) le decimos a ps que muestre
todos nuestros procesos independientemente de qué terminal (si hay alguno) los controla. La
presencia de un “?” en la columna TTY indica que ningún terminal controla. Usando esta
opción, vemos una lista de cada proceso que tenemos.
Como el sistema está ejecutando muchos procesos, ps produce una lista larga. A menudo
ayuda pasar la salida por un pipe ps a less para verlo más fácilmente. Algunas
combinaciones de opciones también producen salidas con listas largas, así que maximizar
la ventana del emulador de terminal puede ser una buena idea también.
Una nueva columna llamada STAT se ha añadido a la salida. STAT es una abreviatura de
“state” y revela el estado actual del proceso:
El estado del proceso puede ir seguido de otros caracteres. Ésto indica varias características
exóticas de los procesos. Mira la man page de ps para más detalles.
Otro popular grupo de opciones es “aux” (sin guión delante). Nos da incluso más
información:
[me@linuxbox ~]$ ps aux USER PID %CPU %MEM VSZ RSS TTY
STAT START TIME COMMAND root 1 0.0 0.0 2136 644 ? Ss
Mar05 0:31 init root 2 0.0 0.0 0 0 ? S< Mar05 0:00 [kt]
root 3 0.0 0.0 0 0 ? S< Mar05 0:00 [mi] root 4 0.0 0.0 0
0 ? S< Mar05 0:00 [ks] root 5 0.0 0.0 0 0 ? S< Mar05
0:06 [wa] root 6 0.0 0.0 0 0 ? S< Mar05 0:36 [ev] root 7
0.0 0.0 0 0 ? S< Mar05 0:00 [kh] and many more...