Administración de usuarios y grupos en GNU/Linux

● Docente: Carmine Fernando
● Correo: fcarmine@udc.edu.ar
● Duración: Cuatrimestral
● Ciclo Lectivo: 2021
● 2° Cuatrimestre

Contenidos de la unidad
Unidad 1. Repaso de comandos. Scripting en GNU/Linux.
Administración de usuarios y grupos. Comandos: useradd, usermod,
userdel, groupadd, groupmod, groupdel. Administración de permisos de
usuario.
Comandos: chmod, chown, chgrp. Manipulación de archivos.
Comandos: mv, cp, rm, file, du, less, more, grep, cat, tail, head, cut,
diff, grep. Empaquetado y desempaquetado de archivos. Comando: tar.
Compresión y descompresión de archivos. Comandos, gzip, gunzip, rar,
unrar, zip, unzip, gzip2, tar. Administración de filesystem.
Comandos: fdisk, mkfs, fsck, mount, umount. Pipelines de comandos.
Lenguajes compilados y lenguajes interpretados. Conceptos y bondades
del Scripting. Intérpretes de comandos. Scripting en bash: variables,
estructuras condicionales y repetitivas, funciones, librerías. Scripts
como herramienta para el administrador.

Administración de usuarios y grupos
GNU/Linux es un sistema:
● Multiusuario: varias personas pueden trabajar con el sistema, que
proporciona mecanismos de protección de datos de cada usuario.
● Multitarea: varios procesos (de varios usuarios) pueden ejecutarse a
la vez
● De tiempo compartido: los procesos se ejecutan todos todo el tiempo
– Cuenta de usuario: datos e información de cada usuario.
Cada usuario posee un nombre de usuario y una clave para acceder
al sistema.
– Grupo de usuarios: cada usuario puede pertenecer a uno o varios
grupos
– Permisos: sistema de protección de datos de un usuario respecto
de otros.

Características de las cuentas de Usuario:
– Nombre de usuario (“username”)
Identifica al usuario dentro del sistema (cada usuario lleva
asociado un número de identificación)
– Clave (password)
para acceder al sistema
– Grupo principal del usuario
En Ubuntu “por defecto” se crea un grupo de mismo nombre que el
“username”
– Carpeta personal
Donde el usuario guarda sus propias carpetas y archivos (por
defecto en /home/username)
– Otros grupos a los que pertenezca el usuario

Configuración del sistema → Cuentas de usuario
– Configuración del usuario propio
– Configuración básica de otros usuarios (administrador)
– Añadir/eliminar usuarios

● Añadir usuarios:
– # adduser <username>
● Asignar un usuario a un grupo
– # adduser <username> <groupname>
● Borrar usuarios:
– # userdel <username>
● Añadir grupos:
– # addgroup <groupname>
● Borrar grupos:
– # groupdel <groupname>
Administración de usuarios y grupos en
interfaz de comandos

Modificando propiedades de los usuarios y grupos
(usermod, groupmod). Ejemplos:
# usermod -d /home/profes/pepe -m
cambia la carpeta del usuario pepe a /home/profes/pepe.
-m hace que se mueva todo el contenido.
# usermod -l joseg pepe:
cambia nombre de usuario pepe por joseg.
# usermod -g profes pepe
cambia grupo principal del usuario pepe a profes.
# groupmod -n profesores profes
cambia el nombre del grupo profesores a profes
Administración de usuarios y grupos en
interfaz de comandos

● Desde el administrador de archivos
– Menú contextual -> Propiedades -> Permisos
● Cambiar propietarios de archivos/carpetas
– chown [-R] <usuario> <ruta>
– chown [-R] <usuario>:<grupo> <ruta>
● Cambiar grupo de un archivo/carpeta
– chgrp [-R] <grupo> <ruta>
Cambios de propietario/grupo

● Opciones por defecto al crear usuarios:
– /etc/adduser.conf
● Contenido inicial de las nuevas cuentas de usuarios:
– /etc/skel
● Ficheros con información sobre usuarios y grupos.
Normalmente no se editan “a mano”
– /etc/passwd: Usuarios, ID, grupo principal, carpeta inicio,
shell, etc.
– /etc/shadow: contiene los passwords encriptados de los
usuarios.
– /etc/group: Grupos, miembros de cada grupo.
– Se usa “vipw” y “vigr” para editarlos con seguridad
Gestión de usuarios y grupos.
Archivos de configuración

