El Shell Bash de GNU/Linux

7 March, 2017 Jose Blanco GNU/Linux, Shell, Sistemas Operativos

En la serie de artículos “El Shell Bash de GNU/Linux” vamos a tratar los principales comandos para manejarnos por la consola de una distribución GNU/Linux.

1. Shell

El Shell es el intérprete de comandos con el que cuenta el Sistema Operativo.

Actúa como interfaz de comunicación entre el usuario y el ordenador, y cuando un usuario se conecta con un servidor Unix/Linux, automáticamente se arranca un Shell para que pueda trabajar.

Cada usuario conectado al servidor tendrá un Shell para su uso: Bash, sh, csh.

Con la orden who podemos averiguar qué usuarios hay conectados en cierto momento.

En entornos gráficos podemos lanzar Shell desde: Aplicaciones / Accesorios / Terminal

Consolas virtuales, que permiten entrar al sistema en modo texto o gráfico

CTRL+ALT+F1 a CTRL+ALT+F6 → texto
CTRL+ALT+F7 → gráfico

Si estamos trabajando en VirtualBox se utiliza la combinación CTRL-DERECHO + F#

Hoy en día nadie trabaja en modo texto y arrancamos en un modo gráfico, que nos ofrece un entorno de escritorio y gestor de ventanas (GNOME, KDE, etc…)

Pero disponemos de emuladores de Terminal, ubicados normalmente en el menú accesorios. En la gran mayoría de Escritorios con la combinación ALT+F2 se abre una caja de texto para escribir un comando, prueba a buscar ‘terminal’.

Ciertos comandos que en seguida empezaremos a utilizar son estos, te los introduzco muy brevemente:
ls → permite listar archivos/carpetas
cat → permite visualizar el contenido de ficheros desde la terminales
echo → permite visualizar el contenido de variables de entorno, del sistema o de usuarios

1.1 Funciones del Shell

Cuando un usuario escribe una orden o comando en la terminal, se está relacionando con el Shell, parte del Sistema Operativo a través de la cual se controlan los recursos del Sistema, proporcionando características que hacen que el sistema sea potente, flexible y usable.
El Shell es tanto un intérprete de comandos como un lenguaje de programación interactivo y con el que podemos crear pequeños programas denominados Shell Scripts.
Podemos ver los Shell instalados en cierta distribución examinando el fichero /etc/shells, con un editor de texto gráfico, de consola, o con la orden cat:
cat /etc/shells
La carpeta /etc contiene los ficheros de configuración del sistema y sus aplicaciones.

1.2 Fichero /etc/passwd

El denominado Shell de presentación se carga de forma automática cuando se accede al fichero /etc/passwd en el inicio de sesión.

Este archivo contiene la información que el sistema necesita conocer de cada usuario.

Es un fichero CSV delimitado por dos puntos ‘:’

Dentro de este archivo en el último campo (7) de cada línea, se encuentra la ruta del Shell que tiene asignado cada usuario, por norma general, en el caso de usuarios “humanos” se trata de /bin/bash. Donde /bin es una carpeta que cuelga de la raíz del sistema de ficheros “/” que almacena archivos binarios ejecutables.

En el fichero /etc/passwd, se almacenan 7 columnas para cada usuario, ya sea “humano” o “demonio” del sistema:

  1      2      3   4       5       6    7
login:password:uid:gid:descripción:home:shell
root:x:0:0:root:/root:/bin/bash
jblanco:x:1001:1001:Jose Blanco,,,,:/home/jblanco:/bin/bash

login: nombre de usuario
password: ‘x’ → las claves se almacenan codificadas en otro archivo /etc/shadow
uid: Identificador numérico del usuario (user id)
gid: Identificador numérico del grupo al que pertenece el usuario (group id)
descripción: Podría ser el nombre completo del usuario “Jose Blanco”
home: Ruta a la carpeta de trabajo personal del usuario
shell: Ya lo hemos explicado

