Todo linux

1. Historia ........................................................................................................... 3
Antecedentes:............................................................................................................. 3
Nacimiento:................................................................................................................. 3
Expansión de Unix:..................................................................................................... 3
Evolución: ................................................................................................................... 4
La G.N.U..................................................................................................................... 5
Distribuciones de Linux. ............................................................................................. 6
2. Generalidades de la gestión del S.O. ........................................................... 6
3. Características ............................................................................................... 7
4. Estructura del S.O. UNIX ............................................................................... 8
Kernel o Núcleo .......................................................................................................... 8
Dispositivos ................................................................................................................ 8
Utilidades .................................................................................................................... 8
SHELL o Caparazón................................................................................................... 8
5. Primera Aproximación................................................................................... 9
Antes de entrar al Sistema: ........................................................................................ 9
Escribir algunos comandos para tomar contacto. ...................................................... 9
6. Algunas utilidades para experimentar. ...................................................... 10
Consultar el manual.................................................................................................. 10
Hacer cálculos .......................................................................................................... 10
Mirar el almanaque ................................................................................................... 11
7. Conceptos Básicos del Sistema de Ficheros ............................................ 12
Distribución de la información en disco: ................................................................... 12
Inodos ....................................................................................................................... 12
Los ficheros pueden ser esencialmente de tres tipos: ............................................. 13
Trayectoria o pathname:........................................................................................... 16
Nombres de ficheros y Metacaracteres.................................................................... 16
8. Trabajo del Usuario con Ficheros Ordinarios. .......................................... 18
Formato de las órdenes............................................................................................ 18
Crear ficheros ........................................................................................................... 18
Listar nombres e informacion sobre ficheros............................................................ 18
Copiar, Mover, Enlazar y Borrar Ficheros. ............................................................... 19
Permisos, Propietario y Grupo. ................................................................................ 21
9. Operaciones Con Ficheros Directorios...................................................... 26
10. Flujo De Información. .................................................................................. 28
Entrada y salidas estándar (std)............................................................................... 28

El Sistema Operativo Unix - Linux 1

Redireccionamiento:................................................................................................. 28
Tuberías (pipes): ...................................................................................................... 29
Filtros para: Contar, Ordenar y Eliminar Repetidos.................................................. 30
Filtros para ver que hay en los ficheros.................................................................... 32
Filtro para cambiar caracteres.................................................................................. 33
Buscar en ficheros. Familia grep. ............................................................................. 35
Comparacion de Ficheros. ....................................................................................... 36
Cortar y Pegar Ficheros. .......................................................................................... 37
11. Búsqueda de ficheros. ................................................................................ 39
12. Editores: ....................................................................................................... 42
Editor VIsual. Generalidades. ................................................................................... 42
Configuración ........................................................................................................... 44
Búsquedas y reemplazos. ........................................................................................ 46
Los Búfers del VI ...................................................................................................... 47
13. Comunicación entre Usuarios .................................................................... 49
finger......................................................................................................................... 49
who ........................................................................................................................... 49
w ............................................................................................................................... 49
write .......................................................................................................................... 50
wall............................................................................................................................ 50
Mensaje del día. ....................................................................................................... 51
Mensaje de preentrada............................................................................................. 51
mail ........................................................................................................................... 51
14. Empaquetar y Comprimir Ficheros. ........................................................... 54
tar ............................................................................................................................. 54
gzip ........................................................................................................................... 55
Los dos a la vez: tar y gzip ....................................................................................... 56
zcat ........................................................................................................................... 56
compress, uncompress ............................................................................................ 56
bzip2, bunzip2........................................................................................................... 56
15. Sistema de Impresión.................................................................................. 57
Mandar trabajos a la impresora ................................................................................ 57
Control de la cola...................................................................................................... 58


Historia

Antecedentes:
El SO Multics se utilizó durante algún tiempo en los laboratorios Bell.
En Europa se había desarrollado el sistema de acceso multiple de Cambridge (The Cambridge
Multiple Access System).
También se empleó durante algún tiempo el CTSS (sistema de tiempo compartido compatible).
Los desarrolladores de Unix aprovecharon este trabajo realizado con estos y otros sistemas
operativos, para combinar las mejores características de cada uno.

Nacimiento:
El UNIX surgió en 1964-66 cuando Ken Thompson intentaba utilizar un programa de un
ordenador grande, que funcionaba con el SO Multics, en otro ordenador llamado PDP-7. Para ello
escribió un sistema operativo nuevo llamado UNIX.
A él se unió Dennis Ritchie y el UNIX se comenzó a utilizar en los laboratorios Bell.
Pronto se adaptó a otros ordenadores y tuvo gran aceptación en el ambiente universitario, del
cual recibió un gran impulso, en especial de la Universidad de Berkeley en California.
En un principio fue escrito en Ensamblador, pero el hecho de que se pudiese adaptar a
muchos tipos de ordenadores (portabilidad), se debe a que se reescribió casi en su totalidad en
lenguaje C, lenguaje de nivel medio desarrollado por Dennis Ritchie modificando otro ya existente
llamado lenguaje B.
El nacimiento de UNIX y el lenguaje C se hizo a la par y su posterior desarrollo continuó
paralelo.

Expansión de Unix:
El sistema operativo Unix ha estado ejecutándose en ordenadores más de 40 años. En un
principio se ejecutaba en mainframes y miniordenadores, aunque su principal plataforma de
desarrollo han sido las estaciones de trabajo RISC. En la actualidad el acercamiento de los PC,s a
las estaciones de trabajo ha hecho de las plataformas Intel una buena base para utilizar Unix.
Debido a la gran portabilidad que ofrece el lenguaje C, no pasó mucho tiempo antes de que
creasen versiones destinadas a otros procesadores.
La evolución de Unix comenzó a complicarse cuando Unix se escindió para satisfacer a
diferentes plataformas hardware. Por un lado se obtuvo Xenix, de Microsoft, el primero en
ejecutarse en ordenadores Intel. La versión BSD, desarrollada en la Universidad de California, en
Berkeley, encontró alojamiento en multitud de miniordenadores de alta potencia. Unix 2.0, el
predecesor del presente System V Unix de AT&T, fue el que más atención acaparó y es el estándar
de hoy en día.
El diagrama muestra un árbol genealógico de Unix desde 1969 hasta nuestros días. Obsérvese
cómo Unix se divide en varias versiones. Además, es importante destacar de qué forma se
combinaron diversas versiones con el fin de obtener nuevos enfoques del sistema operativo. El
nacimiento de híbridos de diferentes versiones parece la tendencia del momento. Algunos de los
elementos más destacables de esta numerosa familia son AIX, el sistema operativo IBM RS/6000,
Solaris de SunSoft y Mach.

El árbol genealógico de Unix.:
V1


V6

Xenix 2.0 V7 BSD

SIII 32V 2BSD

System V V8 3BSD

SVR2 V10 4BSD

SCO SVR3 Plan 9 4.2

4.3

SVRS3.2
AIX V1 Mach

SVR4

Evolución:
Cuando Unix era joven (versión 6), su código fuente se encontraba por todas partes, con
autorización de AT&T, y se estudiaba frecuentemente en muchas universidades, de las cuales
había recibido y recibía un gran impulso.
Pero AT&T, en la versión 7 (1979), comprendió que Unix era un valioso producto comercial; y
prohibió el estudio y distribución del código fuente, para evitar poner en peligro su condición de
secreto comercial.
Para remediar la situación y especialmente con fines educativos, en 1983, Andy Tannembaum
desarrolló un SO nuevo en cuanto a código, pero compatible con Unix en cuanto a su funcionalidad,
evadiendo los problemas legales para su estudio. Lo llamó Minix de Mini-Unix. Finalmente su
creador cedió todos los derechos sobre Minix a una empresa que comenzó a cobrar por licencia.
A principios de la decada de los 90, un estudiante de informática se pone a trabajar en una
variante de Unix llamada Linux, con la idea de que estubiese enmarcado dentro del proyecto GNU.
El padre de la criatura es Linus Benedict Torvalds, nacido en Helsinki en 1969.
El 5 de octubre de 1991 Linus dio a conocer la primera versión oficial, que podía ejecutar el
bash (shell de GNU) y el compilador de C. Lo puso en un grupo de noticias con el siguiente
mensaje:
”¿Suspiráis por recordar aquellos días del Minix-1.1, cuando los hombres eran
hombres y escribían sus propios drivers? ¿Os sentís sin ningún proyecto interesante y os
gustaría tener un verdadero SO, que pudierais modificar a placer?
¿Os resulta frustrante el tener sólo a Minix? Entonces, este artículo es para vosotros.
Como dije hace un mes, estoy trabajando en una versión gratuita de algo parecido a
Minix para ordenadores AT-386. He alcanzado la etapa en la que puede ser utilizable y voy a


poner las fuentes para su distribución. Es sólo la versión 0.02 ... pero he conseguido ejecutar
en el bash, gcc, gnu-make, gnu-sed, compress, etc.”
Tras esta versión y el apoyo de voluntarios “enganchados” a Internet, no ha dejado de
evolucionar y mejorarse:
1992 Linus añadió Linux al proyecto GNU.
Abril de 1992, aparece la primera versión capaz de ejecutar X.
Abril de 1994, primera versión completa de Linux, la 1.0.
Diciembre de 1996 aparece la versión 2.0.
Para comprobar la versión actual http://www.kernel.org
Linux ha sido registrado bajo los términos de la Licencia Pública General GNU (GNU General
Public License) o GPL. Esta licencia, escrita por la Free Software Foundation (FSF), está diseñada
para evitar que alguna persona restrinja la distribución de software. En pocas palabras, dice que
aunque Ud. cobre a alguien por entregarle una copia, no podrá impedir que ese alguien la regale.
También significa que debe estar disponible el código fuente. Esto es útil para los programadores.
Cualquiera puede modificar Linux y aún distribuir sus modificaciones, siempre que mantenga el
código bajo la misma licencia.