● Usuarios y/o grupos empleados por el sistema para realizar tareas
concretas con privilegios restringidos
– cupsys: administrador de impresoras
– mail: gestor de correo
– www-data: servidor web
– ...
● Grupos para el control de privilegios
– cdrom: control de las unidades de cd o dvd
– floppy: control de las unidades de diskette
– audio: control de los dispositivos de audio
– admin: dota de permisos de administrador del sistema a sus
miembros (a través de sudo)
Usuarios y grupos especiales

● Superusuario = administrador = root
● Superusuario -> privilegios ilimitados
● Los sistemas GNU/Linux se configuran para realizar el mínimo de
tareas empleando el superusuario
● Convertirse en otro usuario
– $ su [-] <nuevo_usuario>
● Ejecutar un comando como superusuario (sólo usuarios grupo “sudo”)
– $ sudo ...
● Convertirse en root permanentemente
– $ sudo -s
– $ sudo su
Usuarios y grupos especiales.
Superusuario

Permisos
● Cada archivo/carpeta tiene un propietario y está asignado a un
grupo (al que normalmente pertenece el propietario)
● Cada archivo/carpeta posee tres conjuntos de permisos que
controlan el acceso de:
– El propietario (user)
– Miembros del grupo al que pertenece el archivo (group)
– Otros usuarios (other)

Permisos
El primer bit indica el tipo de archivo. Generalmente pueden darse los
siguientes casos:
- | Se trata de un archivo regular
d | Se trata de un directorio
l | Se trata de un enlace simbólico
b | Se trata de un archivo especial de bloques
El resto de los 9 bits que vienen a continuación representan los permisos
del propietario del fichero o directorio, los del grupo al que pertenece
este usuario, y los del resto de usuarios. Aquí tienes el significado:
r | Se dan permisos de lectura
w | Se dan permisos de escritura
x | Se dan permisos de ejecución
- | No se da el permiso de lectura, escritura o ejecución

Permisos
Notación simbólica o nemónica de permisos
Sintaxis:
chmod [ugoa] [-+=] [rwx]
Ejemplos:
chmod u+x archivo.txt
chmod u-w archivo.txt
chmod a+x archivo.txt
chmod g-rw archivo.txt

Permisos
Cambiar de propietario:
sudo chown <usuario> (archivo o carpeta)
sudo chown <usuario> -R <carpeta> (carpeta y todo su contenido)
Si queremos cambiar de Grupo:
sudo chgrp <grupo> <carpeta> (archivo o carpeta)
sudo chgrp <grupo> -R <carpeta> (carpeta y todo su contenido)
Si queremos cambiar de Usuario y Grupo a la vez emplearemos:
sudo chown usuario:grupo <carpeta> (archivo o carpeta)
sudo chown usuario:grupo -R <carpeta> (carpeta y todo su contenido)
Si deseamos cambiar los Privilegios de algún directorio o carpeta
tenemos:
sudo chmod <permisos> <opciones> <archivo o carpeta>
sudo chmod +x foo.sh (dar permisos de ejecución)

Programación - Repaso
Lenguaje de Programación C
● Acceso a memoria de bajo nivel (punteros)
● Interrupciones al procesador
● Conjunto reducido de palabras clave
● Paso de parámetros por valor
● Paso por referencia, pasando direcciones de memoria
● Punteros a funciones y variables estáticas
● Tipos de datos primitivos
● Tipos de datos agregados (struct)

Características de C
● Núcleo del lenguaje simple, con funciones añadidas mediante
bibliotecas
● Funciones matemáticas
● Funciones de manejo de archivos
● Funciones de manejo de cadenas
● Lenguaje flexible. Permite programar con múltiples estilos
● Sistema de tipos que impide operaciones sin sentido
● Lenguaje preprocesado

