Vista previa del material en texto
Introducción al uso y administración del sistema operativo Linux. Redireccionamiento y filtros
Introducción.
Una base muy importante sobre la que se edificó, desde un principio, el sistema operativo Unix fue dotarlo de un elevado número de herramientas que fueran capaces, cada una, de resolver una tarea en concreto de forma muy simple, pero a la vez muy segura. Esto planteó la necesidad de confeccionar muchos programas, uno para cada trabajo. Incluso hay tareas que, para resolverlas, podemos elegir entre dos o más de ellos. Este elevado nivel de modularidad quedó completado con la lógica compatibilidad entre las herramientas citadas.
El hecho de poder combinar unas órdenes con otras, enlazando los diferentes comandos entre sí, y éstos con archivos (y desde archivos), supone dotar a Unix de una elevada potencia de operatividad que, incluso, puede aprovecharse en otros sistemas operativos.
Veremos en la unidad dedicada a la administración y seguridad cómo conseguir esto último, pues, por el momento, estudiaremos en esta unidad cómo funcionan los redireccionamientos y los filtros. Expondremos bastantes ejemplos de aplicación y realizaremos las prácticas necesarias para comprender el funcionamiento y sus múltiples posibilidades de uso.
1. ¿Cómo funciona una orden?
Por definición una orden, o un comando en Unix, no es mas que un programa ejecutable. Todo programa se elabora con la finalidad de realizar una tarea de forma rápida y fiable para ahorrarnos trabajos repetitivos o monótonos y también para hacer trabajos precisos en donde no se puede admitir un elevado índice de posibles fallos.
Desde el punto de vista de los procesos, una orden, es un programa que el shell carga en la RAM del ordenador, partiendo de un archivo en disco, y al cual reserva una zona adicional de memoria para las variables, luego completa un trabajo y finalmente se extingue liberando dichos recursos de memoria.
En cuanto al redireccionamiento se refiere, una orden, es un programa que, normalmente, para trabajar necesita unos datos de entrada sobre los que realizará cálculos, ordenaciones, búsquedas y muchas cosas más. Una vez ha concluído el procesado de la información introducida, el programa suele responder con unos datos de salida que serán enviados a cualquier lugar que nosotros le indiquemos y que por defecto suele ser la pantalla. Estos tres puntos son de una gran importancia y conviene tenerlos siempre muy presentes. Se puede plasmar gráficamente la idea anterior mediante:
Proces
ado
Dato
s d
e
salid
a
Dato
s d
e
en
trad
a
Dicho esto, nos adentraremos progresivamente en cada una de los posibilidades que existen tanto para aplicar la información de entrada como para recoger la de salida.
1.1. Entrada de información
Una orden puede recibir la información de entrada desde:
1.El teclado. Si escribimos $ echo Hola Mundo, todos los datos que la orden echo necesita, en este caso, los tecleamos como argumentos a continuación de su nombre. En este ejemplo no se utiliza ningún carácter de redirección. Es la opción por defecto, pues, toda orden que espere datos de entrada, si no se le indica lo contrario, intentará leerlos del archivo /dev/console, o teclado, conocido como entrada estándar. Esta situación también se da si escribimos $ cat sin ningún argumento. (Control+d finaliza cat).
2.Un archivo. Si le decimos a la orden cat que nos imprima el contenido de un archivo, podemos utilizar el carácter especial de redireccionamiento simple a la entrada < . Un ejemplo sería $ cat < .bash_history.
3.La salida de otra orden. En este caso debe usarse el carácter | (tubería o pipe) para enlazar la salida de una orden con la entrada de otra. Si tecleamos $ ls /etc | more, el paginador more recibe, como entrada, la salida de ls y página a página nos permite visualizar listados extensos que, por su extensión, no caben en una sola pantalla.
4.Un documento inserto. Es el caso típico que utiliza el par de caracteres <<, que recibe el nombre de doble redireccionamiento a la entrada. Para decirle a la orden cat que imprima un texto, que no está en un archivo en disco, sino que debe leerlo directamente del texto que aparece escrito después de ésta (documento inserto), lo especificamos así:
$ cat <<DOCU
> Esto es un
> documento
> inserto
> DOCU
En este ejemplo el $ es el prompt de nivel 1 y el > es el prompt de nivel 2.
5. Nada. Existen casos en los que un comando no recibe ningún dato de entrada porque no lo necesita pues, implícitamente en éste, queda muy claro el trabajo que debe realizar, tarea que de otra parte siempre suele ser la misma. Es el caso de las órdenes $ clear , $ exit o $ halt.
1.2. Salida de la información
Una vez vistas las posibles entradas de datos, que necesita una orden, es el momento de analizar dónde van a parar la información de salida de la misma. Pues bien, hay múltiples formas de enviar dichos datos según nos interese. Estas formas posibles son:
1. La pantalla. Es la opción por defecto pues, si no se especifica ninguna, todas aquellas órdenes que suministran datos de salida, éstos, serán enviados a un archivo concreto (/dev/console), la pantalla, conocido también como salida estándar. Cuando tecleamos $ cal vemos que se imprime en pantalla el calendario del mes actual. Por ser la opción de salida por defecto, no se emplea ningún carácter de redirección. 2. Un archivo para sobreescribir. Cuando no interese presentar en pantalla los datos de salida, o bien cuando éstos no sean imprimibles por ser datos binarios, puede utilizarse el carácter > para la redirección simple de la salida a un archivo. Es importante percatarse de que el carácter > crea el archivo de destino, si éste no existe, pero caso de existir lo sobreescribe, es decir, comienza a escribir a partir del principio de éste. Veámoslo con unos ejemplos:
$ cal 4 2003 (Por defecto, a pantalla el calendario de abril). $ cal 4 2003 > calendario (Redirección simple a archivo. Se crea).
$ cat < calendario (Para ver el contenido del archivo). $ cal 5 2003 > calendario (Sobreescritura por el calendario de mayo).
$ cat < calendario (Para ver el nuevo contenido del archivo).
$ cat < /bin/gzip > migzip (Un modo de copiar un archivo binario).
3. Un archivo para añadir. Puede que interese redirigir la salida de una orden hacia un archivo que ya contiene alguna información que no queremos perder. Para que los nuevos datos sean añadidos, a continuación de los ya existentes, debe utilizarse el par de caracteres >> de doble redireccionamiento de salida hacia un archivo. En este caso, si el archivo de destino no existe, será creado y la escritura comenzará en el principio de éste. Comparemos, con los del párrafo anterior, los siguientes ejemplos:
$ cal 4 2003 (Por defecto, a pantalla el calendario de abril).
$ cal 4 2003 >> calendario (Redirección doble a archivo. Se crea). $ cat < calendario (Para ver el contenido del archivo).
$ cal 5 2003 >> calendario (Añade, a abril, el calendario de mayo).
$ cat < calendario (Para ver el nuevo contenido del archivo).
4.La entrada de otra orden. Si la salida de un comando, no la queremos enviar directamente a la pantalla, ni tampoco a un archivo, porque necesitamos elaborarla todavía más podemos recurrir entonces a la redirección de salida mediante el carácter | (tubería) hacia la entrada de una segunda orden. Ejemplos:
$ cal 2003 | more (Salida final a pantalla). $ cat < .bashrc | grep " alias " > misalias (Salida final a archivo).
$ cat < misalias (Para verlo en pantalla).
El carácter | puederepetirse dos o más veces de modo que tres, o más, órdenes queden enlazadas para dotar de mayor poder de procesado a una línea de comandos. No ocurre lo mismo con <, >, << y >> que pueden aparecer tan sólo una vez en cada línea.
5.El archivo /dev/null. Puede ocurrir que la información de salida de una orden no nos interese verla absolutamente para nada. En tal caso, puede depositarse en un archivo especial, que funciona como un sumidero, de manera que todo cuanto se escribe en él se pierde sin ocupar espacio en disco. A primera vista, esto, puede parecer absurdo pero puede que no lo sea tanto cuando buscamos una segunda finalidad al usar una orden. Por ejemplo, supongamos que necesitamos evaluar el tiempo que tarda en leerse un disquete de 1.4 MB. Simplemente colocamos el disquete en la unidad y escribimos lo siguiente:
$ time -p cat < /dev/fd0 > /dev/null (40/75 segundos para 1.4/1.7
MB).
La utilidad time -p informa del tiempo que tarda en completarse la lectura del archivo /dev/fd0 es decir el disquete entero (2880 sectores). Podemos, incluso, evaluar el tiempo real de lectura del disco, obteniendo información muy útil como saber la su velocidad real, buscar la partición más rápida, etc.
6. Nada. Finalmente, es posible, que en algunos casos, una orden, termine en "modo silencioso" sin devolver ninguna información cuando ha completado su trabajo, lo cual nos confirma que todo ha funcionado bien . Por ejemplo: $ mkdir midirectorio (en el caso de que midirectorio no exista) o $ touch archivo1 archivo2.
1.3. Salida de error estándar
El canal de entrada estándar (teclado) suele asociarse con el número 0, el canal de salida estándar (pantalla) con el número 1 y el canal de salida de error estándar (pamtalla) con el 2 (de ahí el símbolo 2>). Cada programa, u orden, utiliza la salida de error para enviar a pantalla la información que se considere oportuna. Para evitar que ambas salidas se mezclen en pantalla, se puede separar la salida de error estándar, mediante redirección, a un archivo, usando el par de caracteres 2>.
Si queremos acumular, en un sólo archivo, las salidas de error procedentes de la ejecución de varias órdenes, el shell bash, dispone de la opción 2>> que evita la sobreescritura del archivo. En cualesquiera de los casos anteriores, si esta información de error no nos interesa siempre se puede "tirar" a /dev/null usando 2> o 2>>. Teclear, secuencialmente, los ejemplos que se exponen:
$ cat < error (Aparece el mensaje: No existe el fichero o el directorio).
$ cat < eror 2> error (Nada en pantalla. Se crea el archivo error). $ cat < error (Ver el contenido del archivo de errores).
$ cat < eror 2>> error (Nada en pantalla. Se añade al archivo error).
$ cat < error (Ver el nuevo contenido del archivo de errores).
$ cat < eror 2> /dev/null (Este error no se guarda, se tira al sumidero).
2. Los metacaracteres del shell
Existe un conjunto, o grupo, de caracteres con un significado especial para el shell. Son los llamados metacaracteres. Algunos de ellos se han visto en los apartados 2, 2.1 y 2.2. Son los siguientes: < , << , > , >> , 2> , 2>> y |.
Existen muchos más. Los más importantes son los que veremos ahora.
1.? (interrogación). Puede ser substituído por un sólo carácter en cualquier posición del nombre de un archivo o directorio. Ejemplos: $ ls /dev/tt?? , $ ls /dev/hd??? . En el primer caso se listan sólo archivos del subdirectorio /dev con cuatro caracteres tal que los dos primeros son tt. En el segundo caso se listan archivos con cinco caracteres que comienzan siempre por hd.
2.* (asterisco). Puede ser reemplazado por cualquier cadena de caracteres que se corresponda con un nombre de archivo o directorio. Esta cadena puede contener uno dos o más caracteres . (punto). El patrón *.* no tiene nada que ver con su homólogo del DOS/Windows. Si tecleamos $ ls /etc/*.* veremos un listado de los archivos contenidos en /etc, y en sus subdirectorios, tales que en su nombre exista al menos un punto en cualquier posición del mismo. De modo análogo, $ ls /etc/*.*.* listará nombres que contengan al menos dos veces un punto.
3.[ ] (corchetes). Forman un patrón de búsqueda tal que el shell selecciona nombres de archivo que contengan sólo uno de los caracteres encerrados en él. Practicando los siguientes ejemplos quedará más claro el uso de corchetes.
$ ls /dev/fd[0123]
$ ls /dev/hd[abcd]
$ ls /dev/hd[abcd]? $ ls /bin/[vwxyz]* $ ls /bin/[aeiou]???
$ ls /bin/[aeiou]????
4.^ (circunflejo). Colocado dentro de un par de corchetes, niega la condición expresada por los caracteres que le siguen. Probar con $ ls /dev/hd[^ab]. A efectos de la salida
se puede escribir lo siguiente:
$ ls /dev/hd[abcdefgh] = $ ls /dev/[^abcd] + $ ls /dev/[^efgh]
5.( ) (paréntesis). Tienen un doble uso. Por un lado deben escribirse después del nombre de una función, dentro de un guión, indicando que dicha función puede recibir argumentos. Por otro lado, si encerramos con un par de paréntesis un grupo de órdenes, se creará un nuevo shell para ejecutarlas. Una forma muy fácil de comprobar que se ejecutan en el shell actual, o en un subshell, es probar las dos secuencias siguientes:
$ (clear ; echo Hola ; exit) (Este exit termina el subshell).
$ clear ; echo Hola ; exit (Este exit termina el shell y la sesión).
6.{ } (Llaves). Se utilizan para la definición de funciones del shell. Estas funciones generalmente aparecen en los guiones (scripts) y consisten en una o varias sentencias que se encierran entre llaves, de modo similar a las funciones del lenguaje C de programación. Deben ser leídas por el shell antes de su ejecución, por tanto, deben colocarse al comienzo del guión, o en un archivo como .bashrc que se ejecuta al inicio de una sesión. Ejemplo:
saludar () $ . .bashrc $ saludar
{
echo Hola Mundo
}
7.- & (ampersand). Se escribe al final de una orden, un programa, o conjunto de órdenes, que deban ejecutarse en segundo plano (modo background) para dejarnos el terminal libre y poder así realizar otra tarea. Ejemplo:
$ while true ; do echo -e -n "\007" ; sleep 1 ; done &
(Nota: Para traer el trabajo, a primer plano, teclear $ fg 1 y luego Ctrl+c para terminar).
8.- | | (doble tubería). Cuando se escribe entre dos comandos, el shell, ejecuta uno O el otro pero no los dos. Equivale, pues, a una función lógica O exclusiva entre dos comandos. Por ejemplo, la orden touch crea un archivo vacío y la orden echo imprime un mensaje, por tanto, si tecleamos las dos líneas siguientes:
$ touch /archivo || echo No se tiene permiso.
$ touch archivo || echo No se tiene permiso.
El primer caso imprime el mensaje No se tiene permiso, porque un usuario no puede crear un archivo en el directorio raíz. La ejecución de la segunda línea es silenciosa porque crea el archivo y no da error.
9.- && (doble ampersand). Funciona de modo parecido al anterior pero realiza una función Y (AND) en vez de realizar una XOR. Por ejemplo, al teclear estas dos líneas:
$ rm archivo && echo Archivo borrado.
$ rm archivo && echo Archivo borrado.
La primera línea imprime el mensaje Archivo borrado. pero la segunda no.
3. Algunos filtros muy sencillos: more, less, cat, head, tail y wc
La orden cat es un comando externo. Es un programa que se encuentra en /bin y permite hacer muchas cosas, pues, aunque no se comporte exactamente como un filtro, permite realizar muchas tareas directamente relacionadas con el filtrado de archivos. Puede decirse que es un filtro queno modifica el contenido de un archivo porque los datos de salida son los mismos que los de entrada, pero sí que podemos cambiar su destino y de ahí el interés de su empleo. Puede trabajar con archivos de texto y también con archivos binarios, motivo este último por el cual no dispone de capacidades de filtrado. Algunas de las cosas que puede hacer /bin/cat, son:
Crear un archivo de texto mediante la redirección simple, o doble, de su salida. La entrada por defecto será el teclado.
$ cat > miarchivo (Inicializa el programa cat).
Esto es una prueba de texto. (Se introduce texto en miarchivo).
Ctlr+d (Cierra el archivo. Termina el programa cat).
$ (Vuelta al prompt del shell).
Visualizar un archivo de texto existente. Para ver al archivo anterior, escribir:
$ cat miarchivo (Es equivalente a $ cat < miarchivo).
Copiar un archivo, sin visualizarlo, sea éste de texto o binario.
$ cat miarchivo > tuarchivo (o $ cat < miarchivo > tuarchivo).
Concatenar dos o más archivos dejando el resultado en un tercero. $ cat miarchivo tuarchivo > archivos
Copiar "en bruto" un disquete, o una partición de disco duro, en un archivo (y viceversa) siempre que haya suficiente espacio en el disco de destino.
$ cat /dev/fd0 > disquete.img (Genera una imagen del disquete).
$ cat disquete.img > /dev/fd0 (Vuelca la imagen al disquete).
3.1. Órdenes more y less
El programa /bin/more, es un comando externo que funciona como un filtro, a nivel de página, y en un sólo sentido. Su utilidad está enfocada a emplearlo como paginador de textos que ocupan más de una pantalla. Un detalle importante; more admite redirección a su entrada procedente de un archivo o bien de la salida estándar (pantalla). A su vez, la salida será enviada a la pantalla, por tanto no podrá mostrar archivos binarios. La paginación avanza línea a línea, cada vez que se pulsa INTRO, pero avanza pantalla a pantalla si pulsamos la barra de espacios. Cuando no deseamos ver más texto, la tecla q (quit), y también Ctrl+c, finalizan la ejecución de more.
Ejemplos para practicar:
$ ls -la /dev (La salida de ls no cabe en una sola pantalla).
$ ls -la /dev | more (Paginando la salida de ls. Usar INTRO, espacio y q).
$ ls -la /dev > listado ( Creación de un archivo mediante redirección).
$ more listado (Paginando un archivo. Usar INTRO, espacio y q).
$ cat listado | more (Paginando la salida de cat. Usar INTRO, espacio y q).
$ cal 5 2003 | more (La entrada de more es la salida de cal o salida estándar).
Por otra parte, el progrma /usr/bin/less, es un paginador de Unix más moderno y por tanto aporta mayor comodidad de uso. La diferencia más importante, respecto a more, es que puede recorrer el archivo en dos sentidos, hacia el final o bien hacia el principio, sólo con hacer uso de las teclas de ↓ (flecha abajo) y ↑ (flecha arriba), respectivamente. Las teclas INTRO, espacio y q, funcionan de la misma forma, pero no admite utilizar Ctrl+c, que, por otra parte, es el modo menos elegante de terminar un programa. Acepta un elevado número de comandos para búsqueda, visualización, etc. con una sintaxis similar a la que emplea el editor vi. Consultar las páginas del manual ($ man less) para obtener una información completa sobre todas las posibilidades de uso.
Es frecuente que, si somos usuarios de Debian, se nos presente en un momento determinado la necesidad de listar los paquetes que tenemos instalados en nuestro sistema para poder examinarlos. Podemos hacerlo sencillamente con la línea de comandos siguiente:
$ dpkg -l | less (Esto puede llevar un tiempo, según la velocidad del PC). $ dpkg -l > paquetes.250503 (Si lo guardamos en un archivo).
$ less paquetes.250503 (Lo podemos consultar, o imprimir, más cómodamente).
3.2. Las órdenes head y tail
Una y otra, son comandos externos al shell que residen en /usr/bin/head y /usr/bin/tail, respectivamente. Pueden trabajar con archivos de texto o binarios, aunque lo más frecuente es hacerlo sobre archivos de texto. Ambas admiten redirección a su entrada procedente de un archivo o de la pantalla. La salida puede enviarse a pantalla o bien guardarse en otro archivo. Veamos con mayor detalle qué es lo que hace cada una.
El programa head (cabeza) recorta un número determinado de líneas contadas a partir del principio de un archivo de texto. Si no se especifica su número, por defecto, se muestran sólo 10. Con el modificador -c (character) y un número N muestra los N primeros caracteres del archivo.
De modo paralelo, el programa tail (cola) recorta un archivo a partir del final del mismo. Con respecto a todo a las demás capacidades funciona igual que head.
Ejemplos:
$ clear ; cal 2003 | head (Imprime las 10 primeras líneas de la salida estándar).
$ clear ; cal 2003 | head -20 (Muestra las 20 primeras).
$ clear ; cal 2003 | tail (Por defecto muestra las 10 últimas líneas). $ clear ; cal 2003 | tail -20 (Muestra las 20 últimas líneas).
$ cal 2003 | head -18 | tail -8 > trimestre2 (Selección de una parte intermedia).
$ clear ; cat trimestre2 (Ver lo seleccionado).
$ clear ; cat trimestre2 | head -c 65 (Imprime los primeros 65 caracteres). $ clear ; cat trimestre2 | tail -c 65 (Imprime los 65 últimos caracteres).
3.3. La orden wc
La utilidad /usr/bin/wc, cuyo nombre procede de las iniciales de word counter (contador de palabras), es un programa o comando externo que permite realizar la cuenta de los caracteres, de las palabras y de las líneas contenidas en un archivo de texto. A su entrada se le puede aplicar también, mediante redirección, el texto proveniente de la salida estándar.
Este comando admite tres opciones:
-l lines Para mostrar sólo el número total de líneas del archivo. -w words Si se desea contabilizar sólo el número total de palabras. -c characters Cuando necesitamos saber el número total de caracteres.
Por defecto, si no se le facilita ninguna de las opciones anteriores, wc imprime la cuenta realizada por las tres: líneas, palabras y caracteres (y en este orden). Cuando trabaja con archivos, se le pueden pasar como argumentos dos o más nombres de archivos, e incluso un comodín que englobe a todos los archivos cuyo nombre encaje con un determinado patrón de búsqueda.
Ejercicios para practicar.
$ cal 4 2003 > mes_abril
(Crea un archivo con el calendario de abril).
$ cal 5 2003 > mes_mayo
(Idem con el mes de mayo de 2003).
$ cal 6 2003 > mes_junio
(Y con el de junio).
$ wc -l mes_abril (Imprime --> 8 mes_abril --> líneas).
$ wc -w mes_abril (Imprime --> 39 mes_abril --> palabras). $ wc -c mes_abril (Imprime --> 134 mes_abril --> caracteres).
$ wc mes_abril (Imprime --> 8 39 134 mes_abril --> las tres).
$ wc mes_abril mes_mayo (Datos de dos meses).
$ wc mes* (Datos de los tres meses).
$ cal 4 2003 | wc -l (Comprueba que es equivalente a $ wc -l mes_abril). $ cal 4 2003 | wc -w
$ dpkg -l | wc -l (Averigua qué significa el número que imprime en pantalla).
4. El filtro grepGlobal regular expression print. Con las iniciales de las palabras anteriores se forma el nombre del filtro grep que es un programa guardado en el subdirectorio /bin. Por tanto, /bin/grep, es un comando externo que permite filtrar archivos, o la salida estándar, y luego escribir en pantalla aquella línea, o conjunto de líneas, que contengan una coincidencia con una cadena previamente especificada como argumento. El filtro grep es una de las órdenes más potentes de Unix que tiene incluso otras dos variantes, fgrep (por fast grep) y egrep (por extended grep), con funciones más rápidas, o búsquedas múltiples, respectivamente, pero con una sintaxis algo menos estándar que grep. La sintaxis típica de uso es:
$ grep cadena_o_patrón_a_buscar archivo_o_archivos_o_salida_estándar
Ejemplos:
$ grep 2 mes_abril (Imprime todas las líneas del archivo que contienen un 2).
$ grep " 2 " mes_abril (Sólo líneas que contienen la cadena espacio2espacio).
$ grep Mayo mes* (Sólo la línea del archivo que contiene la cadena Mayo).
$ cal 2003 | grep Ju (Sólo las líneas que contienen la cadena Ju).
$ ls /dev | grep hda | wc -l (Cuenta los dispositivos particiones de hda). # fdisk -l /dev/hda | grep hda | wc -l (Número de particiones creadas en hda).
$ dpkg -l | grep " vim " (Para ver si está instalado el paquete vim). # fdisk -l /dev/hda | grep "*" (Para ver la partición activada).
$ ls -l /dev | grep lrwx (Para listar todos los enlaces simbólicos de /dev).
NOTA: Para especificar la búsqueda del *, debe indicarse con "*", '*' o \*, para que el shell no lo malinterprete por tratarse de un metacarácter con especial significado para el mismo.
El filtro grep, dispone de varias opciones que mejoran y facilitan su uso. Una de ellas es la opción -c (count) que nos cuenta directamente el número de líneas que presentan una coincidencia con el patrón de búsqueda especificado, haciendo innecesario el uso de un redireccionamiento hacia la orden wc. La salida de las dos líneas siguientes son, pues, equivalentes. $ cal 2003 | grep "ma mi" -c (Comprobarlo).
$ cal 2003 | grep "ma mi" | wc -l
Sabido es que, en Unix, al igual que ocurre en el lenguaje C, tienen diferente significado las letras mayúsculas y las minúsculas. Si en algún momento no recordamos el tipo de una determinada letra, podemos decirle a grep que ignore la diferencia (ignore case) mediante la opción -i. Teclear y analizar la diferencia en la salida de las dos secuencias de órdenes siguientes:
$ ls /dev | grep ttyS -c (Cuenta ttyS0, ttyS1, ttyS2 y ttyS3. 4 puertos serie). $ ls /dev | grep ttyS -i -c (Cuenta, además, de ttys0 a ttysf. Los 16 terminales).
Para imprimir el número de orden que la línea, o líneas, encontradas tienen dentro del archivo, o de la salida estándar, existe la opción -n (number). Ejemplos:
$ cal 2003 | grep Ma -n (Sólo las líneas de Marzo y Mayo contienen Ma).
$ cal 2003 | grep Ma -ni (Ahora se incluye ma. Es lo mismo poner -ni que -n i).
$ cal 2003 | grep Ma -n > numerado (Para guardar la salida en un archivo).
$ cal 2003 | grep Ma -in > Numerado (En general -in es lo mismo que -ni).
Si se quiere invertir la lógica del patrón a buscar, es decir, cuando se necesita mostrar todas las líneas que no contienen la cadena especificada, se puede utilizar la opción -v (invert). Se puede escribir que, a efectos de lo que se imprime en la pantalla, se cumple:
$ cal | grep 4 -v + $ cal | grep 4 = $ cal Existen muchas más opciones disponibles en la orden grep, pero con las expuestas es suficiente para hacerse una idea acerca de sus posibilidades de empleo. Para mayor información, es conveniente consultar las páginas del manual ($ man grep).
5. El filtro sed
El nombre de este filtro proviene de stream editor, es decir, editor de flujo. sed es un programa externo, residente en el subdirectorio /bin, (/bin/sed) que funciona como editor y filtro. A su entrada se aplica la información procedente de un archivo de texto, o de la salida estándar, para que el filtro la modifique según sea necesario y finalmente, el resultado, se envía a la pantalla o bien se redirecciona a un archivo o hacia una tubería para introducir los datos a la entrada de otra orden.
Este filtro, en la sintaxis, tiene muchos comandos parecidos al editor de texto vi pero, en cuanto al modo de funcionamiento, difiere bastante porque trabaja a nivel de línea. En efecto, lee una línea del archivo origen, la procesa y la entrega. Esto le confiere la capacidad de trabajar con archivos de tamaño de hasta 1 MB, muy superior al máximo que admite vi (inicialmente en Unix 256 KB). Por otra parte, sed, no es interactivo ya que se le debe indicar, mediante argumentos durante el inicio, el archivo y todos los cambios que deben hacerse en el mismo. Estos argumentos deben escribirse entre " " (dobles comillas) a diferencia de vi, que en modo orden no las utilizaba. La sintaxis general de uso es:
$ sed "comandos para sed" archivo_de_entrada
Veremos una serie de ejercicios utilizando, por ejemplo, la salida estándar como información de entrada de sed.
$ cal | sed "1,$ s/ /*/g" (Cambia todos los espacios por asteriscos).
$ cal | sed "1,$ s/^/ /g" (Añade un espacio al principio de cada línea).
$ cal | sed "1,$ s/$/ /g" (Añade un espacio al final de cada línea). Además de poder realizar cambios, sed, está dotada con la opción d (delete) para suprimir todas las líneas de un archivo que contengan determinada cadena. Incluso se le puede dar un rango de líneas para que las suprima incondicionalmente. Por ejemplo:
$ cal | sed "/20/d" (Borra 2 líneas, la que contiene el 20 y la del 2003).
$ cal | sed "/20 /d" (Suprime sólo la línea que contiene 20espacio). $ cal | sed "1,3 d" (Elimina, incondicionalmente, las líneas 1, 2 y 3). # fdisk -l /dev/hda | sed "1,5 d" | grep "hda[1234] "
(Lista las particiones primarias del disco hda).
Otra opción interesante es grabar en un archivo, en el disco, un rango de líneas del archivo entrante. La opción a emplear es w (write) precedida del número de la primera y de la última línea a escribir y seguida del nombre del archivo. Supongamos que deseamos filtrar el calendario del mes actual y guardarlo de modo que aparezcan sólo las líneas que contienen las fechas del mes de mayo, debemos teclear:
$ cal 5 2003 | sed "3,8 w mayo" (Genera el archivo mayo).
$ cat mayo (Para verlo). $ cal 5 2003 | sed "1,2 d" > Mayo (Esta línea es equivalente, pero más larga).
$ cat Mayo (Para comprobar que Mayo contienen lo mismo que mayo).
Del mismo modo que puede seleccionarse parte de un archivo y guardarlo en disco, también puede leerse un archivo entero, desde el disco, y después insertarlo a partir de una línea especificada del archivo, o de la salida estándar, que está en fase de filtrado a través de sed. Hay que emplear la opción r (read), precedida de la línea de inserción y seguida del nombre del archivo a incluir. Ejemplos:
$ cal 5 2003 | sed "5 r Mayo" (Inserta Mayo en la salida de cal).
$ sed "4 r Mayo" mayo (Inserta Mayo en mayo).
$ sed "4 r Mayo" mayo> meses (La salida se guarda en el archivo meses).
Otra opción es la p (print) que imprime en pantalla una línea, o un rango de líneas, añadiéndola, o no, a la salida estándar. Probar con el siguiente ejemplo:
$ cal 5 2003 | sed -n "4,5 p" (-n --> no añade. Sólo imprime las líneas 4 y 5). $ cal 5 2003 | sed "4,5 p" (Añade. Imprime repetidas las líneas 4 y la 5).
6. El filtro dd
Tal vez no exista otra utilidad que ofrezca más servicios de los que el filtro dd pone al servicio del administrador de un sistema Unix. Está disponible en cualquier distribución de Línux, incluso en los disquetes de rescate y también en las minidistribuciones. Se puede localizar en /bin/dd. Una capacidad muy interesante de esta orden es que puede trabajar tanto con archivos de texto y como con archivos binarios y lo mejor es que puede utilizar dispositivos "en bruto", es decir, no le importa qué sistema de ficheros está utilizando el dispositivo. Por tanto se puede copiar de byte en byte, o de sector a sector de disco, sin analizar su significado. Veremos, paso a paso, las opciones más importantes.
La primera característica a tener en cuenta es que, a dd, se le puede indicar cuál es la fuente de los datos de entrada mediante tres formas sintácticas diferentes:
Utilizando la redirección simple (<) y el nombre de un archivo . Empleando una tubería (|) y la salida proveniente de otra orden.
Aplicando la opción específica if= (input file).
Ejemplos (en los que la salida siempre se envía a la pantalla):
$ echo 0123456789 > digitos (Se crea un archivo de 11 bytes. CR incluído).
$ dd < digitos (Con redirección de un archivo).
$ cat digitos | dd (Con tubería desde otra orden).
$ dd if=digitos (Con la opción if= y el nombre de un archivo).
Lo segundo a considerar es que la salida de los datos del filtro dd puede enviarse a:
Por defecto, si no se especifica otro camino, a la salida estándar (pantalla). Hacia un archivo utilizando la redirección simple (>) o doble (>>). La entrada de otra orden, incluso otra dd, mediante una tubería (|).
Un archivo indicado mediante la opción específica of (output file).
Ejemplos en los que la entrada se aplica siempre con la opción if.
$ dd if=digitos | sed "1 s/0/9/" (Salida con tubería. Cambia el 0 por el 9). $ dd if=digitos > copia.digitos (Salida a archivo con redirección). $ dd if=digitos of=copia.digitos (Salida a archivo con of=
).
APLICACION: Si se quiere copiar un disquete entero, o una partición del disco duro, con un sistema de archivos cualquiera, sea FAT12, ext2, reiserfs, etc. para obtener una copia exacta del original, sector a sector, haríamos lo siguiente:
$ dd if=/dev/fd0 of=/dev/fd1 (En un sistema con dos unidades de disquetes).
$ dd if=/dev/fd0 of=disquete.img (Con una sola unidad, primero crear una imagen).
$ dd if=disquete.img of=/dev/fd0 (Luego, volcar la imagen a otro disquete).
En los ejemplos anteriores, es imprescindible que el tamaño en bytes del dispositivo de destino sea idéntico al del original. En el caso de los disquetes, origen y copia, deben tener el mismo formato, mismo número de pistas y mismo número de sectores. Si se trata de un disco duro, la partición origen y la partición destino deberán contener el mismo número de cilindros. Sin embargo una imagen, en nuestro ejemplo disquete.img, sólo es necesario que sea de menor tamaño que el dispositivo que la almacena porque dicha imagen es un archivo guardado bajo un determinado sistema de archivos creado, previamente, en un dispositivo.
6.1. Modificación del tamaño de bloque en el filtro dd
En todos los ejemplos vistos hasta ahora, el filtro dd, transfiere los datos desde su entrada hasta la salida en paquetes de 512 bytes. En el caso de un disquete estos paquetes, o bloques, coinciden exactamente con el tamaño del sector y ésta es la opción por defecto, es decir, si no se especifica otra cosa en la línea de comandos de la orden dd. Por otra parte, en todos los ejemplos hasta ahora vistos, el archivo de entrada de dd se ha filtrado completo. Así, al crear la imagen del disquete, primero se lee todo su contenido (2880 sectores) y después se escribe todo íntegro (los mismos 2880 sectores) en un archivo imagen.
Una posibilidad realmente interesante que ofrece dd es adaptar el tamaño en bytes del bloque que lee por su entrada y luego escribe en su salida. Esto se especifica sencillamente con la opción bs=n (bytes=n), siendo n un número entero positivo distinto de cero. Algunos ejemplos para un tamaño de bloque válido son:
bs=1
--> 1 byte
bs=1k
--> 1.024 bytes
bs=128
--> 128 bytes
bs=1M
--> 1.048.576 bytes
bs=256
--> 256 bytes
bs=1G
--> 1.073.741.824 bytes
Es evidente que la posibilidad de que el filtro dd pueda "trocear" un archivo en segmentos, o bloques, de un tamaño en bytes determinado, cobra todo su sentido cuando, además, se puede contabilizar dicho número de bloques. Esta opción es count=n, en donde n representa el número de bloques, del tamaño especificado en bs, que serán leídos y luego escritos. Veamos unos ejemplos.
$ echo abcdefghij > letras (Creación de un archivo con 11 bytes, CR incluído).
$ dd if=letras (Se filtra el archivo completo. Se envía a pantalla).
$ dd if=letras bs=5 count=1 (Se filtra un bloque de 5 bytes). $ dd if=letras bs=1 count=5 (Se filtran 5 bloques de 1 byte. Mismo que anterior).
$ dd if=letras bs=2 count=3 of=letras.6 (3 bloques de 2 bytes a un archivo).
$ cat letras.6 (Debe imprimir abcdef).
Para hacer una copia del MBR del disco duro /dev/hda y guardarla directamente en el boot de un disquete podemos emplear, desde una sesión como root, el siguiente comando:
# dd if=/dev/hda bs=512 count=1 of=/dev/fd0 (De sector 1 a sector 1).
Si la copia del MBR se quiere guardar como archivo, y si incluso se quiere editar, podemos hacer lo siguiente:
# dd if=/dev/hda bs=512 count=1 of=MBR_hda (Crea el archivo en disco). # cp MBR_hda /floppy (Copia del archivo en un disquete).
# hexedit MBR_hda (Edición en hexadecimal. Ayda F1. Salir con Ctrl+c).
El programa /usr/bin/hexedit es un editor hexadecimal de libre distribución en Linux.
6.2. Contando los bloques de entrada y de salida en el filtro dd
Otra capacidad añadida, que dispone el filtro dd, es la posibilidad de fijar la posición a partir de la cual se leen los datos en el archivo de entrada, que no debe ser necesariamente su primer byte, y la posibilidad de variar la posición de escritura en el archivo de salida, que tampoco tiene porqué ser el byte primero, o el último. Esta flexibilidad permite abrir, aún más, el abanico de uso de este potente filtro. Veremos, por separado, cada una de estas dos nuevas opciones.
Para la entrada, se utiliza la opción saltar, (skip=m), la cual permite suprimir de la entrada los n primeros bloques del tamaño especificado en la opción bs, es decir, el primer bloque efectivo que entra al filtro es el m+1 contado a partir del principio del archivo. Se puede combinar con la opción count=n para especificar los n bloques que se aceptarán en la entrada, siendo el primero el m+1. El tamaño x de bloque especificado en bs=x, es común para la opción skip y count. Veremos unos ejemplos sencillos para practicar.
$ echo 0123456789 > digitos(Crea un archivo con 11 bytes. Incluído el CR).
$ dd if=digitos (Imprime 0123456789. Se incluye el CR). $ dd if=digitos bs=1 skip=3 (Imprime 3456789. Se imprime el CR). $ dd if=digitos bs=1 skip=3 count=4 (Imprime 3456. No hay CR).
$ dd if=digitos bs=1 skip=3 count=4 of=digitos.cuatro (Lo guarda en un archivo).
Un ejemplo práctico de la utilidad de lo visto más arriba, es capturar la tabla principal de particiones del disco duro, aislándola del gestor de arranque, para guardarla como copia de seguridad. En este caso el archivo de entrada es el dispositivo /dev/hda y el tamaño del bloque se fija en 1 byte. Recordando que el gestor ocupa los 446 primeros bytes del MBR y que la tabla de las 4 particiones primarias tiene una extensión de 4 x 16 = 64 bytes, la línea de comandos a utilizar, desde una sesión como root, es:
# dd if=/dev/hda bs=1 skip=446 count=66 of=tabla.particiones
# hexedit tabla.particiones (Si queremos verla en hexadecimal).
00 01 01 00 06 FE 3F 0B 3F 00 00 00 CD F0 02 00 (Tipo 06 FAT16 MSDOS). 80 00 01 0C 0C FE 7F 8B 0C F1 02 00 80 21 5E 00 (Tipo 0C FAT32 WIN98).
00 00 41 8C 0F FE FF FF 8C 12 61 00 FA B8 48 04 (Tipo 0F extendida LBA).
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (/dev/hda4 --> libre).
55 AA (Fin de tabla).
En cuanto a los datos de salida del filtro, si se envían a un archivo, está disponible la opción para buscar, (seek=n), el bloque a partir del cual deben escribirse. Los n primeros bloques que se salta la opción skip tienen el tamaño en bytes especificado en la opción bs. Los bloques sobreescriben el contenido del archivo de salida, es decir, no hay desplazamiento de éstos hacia el final del archivo. Ejemplos:
$ echo 0123456789 > digitos (Creación del archivo digitos).
$ echo abcdefghij > letras (Creación del archivo letras). $ dd if=digitos bs=1 seek=5 of=letras (Se modifica el archivo letras).
$ cat letras (Debe imprimir abcde0123456789. Se incluye el CR).
$ echo abcdefghij > letras (Reconstrucción del archivo letras).
$ dd if=digitos bs=1 count=4 seek=3 of=letras (Se modifica el archivo letras).
$ cat letras (Debería imprimir abc0123hij. Se incluye el CR).
IMPORTANTE. La realización del siguiente ejercicio requiere una precisión absoluta porque, el comando utilizado, escribe directamente en un sector lógico del disco. Caso de introducir algún parámetro equivocado, un error en un sólo carácter es suficiente, podría producir la invalidez lógica del disco, y la consecuente pérdida de todos sus datos. No obstante se expone por el interés que ofrece. Si se tiene algun reparo, se puede experimentar primero con un disquete.
Supongamos que deseamos copiar el MBR del disco duro /dev/hda en una zona
"segura" dentro del mismo disco duro. Podemos buscar un sector libre, por ejemplo el 31 de la primera pista del primer cilindro. En notación lineal es el sector lógico 31. Durante una sesión como root, utilizaríamos las secuencias siguientes:
# dd if=/dev/hda bs=512 count=1 seek=30 of=/dev/hda (Para copiar el MBR).
# dd if=/dev/hda bs=512 skip=30 count=1 of=/dev/hda (Para restaurar el MBR).
Para practicar, la utilidad anterior, sobre un disquete, podemos realizar este ejercicio:
1º.
# dd if=/dev/zero bs=512 count=1 of=/dev/fd0 (Borra el primer sector o boot).
2º.
# fdisk /dev/fd0 (Crear varias particiones en el disquete).
3º.
# dd if=/dev/fd0 bs=512 count=1 seek=2879 of=/dev/fd0 (Salvar en último sector).
4º.
# dd if=/dev/zero bs=512 count=1 of=/dev/fd0 (Borra, de nuevo, el primer sector).
5º
# fdisk /dev/fd0 (Comprobar que no hay particiones en el disquete).
6º
# dd if=/dev/fd0 bs=512 skip=2879 count=1 of=/dev/fd0 (Restaura el boot).
7º.
# fdisk -l /dev/fd0 (Comprobar que se han restaurado las particiones).
7. El archivo /dev/zero y el filtro dd. Archivos llenos de "zeros".
Conviene recordar, una vez más, que en Unix los diferentes dispositivos del hardware son tratados como archivos. Existe un dispositivo virtual, pues no tiene realidad material, que se le llama /dev/zero. Desde un punto de vista matemático, /dev/zero, es un archivo que sólo contiene "zeros" y en cantidad infinita. Un "zero" es un byte cuyos 8 bits son cero. Sin embargo un cero es un byte cuyos bits no son todo ceros, pues su equivalente decimal es el 48.
byte "zero" ---> 0 0 0 0 0 0 0 0 Equivale al NULL del lenguaje C. Decimal 0. (ascii '\0' en C). byte cero ---> 0 0 1 1 0 0 0 0 Equivale al dígito 0 del teclado. Decimal 48. (ascii '0' en C).
La utilización del archivo /dev/zero está íntimamente ligada con el uso del filtro dd para contar el número de bytes "zeros" necesarios. Un caso práctico ya se ha visto en el ejemplo anterior cuando se pretende borrar a "zeros" el primer sector de un disquete, en el cual se he elegido un tamaño de bloque de 512 bytes y se ha contado sólo un bloque. Caso de haber contado 2880 bloques se habría perdido el sistema de archivos y los datos de todo el disquete, pero no su formato.
Observar que, si no se cuentan los bytes (o bloques) y si el archivo de entrada es /dev/zero, que contiene infinitos, y el de salida es un dispositivo de disco duro, se escribirían todos los sectores del disco con bytes "zeros" perdiéndose así toda la información en todas las particiones existentes en el mismo. Sin embargo esta posibilidad, mediante un uso controlado, es muy rentable utilizarla antes de instalar un sistema operativo en el disco con el fin de minimizar el tamaño de las copias imagen creadas después. Veremos con detalle todo esto en la unidad dedicada a la seguridad y administración del sistema.
El tándem formado por el archivo /dev/zero y el filtro dd, como se acaba de ver, puede operar enviando su salida hacia un dispositivo en "bruto", es decir ignorando el sistema de archivos que emplea tal dispositivo. Otra posibilidad, también muy útil, es enviar la salida de este par de órdenes hacia un archivo para ser guardado en el área de datos de un dispositivo que tenga creado un determinado sistema de archivos. Veremos algunos ejemplos.
$ dd if=/dev/zero bs=1 count=256 of=zeros_uno (Crea un archivo con 256 bytes). $ hexedit zeros_uno (Editar, en hexadecimal, para verlo).
$ dd if=/dev/zero bs=1k count=1024 of=zeros_dos (Crea el archivo de 1 MB).
$ dd if=/dev/zero bs=1M count=1024 of=zeros_tres (Crea un archivo de 1 GB).
Si seguimos aumentando el tamaño, del archivo generado, o creamos varios archivos de menor volumen y llenos de "zeros", hasta agotar por completo el espacio libre en disco y, más tarde, los suprimimos con la orden rm, habremos logrado una limpieza absoluta y completa de todos los bloques libres de una partición pero sin alterar el sistema de archivos ni el contenido existente en el mismo. Es más, podemos "limpiar" también una partición de Windows previamente montada como FAT. Trataremos con detalle esta posibilidad en una próxima unidad.
8. ¿Cómo partir archivos con el filtro dd?
Con cierta frecuencia surge la necesidad de dividir un archivo que tiene, relativamente, excesivo tamaño para ser guardado en un disquete, o para enviarlo por correo o para grabarlo en un disco CD. Posteriormente, en la lectura o en el destino, se reúnen, de modo ordenado, las diferentes partes que lo componen y se obtiene de nuevo el archivo original. El filtro ddpuede realizar el particionado de archivos binarios o de texto con cierta facilidad.
Veremos primero, como ejemplo, el caso de un archivo de texto que tiene un tamaño de 1977 bytes y quedará partido en otros tres iguales de 659 bytes cada uno (aunque no es necesario que tengan todos el mismo tamaño). Por tanto el primer archivo contendrá del byte 1 al 659 del original, el segundo archivo contendrá desde el 660 hasta el 1318 y el tercero desde el byte 1319 al último, siempre ambos inclusive. Las líneas de los comandos a utilizar son las siguientes:
$ cal 2003 > año (Crea un archivo de 1977 bytes).
$ less año (Para ver su contenido en pantalla).
$ dd if=año bs=1 count=659 of=año_uno (Crea el primer archivo).
$ dd if=año bs=1 skip=659 count=659 of=año_dos (Crea el segundo archivo). $ dd if=año bs=1 skip=1318 count=659 of=año_tres (Crea el tercer archivo).
$ ls -l año* (Un listado para ver el tamaño de cada uno). $ cat año_uno año_dos año_tres > año_total (Reconstrucción del original). $ less año_total (El contenido de año_total es el mismo que hay en año).
Observar que el ejemplo anterior sirve también para dividir un archivo de 1977 MB (casi 2 gigabytes) en otros tres que caben perfectamente, cada uno, en un disco CD. Sólo es necesario aumentar el tamaño de los bloques a contar hasta un megabyte reemplazando bs=1 por bs=1M. Los discos grabados sólo deben llevar la referencia 1/3, 2/3 y 3/3 para saber el orden en que deben ser concatenados durante la reconstrucción del archivo original.
Veremos ahora otro ejemplo. En este caso sobre cómo llevar a cabo la partición y la reconstrucción de un archivo binario. Concretamente de /bin/gzip que tiene un tamaño de 48844 bytes, en Linux Debian 3.0.1. Lo dividiremos en tres archivos: dos de 15 bloques de 1k, cada uno, mas un tercero con el resto.
$ cp /bin/gzip . (Para experimentar, lo copiamos en nuestro directorio). $ dd if=gzip bs=1k count=15 of=gzip1 (Crea el primer archivo).
$ dd if=gzip bs=1k skip=15 count=15 of=gzip2 (Segundo archivo).
$ dd if=gzip bs=1k skip=30 of=gzip3 (El resto para el tercero. No se cuentan).
$ cat gzip1 gzip2 gzip3 > gzap (Reconstrucción. Poner permisos y probar gzap).
$ ls -l gz* (Un listado largo para ver los tamaños).
9. ¿Cómo encontrar archivos? Órdenes whereis, which y find
Si por algún motivo o razón necesitamos localizar dónde se encuentra alguno de los archivos binarios (ejecutables) que tenemos instalados en nuestro sistema podemos hacer uso del comando externo "dónde está", /usr/bin/whereis, que nos facilita su localización exacta, en el árbol de directorios del sistema. Con la opción -b nos imprime dónde está situado el binario. Con la opción -m nos muestra dónde está su página del manual. Por defecto muestra las dos opciones. Ejemplos:
$ whereis -b cat (Muestra /bin/cat).
$ whereis -b less (Imprime /usr/bin/less). $ whereis dd (Binario --> /bin/dd Manual --> /usr/share/man/man1/dd.1.gz).
$ whereis -m whereis (Aparece /usr/share/man/man1/whereis.1.gz).
Existe otra orden para localizar la ruta completa del subdirectorio en donde se encuentra guardado un comando determinado del sistema, o de una aplicación instalada. Se trata de /usr/bin/which. Es más simple que whereis pues no admite ninguna opción. Por ejemplo:
$ which grep equivale a
$ whereis -b grep (/bin/grep).
$ which gimp equivale a
$ whereis -b gimp (/usr/bin/gimp).
$ which startx equivale a
$ whereis -b startx (/usr/X11R6/bin/startx).
$ which mkfs equivale a
$ whereis -b mkfs (/sbin/mkfs).
Para encontrar un archivo cualquiera, sea binario o no, disponemos de otra orden externa /usr/bin/find la cual dispone de múltiples opciones para realizar la búsqueda de acuerdo con uno u otro criterio. Además podemos especificarle el punto de partida en donde debe comenzar a buscar el archivo, que puede ser el mismo directorio actual, un subdirectorio cualquiera o el mismo directorio raíz. La sintaxis a emplear es:
$ find directorio_de_partida -criterio_de_búsqueda argumento
Para buscar, por nombre, partiendo del directorio raíz, un archivo llamado texto.dos, utilizamos el comando siguiente:
$ find / -name texto.dos (/home/usuario1/texto.dos). $ find /home -name texto.dos (Mismo que el anterior, pero más rápido).
Para buscar, por tamaño, a partir del directorio /bin, todos aquellos archivos que superen los 100 kilobytes de espacio ocupado en disco, escribiremos:
$ find /bin -size +100k
Existen muchas más posibilidades de uso para la orden find. que veremos en la unidad correspondiente, ya que para satisfacer las necesidades planteadas en esta unidad es suficiente con las dos expuestas.
---- end dd ----
10. Índice de contenidos.
1. Introducción.
2. ¿Cómo funciona una orden?
2.1. Entrada de información
2.2. Salida de la información 2.3. Salida de error estándar
3. Los metacaracteres del shell
4. Algunos filtros muy sencillos: more, less, cat, head, tail y wc
4.1. Órdenes more y less
4.2. Las órdenes head y tail
4.3. La orden wc
5. El filtro grep
6. El filtro sed
7. El filtro dd
7.1. Modificación del tamaño de bloque en el filtro dd
7.2. Contando los bloques de entrada y de salida en el filtro dd
8. El archivo /dev/zero y el filtro dd. Archivos llenos de "zeros"
9. ¿Cómo partir archivos con el filtro dd?
10. ¿Cómo encontrar archivos? Órdenes whereis, which y find
11. Indice de contenidos
INICIACIÓN AL USO Y ADMINISTRACIÓN DEL S O LINUX UNIDAD 5. REDIRECCIONAMIENTO Y
FILTROS
________________________________________________________________________________________________________________________
_
INICIACIÓN AL USO Y ADMINISTRACIÓN DEL S O LINUX UNIDAD 5. REDIRECCIONAMIENTO Y
FILTROS
________________________________________________________________________________________________________________________
_
GVA CEFIRE ESPECÍFICO DE FP CHESTE V. Ros Brandon - M. Blanes Monllor
-- 1 --
GVA CEFIRE ESPECÍFICO DE FP CHESTE V. Ros Brandon - M. Blanes Monllor
-- 1 --
INTRODUCCIÓN AL USO
Y ADMINISTRACIÓN DEL
SISTEMA
OPERATIVO LINUX. RED
IRECCIONAMIENTO Y FI
LTROS
INTRODUCCIÓN.
Una base muy importantesobre la que se edificó, desde un principio, el sistema operativo Unix fue dotarlo
de un elevado número de herramientas que fueran capaces, cada una, de resolver una tarea en concreto
de forma muy simple, pero a la vez muy segura.
Esto planteó la necesidad de confeccionar muchos
programas, uno para cada trabajo. Incluso hay tareas que, para resolverlas, podemos elegir entre dos o más
de ellos. Este elevado nivel de modularidad quedó completado con la lógica compatibilidad entre las
herramientas citadas.
El hecho de poder combinar unas órdenes con otras, enlazando los diferentes comandos entre sí, y éstos
con archivos (y desde archivos), supone dotar a Unix de una elevada potencia de operatividad que, incluso,
puede aprovecharse en
otros sistemas operativos
.
Veremos en la unidad dedicada a la administración y seguridad cómo conseguir esto último, pues, por el
momento, estudiaremos en esta unidad cómo funcionan los redireccionamientos y los filtros. Expondremos
bastantes ejemplos de
aplicación y realizaremos las prácticas necesarias para comprender el
funcionamiento y sus múltiples posibilidades de uso.
1.
¿CÓMO FUNCIONA UNA O
RDEN?
Por definición una orden, o un comando en Unix, no es mas que un programa ejecutable. Todo pr
ograma
se elabora con la finalidad de realizar una tarea de forma rápida y fiable para ahorrarnos trabajos
repetitivos o monótonos y también para hacer trabajos precisos en donde no se puede admitir un elevado
índice de posibles fallos.
Desde el punto d
e vista de los procesos, una orden, es un programa que el
shell
carga en la RAM del
ordenador, partiendo de un archivo en disco, y al cual reserva una zona adicional de memoria para las
variables, luego completa un trabajo y finalmente se extingue liberand
o dichos recursos de memoria.
En cuanto al redireccionamiento se refiere, una orden, es un programa que, normalmente, para trabajar
necesita unos
datos de entrada
sobre los que realizará cálculos, ordenaciones, búsquedas y muchas cosas
más. Una vez ha c
oncluído el
procesado de la información
introducida, el programa suele responder con
unos
datos de salida
que serán enviados a cualquier lugar que nosotros le indiquemos y que por defecto
suele ser la pantalla. Estos tres puntos son de una gran importancia
y conviene tenerlos siempre muy
presentes. Se puede plasmar gráficamente la idea anterior mediante:
INTRODUCCIÓN AL USO Y ADMINISTRACIÓN DEL SISTEMA
OPERATIVO LINUX. REDIRECCIONAMIENTO Y FILTROS
INTRODUCCIÓN.
Una base muy importante sobre la que se edificó, desde un principio, el sistema operativo Unix fue dotarlo
de un elevado número de herramientas que fueran capaces, cada una, de resolver una tarea en concreto
de forma muy simple, pero a la vez muy segura. Esto planteó la necesidad de confeccionar muchos
programas, uno para cada trabajo. Incluso hay tareas que, para resolverlas, podemos elegir entre dos o más
de ellos. Este elevado nivel de modularidad quedó completado con la lógica compatibilidad entre las
herramientas citadas.
El hecho de poder combinar unas órdenes con otras, enlazando los diferentes comandos entre sí, y éstos
con archivos (y desde archivos), supone dotar a Unix de una elevada potencia de operatividad que, incluso,
puede aprovecharse en otros sistemas operativos.
Veremos en la unidad dedicada a la administración y seguridad cómo conseguir esto último, pues, por el
momento, estudiaremos en esta unidad cómo funcionan los redireccionamientos y los filtros. Expondremos
bastantes ejemplos de aplicación y realizaremos las prácticas necesarias para comprender el
funcionamiento y sus múltiples posibilidades de uso.
1. ¿CÓMO FUNCIONA UNA ORDEN?
Por definición una orden, o un comando en Unix, no es mas que un programa ejecutable. Todo programa
se elabora con la finalidad de realizar una tarea de forma rápida y fiable para ahorrarnos trabajos
repetitivos o monótonos y también para hacer trabajos precisos en donde no se puede admitir un elevado
índice de posibles fallos.
Desde el punto de vista de los procesos, una orden, es un programa que el shell carga en la RAM del
ordenador, partiendo de un archivo en disco, y al cual reserva una zona adicional de memoria para las
variables, luego completa un trabajo y finalmente se extingue liberando dichos recursos de memoria.
En cuanto al redireccionamiento se refiere, una orden, es un programa que, normalmente, para trabajar
necesita unos datos de entrada sobre los que realizará cálculos, ordenaciones, búsquedas y muchas cosas
más. Una vez ha concluído el procesado de la información introducida, el programa suele responder con
unos datos de salida que serán enviados a cualquier lugar que nosotros le indiquemos y que por defecto
suele ser la pantalla. Estos tres puntos son de una gran importancia y conviene tenerlos siempre muy
presentes. Se puede plasmar gráficamente la idea anterior mediante:
