directorio, o si el parametro no existe.
#!/bin/bash
Error(){
echo "Error. Sintaxis de uso: $0/ archivo | directorio"
}
if test $# -lt 1 then
Error
elif test -d $1 then
echo "$1 es un directorio."
elif test -f $1 then
echo "$1 es un archivo."
else
echo "$1 no existe."
fi
· Escribir un script que al pasarle por argumento un archivo o directorio, devuelva el tamaño
en MB.
#!/bin/bash
# Este script recibe por argumento un archivo o directorio y devuelve el tamaño en MB.
Error(){
echo "Error. Sintaxis de uso: $0/ archivo | directorio"
}
if test $# -lt 1 then
Error
elif test -d $1 then
echo "$1 es un directorio y su tamaño es el siguiente:"
du -hs $1
elif test -f $1 then
echo "$1 es un archivo regular y su tamaño es el siguiente:"
du -hs $1
else echo "$1 no existe."
fi
· 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
· 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
· Recibir un nombre de directorio, validar existencia y condición de directorio y mostrar
nombres de todos los directorios y subdirectorios bajo él.
#!/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
· 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
· 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
· 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
· Usando solamente el archivo /etc/group, escribir los siguientes programas:
o 'grupo1': listar los nombres y números de grupo y la lista de usuarios de cada uno,
ordenados por nombre.
o 'grupo2': igual, ordenados por número de grupo.
o '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`
· Escribir los siguientes programas:
o ligass: muestra los nombres de archivo que son enlaces simbólicos.
o ligash: muestra los archivos que tiene enlaces hard.
o 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 -
· Crear un script de Shell que monte la diskettera, copie todos los archivos (incluyendo
subdirectorios) de la diskettera a un directorio que se pase como parámetro, y luego
desmonte la diskettera. (Ayuda: para copiar tambien los subdirectorios, debe utilizarse un
comando recursivo)
#!/bin/bash
# disketera.sh
mount /floppy
cp -r /floppy $1
umount /floppy
· Crear un script de Shell que liste únicamente los nombres de los directorios que se
encuentran a partir del directorio actual.
#!/bin/bash
# direc.sh
for i in `ls`; do
if [ -d $i ]; then
echo $i
fi
done
· Realizar un script que espere hasta que un determinado proceso se ejecute. Y cuando ese
proceso se ejecuta, matarlo. (Ayuda: utilizar el comando killall).
#!/bin/bash
# kila.sh
while true; do
if ps ax | grep $1 | grep -v ' grep '; then
killall $1
fi
done
· Crear un script que reciba un directorio como primer parámetro, y a continuación una lista
de archivos. El script debe validar que los parámetros recibidos sean realmente archivos y
luego copiarlos al directorio recibido.
#!/bin/bash
# copiadir.sh
if [ -d $1 ]; then
nombre_dir=$1
shift
for i in $*; do
if [ -f $i ]; then
cp $i $nombre_dir
else
echo "El archivo $i no es válido"
fi
done;
else
echo "El primer parámetro debe ser un directorio!"
fi
· Escribir un script que al ejecutarlo como root reinicie el equipo después de 1 minuto.
#!/bin/bash
# Este script reiniciará el equipo después de 1 minuto al ejecutarlo como root.
if [ "$(whoami)" = 'root' ] then
shutdown -r +1
else
echo "El script no se ejecutará porque usted no es usuario 'root'".
fi
· Escribir un script que genere un backup del directorio de trabajo /home/jaime/work cada 5
minutos asignándole el nombre de "backup-hora de generación".
#!/bin/bash
# Este script genera un backup del directorio de trabajo /home/jaime/work
"crontab -e"
*/5 * * * * /home/jaime/work/10
cp -r /home/jaime/work /home/jaime/work/backup_$(date +%H%M%S)
· Escribir un script que encienda el LED del teclado numerico al ejecutar el script desde la
consola tty1 y apague el LED de CAPS (mayusculas).
#!/bin/bash
setleds -D +num >> /dev/tty1
setleds -D -caps >> /dev/tty1
· Escriba un script que elimine un archivo o directorio pasado como parámetro, y le pregunte
si está seguro de llevar a cabo la acción.
#!/bin/bash
rm –r $1
0 comentarios:
Publicar un comentario en la entrada