1.3 Profile, Prompt, PATH y comandos

Cuando se inicia sesión en el Sistema, el Shell de presentación, primero busca el fichero .profile dentro del directorio $HOME.

Este fichero contiene comandos que personalizan el entorno de trabajo. Para poder comprobar la existencia de ese fichero, que permanece oculto por el hecho de comenzar por un punto ‘.’, deberíamos incluir una opción al comando ls que lista archivos/directorios -a:

ls -a

Si quisiéramos ver su contenido podríamos utilizar cat:

cat .profile

Un posible contenido del mismo podría ser este:

# ~/.profile: executed by the command interpreter for login shells.

# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login

# exists.

# see /usr/share/doc/bash/examples/startup-files for examples.

# the files are located in the bash-doc package.

# the default umask is set in /etc/profile; for setting the umask

# for ssh logins, install and configure the libpam-umask package.

#umask 022

# if running bash

if [ -n "$BASH_VERSION" ]; then

# include .bashrc if it exists

if [ -f "$HOME/.bashrc" ]; then

. "$HOME/.bashrc"

fi

fi

# set PATH so it includes user's private bin if it exists

if [ -d "$HOME/bin" ] ; then

PATH="$HOME/bin:$PATH"

fi

En este fichero se puede observar la personalización para el usuario de variables del sistema como PATH:
PATH="$HOME/bin:$PATH"
Podemos ver su contenido mediante la orden echo, anteponiendo un dolar ‘$’ al nombre de la variable:
echo $PATH

Después se muestra en pantalla de la terminal el prompt, o “indicador de la linea de comandos”, que normalmente es el símbolo dolar ‘$’, que indica que somos usuarios “normales”; para que el usuario pueda introducir sus comandos. Por ejemplo:

ls -la

Si en cambio el prompt, es el símbolo “#”, denota que hemos iniciado sesión como root, es decir como “superusuarios” o “administradores”. Con lo que podemos realizar tareas administrativas y a su vez peligrosas si no sabemos que estamos haciendo.
En general, todas las órdenes son programas que están almacenados en el sistema de archivos. En el mencionado directorio /bin, otros como /sbin y algunos más. Concretamente los almacenados en la variable de entorno PATH.

Si quieres saber en que directorios se almacenan estos comandos podemos echar un vistazo a lo que contiene la variable de entorno PATH, mediante la orden echo:

echo $PATH

Y una posible salida puede ser esta:

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Fijaos que vuelve a ser “algo” delimitado por el carácter dos puntos ‘:’, y cada trozo constituye una ruta hacia un directorio/carpeta que contiene ficheros ejecutables:

/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
/usr/games

Todos los comandos se escriben de forma similar a como se hace en la consola de Windows, y su sintaxis general es la siguiente:

comando [-modificadores] [argumentos]

Un corchete indica que “algo” es opcional.

1.4 Interfaces de Usuario

Éstas se definen como la parte del Sistema Operativo que determina como interactúa el usuario con él, y al final con el hardware que hay debajo.

De qué forma el usuario introduce comandos o cualquier otra información y cómo el sistema visualiza los mensajes o resultados después de procesar esa información.

La interfaz primaria o básica es de tipo texto y ya la hemos introducido.
La interfaz gráfica, X-Windows, incorpora un modelo cliente-servidor para el modo en que las aplicaciones interactúan con los dispositivos terminales de entrada y de salida:
- Entrada: ratón, teclado
- Salida: Monitor

X-Windows incorpora un protocolo de red X y herramientas software que pueden ser utilizadas para crear aplicaciones basadas en Ventanas para ambientes Linux.

Actualmente hay muchos gestores de interfaces gráficas cliente como GNOME o KDE, que son los más conocidos, que hacen diferentes implementaciones de los servicios del servidor X-Windows.

Son los denominados “Display Manager”, y se apoyan en el servidor X-Windows para decorar las ventanas del escritorio, y reaccionar a los eventos que genera el usuario.

