Vous êtes sur la page 1sur 28

Tema 2

Shell Scripts
Administracin de Sistemas de Informacin
4 Grado en Ingeniera Informtica Tecnologas Informticas
Curso 2016/17

La shell
SHELL

Permite al usuario interactuar con


el S.O. (p.ej: ejecutar programas).

Kernel

Existen varios tipos de shell (se indican las ms relevantes):

Bourne Shell (la original, en sistemas Unix 7ed): sh


Bourne Again Shell (GNU/Linux y MAC OSX): bash.
C Shell (SunOS): csh.
C Shell mejorada (FreeBSD): tcsh.
Korn Shell (AIX, HP-UX): ksh.

Cada una de ellas tiene sus propias caractersticas => son diferentes
(programacin, ficheros de arranque, etc).

La shell
Bash
Es la shell por defecto en sistemas GNU/Linux.
Una shell puede ser:
Login shell o non-login shell:
Si se inicia sesin desde un terminal (tty2, por ejemplo) => login shell.
Si se abre un terminal nuevo (una vez iniciada sesin) => non-login shell.

Interactiva o no interactiva.

Ficheros de arranque:
Para una login shell: /etc/profile y una de (~/.bash_profile | ~/.bash_login |
~/.profile). Y ~/.bash_logout
Para una non-login shell: /etc/bash.bashrc y ~/.bashrc.

Estructura bsica del sistema de ficheros


Sigue la tpica estructura de directorios y ficheros (hay unidades?).

Vistazo general.
Permisos generales.
Permiso ejecucin.
Ficheros ocultos.
Directorios.
Directorios especiales.

Ejecutables
Puede ser o bien un binario o bien un script (shell, perl, etc):
Se puede usar el programa file para saber de qu tipo es.

Criterios de bsqueda del fichero ejecutable:


Si uso un path absoluto o relativo se escoge este:

/usr/bin/ls.
./mi_script. Y mi_script sin ms?
~/mis_scripts/enviar_correos
~usuario/mis_scripts/enviar_correos

Si pongo el nombre del ejecutable sin ms:


Se usa la variable de entorno $PATH:
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
Y si uso .?

Pginas de manual
Permiten conocer para qu sirve un determinado programa (normalmente
del SO) y la sintaxis. Tambin se aplica para ficheros de configuracin.

rdenes bsicas (1/2)


ls: Lista el directorio o fichero indicado. Ej: ls l ~benjumea/
Opciones: -l (listado largo), -a (incluye ficheros ocultos), -d (directorio), -R (recursivo).

pwd: Muestra el directorio actual.


cp: copia. Ej: cp origen destino.
Opciones: -r (recursivo), -p (preserva permisos), -P (deja los enlaces como tales).

cd: Cambiar directorio. (OJO: cd.. no vale).


mv: Mover fichero/directorio (tiene el efecto de renombrar). Ej: mv dir1/ dir2/
rm: Eliminar fichero.
Opciones: -r (recursivo, para directorios), -i (siempre pregunta), -f (forzar, nunca pregunta).

rmdir: Elimina directorio (solo si est vaco).


Opciones: -p (elimina el rbol).

rdenes bsicas (2/2)

cat: Imprime un fichero.


More: pagina un fichero.
Mkdir: Crea un directorio (opcin p).
Touch: Crea un fichero vaco / modifica fecha acceso/modificacin (0 bytes).
File: Indica el tipo de fichero.
w: muestra los usuarios, el tiempo de uptime y la carga. Ver: uptime.
uname: Muestra informacin del S.O. (opciones: -a).
Hostname: Muestra el nombre del ordenador.
Which: Indica dnde est el ejecutable (relacionado con $PATH).
echo: Escribir algo por pantalla. Ejs: echo Hola, hola.
printf: Idem, pero con formato printf de C. Ejs: printf Hola\nHola\n.

EN CASI TODAS ELLAS: COMODINES * y ?

Misc
Histrico (flechas) y autocompletar (TAB).
Alias y aliases.
Variables: Se establecen con variable=valor. Caso: var. de entorno.
Promocin a variable de entorno: export variable=valor. Se heredan.
Ver variables de entorno: env o printenv.
Algunas variables: $PATH, $HOME, $PS1.

Comillas dobles, simples e invertidas (ej: var=hostname):

echo El valor es $hostname


echo El valor es $hostname
echo El valor es `hostname`
Y echo El valor es `hostname`? Y echo El valor es `hostname`?

Escapndome del ? y del *


*, ?, : Tienen un significado especial. Y si los quiero como nombre?
Qu pasa si mkdir Directorio con espacios y *?
Una solucin es usar el carcter \ antes del carcter especial:
Mkdir Directorio\ con\ espacios\ y\ *

