C Piscine — Shell 00

Primer contacto con la terminal: archivos, permisos, tar, SSH, git y los rincones raros de Unix. 10 ejercicios (ex00–ex09), todos con funciones autorizadas: ninguna — solo comandos del sistema.

El prólogo — El enunciado abre con la letra completa de Moonlight Shadow (Mike Oldfield, 1983), presentándola como "el tema de City Hunter" — en Francia, una versión de esta canción sonaba en el anime City Hunter (allí Nicky Larson), del que toda una generación de franceses se acuerda. Tras dos páginas de letra, el enunciado remata: "Desafortunadamente, este enunciado no tiene relación con City Hunter". Este tipo de introducción absurda es marca de la casa en los subjects de 42.

GGlosario de teoría

Shell 00 es el primer día delante de una terminal Unix, y la página usa palabras que nadie te ha explicado todavía: inodo, permisos en octal, enlace simbólico, hash, número mágico… Aquí está cada una desde cero, con un ejemplo sacado del propio módulo. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

Archivos y sistema de ficheros

Archivo: una secuencia de bytes

Para Unix, un archivo es solo una lista de bytes con un nombre. No sabe si es texto, una imagen o un programa: eso lo decide quien lo lee. Un byte son 8 bits y puede valer de 0 a 255; los caracteres de texto se guardan como un byte cada uno según la tabla ASCII (la Z es el 90, en hexadecimal 0x5A).

En ex00, od -c z enseña exactamente lo que hay dentro:

$ od -c z
0000000   Z  \n
0000002

Dos bytes y nada más. El tamaño que muestra ls -l (el 40 de ex01, el 4 de test1 en ex02) es este número de bytes.

Salto de línea (\n) y cat -e

El final de una línea no es «nada»: es un byte más, el 10 (0x0A), que se escribe \n. La terminal lo pinta como un cambio de línea, así que a simple vista no se ve. cat -e lo hace visible poniendo un $ justo donde está.

printf 'Z\n' > z da un archivo de 2 bytes; printf 'Z' > z, uno de 1 byte que se ve igual en pantalla pero no es lo que pide ex00. echo Z > z también vale, porque echo añade el \n solo. Los ejemplos de ex05 y ex06 del enunciado pasan la salida por cat -e para que se vea que cada línea acaba justo después del hash, sin espacios.

Archivo oculto

En Unix no hay un atributo «oculto»: es oculto todo archivo cuyo nombre empieza por un punto (.gitignore, .ssh, .git). ls no los enseña salvo que le pases -a. Cada directorio tiene además dos entradas ocultas especiales: . (él mismo) y .. (su padre).

Por eso midLS (ex04) no tiene que hacer nada para excluir los ocultos: basta con no poner -a. Y por eso tu clave SSH está en ~/.ssh/ y no la ves con un ls normal.

Inodo

El inodo es la ficha que el sistema guarda de cada archivo: su tamaño, sus permisos, su dueño, sus fechas y dónde están sus bytes en el disco. Lo que no guarda es el nombre. Los nombres viven en los directorios, que son simples listas de parejas «nombre → número de inodo».

ls -i enseña el número de inodo. Al extraer el exo2.tar de ex02:

$ ls -li test3 test5
30410950 -r-----r-- 2 xalara 2026_barcelona 1 Jun  1 23:44 test3
30410950 -r-----r-- 2 xalara 2026_barcelona 1 Jun  1 23:44 test5

El mismo número: dos nombres para una sola ficha. El número concreto cambia en cada máquina; lo que importa es que coincide.

Fecha de modificación (mtime)

Cada inodo guarda varias fechas; la que enseña ls -l es la mtime, la última vez que cambió el contenido. touch la pone a la hora actual, y touch -t MMDDhhmm a la que tú digas (el año, si no lo pones, es el actual).

En ex01, touch -t 06012342 testShell00 da el «Jun 1 23:42». ls -l enseña la hora si la fecha es de los últimos seis meses y el año si es más antigua o está en el futuro: por eso el enunciado acepta el año en lugar de la hora. ls -t (ex04) ordena por esta fecha.

Permisos

Permisos rwx: propietario, grupo y resto

Los diez caracteres del principio de ls -l son el tipo (- archivo, d directorio, l symlink) y tres grupos de tres permisos: los del propietario, los del grupo y los del resto de usuarios. r es leer, w escribir y x ejecutar; un guion es que ese permiso no está.

En un directorio cambian de sentido: r es poder listar sus nombres, w crear o borrar dentro, y x poder entrar y llegar a lo que contiene. test2 de ex02 (dr-x---r--) se puede listar y recorrer por su dueño, pero no se pueden crear archivos dentro.

Notación octal de permisos (chmod 455)

Cada grupo de tres permisos se escribe como un número de 0 a 7 sumando r=4, w=2 y x=1. Son tres bits, y tres bits dan justo 8 valores: por eso es base 8, octal. Tres cifras, una por grupo.

-r--r-xr-x (ex01): r--=4, r-x=4+1=5, r-x=5, así que chmod 455. Al revés se comprueba con stat -c '%a %A', que en ex02 da 715 drwx--xr-x para test0 y 641 -rw-r----x para test4.

La terminal

Shell, /bin/sh y script

La shell es el programa que lee lo que escribes en la terminal y lanza los comandos. Hay varias: sh (la clásica, POSIX), bash, zsh… Un script es un archivo de texto con comandos, que la shell ejecuta línea a línea como si los teclearas.

El enunciado exige que los ejercicios funcionen con /bin/sh, así que no se pueden usar extras propios de bash. git_commit.sh (ex05) es un script de una sola línea, y el enunciado lo lanza con bash git_commit.sh: pasando el archivo a la shell no hace falta que sea ejecutable.

Opciones (flags) de un comando

Las letras con guion que van detrás de un comando cambian lo que hace: ls -l da el listado largo, ls -a incluye ocultos. Se pueden juntar: ls -tpm es lo mismo que ls -t -p -m. Las largas llevan dos guiones y una palabra (--format=%H, --others).

Casi todo Shell 00 se resuelve encontrando la opción justa: -t en touch, -h para que no siga el symlink, -tpm en ls, -5 en git log.

man y RTFM

man comando abre el manual de ese comando: qué hace y todas sus opciones. Se busca dentro con / y se sale con q. Las secciones van numeradas: man 1 file es el comando, man 5 magic el formato del archivo que lee. RTFM (Read The F… Manual) es la manera brusca de decir «está en el manual».

El enunciado lo pide en ex04, ex05 y ex06, y da como única pista man patch, man find y man file en ex07, ex08 y ex09.

Salida estándar, redirección (>) y tubería (|)

Todo programa escribe su resultado en la salida estándar (stdout), que por defecto es la pantalla, y sus errores en la salida de error (stderr). > archivo manda stdout a un archivo (lo crea o lo vacía antes). < archivo hace lo contrario: el programa lee de ese archivo. a | b conecta stdout de a con la entrada de b.

En el módulo: printf 'Z\n' > z (ex00), patch b < sw.diff (ex07), bash git_commit.sh | cat -e (ex05). Fuera de un repositorio, git_commit.sh no escribe nada en stdout: el «fatal: not a git repository» sale por stderr.

Comodines (*) y por qué se escapan

* significa «cualquier cosa, incluso nada». Si lo escribes suelto, la shell lo sustituye antes de lanzar el comando por la lista de nombres que encajan: en ex02, tar -cf exo2.tar * recibe en realidad test0 test1 … test6. Esa expansión no incluye los ocultos.

A veces quieres que el patrón le llegue intacto al comando. Por eso en ex08 va entre comillas, -name "*~": es find quien lo compara con cada archivo, en cada subdirectorio. Lo mismo con \( y \): la barra invertida evita que la shell trate los paréntesis como suyos y se los pasa a find.

Herramientas

tar: empaquetar archivos

tar junta varios archivos en uno solo, guardando delante de cada uno una cabecera con su nombre, tamaño, permisos, dueño y fecha. Empaquetar no es comprimir: un .tar ocupa lo mismo que la suma de lo que lleva (o algo más). -c crea, -x extrae, -t lista, -v da detalle y -f dice qué archivo usar.