Un concepto fundamental es la separación de las aplicaciones con respecto al software que maneja la entrada y salida por Terminal.

Todas las operaciones realizadas mediante la entrada o salida estándar (teclado y monitor) son manejadas por un programa que se dedica exclusivamente a ello (servidor).
Las aplicaciones (clientes) envían al servidor información a visualizar, y el servidor envía a las aplicaciones información referente a la entrada de usuario (por ejemplo, el movimiento del ratón).

1.5 Procedimiento de Conexión/Desconexión

Podemos conectar a un host Linux localmente o remotamente (desde cualquier ordenador).

Nos podremos conectar como un usuario cualquiera o como el administrador del sistema, es decir, como root.

Cuando conectamos con cierto usuario por la pertenencia a ciertos grupos puede hacer más o menos labores administrativas.

1.5.1 Práctica de Conexión remota a Linux

El protocolo de comunicación utilizado en esta pequeña práctica guiada es TELNET, un servicio de red obsoleto, ahora conviene utilizar SSH, donde la información viaja encriptada. Pero es sencillo de instalar y probar.

Existe un Software Cliente (cliente de telnet, normalmente la orden ‘telnet’) y un Software Servidor; que permitirán la conexión entre terminales mediante el protocolo de comunicaciones TCP/IP.

Sirve para conectarse a cualquier equipo identificado con una dirección IP.

Conexión remota Win→Lin

A continuación vamos a observar el proceso de conexión remota, teniendo encendidas 2 máquinas virtuales, una Windows y otra Linux.

Procederemos mediante un software cliente de telnet a realizar una conexión remota hacia la máquina Linux, donde necesariamente deberemos tener instalado y funcionando un servidor telnet.

De esta forma deberías entender el concepto de arquitectura Cliente – Servidor, y que Linux es un Sistema Operativo Multiusuario ya que 2 o más usuarios pueden disfrutar simultaneamente del hardware de una máquina.

Para hacer telnet desde Windows tenemos 2 opciones:

usar el comando telnet cliente desde la consola
utilizar un cliente telnet como Putty

Los Sistemas Operativos suelen venir con la parte cliente instalada (telnet) por defecto, no así con la parte servidor, el demonio telnetd. Fijaos la terminación en “d” de daemon.

Por lo tanto, una vez arrancada la máquina Linux deberemos instalar el servidor “telnetd”, que permita conexiones desde la red en modo remoto.

Ni que decir tiene que ambas máquinas, han de estar conectadas entre sí en la misma red, y tener conexión a Internet.

Para ello, si no sabéis montar una red interna en VirtualBox, os recomiendo de momento la “conexión puente” que nos ofrece, que hará que ambas máquinas se pinchen a la red del anfitrión.

SERVIDOR

Salimos a consola y ejecutamos el siguiente comando para instalar el paquete que contenga el demonio “telnetd”:

sudo apt-get install telnetd

Ahora debemos iniciar el servicio:

sudo /etc/init.d/openbsd-inetd start

El servicio es openbsd-inetd, al que le pasamos el parámetro start (los servicios se inician (start), paran (stop), …):

Usage: 

/etc/init.d/openbsd-inetd {start|stop|reload|force-reload|restart}

Debemos ser administradores para poder interactuar con servicios, de ahí el uso del comando sudo, para elevar privilegios y poder ejecutar la orden.

La carpeta /etc/init.d/ no tiene desperdicio, conviene que le hagáis un ls para ver su contenido:

ls -l /etc/init.d

Son todo servicios, entre ellos se encuentra el que acabamos de instalar.

Si todo va bien, al levantar el servicio aparecerán líneas como estas:

sudo /etc/init.d/openbsd-inetd start

[sudo] password for ubuntu:
 Starting internet superserver inetd [ OK ]

CLIENTE

Ahora desde la consola en XP introduciremos el comando siguiente:

telnet IP_servidor

Un posible ejemplo podría ser:

telnet 192.168.1.131

Donde 192.168.1.131 podría ser la IP que me da el comando ifconfig de Linux, ejecutado sobre la maquina Linux a la que queremos conectar desde la otra máquina Windows.

El usuario recibirá la pantalla de inicio de sesión en modo texto suministrada por el servidor (login).

Introduciremos las credenciales de nuestro usuario (login y password) y si son correctas, estaremos dentro del sistema Linux, mediante una conexión remota.

El sistema remoto nos dará la bienvenida, nos presentará el prompt y responderá a cualquiera de los comandos que le lancemos desde el indicador de la linea de comandos.

Si nos hemos equivocado, el sistema no nos dejará entrar, enviará un mensaje y volverá de nuevo a la situación de partida.

Tened en cuenta que Linux, es case sensitive, hace diferencia entre mayúsculas y minúsculas. Al principio es normal que cometas errores al introducir comandos, y sus argumentos, te iras acostumbrando, de momento un consejo ‘lee lo que te dice la consola’.

Después de estos mensajes, el sistema carga un Shell para ese usuario y aparece el símbolo del sistema, que variará:

el símbolo “$” para usuarios
el símbolo “#” para el administrador, root en Linux

A partir de este momento podremos trabajar sobre el sistema Unix/Linux con los privilegios que tengamos concedidos en el mismo.

Prueba a apagar la máquina Linux desde la máquina Windows lanzando un comando halt.

1.5.2 Conexión local

Del mismo modo que podemos conectar a un sistema Linux de forma remota, podemos hacerlo de forma local, de varias maneras:

Cada vez que abrimos un emulador de terminal desde la interfaz gráfica, se usan nuestras credenciales de usuario de escritorio, las que tuvimos que introducir al arrancar la máquina. Si usamos el comando who, veremos que se inicia sesión el el sistema, tanto el gráfico cómo el de texto, ya sea mediante el emulador lanzado desde la sesión gráfica, o el de inicio de sesión en alguna de las consolas TTY.

También podemos acudir a alguna de las consolas virtuales que ya hemos visto, a las que se accede mediante combinaciones de teclas CTRL+ALT+F# o si estamos en entornos virtuales como VirtualBox CTRL-DERECHO+F#.

Aquí se nos pedirán credenciales como en la práctica que hicimos en el apartado anterior.

Incluso una vez tenemos instalado el servidor telnetd, podríamos conectarnos hacia nosotros mismos, haciendo telnet hacia nuestra propia IP o al nombre localhost, o a la IP 127.0.0.1.

1.5.3 Desconexión (Cierre de sesión) / Reinicio y Apagado

Para cerrar la sesión de trabajo, si estamos conectados en modo texto, el usuario podrá hacerlo de dos formas distintas:

Teclear exit y luego pulsar Return / Intro
Teclear Ctrl+d

El sistema mostrará de nuevo login: y el usuario podrá conectarse de nuevo o no.

El cierre de sesión en modo gráfico es muy parecido al de sistemas Windows. Si queremos terminar la sesión de usuario, o cambiar de usuario, sin cerrar el sistema, haremos clic en el icono y opción correspondiente.

Desde la consola para apagar el equipo, ejecutaremos el comando halt:

#halt

Una almohadilla indica que se ha de ejecutar como root, si estuviésemos como un usuario normal → símbolo $, que es lo habitual, utilizamos el comando modificador sudo:

sudo halt

Para reiniciar el equipo, ejecutaremos reboot en modo comando:

reboot

Lo veremos más adelante pero convendría que os vayáis familiarizando con las páginas del manual, y con el comando shutdown:

man shutdown

La orden “man” nos proporciona, si existe, las páginas del manual del comando que escribimos a continuación. Por ejemplo para pedir el manual de otro de los comandos vistos hasta ahora, el que permite listar archivos y carpetas:

man ls

Aparece una pantalla de información de la que podéis salir presionando la tecla “Q” de “Quit”.

