Curso Básico de UNIX
Programación del Shell
Ejercicios resueltos
Estructura de archivos.
Estructura del archivo /etc/passwd:
#nombre:contraseña:UID:GID:comentarios:dir_propio:shell
jperez:Xdio0IKLLP:1130:103:Juan Pérez:/home/jperez:/bin/bash
Estructura del archivo /etc/group:
#grupo:GID:lista_usuarios
docentes:103:victor,german,fernando
Estructura del archivo /etc/hosts:
#número_IP nombre_máquina alias
10.137.137.250 liebre.cdi.edu.uy liebre localhost
mailhost
Todos los archivos anteriores pueden tener comentarios (líneas
comenzadas por #).
En los sistemas con NIS, para passwd y group usar el
comanto ypcat en lugar de cat para listar estos archivos, o el comando
ypmatch para extraer una línea sola de alguno de ellos. Ejemplos:
ypcat passwd
ypcat group
ypmatch jperez passwd
Nota.
En la construcción de los siguientes programas o 'scripts' se valorará
la presentación interna y externa. En la presentación interna,
importa la indentación, los comentarios, la claridad de los comandos,
la significación de los nombres elegidos; todo esto debe permitir considerar
al programa como 'autodocumentado'. En la presentación externa, importan
las leyendas aclaratorias, ayudas, y avisos de ejecución que favorezcan
al usuario ocasional. Se aconseja colocar los archivos de los programas en
un subdirectorio bin del directorio propio del usuario, donde no deberá
haber otra cosa que estos programas.
1. Recibir un nombre de archivo como parámetro e indicar,
imprimiendo todas las leyendas que correspondan, si el archivo es legible,
modificable y ejecutable por el usuario.
#!/bin/bsh
# carsarch.sh: características de un archivo
echo Caracteristicas del archivo $1
if [ -r $1 ]
then
echo es legible
fi
if [ -w $1 ]
then
echo es grabable
fi
if [ -r $1 ]
then
echo es ejecutable
fi
2. Recibir varios
nombres de archivo como parámetros, y para cada uno validar si el
nombre corresponde a un archivo común existente, y si es así
mostrarlo en pantalla paginando.
#!/bin/bash
# mostrarchs.sh: muestra contenido de varios archivos
for VAR in $*
do
if [ -f $VAR ]
then
more $VAR
else
echo No existe $VAR
fi
done
3. Recibir un nombre de directorio, validar existencia y condición
de directorio y mostrar nombres de todos los directorios y subdirectorios
bajo él, en formato de página largo 23.
#!/bin/bash
# esdir.sh: verifica directorio y muestra contenido recursivo
clear
if [ -d $1 ]
then
echo Directorios bajo $1
echo "Digite Enter para continuar"; read; clear
ls -lR $1 2>/dev/null | grep '^d' | pr -l24 | more -24
# el valor 24 en more es para visualizar en pantalla
else
echo No existe el directorio $1
fi
4. Escribir un programa seaejec que reciba un nombre de
archivo, verifique que existe y que es un archivo común, lo convierta
en ejecutable para el dueño y el grupo y muestre el modo final.
#!/bin/bash
# seaejec: convierte un archivo en ejecutable
#
ARCH=$1
if [ -f $ARCH ] # existe
y es archivo regular
then
chmod ug+x $ARCH
ls -l $ARCH
else
echo "seaejec: el archivo $ARCH no pudo ser convertido"
fi
5. Escribir un programa copiabin.sh que mueva todos los
programas del directorio actual (archivos ejecutables) hacia el subdirectorio
bin del directorio propio del usuario, muestre los nombres de los
que mueve e indique cuántos ha movido o que no ha movido ninguno.
Si el directorio bin no existe, deberá ser creado.
#!/bin/bash
# copiabin.sh: copia archivos ejecutables hacia $HOME/bin
#
# si el directorio bin no existe lo crea
if [ ! -d $HOME/bin ]
then
mkdir $HOME/bin
fi
# copia de archivos
N=0 # contador
de archivos copiados
for ARCH in *
do
if [ -x $ARCH -a -f $ARCH ] # ejecutable y archivo común
(no directorio)
then
cp $ARCH $HOME/bin
echo " $ARCH fue copiado a $HOME/bin"
N=`expr $N + 1`
fi
done
if [ $N -eq 0 ]
then
echo "No se copió ningún archivo"
else
echo "Fueron copiados $N archivos"
fi
6. Usando el archivo /etc/passwd escribir el programa usuarios
que lista los nombres de login, el directorio propio del usuario y el intérprete
invocado por defecto de todos los usuarios, ordenados alfabéticamente
por nombre de login.
# usuarios: lista datos de usuarios
#
echo "Nombres de usuarios, Directorio propio, intérprete de comandos"
ypcat passwd | cut -d: -f1,6,7 | sort | more
echo
7. Usando solamente el archivo /etc/group, escribir los siguientes
programas:
a) 'grupo1': listar los nombres y números de grupo y la lista de
usuarios de cada uno, ordenados por nombre.
b) 'grupo2': igual, ordenados por número de grupo.
c) 'grupo3': reúne las dos salidas anteriores, con leyendas explicativas
adecuadas para cada parte y para cada columna, así como nombre de la
máquina y fecha del día.
#!/bin/bash
#
# grupo1:
clear
echo "Grupos por nombre:"
echo ---------------------------------------------------------
echo "login:número_de_grupo:lista de usuarios"
echo ---------------------------------------------------------
ypcat group | cut -d: -f1,3,4 | sort | more -18
echo ---------------------------------------------------------
echo Digite Enter para continuar
read
clear
#!/bin/bash
#
# grupo2:
echo "Grupos por número:"
echo ---------------------------------------------------------
echo "login:número_de_grupo:lista de usuarios"
echo ---------------------------------------------------------
ypcat group | cut -d: -f1,3,4 | sort -t: -n +1 | more -18
echo ---------------------------------------------------------
echo
#!/bin/bash
#
# grupo3:
clear
./grupo1
echo
./grupo2
echo
echo Máquina: `hostname`
echo Fecha: `date`
8. Escribir un programa usugrup que dado un nombre de
login de usuario determine si existe en el sistema, y si es así, presente
su nombre de usuario, , número de usuario (UID), grupo primario y
grupos secundarios si los tiene, con leyendas adecuadas.
#!/bin/bash
# usugrup: datos y grupos de un usuario
#
USUARIO=$1
id $USUARIO 1>/dev/null 2>&1
ERROR=$?
if [ $ERROR -ne 0 ]
then
echo "El usuario " $USUARIO "no existe"
exit
fi
NOMBRE=`id $USUARIO | cut -f1 -d" "`
echo \(UID\) y nombre: $NOMBRE
GRUPO1=`id $USUARIO | cut -f2 -d" "`
echo \(GID\) y grupo primario: $GRUPO1
if test `id $USUARIO | tr " " "\n" | wc -l` -gt 2
then
GRUPOS2=`id $USUARIO | cut -f3 -d" "`
echo \(GIDs\) y grupos secundarios: $GRUPOS2
fi
9. Escribir un programa grupusu que dado un nombre de
grupo determine si existe en el sistema, y si es así, presente su
nombre, número de grupo (GID), y lista de usuarios que pertenezcan
a él, ya sea como grupo primario (en /etc/passwd) o como grupo secundario
(lista en /etc/group).
#!/bin/bash
# determina usuarios en un grupo
GRUPO=$1 # nombre de variable significativo
EXISTE=`ypcat group | grep "^$GRUPO"`
if [ ! $EXISTE ]
then
echo "El grupo $GRUPO no existe."
exit
fi
# extrae número del grupo
GID=`echo $EXISTE | cut -d: -f3`
echo "El número del grupo $GRUPO es $GID"
# busca usuarios con este grupo primario
echo Usuarios en este grupo como primario:
# corta campos usuario e id grupo,
# selecciona líneas con $GID al final,
# luego corta el GID, deja nombre usuario
ypcat passwd | cut -d: -f1,4 | grep :$GID$ | cut -d: -f1
# busca usuarios con este grupo secundario
echo Usuarios en este grupo como secundario: echo $EXISTE | cut -d: -f4
| tr "," " "
10. Escribir los siguientes programas:
a) ligass: muestra los nombres de archivo que son enlaces simbólicos.
b) ligash: muestra los archivos que tiene enlaces hard.
Ambos programas reciben un nombre como como parámetro, y validarán
que corresponda a un directorio del sistema.
#!/bin/bash
# ligass: lista archivos que son enlace simbólico o tienen enlaces
hard
# simbólicos: en ls -l se busca que empiece con l
if [ ! -d $1 ]
then
echo Error: ligas: $1 no es un directorio
exit
fi
echo Archivos que son enlace simbólico:
ls -l | grep "^l" | cut -56 -
echo
# hard: se busca 3 espacios y distinto de 1 como contador de enlaces
echo Archivos que tienen enlace hard:
ls -l | grep -v "^d" | cut -c11 - | grep -v "^ 1" | cut -c46 -
*11. Escribir un programa saludo que, según la
hora, escriba el saludo correspondiente al nombre de pila del usuario. En
el archivo /etc/passwd los usuarios deben estar ingresados con nombre y apellido
separados por blanco. Los saludos corresponden a las siguientes horas: Buenos
días, de 05:00 hasta 12:59; Buenas tardes, de 13:00 hasta 19:59; Buenas
noches 20:00 hasta 04:59. Ejemplo de mensaje: Buenos días, Juan.
A efectos de pruebas, se recibirán la hora y el nombre de login
como parámetros, dejando comentados los comandos donde se extrae la
hora real y se toma el usuario real.
#!/bin/bash
# saludo.cmd
# script en UNIX que saludo al usuario por su nombre
NOMBRE=`cat /etc/passwd | grep "^$LOGNAME" | \
cut -d: -f5 | cut -d' ' -f1`
# si el usuario no tiene ingresado un nombre, toma "Nadie"
NOMBRE=${NOMBRE:-Nadie}
HORA=`date | cut -c12-13 | tr -d ' '`
if expr "$HORA" \<= 5 > /dev/null
then
echo 'Buenas noches, '$NOMBRE
elif expr "$HORA" \<= 12 > /dev/null
then
echo 'Buenos dias, '$NOMBRE
elif expr "$HORA" \<= 19 > /dev/null
then
echo 'Buenas tardes, '$NOMBRE
elif expr "$HORA" \<= 24 > /dev/null
then
echo 'Buenas noches, '$NOMBRE
fi
12. Un script de respaldo produce, entre otros mensajes, líneas
del tipo
"Total bytes written 18804023"
Guarda su salida en el archivo respaldo.error. Escribir un script
total.cinta que sume los bytes grabados e indique el total en bytes,
Mb y Gb.
Crear un archivo respaldo.error de prueba, con un contenido tal
como
Total bytes written 1800
Total bytes written 1000
#
# total.cinta: cantidad de bytes grabados en cinta
#
TOTAL=0
LISTA=`cat respaldo.error | tr -dc "[0-9] "`
for NUM in $LISTA
do
TOTAL=`expr $TOTAL + $NUM`
done
echo "Total General de bytes respaldados: "$TOTAL
TOTALMB=`expr $TOTAL \/ 1000000`
echo "Total General de MB respaldados: "$TOTALMB
TOTALGB=`expr $TOTALMB \/ 1000`
echo "Total General de GB respaldados: "$TOTALGB
Víctor A. González Barbone vagonbar en fing edu uy
Instituto de Ingeniería Eléctrica
- Facultad de Ingeniería - Montevideo,
Uruguay.