Por eso ex01 y ex02 se entregan como tar: git no guarda permisos completos ni fechas, y el tar sí. tar -tvf testShell00.tar da -r--r-xr-x … 40 2026-06-01 23:42 testShell00 sin extraer nada.

SSH y clave pública / clave privada

SSH es el protocolo para conectarse a otra máquina de forma cifrada. En vez de contraseña puede usar un par de claves: la privada se queda en tu ordenador y la pública se reparte. Lo que firma la privada lo puede comprobar cualquiera con la pública, pero de la pública no se puede sacar la privada. Así el servidor sabe que eres tú sin que tu secreto salga nunca de tu máquina.

ssh-keygen -t ed25519 (ex03) crea ~/.ssh/id_ed25519 (privada) e id_ed25519.pub (pública). La pública es una sola línea: ssh-ed25519 AAAA… usuario@máquina. Esa es la que se entrega y la que se sube a la intra para poder hacer git push. ed25519 es el algoritmo: firmas sobre una curva elíptica, con claves cortas.

Git, commit y hash

Git guarda la historia de un proyecto como una cadena de commits: fotos del estado de los archivos con autor, fecha y mensaje. Cada commit se identifica por su hash, un número de 40 cifras hexadecimales (SHA-1) calculado a partir de su contenido: si cambia algo, cambia el hash. git log enseña la historia, del más reciente al más antiguo.

ex05 pide justo esos identificadores: git log -5 --format=%H, donde %H es el hash completo y -5 limita a cinco. Por eso cada línea de su salida tiene 40 caracteres.

.gitignore y archivos ignorados

Un archivo del directorio puede estar rastreado (git lo sigue), no rastreado (está pero git no lo sigue) o ignorado (no rastreado y además encaja con una regla para no proponerlo nunca). Las reglas son patrones en .gitignore, .git/info/exclude o la configuración global: *.o, .DS_Store, *~…

ex06 lista los ignorados con git ls-files --others --ignored --exclude-standard. Probado en un repo con *.o en el .gitignore, sale x.o; sin --exclude-standard, git se niega: «fatal: ls-files --ignored needs some exclude pattern».

diff y patch

diff a b compara dos archivos línea a línea y escribe las instrucciones para convertir el primero en el segundo: qué líneas borrar y cuáles añadir, y dónde. patch lee esas instrucciones y las aplica. Son dos caras de lo mismo: un diff es la receta y patch la cocina.

En ex07: cp a b y patch b < sw.diff. Se comprueba volviendo a hacer el diff: el que sale de diff a b con el b entregado es idéntico byte a byte al sw.diff del material.

find: tests, acciones y operadores

find recorre un directorio y todos sus subdirectorios y, para cada archivo, evalúa de izquierda a derecha una expresión. Tiene tests (-type f, -name), que dan verdadero o falso, y acciones (-print, -delete), que hacen algo. Dos piezas seguidas son un Y; -o es un O. El Y se aplica antes que el O, como la multiplicación antes que la suma.