1.5.4 Primera conexión

En ciertas distribuciones, si el usuario que se conecta lo hace por primera vez, y si el administrador no ha decidido asignarle una clave, no habrá contraseña.

Si se da este caso, el usuario podrá asignarse él mismo una clave de acceso utilizando el comando:

passwd [usuario]

Os dejo un ejemplo del posible diálogo del comando passwd interactivo:

passwd

Passwd: changing password for ubuntu

Old password:

New password:

Re-enter new password:

Password Changed

Como se puede apreciar, se trata de un comando interactivo, primero solicita la clave antigua (si ya la había), si esto no fuera así, cualquier usuario podría cambiar las claves de los demás. Con ello el sistema consigue que sólo el usuario pueda cambiar su propia clave de acceso.

Después tecleamos la nueva clave dos veces. De esta forma se comparan las dos claves para verificar que la introducida originalmente es la deseada y no nos hemos equivocado al teclear

Al cambiar la palabra clave, hay que seguir una serie de normas → “Política de contraseñas”. Estas normas suelen ser definidas por el administrador del sistema, las más habituales, o un ejemplo, podrían ser estas:

La palabra clave ha de ser diferente a la anterior
Debe tener al menos 8 caracteres
Al menos 2 de estos caracteres tienen que ser alfabéticos.
Al menos 2 de estos caracteres tienen que ser numéricos.
Debe contener al menos una mayúscula.
…

Si no lo habéis hecho todavía, podéis aprovechar y hacerlo o verificarlo ahora; en los sistemas Linux que manejamos, el usuario root no suele tener contraseña asignada.

En el caso de Debian sí, ya que el proceso de instalación se preocupa de pedirla.

El comando para modificar la clave de otro usuario requiere permisos administrativos(en este caso root, con más razón) por ello debemos usar el elevador de privilegios sudo, y el comando sería este:

sudo passwd root

A nosotros como usuario administrador nos deja cambiar contraseñas de otros usuarios, incluido el propio superusuario root, ya que pertenecemos al grupo de administradores, normalmente adm o admin. En otras distribuciones como Fedora el grupo se llama sudoers.

Podemos comprobar a qué grupos pertenece nuestro usuario con el siguiente comando:

groups

Obtendréis una salida como esta:

administrador adm dialout cdrom plugdev lpadmin admin sambashare vboxsf

Otro comando que también proporciona información sobre nuestro u otro usuario es:

Y la salida se parecerá a esto:

uid=1000(administrador) gid=1000(administrador) grupos=4(adm),20(dialout),24(cdrom),46(plugdev),105(lpadmin),119(admin),122(sambashare),999(vboxsf),1000(administrador)

De la misma forma que podemos cambiar la clave de otro usuario que no sea el nuestro, podemos pedir información de otro usuario:

id root

uid=0(root) gid=0(root) grupos=0(root)

Conclusión:

passwd sin parámetros cambia de forma interactiva la clave de el usuario actual
passwd seguido de un nombre de usuario cambia de forma interactiva la clave de el usuario especificado, si tenemos permiso para ello
id muestra información sobre mi usuario o sobre otro usuario

1.6 La línea de ordenes del Shell

Es el intérprete de comandos: actúa como interfaz entre el usuario y el sistema operativo. Permite:

Utilizar abreviaturas de nombres de ficheros usando comodines → A* → archivos que comienzan por A mayúscula
Expandir otras órdenes o bien variables del sistema → echo “La fecha es: `date` y estamos en $HOSTNAME” → La fecha es: sáb dic 5 13:14:50 CET 2015 y estamos en NADX
Redireccionar la E/S → cat /etc/passwd > usuarios.txt → genera un fichero con nombre usuarios.txt, con el contenido del fichero de usuarios del sistema. Como no hemos especificado una ruta si no solo el nombre del fichero, lo crea donde estamos.
Encadenar varias ordenes → clear; cat /etc/passwd | less
Proporciona un lenguaje de programación muy potente que veremos más adelante, y nos permitirá hacer Shell Scripts → Archivo con varias ordenes o comandos, no solo de ejecución secuencial (uno detrás de otro), si no también con cierta lógica condicional gracias a las estructuras de condicionales, bucles y otras herramientas de programación que incorpora.