La G.N.U.
Linux está regido por lo que se conoce como la Licencia Pública General de GNU, o GPL,
General Public License. La GPL fue desarrollada para el proyecto GNU por la Free Software
Foundation, que podemos traducir como "Fundación por el Software Gratuito". La licencia hace una
serie de previsiones sobre la distribución y modificación del "software gratis". "Gratis" en este
sentido se refiere a libertad, y no sólo al coste. La GPL puede ser interpretada de distintas formas,
y esperamos que este resumen ayude a entenderla y cómo afecta a Linux. Se puede encontrar una
copia completa de la Licencia en Internet o en cualquier libro de Linux.
Originalmente, Linus Torvalds lanzó Linux bajo una licencia más restrictiva que la GPL, que
permitía que el software fuera libremente distribuido y modificado, pero prohibía su uso para ganar
dinero. Sin embargo, la GPL autoriza que la gente venda su software, aunque no le permite
restringir el derecho que su comprador tiene a copiarlo y venderlo a su vez.
En primer lugar, hay que aclarar que el "software gratis" de la GPL no es software de dominio
público. El software de dominio público carece de copyright y pertenece literalmente al público. El
software regido por la GPL sí tiene el copyright de su autor o autores. Esto significa que está
protegido por las leyes internacionales del copyright y que el autor del software está declarado
legalmente. No sólo porque un programa sea de libre distribución puede considerársele del dominio
público.
El software regido por la GPL tampoco es "shareware". Por lo general, el "shareware" es
propiedad del autor, y exige a los usuarios que le paguen cierta cantidad por utilizarlo después de la
distribución. Sin embargo, el software que se rige por la GPL puede ser distribuido y usado sin
pagar a nadie.
La GPL permite a los usuarios modificar el software y redistribuirlo. Sin embargo,
cualquier trabajo derivado de un programa GPL se regirá también por la GPL. En otras
palabras, una compañía nunca puede tomar Linux, modificarlo y venderlo bajo una licencia
restringida. Si un software se deriva de Linux, éste deberá regirse por la GPL también.
La GPL permite distribuir y usar el software sin cargo alguno. Sin embargo, también permite
que una persona u organización gane dinero distribuyendo el software. Sin embargo, cuando se
venden programas GPL, el distribuidor no puede poner ninguna restricción a la redistribución. Esto
es, si compras un programa GPL, puedes a su vez redistribuirlo gratis o cobrando una cantidad.


Esto puede parecer contradictorio. ¿Por qué vender software cuando la GPL especifica que
puede obtenerse gratis? Por ejemplo, supongamos que una empresa decide reunir una gran
cantidad de programas GPL en un CD-ROM y venderlo. La empresa necesitará cobrar por el hecho
de haber producido el CD, y asimismo querrá ganar dinero. Esto está permitido por la GPL.
Las organizaciones que vendan el software regido por la GPL deben tener en cuenta algunas
restricciones. En primer lugar, no pueden restringir ningún derecho al comprador del programa.
Esto significa que si compramos un CD-ROM con programas GPL, podremos copiar ese CD y
revenderlo sin ninguna restricción. En segundo lugar, los distribuidores deben hacer saber que el
software se rige por la GPL. En tercer lugar, el vendedor debe proporcionar, sin coste
adicional, el código fuente del software a distribuir. Esto permite a cualquiera adquirir el software
y modificarlo a placer.
Permitir a una empresa distribuir y vender programas que son gratis es bueno. No todo el
mundo tiene acceso a Internet para llevarse los programas, como Linux, gratis. La GPL permite a
las empresas vender y distribuir programas a esas personas que no pueden acceder al software
con un coste bajo. Por ejemplo, muchas empresas venden Linux CD-ROM por correo, y hacen
negocio de esas ventas. Los desarrolladores de Linux pueden no tener constancia de estos
negocios. Por ejemplo, Linus sabe que ciertas compañías venden Linux, y él no va a cobrar nada
por esas ventas.

Distribuciones de Linux.
Es imprescindible seleccionar una distribución que se adapte a las necesidades de cada uno
para poder instalar, configurar y administrar un sistema Linux con éxito.
Hace años, cuando Linux empezó a distribuirse por Internet, instalar Linux consistía en bajarse
de Internet todos los archivos necesarios a unos disquetes. En esos tiempos la instalación podía
llegar a ser un laborioso proceso, haciendo que muchos usuarios frustrados acabasen por rendirse.
Por ello, programadores de todo el mundo se unieron para crear distribuciones que incorporasen el
sistema operativo y programas que facilitaran la instalación, además de los paquetes conteniendo
programas de todo tipo. De esta forma la instalación se reducía a seguir unos pasos, dando la
posibilidad a los usuarios con pocos conocimientos de poder instalar un sistema operativo de este
tipo con un menor esfuerzo.
En este momento hay un buen número de distribuciones en las que poder elegir, pero cada
una de ellas tiene sus pros y sus contras.

Generalidades de la gestión del S.O.
Está escrito en C, en lugar de enamblador, como la mayoría de los sistemas, lo que le permite
una completa adaptación a los diferenes ordenadores.
Como otros SSOO consta de dos partes:
1. El núcleo, que se encarga de la gestión de la memoria, planificación de la CPU y el
Sistema de ficheros.
2. Los programas del sistema, que facilitan la compilación, ejecución y manipulación de
ficheros.
La CPU está planificada de forma que favorece los procesos interactivos.
La planificación de los procesos se hace mediante un algoritmo de prioridades, de forma que a
números mayores corresponde una menor prioridad y procesos del sistema poseen prioridad
negativa. Para los procesos que utilizan mucho la CPU, se les concede tiempo según Round-Robin.
La espera de un proceso indefinidamente, se resuelve mediante el cambio de prioridad por
envejecimiento de los procesos.
Existen dos tendencias en la planificación de la memoria, dependiendo de las diferentes
versiones de Unix:


a) En unas se utiliza el intercambio (swapping) entre los diferentes procesos. Los
procesos víctimas se eligen: por estar ociosos, llevar mucho tiempo en memoria o ser
grandes. Y se cargan en memoria si llevan mucho tiempo fuera o son pequeños.
b) En las versiones de Berkeley y Linux, se utiliza el sistema de memoria virtual con
paginación bajo solicitud.

El sistema de entrada y salida maneja normalmente dos tipos de dispositivos:
1. De bloque, como discos y cintas.
2. Y de caracteres, terminales e impresoras.
Los ficheros se organizan en directorios estructurados en árbol y se manejan mediante bloques
de datos.

Linux tiene soporte para diferentes sistemas de archivos, algunos son sistemas de archivos de
redes especializados o son sistemas de archivos desarrollados para otros sistemas operativos. Una
sorprendente cantidad de ellos pueden ser utilizados como sistema de archivos nativo en Linux:
ext2, ext3, ext4, ReiserFS, XFS, y Journaled File System (JFS).
La cuarta extensión del sistema de archivos (ext4fs) existe porque algunos desarrolladores
querían incorporar nuevas y mejoradas características al ext3. La mejora más llamativa de ext4
está en el soporte de archivos y sistemas de archivos de gran tamaño.

Características
Multitarea: Un usuario puede ejecutar varios programas (procesos) a la vez, sin tener que
detener una aplicación para ejecutar otra.
Multiusuario: Varios usuarios pueden acceder a las aplicaciones y a los recursos en el mismo
PC y al mismo tiempo. Con la impresión para cada uno de ellos de estar trabajando solo.
Tiempo compartido: Es la forma de conseguir las características anteriores, y se basa en que
en una fracción de tiempo muy pequeña, la CPU atiende a varios usuarios. A cada proceso se le
dedica por turno una unidad de tiempo llamada “cuanto”.
La memoria: es aprovechada al máximo, para acceder al disco el menor número de veces,
consiguiendo mayor rapidez.
Recuperación automática del sistema de ficheros después de una caída del sistema, o
interrupción eléctrica.
Seguridad de acceso a la información de cada usuario, mediante una serie de permisos que el
propietario puede conceder o denegar sobre cada uno de sus ficheros.
Multiplataforma: Corre en muchos PCs distintos (Intel 386/486/Pentium y compatibles,...).
Facilita la portabilidad del software, entre plataformas, al menos a nivel de código fuente.
Shell programables, lo que le hace ser un SO muy flexible.


Estructura del S.O. UNIX
Es un SO jerárquico, ya que se organiza en una serie de estratos, cada uno de los cuales
interactúa con su entorno a través de interfaces bien definidos.

SHELL
Utilidades
Dispositivos
Kernel
Hardware

Kernel o Núcleo
Es el corazón del sistema, la parte más cerrada al usuario y más cercana al hardware.
Reside permanentemente en memoria. Su trabajo consiste en:
• Planificar, coordinar y gestionar la ejecución de procesos.
• Dar servicio al sistema, como entrada / salida y gestión de ficheros.
• Manejar las operaciones dependientes del hardware, realizando las operaciones de más
bajo nivel de manera que se oculten al usuario.

Dispositivos
Los ficheros de dispositivo son los intermediarios entre el SO y el dispositivo físico.

Utilidades
Estas órdenes también conocidas como herramientas, que van desde el compilador de C,
hasta el editor de texto, pueden utilizarse por separado o de forma conjunta para llevar a cabo
tareas útiles. Se invocan por su nombre a través del Shell.

SHELL o Caparazón
Es la parte que permite al usuario comunicarse con el sistema, también se le conoce como
"caparazón".
Puede estudiarse desde dos puntos de vista:
1.- Como intérprete de comandos, es un programa que siempre está en ejecución.
- Espera que introduzcamos una orden.
- Analiza la línea.
- Comprueba su corrección y los permisos.
- Y llama a ejecución al programa o programas necesarios.

2.- Como lenguaje de programación: Combina, mediante estructuras de control grupos
de órdenes, estos ficheros se llaman procedimientos Shell, Shell Script o guiones Shell, además
posee sus propias sentencias. (se estudiarán más adelante)