Por eso en ex08 hacen falta los paréntesis. Sin ellos, find . -type f -name "*~" -o -name "#*#" -print -delete se lee como «(archivo y acaba en ~) o (empieza y acaba en #, imprime, borra)»: probado, solo borra los #…# y deja los ~ sin tocar.

Número mágico y offset

Muchos formatos empiezan con unos bytes fijos que los identifican: un PNG con \x89PNG, un ELF (los ejecutables de Linux) con \x7fELF, un PDF con %PDF. Son los números mágicos. El offset es la posición en bytes desde el principio del archivo, contando desde 0. file mira esos bytes, no la extensión.

ex09 inventa un formato: la cadena 42 en el offset 42. La línea de ft_magic va separada por tabuladores: offset, tipo, valor y mensaje. Con printf '%042d42' 0 > f42 se crean 42 ceros y luego 42, y file -m ft_magic f42 responde f42: 42 file.

Moulinette y Vogsphere

Vogsphere es el servidor git de 42: lo que hay en tu repositorio cuando se cierra la entrega es lo único que cuenta. La Moulinette es el programa que lo corrige solo, comparando tu salida con la esperada sin ninguna tolerancia: un byte de más o de menos es un ejercicio suspendido. Además, si un ejercicio falla, los siguientes ya no cuentan.

En Shell 00 eso quiere decir: exactamente los archivos pedidos con exactamente esos nombres (id_ed25519_pub, no id_ed25519.pub), nada más en el directorio, y el \n final de z en su sitio.

ex00Z

Entregable: z«Solo quienes dominan lo básico saben mostrar una Z»

Crear un archivo z tal que cat z muestre Z y un salto de línea.

$ printf 'Z\n' > z

El archivo contiene exactamente dos bytes: Z (0x5A) y \n (0x0A). Parece una tontería, pero ya obliga a entender qué es un archivo (una secuencia de bytes, sin magia), qué hace cat (volcarlos a la salida estándar) y que el salto de línea final es un byte más — la Moulinette distingue un archivo de 1 byte de uno de 2.

ex01testShell00

Entregable: testShell00.tar

Crear un archivo testShell00 cuyo ls -l sea exactamente:

-r--r-xr-x 1 XX XX 40 Jun 1 23:42 testShell00

y empaquetarlo con tar -cf testShell00.tar testShell00. Tres cosas que clavar:

$ printf '%040d' 0 > testShell00    # 40 bytes exactos
$ chmod 455 testShell00             # -r--r-xr-x
$ touch -t 06012342 testShell00     # Jun 1, 23:42
$ tar -cf testShell00.tar testShell00

El tar conserva permisos y fechas en sus cabeceras, así que el evaluador puede comprobar todo sin extraer siquiera: tar -tvf testShell00.tar.

ex02Pues toma dos tazas

Entregable: exo2.tar

Reproducir exactamente este listado y empaquetarlo (tar -cf exo2.tar *):

drwx--xr-x 2 XX XX XX Jun 1 20:47 test0
-rwx--xr-- 1 XX XX  4 Jun 1 21:46 test1
dr-x---r-- 2 XX XX XX Jun 1 22:45 test2
-r-----r-- 2 XX XX  1 Jun 1 23:44 test3
-rw-r----x 1 XX XX  2 Jun 1 23:43 test4
-r-----r-- 2 XX XX  1 Jun 1 23:44 test5
lrwxrwxrwx 1 XX XX  5 Jun 1 22:20 test6 -> test0
$ mkdir test0 test2
$ printf 'abc\n' > test1          # 4 bytes
$ printf '1' > test3              # 1 byte
$ printf '2\n' > test4            # 2 bytes
$ ln test3 test5                  # hard link
$ ln -s test0 test6               # symlink
$ chmod 715 test0; chmod 714 test1; chmod 504 test2
$ chmod 404 test3; chmod 641 test4
$ touch -t 06012047 test0; touch -t 06012146 test1
$ touch -t 06012245 test2; touch -t 06012344 test3 test5
$ touch -t 06012343 test4; touch -h -t 06012220 test6
$ tar -cf exo2.tar *

La trampa del ejercicio está en la segunda columna: test3 y test5 marcan 2 enlaces y comparten tamaño, permisos y fecha. No son dos archivos: son el mismo inodo con dos nombres (ln sin -s). Al hacer chmod o touch sobre uno, el otro "cambia" también — porque no hay otro. test6 en cambio es un enlace simbólico: un archivo distinto cuyo contenido es la ruta test0 (por eso su tamaño es 5, los 5 caracteres de "test0", y sus permisos son siempre rwxrwxrwx). Detalle fino: la fecha del symlink se cambia con touch -h, porque touch a secas seguiría el enlace y tocaría test0.

El título — Del refrán español «¿No querías caldo? Pues toma dos tazas»: pediste aprender permisos y aquí tienes siete archivos de golpe, con hard links de regalo.

ex03¡Conéctame por SSH!

Entregable: id_ed25519_pub
$ ssh-keygen -t ed25519
$ cp ~/.ssh/id_ed25519.pub ex03/id_ed25519_pub

Generar un par de claves SSH con el algoritmo ed25519 (curva elíptica moderna: claves cortas, rápidas y sin las dudas históricas de RSA). El ejercicio tiene una función muy práctica: la clave pública se sube a la intra y es la que te permite hacer git push a Vogsphere el resto de la piscine. Quien no entiende este ejercicio no entrega nada más.

La lección real está en la advertencia del enunciado: entender la diferencia entre la clave pública (se comparte, cifra/verifica) y la privada (no sale de tu máquina jamás). Entregar la privada por error es el clásico suspenso doloroso — de ahí que el archivo pedido se llame explícitamente id_ed25519_pub: "el nombre del archivo no fue elegido al azar".

ex04midLS

Entregable: midLS

Un archivo con el comando que lista el directorio actual: sin ocultos, ordenado por fecha de modificación, separado por coma y espacio, y con / al final de los directorios.

ls -tpm

Tres flags hacen todo el trabajo — el ejercicio es un RTFM (Read The F… Manual) puro:

Los ocultos ya quedan fuera por defecto (eso es -a, que precisamente no se pasa). La gracia de midLS es descubrir que ls tiene ~60 opciones y que la respuesta a "¿cómo hago X?" casi siempre está en man ls, no en escribir un script.

ex05Git commit

Entregable: git_commit.sh

Script que muestra los hashes de los últimos 5 commits del repositorio.

git log -5 --format=%H

git log con --format=%H imprime solo el hash completo de cada commit (sin autor, fecha ni mensaje), y -5 corta en cinco. El enunciado enseña la salida pasada por cat -e (que marca los finales de línea con $) para dejar claro que no puede haber espacios ni líneas extra: la Moulinette compara la salida literal.

ex06gitignore

Entregable: git_ignore.sh

Script que lista los archivos ignorados por el repositorio git actual.

git ls-files --others --ignored --exclude-standard

Descomponiendo: ls-files es el comando de "fontanería" (plumbing) de git para consultar su índice; --others pide archivos no rastreados; --ignored los filtra a los que casan con alguna regla de ignorado; y --exclude-standard hace que esas reglas sean las estándar (.gitignore, .git/info/exclude, config global). La pareja ex05/ex06 tiene el mismo mensaje: git no es solo add/commit/push, tiene una API de consulta enorme.

ex07diff

Entregable: bMaterial: a, sw.diff

El proyecto da un archivo a — el texto de apertura de Star Wars: Episodio IV — y un sw.diff. Hay que crear b tal que diff a b produzca exactamente ese sw.diff. La pista del enunciado (man patch) lo dice todo:

$ cp a b
$ patch b < sw.diff

Un diff no es una descripción: es un programa de edición que patch sabe ejecutar. Aplicado sobre la copia de a, produce el b buscado — y se verifica cerrando el círculo: diff a b regenera un diff idéntico al original. Así funcionan por dentro los parches de kernel, los pull requests y el propio git.

El texto — El diff convierte el opening crawl en una versión corrupta: "Episode V, A NEW H0PE", la DEATH STAR pasa a ser "STAR DEATH", la princesa Leia es "Princess Mehdi" (guiño a algún staff de 42) y en vez de restaurar la libertad en la galaxia, restaura "la dictadura". Vándalos.

ex08clean

Entregable: cleanUn solo comando, sin ; ni &&

Buscar en el directorio actual y subdirectorios los archivos que terminan en ~ o que empiezan y terminan con #, mostrarlos y borrarlos.

find . -type f \( -name "*~" -o -name "#*#" \) -print -delete

Los patrones no son arbitrarios: archivo~ y #archivo# son los backups y autosaves que va dejando Emacs — el ejercicio es, literalmente, limpiar la basura del editor.

ex09Son ilusiones, no trucos, Michael…

Entregable: ft_magic

Crear un archivo mágico para que file detecte como "42 file" los archivos que contienen la cadena 42 en el byte 42.

42	string	42	42 file

¿Cómo sabe file que algo es un PNG, un PDF o un ELF sin mirar la extensión? Consultando una base de datos de "números mágicos": patrones de bytes en posiciones fijas (un PNG empieza por \x89PNG, un ELF por \x7fELF…). El formato de esa base de datos (man 5 magic) es: offset, tipo, valor, mensaje. Nuestra línea dice: en el offset 42, si hay la cadena "42", el archivo es un "42 file".

$ printf '%042d42' 0 > f42     # "42" en el byte 42
$ file -m ft_magic f42
f42: 42 file
El título — Cita de Arrested Development: GOB Bluth, mago fracasado, corrige indignado a su hermano cada vez que llama "trucos" a sus ilusiones. Aplica: la detección de tipos de archivo parece magia y es solo mirar bytes en el sitio justo.

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a donde está explicado. En Shell 00 casi todo se defiende enseñando el comando en la terminal, así que ten a mano ls -l, tar -tvf y cat -e. Están agrupadas en: archivos y permisos, SSH y git, y comandos de una línea. Antes de mirar la respuesta, intenta contestar tú.

Archivos y permisos

¿Cuántos bytes tiene z? ¿Valdría printf 'Z' > z?

Dos: Z y el salto de línea (od -c z lo enseña). Sin el \n serían 1 byte, cat z dejaría el prompt pegado a la Z y la Moulinette lo daría por malo. echo Z > z sí vale, porque echo añade el \n. → ex00, salto de línea

¿De dónde sale el 455 de -r--r-xr-x?

Cada grupo de tres letras es una cifra sumando r=4, w=2 y x=1: propietario r--=4, grupo r-x=5, resto r-x=5. → ex01, octal

¿Cómo has puesto la fecha? ¿Y si sale el año en lugar de la hora?

Con touch -t 06012342 (mes, día, hora, minuto). ls -l enseña el año en vez de la hora cuando la fecha tiene más de seis meses o está en el futuro; el enunciado lo acepta. Lo que cuenta es lo que guarda el tar: tar -tvf testShell00.tar da 2026-06-01 23:42. → ex01, mtime

SSH y git

¿Qué clave has entregado? ¿Qué pasa si se te escapa la privada?

La pública, id_ed25519.pub, copiada como id_ed25519_pub: una línea que empieza por ssh-ed25519. La privada no sale nunca de tu máquina; con ella cualquiera podría hacerse pasar por ti ante Vogsphere, así que si se filtra hay que generar otro par y cambiar la de la intra. → ex03, SSH

¿Qué hace git_commit.sh fuera de un repositorio?

Nada por stdout: git escribe «fatal: not a git repository» por stderr y sale con error. Dentro de un repo saca cinco hashes de 40 caracteres, uno por línea y sin nada más, como en el ejemplo con cat -e. → ex05, stdout y stderr

¿Para qué sirve cada opción de git ls-files en ex06?

--others: los no rastreados. --ignored: de esos, los que encajan con una regla. --exclude-standard: que las reglas sean las de .gitignore, .git/info/exclude y la configuración global. Sin esta última git no sabe qué reglas usar y responde «fatal: ls-files --ignored needs some exclude pattern». → ex06, .gitignore

Comandos de una línea

En midLS, ¿cómo quitas los ocultos?

No hace falta: ls no los enseña salvo con -a, y el enunciado dice «haz solo lo que se te pide». -t ordena por fecha, -p pone la / a los directorios y -m separa con coma y espacio. → ex04, oculto

En clean, ¿qué pasa si quitas los paréntesis?

Que el Y de find va antes que el O y la expresión queda como «(archivo y acaba en ~) o (#…#, imprime, borra)». Los ~ se encuentran pero no se imprimen ni se borran. Los paréntesis llevan \ para que la shell no se los quede, y los patrones van entre comillas para que no los expanda ella. → ex08, find

¿Cómo has creado b y cómo sabes que está bien?

Con cp a b y patch b < sw.diff. Se comprueba al revés: diff a b tiene que dar exactamente el sw.diff del material (se puede comparar con diff o cmp y no debe salir nada). → ex07, diff y patch

¿Cómo pruebas ft_magic?

Creando un archivo con 42 en el byte 42, printf '%042d42' 0 > f42, y pasándole el archivo mágico a file con -m: file -m ft_magic f42 responde f42: 42 file. Los campos de la línea van separados por tabuladores. → ex09, número mágico