Como ejemplo podemos creamos un archivo llamado script.sh con nuestro editor preferido, en su interior incluimos estas lineas:

#!/bin/bash

#Mi primer script
 clear

echo "La fecha es: `date` y estamos en $HOSTNAME"

A continuación debemos darle permisos de ejecución mediante la orden chmod:

chmod u+x script.sh → le damos permisos de ejecución al usuario

Y por último lo ejecutamos:

./script.sh → ejecución del script

No sólo hay un Shell, como pasa en Windows de forma nativa, en cualquier distribución Linux vienen varios instalados.

Aunque nosotros utilizaremos el Bash podéis ver todos los que hay en el fichero /etc/shells:

cat /etc/shells

# /etc/shells: valid login shells

/bin/sh

/bin/dash

/bin/bash

/bin/rbash

El Shell que utilizará un usuario es el último campo del fichero /etc/passwd

ubuntu:x:1000:1000:ubuntu,,,:/home/ubuntu:/bin/bash

Cuando un usuario inicia sesión en el equipo, tras ejecutar el programa login, y comprobar que la contraseña del usuario es la correcta (/etc/passwd y /etc/shadow), se carga una configuración por defecto y con esta el Shell que utiliza este usuario.

En el caso de que el usuario haya iniciado sesión con la Shell Bash, esta configuración por defecto se guarda en dos sitios:

1. En los ficheros globales:

/etc/bash.bashrc y
/etc/profile

Estos ficheros contienen configuraciones y comandos que podrán ser utilizados por todos los usuarios. Y solo los puede modificar root.

2. En los directorios home de cada usuario también están los ficheros de configuración locales:

.bashrc y
.profile,

que pueden ser libremente modificados por el propio usuario, ya que es su propietario, y sirven para tener configuraciones personalizadas. Además:

Estos ficheros locales tienen preferencia sobre los ficheros globales.

1.6.0 Anatomía de un comando

orden [-opciones] [argumentos] [; ...]

Una orden es un archivo ejecutable del sistema, también se le llama comando. Se distinguen mayúsculas de minúsculas → Linux es case sensitive.

Una línea de orden en Unix/Linux puede estar formada por:

Comando u orden. Indica al Shell la acción a realizar. Se trata de un comando interno, externo o de terceros, en definitiva un programa o bien un Shell Script.
Opciones. Las opciones se escriben precedidas del carácter “-” guión/menos, ejemplo ls -l, (en DOS se introducen tras el carácter /, ejemplo DIR /W). Se pueden combinar en un solo guión varias opciones ls -la.
- Van precedidas de guión – , salvo las expresadas en notación BSD que no lo llevan:
  - ps aux
- Pueden agruparse precedidas de un guión simple
  - ls -la
- Si no se agrupan deben separarse mediante un espacio o tabulador ls -l -a
- El orden de las opciones no es significativo → Es lo mismo ls -la que ls -al
Argumentos. Caracteres que se utilizan como entrada del comando y que no son opciones, ejemplos de argumentos: archivo o directorio origen/destino de una operación, cadena, numero.
Ejemplo ls -l /etc → listado “largo” de archivos del directorio /etc
- Los argumentos, si hay varios, van separados por espacio o tabulador

Varias órdenes en la misma línea

Se puede introducir más de una orden en la misma línea, mediante un punto y coma (;). Ejemplo:

clear ; ls -la /etc

Acento grave

Es un operador que permite ejecutar un comando y sustituir la expresión entre “ por el resultado del mismo.

Esto permite por ejemplo guardar en variables los resultados de una orden y después iterar por ellos. Un ejemplo sencillo es embeber en un “echo” algún comando para formar una salida más elaborada:

echo Buenas son las `date +%H:%M`

→ Buenas son las 15:56

Resumen

Generalmente, los comandos en Unix/Linux:

Se utilizan por sí solos → pwd
Se utilizan acompañados por argumentos → cd /home/jblanco
Permiten opciones que modifican su comportamiento por defecto → ls -la /home/jblanco

1.6.1 Meta-caracteres

El Shell proporciona una forma de abreviar los nombres de archivos (o de carpetas) mediante el uso de patrones, esto permite realizar cierta acción no solo sobre un archivo/directorio, si no sobre varios a la vez.

Podemos utilizar expresiones que mezclen nuestro alfabeto y meta-caracteres para especificar un conjunto completo de archivos/directorios cuando sólo se conoce parte de su nombre, o bien se quieren realizar acciones masivas sobre archivos/directorios que cumplan cierto patrón.

Cuando el Shell, procesa una línea de orden, va sustituyendo de forma ordenada todas estas combinaciones y mezclas.

* cualquier número de caracteres o ninguno
? uno y solo un carácter

Pero Linux admite todos estos

[] cualquier carácter encerrado en los corchetes → ls -ld [0-9]* → ficheros que comiencen por número
[^] [!] cualquier carácter menos los encerrado en los corchetes →
ls -ld [^0-9]* → ficheros que NO comiencen por número
ls -ld [!a-Z]* → ficheros que NO comiencen por letra
$ contenido de una variable → echo $PATH
# comentario en los scripts y archivos de configuración
“ ejecución de órdenes, operador grave → echo `date`
“” permiten la expansión de $ y de ` ` → echo “La fecha es: `date` y estamos en $HOSTNAME”
‘‘ no permiten la expansión de $ y de ` ` → echo ‘La fecha es: `date` y estamos en $HOSTNAME’
; secuenciamiento de órdenes → clear; ls -la
&& Ejecución condicional and → rmdir mantenimiento && echo eliminado
|| Ejecución condicional or → rmdir mantenimiento || echo no se pudo eliminar
() Agrupamiento de órdenes → (echo “Calendario generado en `date`”; cal 2011)> 2011.txt
& Ejecución en segundo plano → gedit /boot/grub/menu.lst &
| Tubería → cat /etc/passwd | less
> Direccionamiento de salida → ps aux|grep jblanco > procesos-de-jblanco.txt
>> Direccionamiento de salida → date >> procesos-de-jblanco.txt→ añade al final
< Direccionamiento de entrada → mail jblanco < procesos-de-jblanco.txt

Los dos meta-caracteres más conocidos, por existir en todos los Sistemas Operativos, son los que denominaremos “comodines” * y ?

? : Cuando este carácter es utilizado como parte del nombre de un archivo o directorio, la interrogación sustituye a un solo carácter.

$ ls unit?

Listará todos los archivos que comiencen por unit y tengan un carácter más.

$ ls e?s

que comiencen por e y terminen en s y tengan tres caracteres.

* : Cuando este carácter es utilizado como parte del nombre de un archivo o directorio, el asterisco sustituye a una serie de caracteres.

$ ls unit*

$ ls e*s

$ ls *

[ ] : Cuando se utilizan como parte de nombres de archivo o directorio, representan un solo carácter de los incluidos entre los corchetes, que se sustituirán por el carácter en el nombre de archivo o directorio en la posición en la que estén estos corchetes. Pueden incluir rangos separados por un guión. Dentro de [ ] podemos utilizar !, que permite excluir caracteres.

$ ls capitulo1[102]

capitulo10 capitulo11 capitulo12

$ ls capitulo[123]0

capitulo10 capitulo20 capitulo30

$ ls capitulo[1-5]

capitulo1 capitulo2 capitulo3 capitulo4 capitulo5

$ ls [tn]*[ms]

archivos que empiecen por t o n, les siga una cadena de caracteres y, terminen por m o s.