Existen varios tipos de SHELL diferentes:
sh: Bourne Shell (Unix System V, Xenix). Los shell tipo Bourne toman su nombre a partir de su
inventor, Steven Bourne. Este fue el shell original de Unix, denominado sh; a partir de entonces, la
mayoría de los shells tienen un nombre con el sufijo sh para indicar que son extensiones de la idea
original.
Está diseñado para usuarios experimentados, su prompt por defecto es el signo dólar ($).
Tiene capacidad para redireccionar entradas y salidas, interpretar metacaracteres, usar tuberías y
filtros, manejar variables y además posee su propio lenguaje de programación.
Tradicionalmente, los shell Bourne se han utilizado para los scripts de shell por razones de
compatibilidad con el sh original
rsh: Reduced Shell, es un subconjunto del anterior, contiene las órdenes básicas. No permite
el cambio de directorio ni el redireccionamiento.
csh: C Shell (Berkeley), fue implementado por Bill Joy, los shells C han sido más comunes en
su aplicación interactiva. Es similar al sh, pero añade algunas características específicas para el
programador de C.
Ksh: Korn Shell, desarrollado por David Korn de Bell Laboratories, incorpora la mayor parte de
las características del csh y conserva la sintaxis y características básicas del sh.
Bash: Bourne Again Shell. Fue desarrollado en el marco GNU, y es el derivado más extendido
del Bourne Shell.
Tcsh: Una versión de csh para Linux.
En principio el Administrador del sistema adjudica un tipo de Shell a cada usuario, aunque este
puede cambiarse tecleando el nombre de otro Shell (si tiene permiso); se sale de un Shell pulsando
Ctrl + d.

Primera Aproximación

Antes de entrar al Sistema:
Debe de tener creada una cuenta de usuario, la cual tendrá un nombre y que además puede
llevar asociada una palabra clave.
Se podrá acceder al sistema mediante cualquier terminal que esté preparado, en cuyo caso
mostrará por pantalla: login:, esto quiere decir que está esperando a que le introduzcamos un
nombre de usuario. Una vez introducido y pulsado Return puede que nos pida una palabra clave
password: Pasados estos requisitos puede que aparezca algún mensaje y debajo el prompt del
Sistema.
Para los usuarios habitualmente el prompt es sólo el signo dólar ($), pero en linux suele
aparecer por defecto: el nombre del usuario, el de la computadora y la trayectoria actual en el árbol
de directorios (el directorio de conexión se muestra como ~).

Escribir algunos comandos para tomar contacto.
Hay que tener en cuenta que el UNIX distingue entre mayúsculas y minúsculas.
Se adelantan dos órdenes de gestión de ficheros, para crear un directorio “prueba”, en el que
se realizarán las primeras prácticas:

mkdir nombre_dir
Crea un nuevo directorio.


cd nombre_dir
Activa o se traslada al directorio indicado.

date
Muestra la fecha actual.

who
Indica que usuarios están en ese momento conectados al Sistema.

clear
Borra la pantalla.

echo mensaje
Vuelve a escribir el mensaje.

echo mensaje > fichero
El signo mayor que (>), significa redirigir la salida o resultado de un comando. Guardaría el
mensaje dentro del fichero que hayamos indicado.

ls
Lista los nombre de los ficheros.

cat fichero
Visualizaría el contenido del fichero, aunque su principal función es concatenar ficheros.

rm fichero
Borra el fichero indicado.

Cuando se desea terminar un programa antes de su fin normal debemos pulsar la tecla Supr
dos veces en Unix y Ctrl + C en Linux.

Para salirnos del Sistema pulsamos las teclas Ctrl + d.

1ª Práctica de familiarización con las órdenes anteriores.

Algunas utilidades para experimentar.

Consultar el manual
man orden
Nos explica la utilidad y el funcionamiento de la orden. Es un auténtico manual adaptado a
nuestro sistema en particular.

Hacer cálculos
bc
Se puede emplear como una calculadora normal.
Para separar los decimales emplea el punto (.).
Admite cualquier nivel de paréntesis.
Las operaciones son: + (suma), - (resta), * (multiplicación), / (división), % (módulo o resto), ^
(exponenciación).


Tiene capacidad para asignar valores a variables utilizando el signo igual (=).
Utiliza unas variables internas que rigen su trabajo, a las que les podemos cambiar su valor,
como son:
- obase=nº base del sistema de numeración en el que mostrará los resultados.

- ibase=nº ídem para leer las entradas.

- scale=nº nº de dígitos decimales que se deben de tener en cuenta en un
cálculo, comprendido entre 0 y 99,

Permite la creación de funciones, lo cual no se explicará por ahora; un ejemplo:
define a(x,y){
auto z
z = x * y
return(z)
}
Se usaría: a(4, 7.8)

Mirar el almanaque
cal [[mes] año]
Sin argumento nos muestra fecha, hora y despliega el mes actual, anterior y posterior.
Con un solo nº del 0 al 9999 muestra todo el calendario del año correspondiente; y si le
especificamos mes y año sólo muestra ese mes.

2ª Práctica de familiarización con las utilidades anteriores.


Conceptos Básicos del Sistema de Ficheros

Distribución de la información en disco:
- Sector de arranque. Almacena un pequeño programa de inicialización, que a su vez pasa el
control a otro más grande o al mismo KERNEL. En los sistemas de ficheros que no poseen
arranque el primer bloque no se utiliza.
- Superbloque también conocido como Cabecera del Sistema de Ficheros. Contiene datos
importantes sobre el resto de la distribución del disco, como es:
Bloques ocupados por los i-nodos: isize.
Bloque ocupados por los ficheros: fsize.
Puntero a la tabla de bloques disponibles.
- Tabla de i-nodos. Se almacenan a partir del bloque 2 con una longitud de isize bloques; están
numerados secuencialmente con un tamaño fijo de 64 bytes en los que se almacena información
relativa a un fichero.
- Bloques de ficheros. En ellos se almacena la información que contienen los ficheros (y otra
información necesaria como distintas tablas).
- Area de swap

Inodos
Los ficheros son la unidad fundamental del Sistema de Ficheros Linux. Cada fichero al ser
grabado es asociado automáticamente y durante toda su vida a un inodo (nodo-i), este identifica
perfectamente al fichero asociado y contiene los siguientes datos del fichero al que identifica:
TIPO: ordinario (-), directorio (d), especial (b) o (c), enlace simbólico (l)
PROPIETARIO: usuario que creó el fichero.
GRUPO: grupo al que pertenece el usuario.
PERMISOS: pueden ser de lectura, escritura y ejecución para el propietario, su grupo y
el resto de los usuarios. Estos se pueden alterar según las necesidades de seguridad con el
comando chmod.
NÚMERO DE ENLACES: un enlace es la unión entre un nombre de fichero y un inodo.
Un mismo fichero puede estar referenciado por otro nombre. Los enlaces se pueden crear con
la orden ln.
TABLA DE PUNTEROS: es un vector con trece posiciones, cada una de las cuales
almacena un puntero, cuyo significado es:
- Los diez primeros punteros señalan a los diez primeros bloques de información del
fichero.
- El décimoprimer puntero señala a otra tabla que contiene punteros, que a su vez
apuntan a bloques de información.
- El décimosegundo puntero señala a otra tabla que contiene punteros, que a su vez
apuntan a tablas de punteros, que apuntan a bloques de información.
- El décimotercer puntero señala a otra tabla de punteros, cada uno de los cuales
apuntan a tablas de punteros, que a su vez apuntan a tablas de punteros, que
apuntan a bloques de información.
FECHA DE CREACION.
FECHA DE LA ÚLTIMA MODIFICACION.
FECHA DE LA ÚLTIMA UTILIZACION.


Para comprobar el nº de inodo, usar la orden ls con la opción -i.

Los ficheros pueden ser esencialmente de tres tipos:
ORDINARIOS: lo que normalmente se entiende por ficheros, contienen texto, datos o
programas.
ESPECIALES: corresponden a dispositivos físicos (hacen de interface entre el Sistema y el
dispositivo físico), sirven para que nos podamos comunicar con discos, impresoras, terminales y la
memoria del Sistema. Son llamados también ficheros especiales de dispositivos, y pueden ser de:
o Bloques (b), disquete, partición del disco duro, disco duro entero,...
o Caracteres (c), cinta magnética, puerto paralelo, puerto serie,...
Esos ficheros se almacenan en el directorio /dev:
o /dev/fd0 disquete de la primera disquetera (A: en Windows).
o /dev/sda primer disco duro (sin considerar particiones) (antes eran /dev/hda para
discos IDE y /dev/sda para SCSI).
o /dev/sda1 primera partición del primer disco.
o /dev/sdb segundo disco duro.
o /dev/sdc disco USB (se utiliza emulación SCSI).
o /dev/sdc1 partición de un disco USB.
o /dev/ttyS1 primera terminal de consola.
o /dev/ttyS2 segunda terminal de consola.
o /dev/lp0 primer puerto paralelo.
o /dev/null cualquier dato enviado a este dispositivo desaparece.
o /dev/pty pseudoterminales, proporcionan un "terminal" a sesiones remotas.
o /dev/console consola del sistema, monitor conectado directamente a su sistema.
o /dev/tty consolas virtuales del sistema.

DIRECTORIOS:
Con la orden cat fichero ¿Cómo accede el SO a los bloques de este fichero?.
Los directorios son ficheros que contienen información sobre ficheros u otros directorios, esta
información es su nombre y número de inodo. Con el comando ls se pueden visualizar los nombres
de los ficheros contenidos en el directorio y otros datos.
Linux utiliza la estructura de directorios en forma de árbol, para mantener la cohesión entre sus
ramas, cada directorio contiene otro llamado . (punto), que hace referencia a él mismo, y otro .. (dos
puntos), que hace referencia al su directorio padre.
Para ver la información de los directorios . y .., utilizar la orden ls con la opción -a.
Utilizar la orden ls -l, que nos muestra la mayor parte de las características de los ficheros y
directorios (tipo, permisos, enlaces, propietario, grupo, ocupación en bytes, fecha última actualización y
nombre del fichero).
Distingue entre los tipos de ficheros, para ver ficheros de dispositivo en /dev.
Observa los permisos de los ficheros ordinarios y de los directorios. ¿Son iguales?
¿A qué grupo perteneces?
Estudiar el nº de enlaces de los directorios.
a) Recién creado.
b) Con distinto nº de subdirectorios.


Organización de directorios en Unix
Ejemplo de estructura básica de un sistema Linux:
/.

bin boot dev etc home lib proc sbin usr tmp var

Ftp Linux user## X11R6 bin doc etc lib local sbin

