
   Algunas ayudas para usuarios noveles
   
   Notas escuetas sobre algunas particularidades de UNIX para el usuario
   nuevo que viene del DOS
   
   Traducido por: José Ignacio Gracia (joseigra@teleline.es)
   
   
   Indice
   
   --------
   
   o Los metacaracteres
   
   o Comportamientos extraños usando metacaracteres
   
   o Periféricos
   
   o Jugar con los terminales tty [nuevo]
   
   o Cómo duplicar un disco
   
   o Copiar "partes de una fuente a un destino
   
   o Dividir en dos partes un archivo y copiarlas en dos discos
   
   o Un ejercicio con "dd":Qué tipo de archivo s este? [nuevo]
   
   o Copiar y borrar archivos
   
   o Usar pipes: tar y gzip
   
   o Experimentar con discos RAM
   
   o Experimentar con NETCAT . transferencia de ficheros
   
   o Sistema de ficheros en un archivo: loop devices
   
   Los metacaracteres ( comodines)
   
   --------------------------------------------
   
   Los metacaracteres como * están integrados en el propio interprete de
   comandos (shell) y pueden ser usados como listas de parámetros (en C:
   argv(1), argv(2), ...)
   
   Ejemplo:
   
   Si un directorio contiene los ficheros ( more, mount, mv, od), un
   comando como "ls *" equivaldrá a:
   
   # ls more mount mv od
   
   Extraños comportamientos usando metacaracteres
   
   -------------------------------------------------------------------
   
   Si en el mismo directorio anterior escribo el comando:
   
   # cp *
   
   Este vendrá interpretado como:
   
   # cp more mount mv od
   
   Dando como resultado que los ficheros ( more mount y mv) se añadirán
   al fichero od y quizá no es esto lo que pretendíamos.
   
   Para continuar con las operaciones aritméticas, en UNIX se dispone del
   comando "expr":
   
   expr x op y
   
   En el mismo directorio que estábamos, un comando como:
   
   # expr 10 * 2
   
   Daría como resultado:
   
   # expr 10 more mount mv od 2
   
   generando así un error.
   
   Para evitar este inconveniente, los caracteres especiales van
   "protegidos" de la interpretación (como en la Biblia?); ejemplo.
   
   # expr '10 * 2 '
   
   # expr 10 \* 2
   
   Las comillas " no sirven tanto para proteger sino para "recoger", un
   poco como el uso de los paréntesis en las matemáticas.
   
   Periféricos (devices)
   
   ----------------------------
   
   
   Son del tipo "de carácter" (por ejemplo: el módem, ratón) o de
   "bloques" (por ejemplo: el CD, el disco duro etc.), el segundo es de
   acceso secuencial o aleatorio.
   
   Se puede acceder a un periférico a través de los ficheros especiales
   que se hayan en el directorio /dev. Por ejemplo:
   
   /dev/hd* hd=hard-disk
   
   /dev/tty* tty=char devices
   
   /dev/ttyS* Serial ports (mouse, modem)
   
   /dev/fd* fd=floppy disk
   
   /dev/sd* sd=SCSI device
   
   Con fd0H1772, por ejemplo, se refiera a la primera disquetera "Floppy
   disk 0" y del tipo de alta densidad High Density, formateado a 1772
   Kbs.
   
   Puesto que files"fichero" y devices"periférico pueden ser tratados
   casi en cualquier lugar con comandos análogos, en este documento, los
   dos nombres serán usados indistintamente.
   
   Los periféricos por bloques que contengan un sistema de ficheros
   pueden ser "montados" en un "punto de montaje" y así formar parte del
   árbol de directorios.
   
   Por ejemplo, con el comando:
   
   # mount /dev/fd0H1722 /a
   
   se puede acceder a un diskette con un simple cd /a.
   
   Jugar con los terminales tty
   
   ----------------------------
   
   A cada consola abierta le corresponde un dispositivo llamado
   /dev/tty*.
   
   Por ejemplo: el primero es /dev/tty1, el segundo /dev/tty2, etc.
   
   Al terminal por defecto ( donde está conectada la input entrada
   standard) le corresponde /dev/tty.
   
   ES posible enviar datos de una consola abierta a otra de manera muy
   sencilla:
   
   # echo hello > /dev/tty3
   
   # date > /dev/tty3
   
   # cat /etc/profile > /dev/tty5
   
   Si en su lugar, queremos acceder a la lectura de una consola,podemos
   usar los dispositivos /dev/vcs*, uno por cada tty*.
   
   Si, por ejemplo, queremos ver lo que se ha escrito en ttylm todo o que
   tenemos que hacer es escribir:
   
   # cat /dev/vcs1
   
   Cómo duplicar un diskette. (DOS's diskcopy)
   
   -------------------------------------------
   
   Con UNIX, se puede copiar el contenido completo de un periférico en un
   archivo con un comando como este:
   
   # cat /dev/fd0H1440 > myfloppy
   
   Así pues, basta insertar el diskette de destino y escribir:
   
   # cat myfloppy > /dev/fd0H1440
   
   
   Copiar partes predefinidas de una fuente a un destino
   
   -----------------------------------------------------
   
   Para este tipo de actividad, es útil el comando "dd", muy versátil.
   
   Con "dd" /a diferencia del copy del DOS) se pueden copiar bloques de
   datos de un lugar al otro, para controlar la cantidad de cosas que
   transportar y darle el punto exacto desde el que empezará la copia.
   
   Ejemplo 1:
   
   # dd if=/dev/fd0 of=myfile skip=200 bs=1k count=2
   
   Este comando copia un disco sito en "myfile", usando bloques de 1K
   (bs=tamaño de bloque),pero sólamente dos bloques (conut=2) y saltarse
   los 200 primeros (skip=200).
   
   Example 2:
   
   # dd if=/dev/ttyS0
   
   Copia "a la pantalla" (en la stdout) cualquier cosa que venga de COM1,
   hasta que se detiene presionando CTRL-C.
   
   Dividir en dos un fichero y copiarlo en dos discos
   
   --------------------------------------------------
   
   Se puede hacer esto, para practicarlo, usando "dd":
   
   # dd if=myfile bs=1k count=1440 of=part.1
   
   # dd if=myfile bs=1k skip=1440 of=part.2
   
   # cat part.1 > /dev/fd0H1440 { cambia el floppy}
   
   # cat part.2 > /dev/fd0H1440
   
   Para reunir las dos partes basta:
   
   # cat part.1 part.2 > myfile
   
   # rm part.1 part.2
   
   Ved my script en /usr/bin/mkfloppy
   
   Un ejercicio con "dd": Qué tipo de archivo es esté?
   
   ---------------------------------------------------
   
   Supongamos que tenemos un archivo X sin un sufijo exacto que indique
   el tipo de archivo que es; cómo podemos saber qué tipo de datos
   contiene? En el mundo UNIX esta tarea se hace con el comando "file".
   Por ejemplo, si yo escribo:
   
   # file DOSTOOLS.zip
   
   obtengo como respuesta:
   
   "Zip archive data, at least v2.0 to extract"
   
   El comando "file" extrae algunos bites y compara el valor binario con
   una base de datos de "valores binarios" (/etc/magic)
   
   Por ejemplo: un fichero comprimido con pkzip tiene los primeros dos
   bites empezando por "PK" mientras que un archivo ".tar" tiene 5 bites
   dispuestos como "ustar", a partir del bite 257.
   
   De este modo, si yo hago:
   
   dd if=X.zip bs=1c count=2
   
   obtengo "PK", y si hago:
   
   dd if=X.tar bs=1c skip=257 count=5
   
   ostengo "ustar".
   
   Buscando en el directorio /etc/magic (pero en muLinux este fichero no
   está disponible)podemos hacer montones de descubrimientos como estos.
   
   ES de esta manera está implementada la versión "rústica" de "file" en
   muLinux.
   
   
   Copiar y borrar ficheros: los comandos cp y rm
   
   ----------------------------------------------
   
   El comando "cp" espera siempre que el último parámetro escrito sea el
   destino. La copia recursiva se activa con -r.
   
   "rm" trabaja de igual manera. Añadiendo -v se obtiene la lista de
   ficheros sobre los que se está operando.
   
   Ejemplo:
   
   # cp -vr /bin /sbin /tmp
   
   La copia recursiva de /bin and /sbin dirs en /tmp.
   
   # cp -vr /bin/* /tmp
   
   En este caso en /tmp no creará el subdirectorio /tmp/bin.
   
   # rm -r /
   
   Sin comentarios:))
   
   Utilización de los pipes: tar y gzip
   
   ------------------------------------
   
   Comandos muy utilizados como "tar" (empaqueta ficheros y directorios)
   y "gzip" (el compresor standard GNU) pueden recibir/producir
   "materiales" directamente del "standard input/output" y así trabajar
   mucho mejor vía "pipe", sin la necesidad de crear ficheros temporales.
   Normalmente, en LINUX al omitir el nombre del archivo se espera la
   entrada desde stdin/stdout. En cualquier caso, se puede hacer
   explícita el standard input con el símbolo "-" (como hace tar), o con
   otro tipo de opciones (como "-c" en gzip).
   
   Ejemplo 1. crear un archivo TGZ
   
   # gzip -dc doc.tgz | (cd /some/dir ; tar -xf- )
   
   En este caso Tar crea "-c" un archivo de todo el subdirectorio
   /usr/doc y lo copia en stdout (f-), de donde será recogido por Gzip,
   comprimido en el stdout ("-c") y recogido en el fichero doc.tgz.
   
   Ejemplo 2: descompresión de un fichero tgz
   
   Esta es la operación opuesta a la anterior. Gzip descomprime el
   fichero doc.tgz -d lo copia a stdout -c en donde tar lo coge f- y lo
   expande -x en los ficheros individuales originales. Los ficheros son
   creados a partir del directorio especificado con -c (en este caso /)
   el punto más alto del directorio.
   
   Para más información, tar dispone de la opción -z para hacer el
   trabajo que normalmente compete a gzip.
   
   Experimentar con discos RAM
   
   ---------------------------
   
   Se puede experimentar con el sistema de ficheros, (creación, montaje,
   copia, etc.)sin la necesidad de tener particiones reales en el disco
   duro. Para hacer esto podemos usar los discos RAM accesibles mediante
   los ficheros /dev/ram0 /dev/ram1, etc.
   
   De todas formas, evitad el uso de los primeros 4, pues ya están usados
   (normalmente) por muLinux, y no superéis los 4MB de tamaño.
   
   Ejemplo1:
   
   # mkdir /ram { crea el lugar de montaje en /ram }
   
   # mkfs.ext2 /dev/ram5 1440 { crea un fs EXT2 de 1,44M }
   
   # mount /dev/ram5 /ram { monta este en /ram}
   
   Ejemplo 2:
   
   # mkdir /ram {crea el lugar de montaje en /ram }
   
   # cat /dev/fd0H1440 > /dev/ram5 { copia a DOS-floppy en RAM }
   
   # mount -t dos /dev/ram5 /ram { monta en /ram el fs obtenido}
   
   En el ejemplo 2, el fs no ha sido creado aún, simplemente duplicado a
   partir del primer disco (en nuestro caso, un fs DOS)
   
   Sistema de archivo de un fichero:"loop devices"
   
   -----------------------------------------------
   
   El comando mkf2.ext2" puede crear un sistema de ficheros (procedente
   de Linux)en un archivo, en vez de crear una partición.
   
   Para hacer esto, necesitamos crear un fichero de cualquier longitud
   (por ejemplo 300K)
   
   lleno de "0" (ceros) con este comando:
   
   # dd if=/dev/zero of=my_fs bs=1k count=300
   
   Después, creamos el sistema de ficheros:
   
   # mkfs.ext2 -F my_fs
   
   Para acceder a un sistema de ficheros cualquiera de UNIX, primero
   tenemos que "montarlo", bien, esto se hace de la siguiente manera:
   
   # mount -o loop my_fs /mnt
   
   Fijémonos que la opción "-o loop" le dice al kernel que use unas
   características especiales al montarlo.
   
   Escriba "df" si quiere ver el nuevo sistema de archivos montado, su
   espacio disponible etc. .
   
   Ahora podemos ir a /mnt , crear ficheros, directorios, y copiar
   nuestros datos como si se tratara de un dispositivo rígido cualquiera.
   
   Al final, podemos desmontarlo escribiendo:
   
   # umount /mnt
   
   y almacenar el fichero "my_fs" en cualquier lugar, tal vez después de
   haberlo comprimido con gzip.
   
   El sistema de ficheros completo de muLinux podría ser creado de esta
   manera, en realidad los discos de Linux están creados de esta manera.
   
   Experimentar con "netcat", transferencia de ficheros
   
   ----------------------------------------------------
   
   el programilla "nc" (ver nc -h) es la base de la mayor parte de la
   actividad del TCP/IP en muLinux. Lo considero una maravilla de la
   naturaleza. Voy a describir como es posible con "nc" hacer una
   transferencia de ficheros entre dos máquinas UNIX en una LAN.
   
   Obviamente, si no ha instalado muLinux en una LAN con al menos dos
   puestos, (a los que llamaremos host A y host B) puede saltarse esta
   parte.
   
   --cliente & servidor
   
   nc puede ser usado para experimentar la filosofía cliente servidor
   programando la shell de UNIX en lugar de en c:
   
   Aquí esta cómo activar un servidor (-l=listing) que escucha el puerto
   5555
   
   host-A> nc -l -p 5555
   
   Aquí está cómo activar el cliente en el host B en el mismo puerto:
   
   host-B> nc A 5555
   
   Con este simple procedimiento, A y B están ahora conectados a través
   del puerto 5555.Escribiendo cualquier cosa en el teclado, en ambos
   lados, los caracteres se transferirán de un ordenador a otro (en UNIX
   a esto se le llama CONVERSAR).
   
   Con este tipo de trucos es como el servidor web PYGMY, telnet,
   sendmail y otros están constituidos en muLinux.
   
   -- Transferencia de ficheros
   
   Si queremos transferir un fichero usando esta técnica, stdin/stdout lo
   puede hacer por ti.
   
   En el ejemplo siguiente, el host A archiva una parte de su sistema de
   ficheros, lo comprime con gzip y lo envía a través del puerto. El host
   B lo toma del puerto al que está escuchando, lo descomprime y lo
   recrea en su sistema de ficheros. El directorio transferido es
   /usr/doc.
   
   host-A> tar -cf- /usr/doc | gzip -9c | nc -l -p 5555
   
   host-B> nc A 5555 | gzip -dc | tar -C/ -xvf-=20
   
   Como podemos ver, el directorio /usr/doc es transferido de A a B por
   la red en un formato comprimido. Al final de la operación, hemos
   creado el subdirectorio /usr/doc!
   
   Para el uso de tar y gzip, ver la sección anterior.
   
   Si en el host B tiene un cliente Windows con un navegador como
   Netscape, podría intentar de la misma manera la transferencia con el
   siguiente truco:
   
   
   Dele al navegador la siguiente dirección:
   
   http://A:5555/
   
   El fichero debería aparecer (en forma de popurrí si es un fichero
   binario) directamente en la pantalla del navegador.
   
   Solo resta grabarlo con cualquier nombre. No lo he probado pero debe
   funcionar.
   
   [...]
