Bash Shell

Autores:
Pablo Garaizar Sagarminaga (garaizar@eside.deusto.es)
Eduardo González de la Herrán (egonzalez@nht-norwick.net)

Introducción (I)

GNU/Linux:

Herramientas GNU + Linux (núcleo)

Compatible con UNIX (GNU's Not UNIX)

Sistema multiusuario y multitarea

Bash:

Herramienta GNU

Shell, intérprete de comandos

Introducción (II)

Shells

Existen muchas shells: sh, csh, ksh, bash, etc.

Entorno de trabajo:

Case sensitive: sensible a mayúsculas (ECHO != echo).

Sintáxis: comando arg1 arg2... argn

Si un programa no está en el PATH: ./programa

Prompt:

$: usuario normal

#: usuario administrador/a (root)

Introducción (III)

Configuración del entorno de shell (bash)

Con la configuración del entorno de trabajo definimos variables del sistema, prompt, colores, etc. personalizados para cada usuario o para todos los usuarios.

Ficheros implicados:

/etc/profile (se lee siempre en cada login de cualquier usuario)

/etc/bash.bashrc (no se lee en el login, sólo al ejecutar bash)

~/.profile (obtenido de /etc/skel)

~/.bash_profile, ~/.bashrc (obtenidos de /etc/skel)

Introducción (IV)

¿Dónde están los comandos normalmente?

/bin: comandos estándar para todos los usuarios (ls, cat, cp, mv, etc.).

/sbin: comandos estándar para root (shutdown, mkfs, etc.).

/usr/bin: comandos o programas para todos los usuarios no presentes en todo sistema UNIX-like.

/usr/sbin: comandos para root no presentes en todo sistema UNIX-like.

Comandos muy básicos (I)

Movimientos por el árbol de directorios:

ls: listado del contenido del directorio

ls -alh /etc

cd: cambiar de directorio

directorio actual = .

directorio anterior = ..

cd .

cd ..

cd /usr/sbin

cd (va al $HOME del usuario)

Comandos muy básicos (II)

echo: mostrar un mensaje por pantalla

echo hola mundo

man: manual

dentro del man:

q: salir

espacio: avance de página

intro: avance línea a línea

/termino: buscar “termino” dentro del manual

man ls

Comandos muy básicos (III)

Manejo de ficheros:

touch: crear un fichero vacío o abrir uno existente.

touch fichero

touch /etc/motd

rm: borrar ficheros.

rm fichero1 fichero2

rm *.* (!= rm *)

rm -Rf /

Comandos muy básicos (IV)

Manejo de ficheros:

cp: copiar ficheros.

cp fichero1 fichero2

cp fichero1 fichero2 directorio

cp -a fichero1 fichero2

cp -aR directorio1 directorio

Comandos muy básicos (V)

Manejo de ficheros:

mv: mover/renombrar ficheros.

mv fichero1 fichero2

mv fichero1 fichero2 directorio

mv directorio1 directorio2

ln: crear enlaces entre ficheros.

ln -s origen destino

ln -s /usr/bin/games /home/usuario/juegos

Comandos muy básicos (VI)

Manejo de directorios:

mkdir: crear un directorio.

mkdir directorio

mkdir /home/usuario/documentos

rmdir: borrar un directorio.

El directorio tiene que estar vacío (se vacía con rm).

rmdir directorio

rmdir /home/usuario/documentos

Comandos muy básicos (VII)

Mostrar información de un fichero:

cat: muestra el contenido de un fichero.

cat /etc/passwd

more: muestra el contenido de un fichero parando cada pantalla para poder leerlo detenidamente.

Es lo que se conoce como un PAGER o paginador.

“less” es otro comando similar pero más potente

more /etc/passwd

file: muestra información acerca del fichero.

Comandos muy básicos (VIII)

date: muestra la fecha del sistema

$ date

dom jul 11 22:21:48 CEST 2004

$ date +”Dia %d de %m de %Y. Son las %H:%M”

Dia 11 de 07 de 2004. Son las 22:23

Comando muy útil en scripts para generar logs, ficheros temporales, etc.

Gestión de usuarios y permisos (I)

GNU/Linux: entorno multiusuario.

Usuarios, grupos y permisos proporcionan el mecanismo de seguridad básico en linux.

Ficheros de configuración:

/etc/passwd	--> usuarios

/etc/group	--> grupos

/etc/shadow	--> contraseñas

Gestión de usuarios y permisos (II)

Grupos: Definidos en /etc/group. Cada usuario debe pertenecer al menos a un grupo

Creación de grupos mediante groupadd.

Sintaxis: groupadd [-g gid] nom_grupo

Ejemplo: groupadd clientes

groups [user]: groups a los que pertenece el usuario (actual).

gpasswd -[a|d] user group : Añade o elimina al usuario del grupo.

Gestión de usuarios y permisos (III)

Usuarios: Definidos en /etc/passwd. Se pueden crear con useradd o con el script adduser.

Creación de usuarios mediante useradd.

useradd -c “Pedro González” -d /home/pedro -g clientes -G users,audio,cdrom -m -s /bin/bash pedro

passwd: modificación de contraseñas. Cada usuario puede modificar su contraseña. El usuario root puede modificar todas las contraseñas.

Gestión de usuarios y permisos (IV)

¿Quién soy? ¿Hay alguien ahí fuera?

whoami: indica el usuario con el que estamos ejecutando los comandos.

id: credenciales, similar a whoami pero más preciso.

w, who: indican los usuarios conectados en este momento y qué están haciendo.

Gestión de usuarios y permisos (V)

Cambiar propietario y grupo:

chown: cambia el propietario del fichero

chown root /var/tmp/fichero

chgrp: cambia el grupo del fichero

chgrp audio /dev/dsp

chown -R nobody:nobody /tmp/*

Gestión de usuarios y permisos (VI)

Cambiar el modo de acceso a ficheros:

chmod: cambia el modo de acceso al fichero.

dos sintáxis: octal y con letras:

con letras: [ugoa] [+-=] [rwx]

chmod u=rwx fichero

chmod a+rx fichero

octal:

R W X R W X R W X

1 1 1 1 0 1 1 0 1

7 5 5

chmod 755 fichero (= rwxr-xr-x)

Gestión de usuarios y permisos (VII)

Gestión avanzada:

su: cambiar de usuario.

con “-” se simula que se ha entrado desde ese usuario (se va a la $HOME del usuario, se cargan los scripts de arranque, etc.).

con “-c” se puede ejecutar un comando como ese usuario.

su – usuario

su – root

su usuario -c “ls /home/usuario”

Gestión de usuarios y permisos (VIII)

Permisos avanzados:

SUID: en un ejecutable, funciona parecido a su.

/usr/bin/passwd -> -rwsr-xr-x

GID: en un directorio, mantiene el grupo.

/var/spool/mail -> drwxr-sr-x, grupo=mail

cd /var/spool/mail; touch fichero -> grupo=mail

Sticky: en un directorio, los usuarios no pueden borrar cosas que no son suyas, aunque tengan permiso para ello.

/tmp -> drwxrwxrwt

Shell Scripts (I)

Script = Guión.

Un script es un fichero de texto que de forma secuencial ejecuta sentencias.

Tareas repetitivas se pueden agrupar en un guión y ejecutarse automáticamente (Batch Processing).

Es sencillo ejecutar 4 comandos para crear un buzón de correo.

No lo es tanto para crear 20.000 buzones.

Es sencillo hacer un bucle que se repita 20.000 veces ;-)

Shell Scripts (II)

Nuestro primer shell script:

Usamos un editor y creamos el fichero hola.sh

Contenido de hola.sh:

#!/bin/sh

echo hola

Con #! en la primera línea indicamos quién debería interpretar el resto de comandos (/bin/sh).

Posteriormente escribimos los comandos separados por saltos de línea.

Shell Scripts (III)

Variables:

Una variable tiene un nombre y un valor, y sirve para dotar de dinamismo a nuestros scripts:

FECHA=”15/07/2004”

echo “Hoy es $FECHA”

FECHA es el nombre de la variable.

$FECHA es su valor.

Para asignar un valor, se utiliza “=”. ¡¡¡SIN ESPACIOS!!!

Shell Scripts (IV)

Variables de entorno:

Al arrancar una shell, ya hay muchas variables definidas, son las variables de entorno.

Podemos ver su valor con el comando “env”.

Ámbito de una variable:

Si se define una variable en una shell, sólo tiene valor en esa shell, a no ser que se exporte a los programas “hijo”.

export USUARIO=”joaquin”

Si desde esa shell lanzamos un script u otro programa, la variable USUARIO contendrá “joaquin”.

Shell Scripts (V)

Variables: interactividad

Es posible leer del usuario el valor de una variable, dotando a nuestros scripts de interactividad.

cat hola.sh

#!/bin/sh

echo “Dime tu nombre:”

read NOMBRE

echo “Hola $NOMBRE, encantado de conocerte”

Shell Scripts (VI)

Variables: argumentos

Es posible pasar los parámetros o argumentos que queramos y utilizarlos dentro del script.

cat nombre.sh

#!/bin/sh

echo “Nombre: $1”

echo “Primer Apellido: $2”

echo “Segundo Apellido: $3”

./nombre.sh Juan López Martínez

./nombre.sh “Maria Dolores” Pradera Sánchez

Shell Scripts (VII)

Variables: argumentos

$1, $2, $3... ${10}, ${11}: argumentos

$0 es el propio script.

basename $0: nombre del script.

dirname $0: ruta al nombre del script.

shift: rota los argumentos hacia la izquierda

$1 ahora vale lo que valía $2, $2 lo que valía $3, etc.

$0 no cambia.

Shell Scripts (VIII)

Variables: argumentos especiales

$#: número de argumentos que nos han pasado.

$*: todos los argumentos. “$*” = “$1 $2 $3...”

$@: todos los argumentos. “$@” = “$1” “$2” “$3”...

$_: comando anteriormente ejecutado.

$$: PID del propio proceso shell.

$?: Resultado numérico del último comando ejecutado.

Shell Scripts (IX)

Variables: sustitución de comandos

Es posible almacenar en una variable el resultado de la ejecución de un comando.

Dos sintaxis:

Acentos graves: compatibilidad

LISTADO=`ls`

Con $(): anidable

LISTADO=$(ls)

LISTADO=$(ls $(cat directorios.txt))

Shell Scripts (X)

expr: Permite realizar operaciones aritméticas.

Sintaxis: expr ARG1 OP ARG2

$ SUMA=`expr 7 + 5`	(ojo espacios!)

$ echo $SUMA

12

$ expr 7 \> 5	(ojo escapar operadores!)

$ expr \( 7 + 5 \) \* 2

Ejercicio: Obtener el mes anterior al actual con una sola sentencia expr ;-)

Shell Scripts (XI)

Control del flujo de ejecución:

Condiciones: test ó [ ]

test “$NOMBRE” == “Juan”	(==, !=, >, <, >=, <=)

test $DINERO -eq 1000	(-eq, -ne, -gt, -lt, -ge, -le)

test -f /etc/passwd	(-f, -d, -l, -r, -w, -x)

Modifican el valor de $?

cero = verdadero

no cero = falso	(¡¡AL REVÉS QUE EN C!!)

Shell Scripts (XII)

Control del flujo de ejecución:

if: alternativa simple. Sintaxis:

if comando_if

then

comandos_then

elif comando_elif

then

comandos_elif

else

comandos_else

fi

Shell Scripts (XIII)

Control del flujo de ejecución:

if. Ejemplo:

if test “$NOMBRE” == “Juan”

then

echo “Hola Juanin, ¿qué tal?”

elif test “$NOMBRE” == “Pedro”

then

echo “Pedreteee, ¡cuánto tiempo!”

else

echo “No te conozco”

fi

Shell Scripts (XIV)

Control del flujo de ejecución:

case: cómodo para evitar alternativas anidadas. Sintaxis:

case $VARIABLE in

“VALOR1”) comandos_valor1

;;

“VALOR2”) comandos_valor2

;;

*) comandos_default;

esac

Shell Scripts (XV)

Control del flujo de ejecución:

case. Ejemplo:

case $NOMBRE in

“Juan”) echo “Hola Juanin, ¿qué tal?”

;;

“Pedro”) “Pedreteee, ¡cuánto tiempo!”

;;

*) echo “no te conozco”;

esac

Shell Scripts (XVI)

Control del flujo de ejecución:

while. Ejecución de 0 a N veces. Sintaxis:

while comando

do

comandos

done

Shell Scripts (XVII)

Control del flujo de ejecución:

while. Ejemplo:

N=1

while [ $N -lt 100 ]

do

echo “Repito esta frase, ya voy $N veces”

N=$(expr $N + 1)

sleep 1 # Esperamos 1 segundo

done

Shell Scripts (XVIII)

Control del flujo de ejecución:

until. Ejecución de 0 a N veces. Idéntico a while con la condición negada. Sintaxis:

until comando

do

comandos

done

Shell Scripts (XIX)

Control del flujo de ejecución:

until. Ejecución de 0 a N veces. Idéntico a while con la condición negada. Sintaxis:

N=1

until [ $N -ge 100 ]

do

echo “Repito esta frase, ya voy $N veces”

N=$(expr $N + 1)

done

Shell Scripts (XX)

Control del flujo de ejecución:

for: ejecución repetitiva asignando a una variable de control valores de una lista. Sintaxis:

for VARIABLE in LISTA

do

comandos

done

Shell Scripts (XXI)

Control del flujo de ejecución:

for. Ejemplo:

for N in “Sopa” “Carne” “Pan de ajo”

do

echo “Hoy comemos $N”

done

Shell Scripts (XXII)

Control del flujo de ejecución:

for: la LISTA define la separación de cada elemento por el valor de la variable IFS (que por defecto vale “ \t\n”). Ejemplo:

IFS=”:”

echo “Directorios en el PATH...”

for DIR in $PATH

do

echo $DIR

done

Shell Scripts (XXIII)

Control del flujo de ejecución:

for. Ejemplos numéricos:

for N in 1 2 3 4 5 6 7 8 9 10

do

echo “N ahora vale $N”

done

for N in $(seq 10)

do

echo “N ahora vale $N”

done

Shell Scripts (XXIV)

Control del flujo de ejecución:

select: muestra las opciones especificadas en LISTA y asigna a VARIABLE la opción escogida. Sintaxis:

select VARIABLE in LISTA

do

comandos

done

Shell Scripts (XXV)

Control del flujo de ejecución:

select: Ejemplo:

select OPCION in “Doner Kebab” “Pizza”

do

case $OPCION in

“Doner Kebab”) echo “Mmmm...”

break;;

“Pizza”) echo “Slurppp!”

break;;

*) echo “No sé qué es eso”

esac

done

Funciones (I)

function:

Podemos modularizar los scripts agrupando tareas en funciones.

Es necesario que una función esté definida ANTES de que sea llamada.

Dentro de una función, $1, $2, $3, etc. serán los parámetros pasados a la función, no al script en sí.

Funciones (II)

function. Ejemplo:

#!/bin/sh

function suma

{

echo $(expr $1 + $2)

}

suma 4 6

suma 3 234

Funciones (III)

source, .

Con source o con “.” podemos incluir el código de otro script en el nuestro:

#!/bin/sh

source funciones.sh # ahí se define suma

suma 1 3

suma 12 12312

Tuberías (I)

Un proceso en un sistema UNIX-like tiene inicialmente abiertos 3 “desagües”:

0: STDIN o entrada estándar

1: STDOUT o salida estándar

2: STDERR o salida de error

Imaginémonos una refinería:

Metes crudo por 0 (STDIN), consigues gasolina por 1 (STDOUT) y bastantes residuos por el “desagüe” 2 (STDERR).

Tuberías (II)

Redirigiendo la salida de un comando:

> : redirigir STDOUT a un fichero

ls > listado.txt

>> : redirigir STDOUT al final de un fichero (añadir)

ls >> listados.txt

2> : redirigir STDERR a un fichero

ls 2> errores.txt

2>> : redirigir STDERR al final de un fichero

ls 2>> errores.txt

Tuberías (III)

Redirigiendo la entrada de un comando:

< : redirigir el contenido de un fichero a STDIN

tr a A < fichero.txt

Tuberías:

| : es posible recoger la salida de un desagüe y conducirlo a la entrada de otro comando.

cat fichero.txt | tr a A

Comandos de filtrado (I)

sort: Ordena líneas de ficheros de texto. Opciones útiles:

-u (elimina duplicados)

-n (trata la cadena como valor numérico)

-r (ordena en decreciente)

-c (comprueba que el fichero esta ordenado)

$ sort mifile

arbol

casa

coche

Comandos de filtrado (II)

tr: Reemplaza un carácter por otro (trabaja con la entrada estándar)

$ tr 'a' 'A'

casa

cAsA

$ cat fichero | tr 'a' 'A'

tr 'a' 'A' < fichero

uniq: Elimina líneas duplicadas en un fichero ordenado (sort -u)

tail: Muestra las últimas líneas de un fichero.

tail -100 fichero

tail -f fichero

Comandos de filtrado (III)

head: Muestra las primeras líneas de un fichero

head fichero

head -100 fichero

wc: Cuenta palabras (-w), líneas (-l), caracteres (-c)...

wc -l fichero

wc --lines fichero

wc -c fichero

Comandos de filtrado (IV)

cut: Permite “cortar” las líneas de un fichero, mostrando el resto

-dS : selecciona delimitador 'S'

-fLIST : lista de números de campo a mostrar (se utiliza con -d)

-c (caracteres) -b (bytes): como -f pero sin usar con -d

-s : suprime las líneas que no contienen el delimitador.

$ cut -d":" -f1 /etc/passwd

root

daemon

bin

...

Útil, pero superado por otros comandos (awk, sed)

Comando grep (I)

Busca una cadena o patrón en ficheros y muestra las líneas que la contienen.

grep [opciones] patron [fich1 fich2...]

Metacaracteres válidos:

. (un carácter cualquiera)

* (cero o más ocurrencias del carácter anterior)

^ (principio de línea)

$ (fin de línea)

[a-f] (cualquier carácter del rango)

\< \> (principio y fin de palabra)

Comando grep (II)

Opciones típicas:

-c	escribe sólo el número de ocurrencias encontradas.

-i	ignora mayúsculas y minúsculas.

-l	escribe sólo los nombres de fichero donde ha encontrado el patrón.

-s	opera en silencio, sólo saca mensajes de error.

-v	escribe líneas que NO contienen el patrón

-w	trata el patrón como una palabra entera.

Uso típico: filtrar la salida de un comando

$ comando | grep ....

Expresiones Regulares (I)

Patrones

. (un carácter cualquiera)

* (cero o más ocurrencias del carácter anterior)

^ (principio de línea)

$ (fin de línea)

[a-f] (cualquier carácter del rango)

[-AD] (caracteres '-', 'A', 'D')

[^56] (todos los caracteres excepto '5' y '6')

[5^6] (caracteres '5', '^', '6')

[[:alnum:]] (todos los caracteres alfanuméricos)

Expresiones Regulares (II)

Quoted Braces (llaves)

Se utilizan para buscar un número determinado de repeticiones de la expresión:

expresion_regular \{min, max\}

grep '[345]\{2,4\}' fichero

expresion_regular \{exact\}

grep 'r\{2\}' fichero (busca dos 'r' seguidas)

expresion_regular \{min,\}

grep 'er\{2,\}' fichero

busca lineas con al menos dos caracteres 'r' precedidos por una 'e'.

Expresiones Regulares (III)

Quoted Parentheses (paréntesis)

Almacena los caracteres que concuerdan con la expresion regular en un registro.

Se pueden utilizar hasta 9 registros en una expresión regular

Para referenciar los registros utilizamos \1 a \9

Ejemplo: listamos líneas con dos caracteres idénticos seguidos:

grep '\(.\)\1' fichero

Expresiones Regulares (IV)

Ejemplos:

Listado de personas con apellido de 6 letras

Listado de personas con nombres de al menos cuatro letras.

Busca entradas cuyo número anterior al guión es el mismo que el posterior (ej: 94-4418777)

Listado de personas cuyo apellido empieza con L, M o N.

Comando sed (I)

sed es la abreviación de “stream editor”

Entrada estándar ---> ACCIONES --> Salida estándar

Típicas sintaxis:

sed 'acciones' fichero

comando | sed 'acciones'

sed -f fichero_comandos fichero

Nota: El fichero de entrada nunca se modifica!!

Nunca se debe redirigir la salida de sed al mismo fichero de entrada.

Comando sed (II)

Opera en todas las líneas que recibe de entrada si no incluimos una “selección” de líneas.

sed 'selección acciones', donde “selección” es:

Un número de línea ($ indica la última)

Un rango de números de línea (5,$)

Una expresión regular para seleccionar las líneas que la cumplen (/regexp/)

Un rango utilizando expresiones regulares (desde la primera línea que cumpla la primera expresión hasta la línea que cumpla la segunda expresión). Ejemplo: /^on/,/off$/

Comando sed (III)

Accion de sustitución (s)

Sintaxis: “s/cadena antigua/cadena nueva/g”

Ejemplo:

sed 's/Smith/Smythe' telefonos.txt

Notas:

“cadena antigua” admite expresiones regulares.

“cadena nueva” no admite expresiones regulares.

Hay que escapar algunos caracteres.

Sin la 'g' final sólo se sustituye la primera ocurrencia de cada línea.

Comando sed (IV)

Acción 'd' (delete)

Sintaxis: 'SELECCIONd'

Ejemplo: sed '5,$d' telefonos.txt

Acción 'p' (print). Por defecto sed siempre saca por pantalla todas las líneas que procesa (-n cambia este comportamiento)

Sintaxis: 'SELECCIONp'

Ejemplo: sed -n '/hola/p'

Comando sed (V)

Ejemplos...

echo “xxx” | sed '/x/y/'

echo “1234” | sed 's/^\(.\)/\1\1/'

Ejercicio:

Duplicar el primer y último carácter de cada línea.

Comando awk (I)

¿Qué es awk?

Awk es un lenguaje de programación utilizado para manipular texto.

Los datos se manipulan como palabras (campos) dentro de una línea (registro).

Un comando awk consiste en un patrón y una acción que comprende una o más sentencias.

awk 'patron { accion }' fichero ...

Comando awk (II)

¿Qué es awk?

awk comprueba cada registro de los ficheros indicados en busca de coincidencias con el patrón; si se encuentra alguna se realiza la acción especificada.

awk puede actuar como filtro tras un pipe o obtener los datos de la entrada estándar si no se especifica ningún fichero.

Comando awk (III)

Expresiones regulares

Las expresiones regulares quedan delimitadas con el carácter '/' (ej: /x/)

Además de todas las comentadas hasta ahora, awk puede utilizar:

/x+/	Una o más ocurrencias de x

/x?/	Una o ninguna ocurrencia de x

/x|y/	Tanto x como y

(string)	Agrupa una cadena para usar con + o ?

Comando awk (IV)

Sentencia print

Es de las más utilizadas

awk 'patron { print }' f_ent > f_sal

este ejemplo sería lo mismo que:

$ grep patron f_ent > f_sal

Referenciando campos:

$0: Registro completo

$1: Primer campo del registro

$2: Segundo campo del registro

...

Comando awk (V)

Más funcionalidades:

Multiples sentencias en una acción

Usando “;” o salto de línea:

Comentarios con “#”

Comparaciones de expresiones regulares o strings

==, !=, <, <=, >, >=, ~, !~, ||, &&

$1 ~ /x/

$ awk '$1 ~ /^[T]/ || $3 ~ /^[46]/ { print } fichero

Comando awk (VI)

Más funcionalidades:

Variables de usuario

Operaciones aritméticas

Estructuras de control

if – else if – else

while

for

Comando find

find: herramienta muy potente para realizar búsquedas de ficheros. Sintaxis:

find [path] opciones

Opciones típicas:

-name “nombre”

-type (d|f|l|s|...)

-maxdepth n

-mindepth n

-mtime n

-exec comando \; ({} indica el fichero)

Comandos de backup

gzip: compresor estándar

bzip2: compresor más pontente pero más lento

tar: empaquetador de ficheros (muy útil)

zcat: cat sobre archivos comprimidos

zmore: more sobre archivos comprimidos

zgrep: grep sobre archivos comprimidos

zgrep cadena file.gz

gzip -c file.gz | grep cadena

Comandos de gestión de procesos (I)

ps: muestra la lista de procesos que se están ejecutando.

ps aux

ps -fe (UNIX compatible)

pstree: muestra la lista de procesos con forma de árbol.

pgrep: muestra los procesos que cumplen con el patron. Es una especie de ps + grep.

Comandos de gestión de procesos (II)

&: Al lanzar un proceso lo lanza en segundo plano.

$ top &

jobs: Muestra los procesos de la sesión actual que se encuentran en segundo plano.

$ jobs

[1]- Stopped top

[2] Stopped more mifile

[3]+ Stopped vi otroFile

Comandos de gestión de procesos (III)

fg (foreground): Lleva un proceso a ejecutarse en primer plano.

$ fg 1

bg (background): Manda un proceso a ejecutarse en segundo plano.

control + Z: Interrumpe un proceso y lo deja en segundo plano suspendido.

control + C: Interrumpe la ejecución de un proceso y lo para (señal KILL).

Comandos de gestión de procesos (IV)

kill: manda una señal a un proceso

kill -SIGNAL PID

Normalmente se utiliza para matar procesos

kill -9 4366

Comandos de red (I)

Configuración de red:

ifconfig: configura interfaces de red. Asigna IP, máscara, dirección mac, etc.

$ ifconfig eth0 172.26.0.12 netmask 255.255.255.0 up

route: añade rutas estáticas. Ejemplo típico:

$ route add default gw 172.26.0.1

$ netstat -nrv (muestra tabla de rutas)

/etc/resolv.conf: indica los servidores DNS

$ cat /etc/resolv.conf

nameserver 195.235.113.3

Comandos de red (II)

ping: manda un mensaje ICMP – echo request

Se utiliza normalmente para comprobar si un interfaz de red remoto está levantado.

$ ping 212.55.8.132

PING 212.55.8.132 (212.55.8.132) 56(84) bytes of data.

bytes from 212.55.8.132: icmp_seq=1 ttl=242 time=166 ms

(hay conectividad!)

Nota: Si no hay ping puede que esté filtrado el tráfico

Comandos de red (III)

telnet: protocolo de terminal remoto.

Se utiliza para conectarse a una máquina remota.

$ telnet IP puerto (default 23)

NO es un protocolo seguro (SSH sí)

Se utiliza también para comprobar estado de servicios remotos. Ejemplo:

$ telnet www.euskalnet.net 80

Connected to eui3h.euskaltel.es.

Escape character is '^]'.

Comandos de red (IV)

netcat (nc): “navaja suiza” de red, capaz de funcionar como cliente, como servidor, etc.

Ejemplos:

cat fichero | nc 192.168.1.1 5000

nc -l -p 5000 > fichero

Comandos de red (V)

Sesión FTP desde Shell Script. Ejemplo:

#!/bin/sh

echo “Iniciando conexión...”

ftp -n ftp.rediris.es <<END_FTP

quote USER anonymous

quote PASS anonymous

get welcome.msg

quit

END_FTP

echo “Conexión finalizada”

Scripts gráficos (I)

Es posible mejorar el aspecto de nuestros menús y opciones más allá de “read” y “select” usando herramientas como “dialog”, “whiptail”, “Xdialog”, “gdialog” o “kdialog”.

Son bastante similares y sencillas de utilizar.

Son capaces de generar cajas de texto, dialogos de petición de texto o contraseñas, menús, barras de progreso, etc.

Scripts gráficos (II)

dialog:

dialogos desde shell scripts en ncurses.

MsgBox:

dialog --title "Alerta" --backtitle "Cursillo de Bash Shell" --msgbox "Este es un mensaje con dialog" 8 50

Scripts gráficos (III)

dialog:

YesNo:

dialog --title "Pregunta" --backtitle "Curso de Bash Shell" --yesno "\n¿Estas aprendiendo algo?" 7 60

RESPUESTA=$?

case $RESPUESTA in

0) echo "Bien!";;

1) echo "Mal!";;

255) echo "Salir [ESC]";;

esac

Scripts gráficos (IV)

dialog:

InputBox y PasswordBox:

dialog --title "Creacion de usuarios" --inputbox "Nombre de usuario" 0 0 2> /tmp/dialog.$$

USUARIO=$(cat /tmp/dialog.$$)

dialog –title "Creacion de usuarios" --passwordbox "Clave" 0 0 2> /tmp/dialog.$$

CONTRASENYA=$(cat /tmp/dialog.$$)

rm /tmp/dialog.$$

Scripts gráficos (V)

dialog:

Menu:

dialog --title "Creacion de usuarios" --menu "Grupos" 0 0 3 0 root 100 users 5 audio 2>

/tmp/dialog.$$

GRUPOS=$(cat /tmp/dialog.$$)

rm /tmp/dialog.$$

Scripts gráficos (VI)

dialog:

Barras de progreso (gauge):

{

echo 10; sleep 1

echo 40; sleep 2

echo 95; sleep 1

echo 100

} | dialog --title "Creacion de usuarios" --gauge “Creando...” 0 0 0

Scripts gráficos (VII)

Todo lo anterior se puede hacer con el resto, con cambios mínimos en la sintaxis:

whiptail: ncurses, aspecto mejorado

Xdialog: widgets X simples

gdialog: GNOME

kdialog: KDE

Optimizaciones (I)

Sintaxis

$(ls) -> *

for F in $(ls) == for F in *

cat fichero | comando -> comando < fichero

cat fichero | grep patron

grep patron < fichero

: es como una NOP

: >> es lo mismo que touch. Ej: :>> fichero

while : ; do echo “siempre”; done

Optimizaciones (II)

Listas AND y OR:

AND (&&): comando1 && comando2

if comando1

then

comando2

fi

test -f “/etc/passwd” && echo “passwd encontrado”

Optimizaciones (III)

Listas AND y OR:

OR (||): comando 1 || comando2

if comando1

then

:

else

comando2

fi

test -f “/etc/passwd” || echo “error: sin passwd”

Optimizaciones (IV)

Bloques:

{ }: agrupar E/S de comandos:

{

echo “Listado...”; ls;

echo “Fin de listado”

} > listado.txt

También se puede hacer con bucles:

for F in *

do

cat $F

done | wc --lines

Optimizaciones (V)

Bloques:

( ): subshells.

(sleep 3 && echo fin shell1) &

(sleep 5 && echo fin shell2) &

Señales:

trap 'echo capturada señal' 2 3

kill -2 PID

kill -3 PID

Referencias

Links

http://www.tldp.org/HOWTO/Bash-Prog-Intro-HOWTO.html

http://www.tldp.org/LDP/abs/html/

Licencia

Este material es libre de ser reproducido de forma literal en cualquier medio tal y como se especifica la Licencia Libre de Documentación (FDL) y siempre que esta nota sea preservada.

Autores:

Pablo Garaizar Sagarminaga

Eduardo González de la Herrán

2003-09-27T13:26:22