bin lib man faq howto bin lib man

/ Directorio raiz del sistema de ficheros. En algunos casos directorio home del
administrador.

bin Abreviatura de “binaries”. En este directorio se encuentran los órdenes básicas del SO.
En /usr/bin también hay órdenes básicas, pero son menos esenciales.

boot Aquí están los ficheros binarios de arranque del sistema (vmlinuz)

dev Contiene los ficheros especiales o de dispositivo (device drivers). Son usados para
acceder a los dispositivos del sistema y recursos, como discos duros, módems,
memoria, etc. Por ejemplo, de la misma forma que podemos leer datos de un fichero,
podemos leerla desde la entrada del módem usando /dev/modem.

etc En este directorio se encuentran las órdenes relacionadas directamente con la
administración del sistema, así como los ficheros de datos asociados. Estos incluyen
/etc/passwd (la base de datos de usuarios), /etc/rc (guiones de
inicialización del sistema), etc.

home Por cada usuario cuelga de home un directorio que por defecto tendrá el mismo nombre
que el del usuario. Ejemplo /home/user01. Estos a su vez dentro de su directorio pueden
crear la estructura de ficheros y directorios que necesiten.

root En algunos sistemas es el directorio de conexión (home) del administrador.

lib Directorio que contiene las librerías compartidas. Estas son comunes para todos los
programas que las usan, en lugar de tener cada programa su copia.


proc No existe físicamente, es un SF virtual. Los ficheros que contiene residen realmente en
memoria. En él podemos encontrar información sobre el sistema (procesos).

sbin Contiene los programa utilizados en la inicialización del sistema y en la recuperación del
mismo.

tmp Contiene los ficheros temporales que el Sistema necesita crear para realizar
determinados trabajos.

usr Para almacenar otros directorios accesibles a los usuarios, tales como: /usr/lib, /usr/bin,
/usr/share/man, /usr/share/doc. En algunos sistemas, de aquí cuelgan los directorios de
los usuarios.
Los directorios descritos arriba son esenciales para que el sistema esté operativo, pero
la mayoría de las cosas que se encuentran en /usr son opcionales para el sistema. De
cualquier forma, son estas cosas opcionales las que hacen que el sistema sea útil e
interesante, contiene la mayoría de los paquetes grandes de programas y sus ficheros
de configuración.
/usr/X11R6 Contiene el sistema X Window si lo instalamos. El sistema X Window es un entorno
gráfico grande y potente el cual proporciona un gran número de utilidades y programas
gráficos.
/usr/bin Es el almacén real de programas del sistema Unix. Contiene la mayoría de los
programas que no se encuentran en otras partes como /bin.
/usr/etc Como /etc contiene diferentes ficheros de configuración y programas del sistema,
/usr/etc contiene incluso más que el anterior. En general, los ficheros que se encuentran
en /usr/etc/ no son esenciales para el sistema, a diferencia de los que se encuentran en
/etc, que si lo son.
/usr/include Contiene los ficheros de cabecera para el compilador de C. Estos ficheros
(la mayoría de los cuales terminan en .h, de header) declaran estructuras de datos,
subrutinas y constantes usados en la escritura de programas en C. Los ficheros que se
encuentran en /usr/include/sys son generalmente usados en la programación de Unix a
nivel de sistema.
/usr/include/g++ Contiene ficheros de cabecera para el compilador de C++ (muy parecido a
/usr/include).
/usr/lib Contiene las librerías equivalentes stub y static a los ficheros encontrados en /lib.
Además, varios programas guardan ficheros de configuración en /usr/lib.
/usr/local En general, los programas que se encuentran en /usr/local son específicos de
nuestro sistema, esto es, el directorio /usr/local difiere bastante entre sistemas Unix.
Aquí encontraremos programas grandes como TEX (sistema de formateo de
documentos) y Emacs (gran y potente editor), si los instalamos.
/usr/man Este directorio contiene las páginas de manual.
/usr/src Contiene el código fuente (programas por compilar) de varios programas de
nuestro sistema. El más importante es /usr/src/linux, el cual contiene el código fuente del
kernel de Linux.

opt Este es la raíz del subárbol que contiene los paquetes de aplicación específicos.


var Este contiene los directorios de todos los ficheros que cambian de tamaño o tienden a
crecer, como /var/adm (ficheros de registro y contabilidad), /var/mail (ficheros de correo
del usuario), /var/spool (ficheros que van a ser pasados a otro programa), /var/news
(mensajes de interés común),...

mnt o media De este cuelgan directorios para montar sistemas de ficheros sobre el Root File
System. Por ejemplo /mnt/floppy, /mnt/cdrom,...

lost+found (perdido+encontrado) Contiene ficheros que por algún problema no están enlazados
al Sistema de Ficheros.
Explorar la estructura de directorios.

Trayectoria o pathname:
Es el camino que hay que seguir dentro de la estructura arborescente de directorios para
encontrar un fichero o directorio.
Vamos a distinguir dos tipos de trayectorias:
1. Trayectoria absoluta es la que parte del directorio raíz (root).
2. Trayectoria relativa es la que parte del directorio de trabajo.

Referencias a directorios especiales:
- Directorio raíz (root) simbolizado con la barra de dividir.
- Directorio domicilio o casa (HOME), es el directorio que le corresponde al
usuario dentro del directorio home o usr; Nos vamos a casa con cd.
- Directorio de trabajo, activo o en curso, es aquel en el que nos encontramos
trabajando en un momento determinado, se representa por un punto (.). pwd
nos informa del directorio actual.
- Directorio padre del directorio en curso, es el directorio del cual cuelga el
directorio activo, se representa por dos puntos (..).

Nombres de ficheros y Metacaracteres
Linux admite nombres largos de hasta 255 caracteres (Unix originalmente hasta 14 caracteres)
normalmente incluyen caracteres alfanuméricos y el punto (.).
En un directorio no puede haber dos ficheros con el mismo nombre, pero sí en directorios
diferentes.
Cuando un nombre empieza por un punto se oculta a algunas órdenes.
Dentro de los nombres de fichero se interpretan de forma especial los siguientes caracteres,
también llamados metacaracteres. Se usan especialmente para hacer referencia a un grupo de
ficheros:
- * Equivale a 0 o más caracteres.
- ? Equivale a un solo carácter.
- [caracteres] Equivale a cualquier carácter contenido dentro de los corchetes,
sólo a uno. Se puede especificar un rango de caracteres con solo indicar el
primero y el último separados por un guión (-). También se puede negar el


conjunto de caracteres, para indicar cualquier carácter que no esté entre los
corchetes, poniéndole delante el signo de admiración [!caracteres].
- Suprime el significado propio del metacarácter que vaya a continuación.
El proceso de sustitución de los metacaracteres, por los nombres de los ficheros que
correspandan se llama expansión de los metacaracteres, y es efectuado por el intérprete de
comandos, de esta forma los comandos u órdenes nunca ven los metacaracteres.

Crear todos los ficheros necesarios para practicar con los metacaracteres, al menos con la orden
ls.


Trabajo del Usuario con Ficheros Ordinarios.

Formato de las órdenes
orden [opción(es)] [argumento(s)]
Siempre es obligatorio el nombre de la orden, teniendo en cuenta que Unix distingue entre
mayúsculas y minúsculas.
Las opciones matizan la forma de trabajar la orden. Suelen ser un solo carácter, normalmente
precedido por un guión (-), si hay varias se pueden colocar juntas (sin mediar espacio) después de
un solo guión.
Los argumentos nos indican con que va a trabajar la orden, suelen ser nombres de ficheros, de
directorios, usuarios, terminales, etc. Si hay que indicar varios se pueden utilizar los metacaracteres
o simplemente se separan con un espacio.
Existen comandos “sucios”, que no responden a este formato.

Crear ficheros
Vacío:
cat /dev/null > fichero
> fichero
Las dos órdenes tienen el mismo efecto, en la primera de ellas se emplea el dispositivo nulo.
Con información tecleada por nosotros:
cat > fichero
cat -> fichero
Esta orden nos permitirá introducir tantas líneas de texto como deseemos, al final de las cuales
pulsaremos ^d como señal de final de fichero, y se almacenarán en el fichero indicado.
Con información procedente de cualquier otra orden
Esta otra orden debe de producir una salida redireccionable.
orden > fichero

Listar nombres e informacion sobre ficheros.
ls [opciones] [ficheros | directorio(s)]
Sin ninguna opción ni argumento produce un listado de los nombres de los ficheros del
directorio activo en orden alfabético. Entre las opciones más interesantes contamos con:
-l Imprime información detallada sobre el fichero: tipo, permisos, enlaces, propietario,
grupo, ocupación en bytes, fecha de la última actualización y nombre del fichero. "ls -
l" se puede abreviar en solo "l".
-n Igual que -l, pero del propietario y grupo no muestra su nombre, sino su número,
llamados UserId y GroupId respectivamente.
-i Muestra el nº de i-nodo de cada fichero.
-a Indica a la orden que tenga en cuenta a todos los ficheros incluidos los ocultos.
-d Para que nos muestre información del directorio y no de los ficheros que contiene el
directorio.
-t Los muestra ordenados por fecha de actualización, primero los más recientes.
-r Invierte el orden de mostrar los ficheros.


-R Recursividad.
-F Pone una (/) después de cada directorio y un (*) después de cada ejecutable.
La orden l es un alias de ls –la.
Como argumentos se puede especificar: nombre(s) de fichero(s), de directorio(s) y utilizar los
metacaracteres.

file fichero(s)
Realiza una suposición sobre qué tipo de información almacena un fichero; así nos puede
indicar sí un fichero es de texto, ejecutable, directorio, un programa fuente, está comprimido ...
Para ello revisa la primera parte del fichero en busca de palabras clave o números especiales
del linkador, también consulta los permisos de acceso. Sus resultados no siempre son correctos.

