Este documento presenta una colección de scripts y fragmentos de código diseñados para diversas tareas de administración de sistemas y programación. Incluye ejemplos prácticos en Bash para la gestión de archivos, directorios, usuarios y procesos, así como un script en Python para la manipulación de archivos de texto. Cada sección detalla la funcionalidad y el propósito del código, proporcionando una referencia útil para la automatización de tareas cotidianas en entornos de TI.

Scripts Bash para Administración de Sistemas

Script 1: Inversión de Líneas de Texto

Este script de Bash permite al usuario introducir múltiples líneas de texto y, una vez finalizada la entrada (mediante una línea vacía), las muestra en orden inverso.

Funcionalidad:

  • Entrada interactiva: Solicita al usuario que introduzca líneas de texto una por una.
  • Almacenamiento en array: Las líneas se guardan en un array de Bash.
  • Salida invertida: Imprime las líneas almacenadas desde la última hasta la primera.
# Array para almacenar las líneas
declare -a lines

echo "Introduce líneas de texto. Presiona Enter para cada línea."
echo "Cuando hayas terminado, introduce una línea vacía para finalizar."

# Leer líneas hasta que se introduzca una línea vacía
while IFS= read -r line; do
    if [ -z "$line" ]; then
        break
    fi
    lines+=("$line")
done

# Mostrar las líneas en orden invertido
echo "Las líneas introducidas en orden invertido son:"
for (( i=${#lines[@]} - 1; i >= 0; i-- )); do
    echo "${lines[i]}"
done

Script 2: Conteo de Archivos y Directorios

Este script de Bash cuenta el número total de archivos y directorios dentro de un directorio especificado como argumento. Es útil para obtener un resumen rápido de la estructura de un directorio.

Funcionalidad:

  • Validación de argumentos: Verifica que se proporcione exactamente un directorio como argumento.
  • Verificación de existencia: Comprueba si el directorio especificado existe.
  • Conteo preciso: Utiliza el comando find junto con wc -l para contar archivos y directorios, excluyendo el directorio raíz del conteo de directorios.
# Verificar si se ha proporcionado un directorio como argumento
if [ $# -ne 1 ]; then
    echo "Uso: $0 <directorio>"
    exit 1
fi

# Directorio proporcionado como primer argumento
directory="$1"

# Verificar si el directorio existe
if [ ! -d "$directory" ]; then
    echo "El directorio '$directory' no existe."
    exit 1
fi

# Contadores para archivos y directorios
file_count=0
dir_count=0

# Usamos find para recorrer los archivos y directorios dentro del directorio dado
# Utilizamos -type f para archivos y -type d para directorios
# wc -l cuenta el número de líneas que es el número de archivos/directorios encontrados
file_count=$(find "$directory" -type f | wc -l)
dir_count=$(find "$directory" -type d | wc -l)

# Restamos 1 al contar directorios para excluir el directorio raíz
(( dir_count-- ))

# Mostramos los resultados
echo "Número total de archivos: $file_count"
echo "Número total de directorios: $dir_count"

Script 3: Gestión de Usuarios y Grupos (Función)

Este fragmento de código Bash define una función crear_grupo_y_usuario() que automatiza la creación de un grupo y la adición de un nuevo usuario a dicho grupo en un sistema Linux. Es fundamental para la administración de usuarios y permisos.

Funcionalidad:

  • Creación de grupo: Verifica si el grupo ya existe; si no, lo crea.
  • Creación de usuario: Verifica si el usuario ya existe; si no, lo crea y lo asocia al grupo especificado.
  • Asignación de grupo: Asegura que el usuario sea miembro del grupo.
  • Manejo de errores: Informa si el grupo o usuario ya existen.
crear_grupo_y_usuario() {
    local grupo="$1"
    local usuario="$2"
    local login="$3"

    # Verificar si el grupo ya existe
    if getent group "$grupo" > /dev/null 2>&1; then
        echo "Error: El grupo '$grupo' ya existe."
        exit 1
    else
        # Crear el grupo
        sudo groupadd "$grupo"
        echo "Grupo '$grupo' creado."
    fi

    # Verificar si el usuario ya existe
    if id "$usuario" > /dev/null 2>&1; then
        echo "El usuario '$usuario' ya existe."
    else
        # Crear el usuario y agregarlo al grupo
        sudo useradd -m -g "$grupo" -c "$login" "$usuario"
        echo "Usuario '$usuario' creado y agregado al grupo '$grupo'."
    fi

    # Agregar el usuario al grupo (redundante si useradd -g ya lo hizo, pero asegura)
    sudo usermod -a -G "$grupo" "$usuario"
    echo "Usuario '$usuario' agregado al grupo '$grupo'."
}

# Ejemplo de llamada a la función (asumiendo argumentos pasados al script principal)
# crear_grupo_y_usuario "$1" "$2" "$3"

Script 4: Monitor de Procesos Interactivo

Este script de Bash proporciona un menú interactivo para monitorear y gestionar procesos en un sistema Linux. Es una herramienta práctica para la depuración y el mantenimiento del sistema.

Funcionalidad:

  • Listar procesos: Muestra todos los procesos en ejecución.
  • Buscar proceso: Permite buscar procesos por nombre.
  • Terminar proceso: Permite matar un proceso por su PID.
  • Menú interactivo: Ofrece opciones claras al usuario.
#!/bin/bash

mostrar_procesos() {
    echo "Procesos en ejecución:"
    ps aux
}

buscar_proceso() {
    echo -n "Introduce el nombre del proceso a buscar: "
    read nombre_proceso
    echo "Procesos que contienen '$nombre_proceso':"
    ps aux | grep "$nombre_proceso"
}

matar_proceso() {
    echo -n "Introduce el PID del proceso a terminar: "
    read pid_proceso
    kill -9 "$pid_proceso"
    echo "Proceso con PID $pid_proceso ha sido terminado."
}

menu() {
    echo "\n--- Menú de Monitor de Procesos ---"
    echo "1. Mostrar la lista de procesos en ejecución"
    echo "2. Buscar un proceso por nombre"
    echo "3. Terminar un proceso por su PID"
    echo "4. Salir"
    echo -n "Elige una opción: "
    read opcion
}

while true; do
    menu
    case $opcion in
        1) mostrar_procesos ;;
        2) buscar_proceso ;;
        3) matar_proceso ;;
        4) echo "Saliendo del programa."; exit ;;
        *) echo "Opción no válida. Por favor, elige una opción del 1 al 4." ;;
    esac