$ ls cap[!1]

que comiencen por cap y terminen con un único carácter que no sea el 1.

$ ls unit[!6-9]

que comiencen por unit, tengan 5 caracteres y el último sea diferente de 6, 7, 8 ó 9.

$ ls cap[!15]

que comiencen con cap y de 4 caracteres, no pudiendo ser ni el 1 ni el 5 el último de ellos.

1.6.2 Redirección

Cada vez que se inicia un intérprete de órdenes, se abren automáticamente tres archivos:

stdin: archivo estándar de entrada, es de donde los programas leen su entrada → descriptor 0
stdout: archivo estándar de salida, es a donde los programas envían sus resultados → descriptor 1
stderr: archivo estándar de error, es a donde los programas envían sus salidas de error → descriptor 2

Los operadores de redirección {>| >>| <} permiten cambiar los flujos E/S estándar.

stdin se identifica generalmente con el teclado.
stdout y stderr se identifican normalmente con la pantalla.

Redirección de salida (stdout)

orden > fichero

orden >> fichero

Se puede redireccionar la salida de cualquier orden a un determinado archivo en vez de hacerlo por la salida estándar stdout o pantalla.

Para obtener una redirección de salida, se utiliza el carácter mayor que, >.

Si el archivo al que redireccionamos no existe, el shell lo creará automáticamente, si, por el contrario ya existía, entonces se sobrescribirá la información, machacando el contenido original del archivo.

date > prueba.txt → Se almacena la fecha actual del sistema en el archivo prueba.txt

Si lo que queremos es añadir información a un archivo sin destruir su contenido, deberemos utilizar para la redirección el doble símbolo de mayor que, >>.

ls >> prueba.txt → Se almacena al final del fichero prueba.txt el contenido del directorio activo.

Redirección de la salida de errores (stderr)

$ orden 2> fichero

$ orden 2>> fichero

Este tipo de redireccionamiento se utiliza para almacenar los errores producidos en la ejecución de un comando en un archivo específico, en vez de utilizar la pantalla. Para ello se utilizan los caracteres 2> para crear y 2>> para añadir.

cat fichero > fichero1 2> errores

Si el archivo fichero no existe o no está en ese lugar, o se da cualquier otro error, se crea un fichero llamado errores con el contenido del mensaje del error que se hubiera mostrado por pantalla. Si el fichero errores existe, se destruye y se queda con la última información; si no existe, se crea.

Si no queremos ver errores en pantalla, podemos redireccionar la salida estándar de errores a /dev/null, es el cubo de basura en Linux. En el siguiente ejemplo, si no colocamos 2> /dev/null apareceran errores de acceso en pantalla

find / -name *.c 2> /dev/null

Redirección de entrada (stdin)

$ orden < fichero

Redirección de la salida estándar y de errores

$ orden &> fichero

Cualquier orden que lea su entrada en stdin puede ser avisada para que tome dicha entrada de otro archivo en lugar de tomarla por el teclado.

Esto se hace utilizando el carácter menor que, <. La redirección de entrada no produce ningún cambio en el archivo de entrada.

mail pepe < listado2 → Se envía el fichero listado2 por correo electrónico al usuario pepe.

En el siguiente articulo “2. Tuberías y filtros” vemos los comandos que nos permiten crear salidas más elaboradas mediante filtros a través de tuberías. Hasta entonces.

7 comments .profile, /bin/bash, /etc/group, /etc/passwd, /etc/shadow, /etc/shells, /etc/sudoers, bash, bashrc, cat, chmod, clear, comodines, date, echo, echo $PATH, exit, GNOME, groups, halt, hostname, id, KDE, ls, man, passwd, PATH, prompt, ps, putty, reboot, redirección, salida estandard, Shell, shutdown, ssh, stderr, stdin, stdout, sudo, telnet, telnetd, Variable PATH, who

Sistemas operativos, redes, programación, hardware, linea de comandos, web, seguridad, herramientas, instalaciones