Ojear la salida de órdenes o contenido de ficheros.
orden | less
less fichero(s)
Dosifica la salida por pantalla, cuando el resultado no entra en ella.
Posee una serie de comandos para poder desplazarnos por la salida.
h.....................................Ayuda de less.
q.....................................Para salir de less.
j, Intro o flecha abajo .....Avanza línea.
k o flecha arriba.............Retrocede línea.
Nºj..................................Avanza Nº líneas.
Nºk.................................Retrocede Nº líneas.
z.....................................Avanza pantalla.
w ....................................Retrocede pantalla.
Barra espaciadora .........Avanza página.
Ctrl + L...........................Refresca pantalla.

Si estamos usando “telnet”, deberíamos usar la siguiente configuración, que podemos
establecer en “Terminal Preferencias”:
Emulación VT100/ANSI.
Búfer 24 líneas.
Flechas VT100 Sí.
Cursor Intermitente Sí. (A mí me gusta más)

Ejercicios:
Ver más opciones de less y ls con man.
Probar las distintas opciones y sus combinaciones.
Seguir practicando con los metacaracteres.
Ver el nº de enlaces de los directorios.
Comprobar que los directorios enlazados tienen el mismo nº de inodo.

Copiar, Mover, Enlazar y Borrar Ficheros.
Copiar:
cp [opc.] f_origen f_destino


-i Pide confirmación antes de sobreescribir.
-r Copia recursiva, incluyendo subdirectorios.
Realiza duplicados de ficheros, en el mismo directorio con distinto nombre o en distinto
directorio con cualquier nombre. Sí el nombre del fichero destino ya existe se pierde la información
que pudiera tener.
Sobre el f_origen hay que tener al menos permiso de lectura (r) y sobre el f_destino, si ya
existe, de escritura (w).
Como destino se puede indicar un directorio, en cuyo caso se copiarían todos los ficheros
origen en él.
cp f(s)_origen directorio
Los ficheros origen se pueden indicar por su nombre completo, separados por blancos o
utilizando metacaracteres; por supuesto se puede emplear una trayectoria.
Con esta orden al duplicarse la información nunca se pierde el contenido del fichero origen.
Mover:
mv [-i] f_origen f_destino
mv [-i] f(s)_origen directorio
Renombra un fichero dentro de un directorio o lo traslada a otro directorio.
La diferencia con la orden cp es que mv no duplica la información, desapareciendo siempre los
ficheros origen.
-i Si en el destino ya existe el fichero, pregunta antes de sobreescribirlo.
La mayoría de las veces es más rápida que cp, ya que se limita solo a anotar el cambio en los
ficheros directorio.
Enlazar:
ln [-f] f_origen f_destino
-f No hace preguntas.
A un mismo fichero se le da otro nombre, los dos nombres se referirán en adelante al mismo
fichero.
No se hace una copia del fichero origen y el nuevo nombre puede estar en distinto directorio.
Lo único que realiza esta orden es añadir una nueva entrada en el directorio que corresponda
con el nombre del fichero destino y el nº de i-nodo del fichero origen.
No es necesario poseer ningún permiso sobre el fichero origen, pero si debemos poseer
permiso de escritura (w) sobre el directorio destino y de lectura sobre el directorio origen.
Como origen se pueden indicar varios ficheros si el destino es un directorio.
-s Realiza un enlace simbólico.
Un enlace o vínculo simbólico es un archivo que sólo contiene el nombre de otro archivo.
Cuando el SO opera sobre el enlace simbólico, se dirige hacia el archivo al que apunta. Se usan
para enlazar ficheros en computadoras diferentes o en distintos sistemas de ficheros, también para
crear varios nombres a un directorio.
Estas tres órdenes tienen en común, que el contenido del fichero destino, si existe, es
destruido.

Borrar:
rm [opc] fichero(s)


Para borrar un fichero es necesario poseer permiso de escritura sobre el directorio, no sobre el
fichero, pues lo que realmente se hace es borrar un entrada del directorio.
Si el fichero a borrar tiene varios enlaces, se borrar el enlace que tiene con el nombre de
fichero indicado, los demás permanecen.
-f (forzar) Sí no tenemos permiso de escritura sobre el fichero, se salta una pregunta
de confirmación y lo borra.
-i (interactivo) Pide confirmación en todos los ficheros.
-r (recursivo) Borra a partir de donde le indiquemos, toda la posible rama de
subdirectorios, es rápida y peligrosa.
Ejemplos peligrosos:
rm * .c
rm -r dir1

Ejercicios:
Duplicar un fichero en el mismo directorio.
Copiar varios ficheros al mismo tiempo a otro directorio.
Renombrar un fichero. Comprobar si le ha cambiado el nº de inodo.
Mover ficheros a otro directorio. ¿Tienen otro inodo?
Crear enlaces de un fichero en el mismo y distinto directorio. Comprobar inodos y el nº de
enlaces. Borrar algunos de los enlaces creados y volver a comprobar el nº de enlaces.
Intentar hacer un enlace duro a un directorio.
Realizar enlaces simbólicos de ficheros. Comprobar el carácter de tipo de fichero. ¿Concuerda el
nº de inodo?. Trabajar con el enlace simbólico. Borrar el fichero origen del enlace. Volver a
trabajar con el enlace simbólico.
Crear un enlace simbólico a un directorio.
Estudiar los permisos de vuestro directorio home. ¿Qué permisos tienen los de tu grupo?.
Entra en el directorio home de algún compañero. Intenta crear ficheros. Borra un fichero.

Permisos, Propietario y Grupo.
Las operaciones que se pueden realizar sobre un fichero son: leer (r), escribir (w) y ejecutar (x).
Estos permisos se conceden o deniegan a tres niveles: el propietario del fichero, el grupo al que
este pertenece y el resto de los usuarios.
Que el grupo posea un permiso determinado no implica que lo posea el usuario, y que el resto
posea un permiso no implica que lo posean el usuario y el grupo.
En un fichero convencional tener permiso de lectura significa poder consultar el contenido del
fichero, el permiso de escritura indica que se puede modificar y el de ejecución que se pueden
ejecutar las órdenes contenidas en el fichero.

En los ficheros directorio el permiso de lectura posibilita que podamos averiguar el contenido
del directorio, es decir, los nombres de los ficheros que contiene, el no poseer este permiso no
impide acceder al contenido de los ficheros.
El permiso de escritura nos permite crear y borrar ficheros, la modificación de un fichero en
particular no la controlan los permisos de directorio sino los de ese fichero.


El permiso de ejecución en el caso de directorios impide que podamos usarlo dentro de una
trayectoria o que lo usemos como directorio de trabajo, denegar el permiso de ejecución si es una
protección real para un directorio y los ficheros que contenga. (Si perdemos el permiso de ejecución
sobre el directorio de trabajo o el padre de este, podemos desplazarnos a cualquier otro usando
una trayectoria absoluta.)

El propietario de un fichero puede cambiarle los permisos con respecto a él mismo, su grupo o
el resto de los usuarios con la orden:

chmod [quien(es)][+-=][permiso(s)] fichero(s)| directorio(s)
[quien]: u Usuario propietario.
g Grupo.
o Otros, el resto.
a Todos (por defecto).
[+-=]: + Añade permiso.
- Elimina permiso.
= Asigna o establece permiso. Añade los permisos indicados y quita
los demás, para los usuarios indicados.
[permiso]: r Lectura.
w Escritura.
x Ejecución.
Ejemplos:
− Un permiso a un quién: chmod g+w fichero
− Varios permisos a un quién: chmod o+rwx fichero
− Varios permisos a gente variada: chmod go-rw fichero
− Permisos distintos para varia gente: chmod o-r,g+w fichero
(nunca espacio después de la coma)
− Asignación absoluta: chmod ug=rw fichero

Ejercicios:
Si a un fichero con varios enlaces se le cambian los permisos ¿Se cambiarán también en sus
ficheros enlazados?
Quitar a un fichero permiso de w: mostrarlo, añadirle información, borrarlo. (Podemos por
ahora escribir en un fichero añadiéndole información con: orden >> f1)
Quitar a un fichero permiso de r: mostrarlo, añadirle información, borrarlo.
Grabar en un fichero: clear
echo hola mundo
echo te encuentras en
pwd
Poner su nombre después del prompt, para ejecutarlo.
Darle permiso de ejecución.
Poner su nombre después del prompt, para ejecutarlo.


También se permite una notación numérica, en octal, para indicar los permisos que se van a
establecer a unos determinados ficheros.
chmod número_octal fichero(s)

Número_octal: Un fichero tiene 9 permisos, se codifican en binario, si se tiene permiso 1 y si no
se tiene 0; resulta un número binario de 9 dígitos binarios, este se pasa a octal y obtenemos el
número octal de tres dígitos.

Ejemplo: permiso de escritura al propietario, permiso de ejecución al propietario y al grupo y
permiso de lectura a todos.
chmod a=r,u+w,ug+x fich
chmod 754 fich

Permisos especiales.
Aún hay otro tipo de permisos que hay que considerar. Se trata de:
o El bit de permisos SUID (Set User ID).
o El bit de permisos SGID (Set Group ID).
o El bit de permisos de persistencia (sticky bit).
Para entender los dos primeros el SUID y el SGID veamos los permisos para un comando de
uso común a todos los usuarios, que es el comando passwd, que como se sabe sirve para cambiar
la contraseña del usuario, y puede ser invocado por cualquier usuario para cambiar su propia
contraseña, si vemos sus permisos observaremos un nuevo tipo de permiso:
#> ls -l /usr/bin/passwd
-r-s--x--x 1 root root 21944 feb 12 2006 /usr/bin/passwd

SUID
En vez de la 'x' para el usuario encontramos ahora una 's' (suid). passwd es un comando
propiedad de root, pero sin embargo debe de poder ser ejecutado por otros usuarios, no solo por
root. Es aquí donde interviene el bit SUID, al activarlo obliga al archivo ejecutable binario a
ejecutarse como si lo hubiera lanzado el usuario propietario y no realmente quien lo ejecutó. Es
decir, es poder invocar un comando propiedad de otro usuario (generalmente de root) como si uno
fuera el propietario.
SGID
El bit SGID funciona exactamente igual que el anterior solo que aplica al grupo del archivo. Es
decir si, permite ejecutar el comando con los permisos del grupo.
Se muestra como una 's' en vez del bit 'x' en los permisos del grupo.
#> ls -l /usr/bin/write
-rwxr-sr-x 1 root tty 10320 Jun 6 2008 write