Otra solucin es usar las comillas (simples o dobles).


Lo mismo pasa con otros caracteres especiales.

Redirecciones y tuberas (1/2)


Todo programa dispone de tres descriptores de fichero:
0: stdin: Entrada estndar (defecto: teclado).
1: stdout: Salida estndar (defecto: pantalla).
2: stderr: Salida de errores (defecto: pantalla).

Se puede mandar a otra parte con <, > y >>. Ver ejemplo.
Otros ejemplos:

find / -name .bashrc > /tmp/salida_find.


find / -name .bashrc > /tmp/salida_find 2> /tmp/errores.
find / -name .bashrc &> /tmp/todo.
Y tiene algo que ver esto?: find / -name .bashrc > /tmp/salida &

Redirecciones y tuberas (2/2)


Las tuberas conectan la salida estndar de un programa con la
entrada estndar de otro.
Se usa |
Ejemplo: ls la|more.
Qu le pasa a stderr?
Ficheros especiales:
/dev/null: Un cubo de basura virtual.
/dev/zero: Una fuente de ceros sin igual.

Cmo descartar los errores de ejecucin de un programa?


mkfifo: Permite crear ficheros que se comportan como tuberas.

rdenes avanzadas
find (1/4)
find: Permite buscar. Su sintaxis es compleja (man). Defecto: recursivo
Su sintaxis simplificada es: find [opciones] [path] [expression]
expression puede ser:
Una opcin (no es igual que opciones)=> Siempre son verdaderas.
Una condicin (TEST, en ingls) => Puede ser verdadera o falsa, depende.
Una accin => Es algo que se ejecuta si es que le toca.

expression puede ser:

expr1 expr2 expr3: Es un AND. expr 2 no se comprueba/ejecuta si expr1 no es cierta.


expr1 o expr2: Es un OR. expr2 no se comprueba/ejecuta si expr1 es cierta.
(expr): Para aplicar precedencia.
expr1, expr2: Ejecuta las dos expresiones pero descarta el valor de expr1.

rdenes avanzadas
find (2/4)
De esta forma, find . name D\* -print, imprime por pantalla todos los
ficheros (y directorios) que empiecen por D (ntese el \).
Tanto name (condicin) como print (accin) son expresiones => En
este caso, -print solo se ejecuta si name es verdadero (si el nombre
coincide con lo que busco).
OJO: El orden importa:
find . name \*.old print delete: Busca de forma recursiva los ficheros
*.old, imprime el path y los borra.
Pero find . delete name \*.old print: Hace algo radicalmente distinto.

rdenes avanzadas
find (3/4)
find tiene bastantes parmetros y expresiones => solo explico algunos
Opciones (expresin):
-xdev: Indica que no se cruce a otro sistema de ficheros.

Condiciones (expresin):

Uso de +n, n y n como parmetro de una condicin.


-amin n: Es cierto si el fichero fue accedido hace n minutos. (-cmin, -mmmin).
-atime n: Es cierto si el fichero fue accedido hace n*24h. (dem min). (*)
-newer fich_ref: Es cierto si el fichero es ms reciente que fich_ref (mod).
-name: Nombre de fichero (ojo con wildcards). (-iname).
-type: Tipo de fichero (b, c, d, p, f, l, s, D).
-size: tamao del fichero (unidades: c->bytes, k, M, G).
-user: Nombre del propietario.

rdenes avanzadas
find (4/4)
Acciones (expresin):
-print: Imprime el path del fichero (relativo). (-print0 si se inyecta la salida a
otro programa).
-ls: Imprime listado extendido del fichero.
-delete: Borra el fichero.
-exec command ;: Ejecuta el programa indicado. {} se sustituye por el nombre
de fichero. Ej: find . user benjumea exec file {} \;
Alternativamente (-exec): -execdir, -ok y okdir.

Expresiones regulares
Se usan en determinados programas (grep, sed, awk, entre otros). Ej:
ls la| grep benjumea.
Permiten buscar patrones (OJO: es distinto de los comodines de la
shell).
Grep PATRON [FICHERO]
Opciones: -v: Invertir, -i: ignora maysculas, -f FICH: obtener patrn de un
fichero, -e PATRON: Usar ese PATRON (se puede poner varias veces), -E:
extendido. l (para que indique los ficheros donde est el patrn).