/* Programa en Lenguaje C. Imprime un texto en pantalla
*/
#include <stdio.h>
#include <stdlib.h>
int main() {
printf(“Hola mundo!!n”);
system("pause");
return 0;
}

Compilación vs. Interpretación
Lenguajes compilados
● Su código fuente necesita ser compilado.
● El proceso de compilación crea un archivo binario traducido a
código máquina.
● Este archivo binario será el ejecutable (programa).
Lenguajes interpretados
● Su código no necesita ser preprocesado mediante un compilador.
● Un programa (intérprete) traduce cada instrucción a código
máquina.
● El intérprete lee una instrucción y la traduce. Así hace con
cada una.
● El archivo de código fuente y el ejecutable son el mismo.

Compilados vs. interpretados:
características
Compilados
● Son más rápidos pues están totalmente traducidos a código máquina.
● Los errores sintácticos se detectan en tiempo de compilación.
● Para ejecutarlo solo es necesario contar con el binario o ejecutable.
● Para compilarlos es necesario contar con un programa compilador.
● Deben ser compilados para cada plataforma.
Interpretados
● No ocultan el código fuente. Siempre debe ser accesible.
● Necesitan del programa intérprete en la máquina en la que se van a
ejecutar.
● Suelen ser más lentos que los compilados.

Algunos lenguajes interpretados

¿Qué es Shell?
● Es el intérprete de comandos o intérprete de órdenes
● Es la interfaz entre el usuario y el sistema operativo.
● Shell significa "caparazón"
● Actúa como intermediario entre el sistema operativo y el
usuario
● Interpreta comandos, los transmite al sistema y arroja
resultados
● Existen varios tipos de shells en Linux
● Nosotros usaremos bash

Algunos shells en Linux
Las diferentes distribuciones de Linux incorporan variedad de
terminales. Lo
tipos principales son los siguientes:
● Shell Bourne (sh)
● C-Shell (csh)
● Shell job (jsh)
● Shell Korn (ksh)
● Bourne Again Shell (bash)

Hola mundo en bash
# Programa en Lenguaje bash. Imprime un texto en pantalla
#!/bin/bash
echo Hola Mundo!
$ chmod +x script.sh

Bash scripting
Es la técnica de uso y escritura de scripts. Nos centraremos en
scripts
bash:
● Variables
● Estructuras selectivas
● Estructuras repetitivas
● Funciones
● Librerías

Bash: Uso de variables
Definiendo una variable:
#!/bin/bash
MENSAJE=" ”Hola Mundo...” "
echo $MENSAJE
Usando variables de entorno:
#!/bin/bash
echo “Soy el usuario $USER”
Asignado resultados de comandos a variables:
#!/bin/bash
MIS_ATRIBUTOS=`/bin/ls -l $0`
echo "Los atributos del script son: $MIS_ATRIBUTOS”

Bash: Uso de variables
Las variables son NO TIPADAS: es un lenguaje débilmente tipado:
VARIABLE_1=Hola
Variable_1=”Hola mundo”
N=127 N=$Variable1
Las variables son globales por defecto. Para declarar variables locales
se antepone la palabra reservada local:
local NOMBRE="Jose"
echo "Hola señor $NOMBRE.

Asignado Resultados De Comandos A
Variables
#!/bin/bash
ATRIBUTOS_SCRIPT=`/bin/ls -l $0`
echo "El usuario '$USERNAME' ha ejecutado el script $0, en el ordenador
'$HOSTNAME'. "
echo "Los atributos del script son: "
echo $ATRIBUTOS_SCRIPT

Variables Numéricas
#!/bin/bash
let A=100
let B=200
let C=$A+$B
echo "A: $A | B: $B | C: $C"

Usando Caracteres Especiales En
Variables
#!/bin/bash
MENSAJE=""Hola Mundo ...""
echo "El valor de la variable $MENSAJE es $MENSAJE"
tendremos que usar el simbolo '' delante de las variables

Parámetros de un script
Un Script puede recibir argumentos por línea de
comando
Estos argumentos son llamados “parámetros”
Veamos dos categorías de ellos:
Parámetros posicionales
Parámetros especiales.