STICKY BIT (Bit de persistencia)
Este bit se aplica para directorios, como en el caso de /tmp y se indica con una 't':
#> ls -ld /tmp
drwxrwxrwt 24 root root 4096 sep 25 18:14 /tmp


Puede apreciarse la 't' en vez de la 'x' en los permisos de otros. Lo que hace el bit de
persistencia en directorios compartidos por varios usuarios, es que el sólo el propietario del archivo
pueda eliminarlo del directorio.
Para cambiar este tipo de bit se utiliza el mismo comando chmod pero agregando un número
octal extra al principio de los permisos, ejemplo:
#> ls -l /usr/prog
-r-x--x--x 24 root root 4096 sep 25 18:14 prog
#>chmod 4511 /usr/prog
#> ls -l /usr/prog
-r-s--x--x 24 root root 4096 sep 25 18:14 prog
Nótese que el valor extra es el '4' y los demás permisos se dejan como se quieran los permisos
para el archivo. Es decir, los permisos originales en este ejemplo eran 511 (r-x--x--x), y al
cambiarlos a 4511, se cambió el bit SUID reemplazando el bit 'x' del usuario por 's'.
Los posibles valores serían los siguientes:
- - - - - - - - - = 0 Predeterminado, sin permisos especiales.
- - - - - - - - t = 1 Bit de persistencia, sticky bit
- - - - - s - - - = 2 Bit sgid de grupo
- - s - - - - - - = 4 Bit suid

MUY IMPORTANTE: Algo sumamente delicado y que se tiene que tomar muy en cuenta es lo
que decidas establecer con permisos de bit SUID y SGID, ya que recuerda que al establecerlos de
esta manera, cualquier usuario podrá ejecutarlos como si fuera el propietario original de ese
programa. Y esto puede tener consecuencias de seguridad severas en tu sistema. Siempre
considera y reconsidera si conviene que un usuario normal ejecute aplicaciones propias de root a
través del cambio de bits SUID o SGID. Mejores alternativas pueden ser los comandos sudo y su.

Máscara de permisos para la creación de ficheros.
El propietario también puede definir con que permisos por defecto se crearán sus ficheros.
umask [número_octal]
Solamente tiene formato numérico, el nº octal al pasarlo a binario, los unos indican los
permisos que quitamos y a quién.
La orden tiene efecto para el usuario que la aplica, y a partir de su uso los ficheros y directorios
se crearán con la restricción de los permisos indicada.
(Atención: a los ficheros de texto, en un principio, no se les asigna permiso de ejecución)
Si utilizamos la orden sin ningún parámetro, muestra la máscara de creación actual, que suele
ser 022.
Para dejarlo fijo en la sesión, agregarlo a .bashrc de nuestro directorio de inicio.
Cambio de propietario.
El propietario de un fichero en System V (en los sistemas Berkeley solo el administrador)
puede cambiar el fichero de propietario y de grupo.
chown [-R] nuevo_propietario[:grupo] fichero(s)
-R Recursividad.
El nombre del nuevo propietario debe de ser un nombre válido de entrada al sistema (login) o
un número de identificación de usuario; estos y otros datos se encuentran en el fichero /etc/passwd.


Si el usuario perteneciese a otro grupo se indica este separado del usuario por (:). Y se cambia
al mismo tiempo de usuario y de grupo.
Cambio de grupo.
chgrp nuevo_grupo fichero(s)
Igualmente el nuevo grupo se puede indicar con el nombre o el número de identificación, que
se encuentra en el fichero /etc/group.

Ejercicios: (en octal)
Poner a dos ficheros al mismo tiempo los permisos rw- -wx r--.
Quitarle a un subdirectorio todos los permisos ¿Qué podéis hacer en él?
Dejarle todos menos el de ejecución ¿Qué podéis hacer en él?
Mostrar el contenido de un directorio al que le falta el permiso de lectura.
Poner al directorio permiso de escritura y un fichero dentro de él sin este permiso, probar a
borrarlo.
Poner una máscara de creación, de forma que a los directorios sólo les de permiso de ejecución
para g y o, y para el propietario todos. Comprobarla creando algún directorio.
La máscara anterior, que permisos da a los nuevos ficheros ordinarios.
Intenta cambiar un fichero de propietario.


Operaciones Con Ficheros Directorios.
Ya sabemos visualizar el contenido de un directorio utilizando las orden ls, para lo cual
debemos de poseer permiso de lectura sobre él.

Creación.
mkdir trayectoria(s)
Para crear un directorio necesitamos permiso de escritura sobre el directorio en el que se va a
crear.
Se pueden crear varios directorios al mismo tiempo, indicando su trayectoria, ya sea absoluta o
relativa.
Ejemplos.
~> mkdir base/direc base2
~> mkdir base/dire1 base/dire1/dire2 (dire1 no existía)

Cambio de directorio activo.
cd [directorio]
Nos podemos desplazar libremente por el árbol de directorios siempre que tengamos permiso
de ejecución sobre los directorios por los que nos desplazamos.
Si no indicamos directorio se asume el directorio HOME o de conexión.

Dónde nos encontramos.
Si necesitamos asegurarnos de cual es nuestro directorio de trabajo utilizaremos la orden
pwd
En otras versiones de Unix no era tan fácil que el prompt nos indicase la trayectoria del
directorio de trabajo, por lo que esta orden era más utilizada. Pero todavía puede ser útil en
programas Shell.

Eliminar directorios
rmdir directorio(s)
Se requiere permiso de escritura sobre el directorio padre.
Antes de borrar un directorio debemos de borrar su contenido y cuidar de que no sea el
directorio de trabajo.
Otro usuario que tenga permiso para ello nos puede borrar nuestro directorio de trabajo, con lo
que nos dejará "como suspendidos en el aire", pero podemos transladarnos a cualquier otro
directorio.
El sistema permite borrar el directorio de trabajo.
Recordar que también se pueden borrar directoros usando la orden rm de forma recursiva.

Cambio de nombre.
mv directorio_antiguo directorio_nuevo
Se requiere permiso de escritura en el directorio padre.


Copia de directorios.
cp (-R) DirectorioOrigen DirectorioDestino
-R De forma recursiva.

Variables PS1 y PS2.
Se usan para definir el prompt o inductor del shell.
El prompt primario (PS1) aparece para solicitarnos la introducción de una orden.
El prompt secundario (PS2) se muestra cuando no se ha terminado de introducir un comando.
Tanto PS1 como PS2 son variables del shell que pueden ser redefinidas por los usuarios (cada
usuario tiene las suyas).
Esto se hace simplemente asignándole un nuevo valor, con el formato:
PS1=”NuevoValor”
El NuevoValor puede ser cualquier cadena, pero hay una serie de códigos con un significado
especial para modificar el inductor, estos son:
! Siguiente nº del histórico de sucesos.
$ Usa el signo $, salvo para root, que usa el signo # (tradicional).
d Fecha actual.
s Shell actualmente activo.
t Hora actual.
u Nombre del usuario.
w Directorio de trabajo actual (directorio activo).
h Nombre de la máquina. Host.

Ejercicios:
Crear varios directorios con la misma orden.
Trayectorias relativas.
Trayectorias absolutas.
Que el directorio activo no sea el padre de los subdirectorios.
Examinar el árbol de directorios de Unix.
Desplazarse usando ambos tipos de trayectorias.
Probar a eliminar un directorio no vacío.
Probar a eliminar un directorio vacío, pero que sea el directorio activo.
Eliminar varios directorios con la misma orden.
Cambiar nombres a directorios. Con y sin permiso de escritura sobre el padre.
Copiar una rama del árbol de directorios de forma recursiva.
Eliminar la rama recién copiada también de forma recursiva.
Modificar el prompt primario y secundario incluyendo texto y códigos especiales de la orden.


Flujo De Información.

Entrada y salidas estándar (std).
Muchas órdenes Unix reciben información desde el teclado, que es la entrada estándar (stdin)
y muestran los resultados por la pantalla, salida estándar (stdout); la pantalla también es la salida
estándar para los posibles errores (stderr).
Ejemplo:
Cat
sort
Sin opciones ni argumentos leen texto del teclado (stdin) y muestran los resultados por pantalla
(stdout), visualizando los posibles errores, en el caso de que se produzcan, por pantalla (stderr).

Tanto la entrada como las salidas estándar son tratadas como ficheros especiales, y el shell
los identifica por su número de descriptor de fichero:
stdin 0
stdout 1
stderr 2
(Deben de emplearse junto al signo de redireccionamiento).

El guión (-) realiza una entrada por teclado.

Redireccionamiento:
Se pueden redireccionar la entrada y salidas estándar mediante metacaracteres de
redireccionamiento: > < >>.
> Redireccionamiento de salida, envía los datos que normalmente saldrían por pantalla hacia
el fichero que indiquemos.
Ejemplo:
cat > file
cat 1> file
cat - > file
Usa la entrada estándar y la salida al fichero especificado.

>> redireccionamiento de adición, igual que el anterior, pero si el fichero al que se dirige la
salida ya existe no se borra la información que tenga, sino que la nueva se añade al final.
Ejemplo:
Cat 1>> file
Añadiendo información a un fichero desde la entrada estándar.

< Redireccionamiento de entrada, la orden no tomará la información del teclado, sino del
fichero especificado.
Ejemplo:
cat file
cat < file


cat 0< file
Toma como entrada el fichero indicado, siendo la salida por pantalla.

cat 0< fichero 1>> otro
La entrada de un fichero y la salida la añade a otro.

cat 2> errores 0< fichero 1> fichero1
cat fichero > fichero1 2> errores
Entrada fichero, salida fichero1 y errores al fichero errores.

Cat fichero1 – fichero2 > total
Entre dos ficheros permite una entrada por teclado

Con el formato:
orden >& fichero
Tanto la salida estándar, como la salida de error se almacenan en el fichero indicado.
Ejemplo:
Cat fichero fichero_inexistente >& todo

Tuberías (pipes):
Orden | Orden2
Mediante el uso de tuberías se consigue que la salida de una orden sea la entrada de otra. El
metacarácter tubería es |.
Ejemplo:
ls –lR /home | less