done

Script 5: Gestión de Usuarios y Grupos desde Archivo de Configuración

Este script de Bash lee un archivo de configuración (users_config.txt) para automatizar la creación de grupos y usuarios. Es ideal para la configuración inicial de sistemas o la gestión masiva de cuentas.

Formato del archivo users_config.txt:

tipo:nombre:argumentos

Ejemplos:

  • grupo:desarrollo:usuario1,usuario2
  • usuario:juan:password123:desarrollo

Funcionalidad:

  • Lectura de configuración: Procesa cada línea del archivo users_config.txt.
  • Creación de grupos: Si el tipo es ‘grupo’, crea el grupo y añade los usuarios especificados.
  • Creación de usuarios: Si el tipo es ‘usuario’, crea el usuario, lo asigna al grupo y establece la contraseña.
  • Manejo de tipos: Soporta ‘grupo’ y ‘usuario’, con un mensaje para tipos no válidos.
#!/bin/bash

# Este script asume que el archivo 'users_config.txt' está en el mismo directorio
# y tiene el formato 'tipo:nombre:argumentos'

while IFS=: read -r tipo nombre argumentos; do
    case "$tipo" in
        "grupo")
            # Eliminar espacios en blanco alrededor del nombre del grupo
            grupo=$(echo "$nombre" | tr -d '[:space:]')
            echo "Creando grupo '$grupo'"
            # Verificar si el grupo ya existe antes de intentar crearlo
            if ! getent group "$grupo" > /dev/null; then
                sudo groupadd "$grupo"
            else
                echo "El grupo '$grupo' ya existe. Saltando creación."
            fi

            # Leer usuarios separados por coma y añadirlos al grupo
            IFS=',' read -ra usuarios <<< "$argumentos"
            for usuario in "${usuarios[@]}"; do
                usuario=$(echo "$usuario" | tr -d '[:space:]') # Limpiar espacios del nombre de usuario
                if [ -n "$usuario" ]; then # Asegurarse de que el nombre de usuario no esté vacío
                    echo "Añadiendo usuario '$usuario' al grupo '$grupo'"
                    # Verificar si el usuario existe antes de añadirlo al grupo
                    if id "$usuario" > /dev/null 2>&1; then
                        sudo usermod -a -G "$grupo" "$usuario"
                    else
                        echo "Advertencia: El usuario '$usuario' no existe. No se pudo añadir al grupo '$grupo'."
                    fi
                fi
            done
            ;;
        "usuario")
            # Eliminar espacios en blanco alrededor del nombre de usuario
            usuario=$(echo "$nombre" | tr -d '[:space:]')
            # Separar contraseña y grupo de los argumentos
            read -r contrasenya grupo_usuario <<<"$argumentos"
            grupo_usuario=$(echo "$grupo_usuario" | tr -d '[:space:]') # Limpiar espacios del nombre del grupo

            echo "Creando usuario '$usuario'"
            # Verificar si el usuario ya existe
            if ! id "$usuario" > /dev/null 2>&1; then
                # Crear el usuario, con directorio home (-m) y grupo principal (-g)
                # Si el grupo_usuario es el grupo principal, usar -g. Si es un grupo secundario, usar -G.
                # Para simplificar, asumimos que grupo_usuario es el grupo principal o uno secundario.
                # useradd -m -g "$grupo_usuario" "$usuario" # Esto crea el usuario con grupo principal
                # Para añadir a un grupo secundario, se usaría usermod después.
                # Aquí se asume que el grupo_usuario es el grupo principal o se añade como secundario.
                sudo useradd -m -G "$grupo_usuario" "$usuario"
                echo "Usuario '$usuario' creado."
                # Establecer contraseña
                echo "$usuario:$contrasenya" | sudo chpasswd
                echo "Contraseña establecida para '$usuario'."
            else
                echo "El usuario '$usuario' ya existe. Saltando creación."
                # Si el usuario ya existe, se podría actualizar su grupo o contraseña si fuera necesario
                # Por ejemplo, para añadirlo a un grupo secundario si no lo está:
                # sudo usermod -a -G "$grupo_usuario" "$usuario"
                # echo "Usuario '$usuario' añadido/confirmado en el grupo '$grupo_usuario'."
            fi
            ;;
        *)
            echo "Tipo no válido: '$tipo'. Saltando línea."
            ;;
    esac