Parámetros posicionales
Podemos pasarle a un script parámetros cuando es invocado:
Parámetro Contenido
---------------------------------------------------------------------------
$0
Nombre del script tal como es invocado
$1
Primer parámetro
$2
Segundo parámetro
$3
Tercer parámetro
$4
Cuarto parámetro
$5
Quinto parámetro
...
$9
Noveno parámetro
${10}
Décimo parámetro

Parámetros posicionales: ejemplos
#!/bin/bash
# muestra algunos de los parámetros recibidos
echo "El 1er parámetro es: $1"
echo "El 3er parámetro es: $3"
echo "El 9no parámetro es: $9"
Invocación:
./muestra_param.sh 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
El 1er parámetro es: 1
El 3er parámetro es: 3
El 9no parámetro es: 9

Parámetros especiales
Parámetro Uso
------------------------------------------------------------
$0 Contiene el nombre del script tal como es invocado
$* El conjunto de todos los parámetros en un solo argumento
$@ El conjunto de argumentos, un argumento por parámetro
$# El número de parámetros pasados al script
$? El código de retorno del último comando
$$ El PID del shell que ejecuta el script
$! El PID del último proceso ejecutado en segundo plano

Parámetros especiales: Ejemplos
#!/bin/bash
#params.sh
#muestra el nombre del script
#y la cantidad de parámetros
echo "El nombre del script es: $0"
echo "He recibido $# parámetros"
Invocado:
./params.sh 1 2 3 cuatro 5 seis
El nombre de mi script es: ./params.sh
He recibido 6 parámetros
./params.sh hola mundo
./params.sh “hola mundo”

#!/bin/bash
#mi_ping.sh
#utilizo parámetro especial $?
IP=$1
ping $IP
if [ $? -eq 0 ];then
echo “OK, host activo”
else
echo “Alerta, host no responde”
fi
Invocado:
./mi_ping.sh localhost
Ok, host activo
./mi_ping.sh 192.168.0.1
Alerta, host no responde