Duplicar la salida
orden | tee [opciones] fichero(s)
orden | tee [opciones] | filtro
La entrada que recibe tee la copia en la salida estándar y en el o los ficheros indicados como
argumentos.
-i No responde a interrupciones.
-a Si los ficheros existen le añade la información al final.

Ejemplo:
date | tee –a fecha
ls –l | tee listado
cat fichero1 – fichero2 | sort | tee FileOrden
El primero muestra la fecha y además la añade en un fichero.
E segundo muestra el contenido del directorio y lo almacena en el fichero listado.
Y el tercero concatena la entrada, la ordena, la muestra ordenada y la almacena en el fichero
FileOrden.


Ejercicios:
Practicar todos los redireccionamientos, con todas las formas de indicar la entrada y salida.
Combinar los redireccionamientos y la tubería.
En los ejercicios anteriores emplear los filtros vistos: less, cat y sort.

Filtros para: Contar, Ordenar y Eliminar Repetidos.
Contar:
wc [opciones] fichero(s)
Abreviatura de Word Counting. Sin opciones cuenta el número de líneas, palabras y caracteres
contenidos en un fichero o en la entrada indicada. Si se especifica un grupo de ficheros contabiliza
en cada uno de ellos y además muestra un total.
Si no especificamos la entrada, toma por defecto la entrada estándar.
Para que no muestre toda la información o la muestre en otro orden, podemos utilizar las
opciones:
-l Sólo cuenta las líneas.
-w Idem las palabras.
-c Idem los caracteres.
Ejemplos:
wc f1 f2 f3
Cuenta el nº de líneas, palabras y caracteres de cada fichero y hace un total.

ls | wc -w
Cuenta el nº de ficheros de un directorio.
Ordenar:
Este filtro además de clasificar puede fusionar ficheros. En principio lo hace siguiendo el código
ASCII.
La entrada, al igual que en todos los filtros, pueden ser: ficheros indicados como argumentos,
pasada por una tubería o suministrada por la entrada estándar.
sort [opciones] [campos] [fichero(s)]
Opciones generales:
-o file Sirve para indicar el fichero de salida. Ya que si redireccionamos la salida a un
fichero que se llame igual que el de entrada, se pierde la información.
-m Mezcla los ficheros que supone que están ordenados.
-c Comprueba si el fichero está ordenado.
-u Muestra las líneas repetidas una sola vez, útil para la mezcla de ficheros.
Opciones de ordenación de datos:
-d (diccionario), sólo tiene en cuenta los caracteres alfabéticos, numéricos y espacio.
-f Convierte mayúsculas a minúsculas a efectos de la ordenación.
-b Ignora los blancos iniciales.
-n Ordenamiento numérico, toman su valor aritmético el signo menos (-) y el punto
decimal (.). Los blancos iniciales no se tienen en cuenta.


-r Ordenación inversa.
-R Ordenación aleatoria (Random).
Ordenación de campos:
Los campos se entienden separados por blancos o tabuladores salvo que se indique la opción:
-tx Donde x es el carácter delimitador de campos. Es aconsejable poner el carácter
entre comillas.
Para indicar a partir de que campo se va a realizar la ordenación, pondremos: +n.c, donde n es
el número de campos que se van a saltar sin ordenar y c el número de caracteres que se saltan
contando a partir del último campo saltado.
+n Nº de campos que se saltan sin ordenar.
Pueden indicarse opciones sólo para un campo, si se colocan inmediatamente después del
especificador de campo, no irán precedidas de guiones; estas son b, f, n, r.
La lista de ficheros caso de ser varios los ordena y mezcla, salvo que se utilice la opción -m,
que sólo mezcla.

Ejemplos:
sort -f +1 lista > lista.ord
Un fichero de nombres y apellidos ordenarlo por apellidos.

who | sort | tee quien.hay
Muestra y almacena los usuarios que hay conectados de forma ordenada.

Eliminar líneas iguales o con parte igual.
uniq [opc] [-campos] [+carac.] [f_in] [f_out]
Controla las líneas consecutivas repetidas mostrando sólo una. Opciones:
-c Precede cada línea del número de repeticiones.
-d Sólo muestra las que se han repetido alguna vez.
-u Visualiza las que no se han repetido.
-campos: Ignora el número de campos que se indique.
+caracteres: Ignora el número de caracteres que se indique.

Si no se especifican ficheros de entrada o salida se utilizan la entrada y salida estándar.
Ejemplos:
Sort alumnos | uniq -1 | wc -l
En un fichero de alumnos compuesto por nombre y apellidos, cuenta todos los que hay con
apellidos distintos.
Sort direcciones | uniq -d –1
Una vez ordenado el fichero muesta los registros repetidos a partir del primer campo.
Ejercicios:
Practicar el filtro wc:
Sin opciones ni argumentos.
Con una opción, y varias cambiándolas de orden.


Con varios ficheros.
Pasándole la información mediante una tubería.
Almacenando el resultado en un fichero.
Practicar sort:
Sin argumentos ni opciones.
Ordenando un fichero.
Almacenando el resultado en otro fichero.
Probar las opciones y su combinación.
Mostrar el listado largo de ficheros de un directorio, ordenado por tamaño, de mayor a menor.
Ordenar el fichero de grupos (/etc/group) por el nº de grupo (campo 3) de menor a mayor.
Crear un fichero con los campos: Nombre, Apellidos y Edad, separados por (;).
Procurar que se repitan algunas edades y algunos apellidos.
Ordenar por edad de mayor a menor.
Ordenar por apellido.
¿Cuántos hay de cada edad?

Filtros para ver que hay en los ficheros.
El filtro más habitual para ver el contenido de un fichero es cat, ya visto.
Ver el final de un fichero.
tail [±nº][lbc] [fichero]
Sin opciones lista las 10 últimas líneas.
Sí el nº es positivo (+) empieza a mostrar a partir de ese nº de unidades, contando desde el
principio del fichero, en el caso de ser negativo (-) cuenta las unidades indicadas desde el final del
fichero. Las unidades se medirán según la letra que siga inmediatamente al nº, que puede ser:
b bloques.
c caracteres.
l (ele) líneas. Por defecto.

Ver el principio de un fichero.
head [-n] [fichero]
-n indica el nº de líneas que se van a mostrar, por defecto 10.
En un fichero tenemos los números del 0 al 9 (cada uno en una línea), escribir la línea de
comando para que nos muestre uno de ellos aleatoriamente.

Volcado en octal (octal dump)
od [opciones] [+desplazamiento] [fichero]
Es útil para ver que contienen los ficheros objeto o de texto con caracteres no imprimibles.
-c Los caracteres imprimibles los muestra con caracteres normales, los no imprimibles
con un nº en octal de tres dígitos, y algunos de estos los muestra de la siguiente
forma:
0 Nulo.
b Retroceso.
f Salto de página.
n Nueva línea.


r Return.
t Tabulador.
-d Decimal.
-x Hexadecimal.

Filtro para cambiar caracteres.
tr (translate), cambia o traduce caracteres procedentes de una entrada de acuerdo a las reglas
que se le indiquen.
Supongamos que tenemos un archivo que usa los dos puntos(:) para separar campos, y que
necesitamos cambiar cada dos puntos por otro carácter, por ejemplo el tabulador.
tr : “t” < fichero t representa un tabulador.
Formato:

tr [opc] lista_de_entrada lista_de_salida
Las listas deben de tener el mismo nº de caracteres, y la sustitución es posicional, el primer
carácter de la lista de entrada es sustituido por el primero de la lista de salida, ...
Normalmente se trabaja redireccionando la entrada y la salida.
Opciones:
-s (squeeze = estrujar, apretar) elimina caracteres repetidos en la salida.
-c (complement) toma como lista_de_entrada el complemento.
-d (delete) borra en la salida los caracteres del conjunto de entrada.