done < users_config.txt

Fragmento de Código de Bajo Nivel / Ensamblador

Este pequeño fragmento de código parece ser parte de una rutina de inicio o un sistema embebido, posiblemente escrito en lenguaje ensamblador o un lenguaje de bajo nivel similar. Define puntos de salto y direcciones de memoria importantes.

Elementos clave:

  • JMP boot: Salto a la rutina de inicio.
  • JMP isr: Salto al vector de interrupción.
  • EQU: Directiva para definir constantes o equivalencias de direcciones de memoria.
  • sStackTop, uStackTop, txt_display: Direcciones de memoria para la cima de la pila (de sistema y de usuario) y una dirección para la visualización de texto.
JMP boot
JMP isr ; Interrupt vector
sStackTop EQU 0x1FF
uStackTop EQU 0x2DF
txt_display EQU 0x2E0

Programación en Python

Script: Búsqueda de Cadena en Archivo

Este script en Python está diseñado para buscar una cadena específica dentro de un archivo de texto. Incluye validaciones robustas para asegurar que los argumentos sean correctos y que el archivo exista y no esté vacío.

Funcionalidad:

  • Validación de argumentos: Comprueba que se proporcionen el nombre del archivo y la cadena a buscar.
  • Manejo de archivos: Abre y lee el contenido del archivo de forma segura.
  • Verificación de existencia y contenido: Asegura que el archivo exista y no esté vacío antes de la búsqueda.
  • Búsqueda de cadena: Determina si la cadena se encuentra en el contenido del archivo.
  • Manejo de errores: Captura y reporta errores comunes como archivo no encontrado o problemas de lectura.
import sys
import os # Importar os para os.path.exists y os.path.getsize

def buscar_cadena_en_archivo(archivo, cadena):
    try:
        with open(archivo, 'r') as f:
            contenido = f.read()
            if cadena in contenido:
                print(f"La cadena '{cadena}' se encontró en el archivo '{archivo}'.")
            else:
                print(f"La cadena '{cadena}' no se encontró en el archivo '{archivo}'.")
    except IOError:
        print(f"Error: No se pudo abrir o leer el archivo '{archivo}'.")

def main():
    if len(sys.argv) != 3:
        print("Uso: python script.py <nombre_archivo> <cadena>")
        return

    archivo, cadena = sys.argv[1], sys.argv[2]

    # Verificar si el archivo existe
    if not os.path.exists(archivo):
        print(f"Error: El archivo '{archivo}' no existe.")
        return

    # Verificar si el archivo está vacío
    if os.path.getsize(archivo) == 0:
        print(f"Error: El archivo '{archivo}' está vacío.")
        return

    # Si el archivo existe y no está vacío, proceder con la búsqueda
    buscar_cadena_en_archivo(archivo, cadena)

if __name__ == "__main__":
    main()