Comillas simples '
#!/bin/bash
#Lo que contiene literalmente
MENSAJE= ‘Hola $USER’
echo $MENSAJE
Comillas dobles “
#!/bin/bash
#Sustituye lo que contiene
MENSAJE= “Hola $USER”
echo $MENSAJE
Comillas invertidas `
#!/bin/bash
#Devuelve la salida del comando entre las comillas invertidas
USUARIOS=`who | wc -l`
echo $USUARIOS

Funciones
Sirve para organizar un script en unidades lógicas de manera que sea más
fácil mantenerlo y programarlo.
En Bash las funciones se pueden deﬁnir de la siguiente manera:
function nombre_de_funcion(){
comandos_del_shell
}

Funciones
Un ejemplo de función en un script:
#!/bin/bash
let A=100
let B=200
# Suma los variables A y B
function suma(){
let C=$A+$B
echo "Suma: $C"
}
# Resta los variables A y B
function resta(){
let C=$A-$B
echo "Resta: $C"
}
suma
resta

Comparación de cadenas
Operador Verdad (TRUE) si:
-----------------------------------------------------------------------
cadena1 = cadena2 cadena1 es igual a cadena2
cadena1 != cadena2 cadena1 no es igual a cadena2
cadena1 < cadena2 cadena1 es menor que cadena2
cadena1 <= cadena2 cadena1 es menor o igual que cadena2
cadena1 > cadena 2 cadena1 es mayor que cadena 2
cadena1 >= cadena 2 cadena1 es mayor o igual que cadena 2
-n cadena1 cadena1 no tiene valor nulo (longitud > 0)
-z cadena1 cadena1 tiene un valor nulo (longitud = 0)

Comparación de valores numéricos
------------------------------------------------------------------------------------------------------------------
x -eq y x equal than y x igual que y
x -ne y x not equal than y x no igual que y
x -lt y x less than y x menor que y
x -le y x less or equal than y x menor o igual que y
x -gt y x grather than y x mayor que y
x -ge y x grather or equal than y x no igual que y

--------------------------------------------------------------------------------------------------------------------------------------
-d archivo archivo existe y es un directorio
-e archivo archivo existe
-f archivo archivo existe y es un archivo regular (no es especial)
-r archivo hay permiso de lectura en archivo
-s archivo archivo existe y no está vacío
-w archivo hay permiso de escritura en archivo
-x archivo hay permiso de ejecución en archivo (o de búsqueda si es d)
-O archivo quien ejecuta es dueño del archivo
-G archivo el grupo del archivo es igual al grupo de quien ejecuta
archivo1 -nt archivo2 archivo1 es más reciente que archivo2
archivo1 -ot archivo2 archivo1 es más antiguo que archivo2

Comparaciones lógicas
Operador Ejemplo de Uso
---------------------------------------------------------------------------------------------------------------------------------
&& and lógico if [[ $1 = $2 && $# = 2 ]]; then
|| or lógico if [[ $# = 1 || $# = 2 ]]; then
OTRA OPCIÓN PARA EXPRESAR LO MISMO
---------------------------------------------------------------------------------------------------------------------------------
-a and lógico if [ $1 -eq $2 -a $# -eq 2 ]; then
-o or lógico if [ $# -eq 1 -o $# -eq 2 ]; then

Comentarios en bash
Símbolo Ejemplo de uso:
--------------------------------------------------------------------------------------------------------
# #Esto es una línea comentada
: ‘’ : ‘ Esto es un bloque comentado
Más de una línea ‘

Operadores
Operador Ejemplo de uso:
----------------------------------------------------------------------------------------------
+ SUMA=$(( A + B ))
- DIF=$(( A - B ))
* PROD=$(( A * B ))
/ DIV=$(( A / B ))
% MOD=$(( A % B ))

Bash scripting
Para controlar el ﬂujo de ejecución de un script:
Selectivas:
● if / else: Ejecuta una serie de comandos dependiendo de una condición
● case: Ejecuta una serie de comandos dependiendo del valor de una variable.
Repetitivas:
● for: Ejecuta una serie de comandos un número determinado de veces.
● while: Ejecuta una serie de comandos mientras una condición se cumpla.
● until: Ejecuta una serie de comandos hasta que una condición se cumpla.
● select: Permite al usuario elegir una opción de un menú de opciones.

Bash: Estructuras selectivas
● Implica la ejecución selectiva de código.
● Se puede elegir entre ejecutar una porción de código u otra, dependiendo de
determinada condición.
● Las condiciones tienen determinado valor de verdad (verdadero o falso).
● La ejecución condicional, les da potencia y dinamismo a los scripts.
● En bash tenemos if y sus variantes y case.

Estructuras selectivas: if / then / else
Sintaxis:
if [ condicion ]; then
#si condicion es VERDADERA
fi
--------------------------------------------------------
if [ condicion ]; then
else
#si condicion es FALSA
fi
Sintaxis:
if [ condicion ]
then
fi
--------------------------------------------------------
if [ condicion ]
then
else
#si condicion es FALSA
fi

#!/bin/bash
#
# Comprobando terminación de un comando
#
DIRECTORIO="/tmp/test"
COMANDO="/bin/mkdir $DIRECTORIO"
if $COMANDO then
echo "$DIRECTORIO ha sido creado"
else
echo "$DIRECTORIO no pudo ser creado"
ﬁ

#!/bin/bash
#
# Comparacion de cadenas alfanuméricas
#
CADENA1="uno"
CADENA2="dos"
CADENA3=""
if [ $CADENA1 = $CADENA2 ]; then
echo "$CADENA1 es igual a $CADENA2"
elif [ $CADENA1 != $CADENA2 ]; then
echo "$CADENA1 no es igual a $CADENA2"
ﬁ
if [ -z $CADENA3 ]; then
echo "$CADENA3 esta vacia"
ﬁ

#!/bin/bash
#
# Comparacion de valores numericos
#
let NUM1=1
let NUM2=2
let NUM3=3
if [ $NUM1 -ne $NUM2 ] && [ $NUM1 -ne $NUM3 ]; then
echo "$NUM1 es diferente a $NUM2 y $NUM3"
ﬁ
if [ $NUM1 -lt $NUM3 ]; then
echo "$NUM1 es menor que $NUM3"
ﬁ

Estructuras repetitivas: for
Ejemplo 1:
#!/bin/bash #!/bin/bash
for i in $( ls ); do
echo item: $i
done
Ejemplo 2:
for nro in `seq 1 10`; do
echo $((nro * 5))
done

Estructuras repetitivas: for
#!/bin/bash
for HOST in www.google.com www.altavista.com www.yahoo.com
do
echo "-----------------------"
echo $HOST
echo "-----------------------"
/usr/bin/host $HOST
echo "-----------------------"
done

Estructuras selectivas: case
Ejemplo 1:
read x
case $x in
1)echo "uno";;
2)echo "dos";;
*)echo "no sé";;
esac
Ejemplo 2:
read color
case $COLOR in
azul) echo "Es azul";;
rojo) echo "Es rojo";;
verde) echo "Es verde";;
*) echo "no sé";;
esac

Estructuras repetitivas: while
Ejemplo 1:
#!/bin/bash
c=1
while [ $c -le 5 ]; do
echo "Bienvenido $c veces"
c=$(( $c + 1 ))
done
Ejemplo 2:
#!/bin/bash
c=1
while [ $c -le 5 ]; do
echo "Bienvenido $c veces"
c=$(( $c + 1 ))
done

Estructuras repetitivas: until
Ejemplo 1:
#!/bin/bash
contador=20
until [ $contador -lt 10 ]; do
echo valor actual $contador
contador= $(( contador - 1 ))
done
Ejemplo 2:
read -p "Ingrese un valor: " a
until [ $a -le 0 ]
do
echo "a is ${a}"
a=$((a-1))
done

Estructuras repetitivas: select
Ejemplo 1:
#!/bin/bash
OPCIONES="Hola Salir"
select opt in $OPCIONES; do
case $x in
"Hola" ) echo "Hola Mundo";;
"Salir" ) echo "Saliendo"; exit;;
*) echo "Opción incorrecta";;
esac
done

Funciones en Bash
Ejemplo 1:
#!/bin/bash
function salir {
exit
}
function hola {
echo ¡Hola!
}
hola
salir
Ejemplo 2:
#!/bin/bash
function mensaje {
echo $1
}
mensaje “hola a todos”
mensaje “Chau adios”
salir

Librerías en Bash
Ejemplo 1:
#!/bin/bash
# mi_libreria.sh
function mensaje {
echo $1
}
function hola {
echo ¡Hola!
}
function salir {
exit
}
Ejemplo 2:
#!/bin/bash
source mi_libreria.sh
mensaje “hola a todos”
mensaje “Chau adios”
salir

Archivos de configuración de bash
Existen, eventualmente, tres archivos en el directorio home
.bas_profile
.bas rc
.bas_logout
Se utilizan para definir variables y/o ejecutar comandos al ingresar al sistema, cuando se invoca un nuevo
shell o al cerrar la sesión
Pueden existir o no dependiendo de como se creo la cuenta de usuario.
Si no existen, el usuario utilizará sólo el archivo de sistema
/etc/profile, o puede optar por editarlos él mismo
El más importante es .bas_profile, el cual es leído por el shell para ejecutar los comandos que contiene cada
vez que se ingresa al sistema

Algunas líneas de .bas_profile
PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/local/bin
SHELL=/bin/bas
MANPATH=/usr/man:/usr/X11/man
EDITOR=/usr/bin/vi
PS1=' :w '
PS2='S '
set -o ignoreeof
export EDITOR
Si se agregan nuevas líneas no serán consideradas hasta que el archivo .bas_profile sea leído/ejecutado
nuevamente, reingresando al sistema, por ejemplo
Comando source: Ejecuta los comandos en el archivo especificado
source .bas_profile
Alternativa para source comando, utilizar el comando punto (.)
./bas_profile

bash admite dos sinónimos para .bas_profile:
-.bas _login, derivado del archivo .login de C shell
-.profile, derivado del archivo .profile del Bourne shell y el Korn shell
Se lee sólo uno de estos al ingresar al sistema
Orden: .bas _profile → .bas _login → .profile
.bas rc puede o no existir
AI iniciar un nuevo sheII (un subsheII) se Ieerán Ios comandos de .bas rc
Separación de comandos de inicio y de personalización de shell
Si .bas rc no existe entonces no se ejecutarán cuando se inicia un subshell

•.bas _logout es leído y ejecutado cada vez que se sale del login
shell
•Brinda la capacidad de ejecutar comandos, como eliminar archivos
temporarios
• Generalmente hay que definirlo mediante edición manual
• Si no existe, no se ejecutarán comandos extra a la salida

Alias
•A veces la sintaxis de los comandos es difícil de recordar, especialmente si se utilizan
con varias opciones y argumentos
• Alias = sinónomo enriquecido
• Los alias pueden definirse en línea de comandos, en el .bas_profile, o en .bas
rc, mediante:
alias [name=command] // sin espacios entre el signo =
• Ejemplos: $ alias lf='ls -F'
$ alias revsort='ls [0-9]* | sort -v'
• Notas:
- Se permite definir un alias de un alias
- No están permitidos los alias recursivos $ alias ls='ls -la'
- Los alias sólo pueden usarse al principio de un comando (existen excepciones)
$ alias pkgs=/var/sadm/pkg
$ alias cd='cd '

Caracteres especiales
• Conocidos también como metacaractes
• Los metacaracteres poseen significado especial para el shell
•Existen diversas categorías de acuerdo a la funcionalidad con que estén
relacionados
• Ejemplos:
$ cd -/libros
$ rm *.bck
$ find / -name a* &

El carácter de escape
• Es el carácter (backslash)
• Evita que el siguiente carácter sea interpretado por el shell
$ echo $1234
234
$ echo $1234
$1234
•Excepción: newline, esta secuencia se interpreta como continuación de línea eliminando
posteriormente esta secuencia de la entrada del comando
• Ejemplo:
$ echo Texto escrito en
> mas de una linea
Texto escrito en mas de una linea

Comillas dobles
• Los caracteres encerrados entre comillas dobles preservan su valor literal
• También se conoce como Weak quoting o Partial quoting
• Los caracteres * y @ tienen un significado especial cuando se encierran con
comillas dobles
• Excepciones:
- $ y ' siguen manteniendo sus significados especiales
- sigue manteniendo su significado especial sólo si antecede los caracteres
, ', “, o newline.
• Ejemplos:
$ echo “El reloj tiene un valor de $123”
El reloj tiene un precio de 23
$ echo “El reloj tiene un valor de $123”
El reloj tiene un precio de $123
$ echo “Es un vino con buen 'bouquet'”
Es un vino con buen 'bouquet'

Comillas simples
• Los caracteres encerrados entre comillas simples preservan su valor literal
• No se permite la desreferencia de variables entre comillas simples
• No puede aparecer una comilla simple entre dos comillas simples
• También se conoce como Strong quoting o Full quoting
• Excepción: newline
• Ejemplos:
$ VAR=10
$ echo '$VAR'
$VAR
$ echo 'd* = el carácter <d> seguido de cualquier cadena, inclusive la vacía'
$ echo 'La comilla simple (') también es llamado aopostrofo'

ANSI-C Quoting
•Las cadenas de la forma 'texto' son consideradas de manera especial
La cadena se expande a texto con los caracteres de escape
reemplazados como lo especifica el estándar ANSI-C
a alerta (alerta)
b retroceso (backspace)
n nueva línea (new line)
t tab horizontal (horizontal tab)
v tab vertical (vertical tab)
barra invertida (backslash)
• Ejemplos:
$ echo Barra invertida = $''
Barra invertida =
$ echo Se oye .... $'a'
Se oye .... (beep)
$ echo Hola '$n' Mundo
Hola
Mundo

Ejemplos combinados
$ echo <-$1250.**>; (update?) [y|n]
$ echo <-$1250.**>; (update?) [y|n]
$ echo '<-$1250.**>; (update?) [y|n]'
$ echo La variable '$UID' contiene el valor --> "$UID"
La variable $UID contiene el valor --> 1002

Variables
• Es posible almacenar en una variable el resultado de la ejecución de un comando.
- Con (...): anidable
$ lista_de_archivos=$(ls)
$ lista_de_archivos=$(ls $(cat directorios.txt))
• Referencia indirecta: Si el valor de una variable es el nombre de una segunda podemos recuperar el
valor de la segunda a través la primera
$ dosmil=numero
$ numero=2000
$ echo $dosmil #referencia directa
numero
$ eval echo $$dosmil #referencia indirecta
2000

Variables de shell y entorno
• Variables Locales
- Presentes en la instancia actual del shell
- No disponibles para programas iniciados desde el shell (no exportadas)
• Variables de Entorno
- Disponibles por todo proceso hijo del shell
- Muy útiles para la escritura de scripts y programas
- Pueden visualizarse mediante el comando env
- Se pueden agregar variables al entorno mediante export
- Nombres en mayúsculas por convención
• Variables de Shell
- Establecidas y utilizadas por el shell para su funcionamiento
- Algunas son variables de entorno otras son locales
- Pueden visualizarse mediante el comando set
- Convencionalmente tienen nombres en mayúsculas
PWD UID SHLVL PATH
HOME IFS (Internal Field Separator)

Variables enteras
• Las variables enteras en Bash son enteros con signo (32 bits)
• Posibilidad de overflow
• Bash por sí mismo no comprende la aritmética de punto flotante
•Bash considera a los números conteniendo punto decimal como cadenas
•Utilizar el lenguaje bc en los scripts si es necesario realizar cálculos de punto flotante o emplear funciones
matemáticas de bibliotecas
• Ejemplos:
$ echo "2.35 + 56.90" | bc > 59.25
$ echo "sqrt(2)" | bc > 1
$ echo "sqrt(2.0)" | bc > 1.4

Arrays
• Un array es una serie de casillas, cada una conteniendo un valor
• Casilla = elemento, los elementos se acceden mediante índices
• Los índices comienzan en 0 hasta más de 5 mil billones
• En bash son únicamente uni-direccionales
• Asignaciones:
$ colores[0]=rojo
$ colores[2]=verde
$ colores[1]=amarillo
$ colores=([2]=verde [0]=rojo [1]=amarillo)
$ colores=(rojo amarillo verde)
$ colores=(rojo [10]=amarillo verde)
• Los arrays se pueden declarar vacíos explicitamente mediante
$ declare -a colores
• Los atributos establecidos para el array (read-only) se aplican a todos los elementos
• Para referenciar un elemento: ${array[i]}
$ echo 'No pasar' es ${colores[0]}
• Para referenciar todos los elementos ${name[*]} o ${name[@]}
$ echo ${colores[*]}

Comando set
• El comando set despliega las variables de shell junto a sus valores
• Permite definir el comportamiento del bash (opciones)
• Sintaxis:
set [-abdefkmntuvxBCHP] [(-|+)o opcion] [argumento...]
-n Lee comandos pero no los ejecuta, útil para depurar sintácticamente scritps
-v Muestra las líneas de entrada del shell tal cual son leídas
-x Muestra una traza de un comando y sus argumentos luego de aplicar expansiones
• Su uso habitual en shell scripts es para establecer los parámetros posicionales
$ set `date`
$ echo Hora actual: $4
Hora actual: 08:40:25

Comando getopts
• bash provee getopts para tratar con opciones múltiples y complejas
• puede utilizarse como una condición en un bucle while, dada la especificación del formato de
opciones (validez y argumentos), en el cuerpo del while se procesan
• Sintaxis:
getopts cadena variable
- cadena conteniendo letras (opciones) y :'s (argumentos)
- variable que almacena el argumento de la opción que está analizándose
• Ejemplo:
while getopts ":ab:c" opt; do
case $opt in
a ) procesar la opción -a ;;
b ) procesar la opción -b
$OPTARG es el argumento de la opción ;;
c ) procesar la opción -c ;;
? ) echo 'usage: alice [-a] [-b barg] [-c] args...'
exit 1
esac
done

Administración de usuarios y grupos en GNU/Linux

Recomendados

Recomendados

Más contenido relacionado

Similar a Administración de usuarios y grupos en GNU/Linux

Similar a Administración de usuarios y grupos en GNU/Linux (20)

Último

Último (13)

Administración de usuarios y grupos en GNU/Linux