Expresiones regulares
funcionamiento
cadena => se corresponde con esa cadena.
. => Se refiere a cualquier carcter. Ej: grep Ho. fichero qu imprime?
[] => Se refiere a alguno de estos. Permite rangos. Ejs: [Oo]bi[Ww]an, [aA-Zb09]. OJO: Subcadenas?
[^] => Se refiere a alguno que no sean estos.
() => Sirve para agrupar una expresin.
^y $ => Son anclajes para el comienzo y final de lnea. Ej: ^yo solo$
*, +, ?, {n}, {min,} y {min,max} => Repiten lo anterior. Ej: ^\(Alehop \)* HOP$
| => OR. Ej: \(Hola\|Adios\)
\w, \s y \d => letra, espacio (incl. TAB), dgito.
Si se usan expresiones regulares bsicas (frente a las extendidas), hay que
escapar ?, + {, |, ( y ).

rdenes avanzadas
cut: permite extraer campos.

Opciones: -d => Indica el carcter delimitador, -f => Indica el campo.

sort: Permite ordenar.

Opciones: -b (ignorar espacios previos), -f (insensible a maysculas), -k (columna


para ordenar), -n (considerar campo numrico), -r (invertir orden), -t (especifica
separador), -u (sin duplicidades).

Uniq: Similar a sort u.

Opciones:-c (cuenta instancias), -d (muestra solo duplicados), -u (no duplicados.


NOTA: La entrada debe estar preordenada.

Tee: Permite copiar stdin a un fichero y a stdout:


Ej: find . name .bashrc 2> /dev/null | tee /tmp/FILE

Head / tail: permite obtener las primeras o las ltimas lneas de un fichero.
Opciones: -n (indica nmero de lneas), -f (monitorizar fichero).

rdenes avanzadas
Tr: Sirve para sustituir caracteres. tr [OPCIONES] SET1 [SET2]
Opciones: -d (borra lo indicado en SET1), -s (elimina/reemplaza repetidos), -c
(reemplaza los que no son SET1).

sed: Sirve para hacer sustituciones de cadenas (no solo de caracteres): sed
OPCIONES... [SCRIPT] [FICHERO...]
Ej: sed -e s/Anakin/Vader/g (g => global, nada => Solo el primero).
Ej: sed -e s/^\s*//

tar: Serva para escribir en cinta el contenido de un directorio.

Opciones: -c (crear), -x (extraer), -z (comprimir -en GNU-), -x (verbose).


Ej: tar cvf fichero.tar directorio/
Ej: tar xvf fichero.tar
Ej: tar cf - diretorio_origen | cd otro_lugar ; tar xf - (Incluso podra ser remoto).

Shell-scripts
introduccin
Permite programar actividades simples.
Variables importantes:

$? => Valor de retorno (0=>OK).


$1, $2, etc => Parmetros.
$0 => El propio programa.
$# => Nmero de parmetros.
$* y $@ => Todos se corresponde con $1 $2 y con $1 $2

Las shell script comiezan por #!/bin/bash (o lo que sea).


El # es el comentario (hasta final de lnea).
Uso de source y ..

Shell-scripts
condicionales (1/2)
expr1 && expr2: expr2 solo se ejecuta si expr1 se ejecuta con xito.
expr1 || expr2: expr2 solo se ejecuta si expr1 tiene error.
EJ: test r $HOME/.bashrc && echo El fichero existe.
EJ2: test r $HOME/.bashrc || echo El fichero no existe.

test: permite hacer comprobaciones.


[ ]: Se suele usar en vez de test.
Ej: [ -r $HOME/.bashrc]
Ej: [ 1 lt 10 ] => $? cunto vale?
Por tanto [1 lt 10] && echo Es correcto qu hace?

Shell-script
condicionales (2/2)

Fuente: Unix and Linux System Administrator Handbook 4th ed.

Shell-scripts
Funciones
#!/bin/bash
function prueba
{
echo En la funcin de prueba
}
echo Inicio del script. Llamando a la funcion.
prueba
echo Fin.

Shell-script
if-then-else
Permite crear las tpicas estructuras condicionales.
#!/bin/bash

#!/bin/bash

#!/bin/bash

if [ ]; then
------------else
------------fi

if [ ]; then
------------else
if [ ]; then # Anidado
------------fi
----fi

if [ ]; then
------------elif [ ]; then # Else-if
------------else
------------fi

Shell-script
case
Permite evitar el sobreuso de secuencias if-elfif.
case $variable in
opc1) --------;; # Esto es obligatorio
opc2) ------ ;;
*) echo Parametro errneo # esto es un catch-all
exit 1 # Permite salir con error.
;;
esac

Shell-script
bucle for, bucle while
#!/bin/bash

#!/bin/bash

for fichero in *; do
echo Fichero es $fichero
done

while [] ; do
----done

Shell-script
expresiones aritmticas
Permite hacer operaciones aritmticas.
c=$a+$b => c valdr 1+2, o 2+2 o lo que sea (no suma).
c=$($a+$b)) => c valdr la suma de a y b.
Se permite el operador ++
#!/bin/bash
i=0
while read linea; do
i=$(($i+1))
done

echo Numero de lneas es: $i