Indicar rangos
Se pueden usar conjuntos de caracteres. Por ejemplo para cambiar letras minúsculas por
mayúsculas:
tr “[a-z]” “[A-Z]” < fichero
Ejemplo para codificar texto, desplazando cada letra trece posiciones en el alfabeto inglés de
26 letras:
tr “[a-m][n-z][A-M][N-Z]” “[n-z][a-m][N-Z][A-M]” < fich > fich.13
Para traducir un conjunto de caracteres de entrada por el mismo carácter de salida, se usa el *
después del carácter de salida indicando que se repita las veces que sea necesario.
tr “[0-9]” “[#*]” < fichero

Eliminación de repetidos en la salida
tr -s “[0-9]” “[#*]” < fichero
Cada nº con todas sus cifras es reemplazado por un solo símbolo “#”.
Sustitución de los caracteres complementarios
tr -c “[a-z][A-Z][0-9]” “[#*]” < fichero
En el ejemplo anterior todo carácter no alfanumérico es sustituido por “#”.
Eliminación de caracteres
tr -cd “[a-z][A-Z][0-9]” < fichero


Son eliminados todos los caracteres no alfanuméricos incluidos los signos de puntuación,
espacios,...

Para representar caracteres especiales:
NNN character with octal value NNN.
a audible BEL
backslash
b backspace
f form feed
n new line
r return
t horizontal tab
v vertical tab

Para representar conjuntos de caracteres:
CHAR1-CHAR2 all characters from CHAR1 to CHAR2 in ascending order
[:alnum:] all letters and digits
[:alpha:] all letters
[:digit:] all digits
[:cntrl:] all control characters
[:lower:] all lower case letters
[:upper:] all upper case letters
[:graph:] all printable characters, not including space
[:print:] all printable characters, including space
[:punct:] all punctuation characters
[:blank:] all horizontal whitespace
[:space:] all horizontal or vertical whitespace

Ejercicio:
Dado un fichero de texto, producir un listado con las palabras que contiene ordenadas
alfabéticamente, sin que estén repetidas e indicar el nº de veces que aparece cada palabra en el
fichero.
tr -s "[:blank:]" "n" < fichero | sort | uniq -c


Buscar en ficheros. Familia grep.
Busqueda de un patrón en un fichero: grep, fgrep, egrep.
Buscar un patrón dentro de un fichero, grupo de ficheros, entrada estándar o la que se
le especifique mediante tubería o redireccionamiento. Cuando se busca en más de un fichero,
encabeza cada línea con el nombre del fichero.
En la formación del patrón se pueden usar expresiones regulares, también llamados
formatos de sustitución. Precisamente de las expresiones regulares toma su nombre que viene
de las siglas: Global Regular Expression and Print

grep [opc] patrón [fichero(s)]

Reglas importantes de los formatos de sustitución, expresiones regulares:
Si el patrón está formado por más de una palabra deben de incluirse entre comillas o
apóstrofos según los sistemas.
El punto (.) sustituye cualquier carácter único, igual que ? para el shell.
Una lista entre corchetes ([]) tiene el mismo significado que para el shell.
El circunflejo (^) dentro de unos corchetes precediendo una lista empareja todos los caracteres
que no estén en la lista, igual que la ! en el shell.
El signo dolar ($) al final de una expresión indica que debe de estar al final de una línea.
El acento circunflejo (^) al principio de una expresión indica el principio de línea.
El asterisco (*) sirve por cero o más repeticiones del carácter que le precede.
La barra invertida () quita el significado especial al siguiente carácter.

Sin opciones produce como salida las líneas que contienen el patrón.

-n Al principio de línea aparece su nº de línea.
-i Ignora mayúsculas y minúsculas.
-c Sólo indica el nº de líneas que contienen el patrón dentro del fichero.
-h No imprime los nombres de los ficheros.
-l (ele) Indica en que fichero(s) se encuentra el patrón.
-v Devuelve las líneas que no contienen el patrón.
Ejemplos:
grep byte *.apuntes
grep ".f" programas
grep [^m-t]ata fichero
grep "^Santa Fe$" america europa
grep ^[0-9][0-9]* datos


fgrep [opc] patrón(es) [fichero(s)]
La principal diferencia es que puede buscar muchos patrones de forma simultánea (puede
buscar miles de palabras al mismo tiempo), pero no permite el uso de metacaracteres para formar
expresiones regulares, sólo cadenas fijas.
Es más rápida que sus hermanas grep y egrep.
Le son válidas las opciones anteriores, y además:
-f fichero Sirve para indicar el fichero que contiene los patrones de búsqueda.
Si se especifican varios patrones en la línea de comando, irán todos entre comillas y separados
por un retorno de carro.
Ejemplo:
fgrep –f palabras lista1 lista2

egrep [opc] patrón(es) [fichero(s)]
Como fgrep puede leer patrones desde un fichero. Y como grep puede emplear expresiones
regulares.

Actualmente las órdenes
grep -E sustituye a egrep
grep –F sustituye a fgrep

Ejercicios:
Buscar una palabra en un fichero. Comprobar la opción para que no distinga las mayúsculas.
En varios ficheros buscar una frase e informar del nombre de los ficheros que la contengan.
Mostrar el nº de veces que aparece la palabra if al principio de línea en un fichero(s).
Eliminar las líneas en blanco de fichero1 y almacenarlo en fichero2.
Borrar todas las líneas que contengan Manolo, Manuel, Lolo o Manolín.

Comparacion de Ficheros.
diff - busca diferencias entre dos ficheros

diff [opciones] fichero-origen fichero-destino

Por defecto muestra los cambios de edición que habría que realizar en f1 para que quedase
igual que f2, de la siguiente forma:
Línea o rango de f1 operación línea o rango de f2
Donde operación puede ser:
a (añadir líneas de f2 a f1)
d (borrar líneas de f1)
c (cambiar líneas de f1 por líneas de f2).
Y a continuación de cada operación muestra las líneas afectadas, si estas se preceden por el
símbolo "<" quiere decir que son de f1, y si se preceden por ">" son de f2.


Opciones
-a Trata todos los ficheros como de texto y los compara línea por línea, incluso si no
parecen ser de texto.
-b No se tienen en cuenta los blancos al final de línea y trata los distinto conjuntos de
blancos como si fuesen iguales.
-B No hace caso de cambios consistentes en sólo insertar o borrar líneas en blanco.
-c Emplea el formato de salida de contexto.
-i Considera las letras mayúsculas y minúsculas equivalentes.
-q Informa sólo de si los ficheros difieren, no de los detalles de las diferencias.
-r Cuando compara directorios, compara recursivamente cualesquier subdirectorios
encontrados.
-u Emplea el formato de salida unificado.

Un estado de salida de 0 significa que no se encontraron diferencias, 1 significa que se
encontró alguna diferencia y 2 significa problemas.

Cortar y Pegar Ficheros.
Cortar de forma horizontal (por líneas).
split [-nº] [fichero] [prefijo]
Divide el "fichero" en trozos de n líneas, los trozos son grabados en ficheros cuyo nombre base
es "prefijo" y se le añaden las terminaciones "aa", "ab", hasta "zz", por lo que se puede dividir hasta
en 676 ficheros. (26 letras)
-nº Nº de líneas de cada trozo, por defecto 1000.
Si no se indica el "fichero" se toma la stdin.
Si no se indica el nombre base se asume "x".

Variante de split
csplit [-f prefijo] fichero arg1 [...argn]
Divide el fichero en las porciones que indiquen los argumentos, estos pueden ser:
n El trozo termina en la línea nº n (no incluida).
"/exp/" Hasta la línea que contiene la expresión (no incluida).
"%exp%" Salta sin grabar en fichero hasta la línea que contiene la expresión, esta línea se
graba en el próximo fichero.
En pantalla se muestra el tamaño de los ficheros en los que se divide. Algunas opciones son:
-f prefijo Prefijo tiene el mismo significado que en split, si no se pone se asume "xx" y
se van numerando, desde xx00 hasta xx99.
-s No muestra el tamaño de las partes en la salida estándar.


Pegar de forma horizontal.
Hemos utilizado la orden cat para crear y visualizar ficheros, con redireccionamientos y
tuberías, pero cat es una abreviatura de concatenar.
cat [opc] [fichero(s)] [-]
Concatena los ficheros especificados, y los muestra por stdout, la cual podemos redireccionar.
El guión (-) significa una entrada por teclado.
-v Muestra los caracteres no imprimibles.
-t Además los TAB los muestra como ^I. Sólo los TAB –T.
-e Además en los EOL muestra un $. Sólo los EOL –E.
-n Numera las líneas de salida.
-b No numera las líneas en blanco.
-s No muestra más de una línea en blanco.
-A Equivale a –vET.
Ejemplos:
cat f1 f2
cat f1 - f2 > f3

Dividir ficheros verticalmente (por columnas).
cut [opc] [fichero]
Permite seleccionar columnas (caracteres o campos) de un fichero, el resultado va a stdout.
-c lista Seleccionamos la columna por caracteres.
-f lista Indicamos la columna por campos (fields).
En ambos casos la lista está formada por un conjunto de números separados por comas o
guiones.
-dcarácter Informa de cual es el carácter delimitador de campos cuando usamos
la opción -f, por defecto se asume tab.
-s Se usa conjuntamente con la opción “f”, para pasar por alto las líneas que no tengan
el delimitador, como son cabeceras, títulos o líneas vacías.
Ejemplos:
Corta el rango de caracteres del 20 al 35:
cut -c20-35 datos
Se obtiene el 2º y 4º campo, actuando como separador los “:”
cut -d”:” -f2,4 datos

Unir ficheros verticalmente.
paste [opc] fichero(s)
Une los ficheros verticalmente, produciendo una única salida nueva.
Sin opciones, sustituye los caracteres de fin de línea por tab, excepto los del último fichero.
-dcarácter Carácter que sustituye los finales de línea.

Ejercicios:


Obtener un listado ordenado de todos los usuarios que son propietarios de algo dentro del
directorio /home; no deben de estar repetidos. Orientaciones:
A la salida de la orden ls -l le podemos eliminar la cabecera.
Cortar la columna de los propietarios.
Ordenar
Eliminar los repetidos.
En un fichero de alumnos, donde tenemos los datos de un alumno por linea, con los datos
Nombre; Apellidos; Edad. Obtener otro fichero con los datos apellidos, nombre; ordenado por
apellidos.

Búsqueda de ficheros.
find [ruta(s)] [opcion(es)]
Es útil para localizar ficheros que cumplan determinadas condiciones o características, en las
ramas del árbol de directorio que se le indique. Finalmente sobre los ficheros o directorios
encontrados se puede ejecutar alguna acción.
Dentro de las opciones, unas indican criterios de búsqueda (en el caso de que se indique más
de un criterio se seleccionan los ficheros que cumplan todos simultáneamente).
Otras opciones indican las acciones a realizar con los ficheros encontrados.
Cuando el criterio se acompaña de un nº n, este puede llevar el signo positivo (+), negativo (-) o
ninguno, significando respectivamente mayor que, menor que o igual que.
Algunas opciones que indican criterios de busqueda:
-name patrón Nombre del fichero a buscar, admite metacaracteres. Se aconseja
poner el nombre entre comillas, para que los metacaracteres no sean
interpretados por el shell.
-iname patrón Como -name, pero no hace distinción entre mayúsculas y minúsculas.
-type t Donde “t” es un carácter que indica el tipo de fichero, este puede ser:
f Ficheros ordinarios.
b Dispositivos de bloques.
c Dispositivos de caracteres.
d Directorios.
l Vínculos simbólicos.
-links [±]n Nº de enlaces.
-inum n Empareja con los ficheros que tengan como nº de inodo n.
-perm n Localiza los ficheros que tengan exactamente los permisos indicados
por el nº n (octal).
-user usuario Ficheros que pertenezcan al usuario, se indica el nombre del usuario.
-uid n Idem, n debe de ser un identificador de usuario. (ls -n muestra uid y gid)
-group grupo Ficheros que pertenezcan al grupo.
-gid n Idem, n debe de ser un identificador de grupo.
-size [±]n Nº de bloques de tamaño del fichero. Si se añade una c detrás del
número se interpreta el tamaño en bytes (caracteres), k (Kbytes), w
(palabras 2 bytes), b (bloques, por defecto).
-empty Si el fichero o el directorio está vacío.
-atime [±]n Si ha sido accedido en los últimos n días.


Todo linux

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (14)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Todo linux

Ähnlich wie Todo linux (20)

Todo linux