curso vzaix01 - manual

Curso VzAIX01

UNIX/AIX Basics for Operators

Ramón Barrios Lascar

2010

Unix U

nix U

nix U

nix

Unix U

nix U

nix U

nix

Unix U

nix U

nix U

nix

Unix U

nix U

nix U

nix

Unix U

nix U

nix U

nix

Unix U

nix U

nix U

nix

Le dedico este libro y todo mi trabajo a la mujer que ha soportado que pase horas y horas frente a

un “jugando” con computadoras que parecen primitivas.

Oh Estefanía!

Marcas registradasEn este documento aparecen una cantidad de términos que son marcas registradas o marcas comerciales de IBM u otras compañías.IBM® es una marca registrada de International Business Machines Corporation.Las siguientes sin marcas registradas de International Business Machines Corporation en los Estados Unidos de América y otros países:

AIX® DB2® DB2 UDB®

POWER PowerPC® SP®

POWERparallel® eServer pSeries

Intel® es una marca registrada de Intel Corporation en los Estados Unidos de América y otros países.UNIX® es una marca registrada de The Open Group en los Estados Unidos de América y otros países.Sun y Sun Solaris® son unas marca registrada por Sun Microsystems Corporation en los Estados Unidos de América y otros países.Linux® es una marca registrada de Linus Torvalds en los Estados Unidos de América y otros países.Microsoft® Windows™ es una marca registrada de Microsoft Corporation en los Estados Unidos de América y otros países.

Edición de septiembre de 2010. © Ramón Barrios Lascar 2003, 2010. Todos los derechos reservados. Este documento no puede ser reproducido sin el permiso y consentimiento expreso de Ramón Barrios Lascar.

AIX/Unix 5 Basics for Operators Ramón Barrios Lascar iKnow 2

Contenidos.............................................................................................................................................INTRODUCCIÓN 9

OBJETIVOS 9AUDIENCIA 9

........................................................................................INTRODUCCIÓN A SISTEMAS IBM P5 Y PSERIES 11

EL CONCEPTO GENERAL 11CAPACIDADES DEL HARDWARE 15

Los Procesadores 15La Memoria De Acceso Directo, RAM 17Los Buses Externos 18Las Comunicaciones Externas 19El Substrato Electrónico 19El Sistema De Manejo De Los Recursos De Hardware 20

CAPACIDADES DEL SOFT WARE 23Capacidades Base (por Ser Unix) 23Capacidades Logradas Debido Al Hardware Que Soporta 23Capacidades Únicas 24

......................................................................................................................SISTEMAS OPERATIVOS UNIX 27

HISTORIA, TERMINOLOGÍA DEFINICIONES 27COMPONENTES DE UN SISTEMA UNIX 29EL KERNEL O NÚCLEO DEL SISTEMA OPERATIVO 31SISTEMAS DE ARCHIVOS/DE ARCHIVADO 33

Nomenclatura De Archivos 33Conceptos: Directorios 34Conceptos: Archivos 34Conceptos: Archivos Especiales Nodo 34

INTÉRFACES DE USUARIO: INTÉRPRETE DE COMANDOS (SHELL) 37Intérprete De Comandos Original: Sh 37Intérprete De Comandos De La Universidad De Berkeley: Csh 38Intérprete De Comandos Comercial AT&T: Ksh 38Intérprete De Comandos De Código Abierto: Bash 38

INTERFACES DE USUARIO: AMBIENTES DE ESCRITORIO GRÁFICO 41Gnome (GNU Network Object Model Environment) 42KDE (K Desktop Environment) 43CDE (Common Desktop Environment) 44

APLICACIONES GENERALES EN UNIX: EDITORES DE TEXTO 45Editor Ed 46Editor Vi 46

APLICACIONES GENERALES EN UNIX: AMBIENTES DE DESARROLLO 49PERFILES DE USUARIOS Y DE GRUPOS DE USUARIO 51

...................................................................................................................COMANDOS BÁSICOS DE UNIX 53

COMANDOS BÁSICOS DE SESIÓN DE USUARIO 53Entrar Al Sistema 53Quién Soy (qué Usuario Soy): Whoami 53Quienes Están En El Sistema (qué Usuarios Están Conectados): Who 54A Qué Grupos Pertenezco: Groups 54Cambiar Mi Contraseña: Passwd 54Salir Y Desconectarse De La Sesión: Logout 55

ESTRUCTURA “ESTANDAR” DE LOS COMANDOS 58


Acerca De Los Comandos 58Acerca De Las Opciones 58

..........................................................................COMANDOS RELACIONADOS CON LA FECHA Y LA HORA 60

Qué Fecha Y Hora Es En El Servidor: Date 60Cuánto Se Demora Una Tarea: Time 60Calendario: Cal 61

...................................................................................................COMUNICACIÓN CON OTROS USUARIOS 64

UNIX Y LAS COMUNICACIONES 64MENSAJES DIRECTOS A LA SESIÓN: WRITE 66COVERSACIÓN (CHAT) CON OTROS USUARIOS: TALK 68MENSAJES A TODO EL MUNDO: WALL 70CORREO ELECTRÓNICO: MAIL 72

Modo Interactivo Y Lectura Del Correo Electrónico 72Modo Directo Y Envío De Nuevos Mensajes De Correo Electrónico 74

...........................................................................ARCHIVOS Y DIRECTORIOS: MANEJO DE DIRECTORIOS 76

DIRECTORIOS 76LISTAR CONTENIDOS DE DIRECTORIO: LS 78

Uso Básico Del Comando “listar Contenidos Del Directorio” 78Listar Contenidos De “otro Directorio” 78Listar Incluyendo Los “archivos Normalmente Ocultos” 79

LISTAR CONTENIDOS DE DIRECTORIO CON DETALLES: LS –L 80MOVERSE ENTRE DIRECTORIOS: CD 82CREAR DIRECTORIOS: MKDIR 84

Crear Toda Una Estructura De Directorios: Mkdir –p 85CAMBIAR NOMBRE DE DIRECTORIO (O MOVER): MV 86REMOVER DIRECTORIOS: RMDIR 88

Remover Una Jerarquía De Directorios: Rmdir –p 88

.................................................................................ARCHIVOS Y DIRECTORIOS: MANEJO DE ARCHIVOS 90

ARCHIVOS 90Nombres De Los Archivos 91Nombres Por Ruta Absoluta Y Por Ruta Relativa 92

LISTAR ARCHIVOS: LS 94LISTAR ARCHIVOS CON DETALLES: LS –L 96CREAR ARCHIVO VACÍO: TOUCH 98COPIAR ARCHIVOS: CP 100

Uso De Cp Para Hacer Una Copia Sencilla De Un Archivo 100Uso De Cp Para Copiar Varios Archivos 100Uso Del Comando Cp Para Copiar Directorios Completos: Cp -R 101

MOVER O RENOMBRAR ARCHIVOS: MV 102Uso De Mv Para Renombrar Un Archivo 102Uso De Mv Para Mover Varios Archivos 102

AGREGAR NOMBRES A ARCHIVOS: LN 104Agregarle Un Nuevo Nombre A Un Archivo Individual 104

AGREGAR ENLACES SIMBÓLICOS: LN –S 106Agregarle Un Enlace Simbólico A Un Archivo Individual 106Agregarle Enlaces Simbólicos A Múltiples Archivos A La Vez 106

REMOVER ARCHIVOS Y NOMBRES DE ARCHIVOS: RM 108Remoción De Directorios 108

DETERMINAR TIPO DE ARCHIVO: FILE 110


......................................................................................................EDICIÓN DE ARCHIVOS DE TEXTO: VI 112

ARCHIVOS DE TEXTO 112Editores De Texto: Vi 112Modos De Vi 112

EDITAR ARCHIVOS EXISTENTES CON VI 114CREACIÓN DE NUEVOS ARCHIVOS DE TEXTO 116MOVERSE DENTRO DE UN ARCHIVO 118

Moverse De A Líneas 118Moverse De A Páginas O Pantallas 118Moverse Según El Contexto 119

INSERCIÓN DE NUEVOS CONTENIDOS DE TEXTO (EN VI) 120COMANDOS BÁSICOS DE EDICIÓN DE TEXTO (DE VI) 122BUSCAR Y REEMPLAZAR TEXTOS CONTENIDOS (DENTRO DE VI) 124TABLEROS DE RECORTES: CORTAR, COPIAR Y PEGAR 126EDITAR Y TRABAJAR CON MÁS DE UN ARCHIVO DE TEXTO 128PERSONALIZACIÓN DEL EDITOR DE TEXTO VI 130

Uso Práctico De Los Archivos De Opciones De Vi 132Formato De Un Archivo De Opciones De Configuración De Vi 132

..............................................................................EL AMBIENTE DE TRABAJO: PROCESOS Y VARIABLES 134

EL AMBIENTE DE TRABAJO 134PROCESOS 136

Iniciar Y Detener Procesos 136LISTAR PROCESOS 138

Listado Básico De Procesos: Ps 138Listado De Todos Los Procesos: Ps –e 138Listado Largo (técnico) De Los Procesos: Ps –l 138Listado Completo (full) De Información De Los Procesos: Ps –f 139Variantes BSD - Listado Extendido De Procesos: Ps –U NombreUsuario 140Listado Extra Extendido De Procesos, En BSD: Ps –aux 141Acerca De Las Columnas: %CPU 142Acerca De Las Columnas: %MEM 143Acerca De Las Columnas: STATE 143

PROCESOS DE FONDO 144Ejecución De Procesos “de Fondo” (en Background) 144Listar Procesos De Fondo 144Manejo De Las Tareas De Fondo Con Fg Y Con Bg 145Señales A Procesos: Combinaciones De Tecla Y El Comando Kill 145Sintaxis Del Comando Kill 146Acerca De Las Señales 146

VARIABLES DE AMBIENTE 150Listar Las Variables De Ambiente Del Intérprete Shell 150Definición De Nuevas Variables En El Intérprete Shell 151

PASO DE VARIABLES ENTRE GRUPOS DE PROCESOS 152Uso Del Comando Export 152Paso De Variables Nuevas No Preexistentes En El Intérprete 153

PASO DE SEÑALES ENTRE GRUPOS DE PROCESOS 154Uso Del Comando Kill Para El Envío De Señales A Grupos De Procesos 154

...................................................................................................SEGURIDAD Y PERMISOS DE ARCHIVOS 156

ARQUITECTURA DE SEGURIDAD DE UNIX® 156PROCESOS Y PERMISOS 158USUARIOS Y GRUPOS DE USUARIOS 160PERMISOS DE ARCHIVOS: LS -L 164


PERMISOS DE DIRECTORIOS: LS -LD 166CAMBIAR PERMISOS: CHMOD 168CAMBIAR PROPIETARIO: CHOWN 170CAMBIAR IDENTIDAD DE USUARIO: SU 172

...................................................................................USO EFECTIVO DEL INTÉRPRETE DE COMANDOS 174

EL INTÉRPRETE DE COMANDOS 174El Intérprete De Comandos Y El Uso De La Multitarea 174El Intérprete De Comandos Y Los Metacaracteres 174

COMODINES (DE NOMBRES) 176Comodín Básico ? (cualquier Un Caracter Del Nombre) 176Comodín Amplio * (cualesquiera Caracteres Del Nombre) 177Comodín [xyz] (cualquier Un Caracter De La Lista) 178Comodín [!xyz] (cualquier Caracter Que No Esté En La Lista) 178Comodín [x-z] (cualquier Caracter Que Esté En Un Rango) 179Comodín [!x-z] (cualquier Caracter Que No Esté En El Rango 179

EJECUCIÓN DE COMANDOS EN SECUENCIA 182EJECUCIÓN CONDICIONAL DE COMANDOS 184

Códigos De Retorno De Una Ejecución 184Ejecución Condicional: Ejecución Sólo Si El Anterior Ejecuta Sin Error 184Ejecución Condicional: Ejecución Sólo Si El Anterior Ejecuta Con Error 185

REDIRECCIÓN: ARCHIVOS 186Archivos Estandar: “entrada Estandar”, “salida Estandar”, “salida De Errores Estandar” 186Redirección De La Entrada Desde Un Archivo 187Redirección De La Salida Hacia Un Archivo 188Redirección De Los Mensajes De Error Hacia Un Archivo 188Redirección De La Salida Sin Destruir 190Redirección De Los Mensajes De Error Sin Destruir 190Combinaciones De Redirecciones 191

SUBSTITUCIÓN DE VARIABLES 192Variables De Ambiente Importantes En El Shell 193

SUBSTITUCIÓN DE COMANDOS 196REDIRECCIÓN: TUBERÍAS 198

Comandos Filtro 198ESCAPES 200

Escape De Un Único Caracter: Símbolo \ 200Escape De Todos Los Significados Especiales: ' 201Escape De No Todos Los Significados Especiales: " 202

..............................................................................................................................UTILIDADES DE TEXTO 204

EL CONCEPTO 204VOLCAR TEXTO A LA SALIDA ESTÁNDAR: CAT 206CONTAR CARACTERES, PALABRAS, LÍNEAS: WC 208NUMERAR LÍNEAS DE TEXTO: NL 210PAGINAR TEXTO: PG 214OBTENER PRIMERAS LÍNEAS DE TEXTO: HEAD 216OBTENER ÚLTIMAS LÍNEAS DE TEXTO: TAIL 218OBTENER COLUMNAS DE TEXTO: CUT 222COMBINAR TEXTO EN COLUMNAS: PASTE 226COMBINAR TEXTO EN COLUMNAS: JOIN 230FILTRAR LÍNEAS DE TEXTO: GREP 234EXPRESIONES REGULARES BÁSICAS (EN GREP) 238FILTRADO AVANZADO DE LÍNEAS DE TEXTO: EGREP 242


EXPRESIONES REGULARES EXTENDIDAS (EN EGREP) 246ORDENAR LÍNEAS DE TEXTO: SORT 250TRANSLITERAR CARACTERES: TR 256

.......................................................................UTILIDADES AVANZADAS DE ARCHIVOS Y DIRECTORIOS 262

UTILIDADES, MÁS UTILIDADES 262BÚSQUEDA DE ARCHIVOS: FIND 264

Criterios De Selección En Find 264Acciones En Find 267Operadores Lógicos En Find 268

EJECUCIÓN DE COMANDOS EN CANTIDADES DE ARCHIVOS: XARGS 274COMPRIMIR ARCHIVOS 1: COMPRESS & UNCOMPRESS 278COMPRIMIR ARCHIVOS 2: GZIP & GUNZIP 282EMPACAR ARCHIVOS: TAR 286COMANDOS VARIOS 292

Comando Host 292Comando Hostname 292Comando Uptime 292Comando Du 293Comando Sum 294Comando Cksum 294Comando True 294Comando Yes 295

.................................................................................USO AVANZADO DEL INTÉRPRETE DE COMANDOS: 296

USO DEL INTÉRPRETE COMO UN LENGUAJE DE PROGRAMACIÓN 296Desarrollo De Shell Scripts 296

PRUEBAS LÓGICAS: TEST 298Pruebas Lógicas Básicas 298Pruebas Lógicas Con Cadenas De Texto 300Pruebas Lógicas Con Archivos 300

OPERADORES Y OPERACIONES: EXPR 302COMANDOS DE CONTROL DE FLUJO: IF, THEN, ELSE & FI 306COMANDOS DE CONTROL DE FLUJO: FOR, DO & DONE 308COMANDOS DE CONTROL DE FLUJO: WHILE, DO & DONE 310MANIPULACIÓN DE VARIABLES: LET 312


Introducción

Objetivos

El presente curso pretende, mostrar, explicar y poner en práctica una serie de comandos y técnicas que permiten a un individuo trabajar con sistemas UNIX, Linux, POSIX y parecidos. La idea del mismo es dar los conocimientos suficientes a un usuario u operador para poder trabajar cómoda y eficientemente a través del uso de una cuenta de acceso a un sistema multiusuario como los mencionados en modo texto; es decir a través del uso de comandos y toda la sintaxis de un intérprete de comandos estilo Bourne.

Al tomar este curso y aprender lo que aquí se pretende, el estudiante logra los conocimientos necesarios para trabajar en sistemas como Sun Solaris, Hewlett-Packard HP-UX, Digital/Compaq/HP UNIX /Tru64, SCO OpenServer/OpenDesktop, SCO UnixWare, QNX y QNX Centrino, FreeBSD/NetBSD/OpenBSD, prácticamente todas las distribuciones de Linux, y muy especialmente, IBM AIX. Adicionalmente los comando son usables también en la interfaz de texto del sistema Mac OS X.

Audiencia

Este documento y el curso relacionado está dirigido a profesionales de sistemas, sin experiencia o capacitación previa en el manejo de sistemas UNIX, pero que saben trabajar y conocen de sistemas de cómputo en general, como sistemas estaciones Microsoft Windows y Apple Mac OS X.


Introducción a sistemas IBM p5 y pSeries

El concepto general

Desde su introducción, los sistemas de servidor multiusuario basados en tecnología POWER disponibles al público por IBM han sido sistemas muy avanzados que ofrecen:

Muy alto desempeño (tal vez el más) en su gama de precios

Flexibilidad en las configuraciones

Las más avanzadas y variadas herramientas y mecanismos de disponibilidad del mercado

Un sistema operativo capaz de usar toda la funcionalidad del hardware

Soporte a tecnologías de terceros –tecnologías abiertas y estándares de la industria-.

Para comprender a cabalidad las capacidades que ofrecen estos sistemas es bueno concentrarnos en los mercados principales a los que IBM ofrece soluciones basadas en POWER:

Organizaciones que, bajo ningún concepto, pueden dejar de disponer de sus servidores centrales más que unas horas al año máximo.

Organizaciones que usan aplicaciones de servidor de datos, en especial como núcleo central en un esquema distribuido cliente/servidor.


Organizaciones que funcionan o hacen disponibles sus servicios las 24 horas del día, los 365 días del año. Estas organizaciones tampoco tienen amplias ventanas de tiempo para mantenimientos del sistema, es más ni aún para tareas rutinarias, como las necesarias –críticas- copias de respaldo.

Organizaciones con más de una sede, que centralizan sus datos en un único punto, con un complejo pero muy eficiente sistema de comunicaciones.

Organizaciones en las que centenares, tal vez miles de usuarios usan aplicaciones cuyas fuentes de datos están contenidos en unos muy pocos sistemas, pero en las que los mismos datos son tal vez contenedores con múltiples o muchos terabytes.

Si analizamos detenidamente, muchísimas organizaciones en nuestro país clasifican en uno o más de los parámetros arriba mencionados, pero en especial:

Organizaciones financieras: bancos, corporaciones financieras y de crédito, corredores de bolsa.

Empresas de servicios públicos (las llamadas utilities): agua, energía, telefonía, gas.

Instituciones del estado, en especial las relacionadas con la seguridad y el sistema impositivo.

Entidades relacionadas con la salud: hospitales y clínicas.

Mirando los conceptos de diseño y desarrollo, los requerimientos de funcionalidad y capacidad de las organizaciones que adquieren servidores p de IBM, es preciso que tanto el hardware como el software se reconozcan mutuamente, que empalmen y sincronicen, de manera que se tengan servidores siempre disponibles (en realidad con “cinco nueves”).

IBM ofrece entonces:

Servidores basados en hardware de alto desempeño, con:

Múltiples procesadores, cada uno con muy alto desempeño. Se ofrecen servidores p con hasta 256 procesadores POWER 6 o POWER 6+ o Power7 (usables como 512 procesadores lógicos) en configuraciones SMP (no de cluster).

Grandes cantidades de espacio de ejecución, RAM. Se ofrecen servidores p con hasta 8TB de RAM (sí, 8192GB de memoria de acceso directo).

Amplia capacidad de expansión en tarjetas. Servidores base y expansiones externas para lograr sistemas con capacidad de centenares de ranuras, todas usables internamente, todas configuradas automáticamente á la Plug And Play. Muchas de estas ranuras, cuando no todas, soportando estándares como PCI-X con conectado en caliente.

Amplísima capacidad de expansión en espacio de disco. Servidores


Es bueno recordar que IBM s i g n i f i c a I n t e r n a c i o n a l Business Machines, es decir “máquinas internacionales de negocios”, y este siempre ha sido y será el mercado que maneja, y para el que diseña sus soluciones y productos.

base y expansiones para lograr servidores con capacidad en centenares de terabytes de espacio. Recordando que las versiones actuales del sistema operativo AIX puede manejar exabytes de espacio en disco.

Los mejores esquemas de detección, diágnóstico y reacción ante los errores. Los sistemas p han sido diseñados desde el comienzo para mejorar, por encima de toda la industria, cómo los mismos reaccionan ante los errores. Es de notar que IBM viene trabajando en estos temas desde la década de los setenta, para implementar y ofrecer esquemas adecuados en sus sistemas mainframe de la época. Las mismas tecnologías las ha ido evolucionando y mejorando para ofrecer en todos sus sistemas i (antes iSeries y AS/400), sus sistemas z (antes zSeries y S/390) y lo que nos atañe de momento, los sistemas p (antes pSeries y RS/6000).


Capacidades del hardware

IBM viene ofreciendo a sus clientes –y el mercado en general- servidores de negocios centrándose en unas pocas pero avanzadísimas tecnologías:

Los procesadores

IBM ofrece servidores con procesadores POWER 6 y Power7 en las familias p, e i. Los mismos procesadores han evolucionando desde su invención e implementación de fines de los ochenta al día de hoy. Entre otras muchas características están:

“Ancho” de dato nativo de 64 bits, pero, pudiendo manejar sin emulaciones por software datos a 32, 128 y 256 bits, según el caso. Los sistemas operativos actuales corren a 64 bits –es decir nativos- en estos procesadores. Los mismos pueden trabajar en dos “orientaciones de palabra”, tanto little-endian como big-endian, siendo nativos en little. AIX siempre ha sido little-endian. Esta última orientación de palabra es la natural de TCP/IP, por eso a veces se le denomina “orden de red”.

Doce (12) unidades paralelas de ejecución (pipelines), con diferente funcionalidad, pero funcionando todas al tiempo si es necesario. Diferentes unidades se encargan de los accesos a RAM (fectch, load, store), los cálculos con enteros y con unidades menores como los bytes, los cálculos con números de punto flotante. Recuerde que por ser tecnología RISC, la RAM no es accedida directamente por el procesador, si no que se usa como una remote data store.

Los procesadores actuales tienen un “archivo de registros” con 64 direccionables directamente, todos con el ancho nativo. Al mismo tiempo tienen un “archivo de registros temporales fantasma” con capacidad para contener hasta 210 estados de registro en etapas parciales de ejecución. Esto último le permite despachar más operaciones en paralelo que cualquier otro ofrecimiento real y actual en el mercado.

Procesadores con la posibilidad de procesar instrucciones de dos hilos de ejecución diferentes simultáneamente. Esta capacidad lleva por nombre –en IBM- Simultaneous Multi-threading (SMT). En otras arquitecturas se conoce con otros nombres, por ejemplo Hyper-Threading.

Los procesadores Power6 actuales son todos fabricados “con doble núcleo” (dual core) o con “cuadruple núcleo” (quad core); los procesadores Power7 actuales son todos fabricados “con ocho núcleos” (octo core). Estas característica de fabricación implica que cada dos, cuatro u ocho procesadores están litografiados en un mismo substrato de silicio. Cuando dos o más procesadores están en el mismo substrato pueden llegar a comunicarse a la velocidad nativa a la que trabajan, no en divisores, como las otras tecnologías. Cuando un cliente adquiere un sistema con un solo


procesador, realmente adquiere un magazín de procesador con un chip de doble núcleo, pero con uno de ellos permanentemente desactivado.

En el mismo substrato donde se han litografiado los procesadores se incluyen tanto la memoria caché de nivel 1 (L1), funcionando a la misma velocidad que el núcleo de cada procesador, y la memoria caché de nivel 2 (L2), funcionando a la mitad de la velocidad que cada núcleo. Cada procesador posee, maneja y accede, su propio caché L1, de 192KB, y su accede a un banco compartido de caché L2, de 1.9MB (realmente 3x640KB). El caché L2 funciona también a la mitad de la velocidad del procesador.

En una circuitería y tarjetería externa a cada procesador, pero protegidas por el mismo magazín contenedor se encuentra la memoria caché de nivel 3 (L3) que, a pesar de ser independiente es controlada directamente por una área dedicada de transistores (cada procesador tiene un controlador integrado de memoria y de caché) dentro de cada procesador. Cada banco de caché L3 es de 36MB por par de procesador. Se dice que cada POWER 5 o posterior incluye un chip RAM Cache Controller.

Todo lo anterior es vigilado permanentemente por circuitería de diagnóstico integrada; diseñada e implementada con, y al mismo tiempo que cada procesador, controllador y banco de caché. Los mecanismos de diagnósticos ni son externos ni son agregados a cada elemento, son una parte fundamental del diseño y de la fabricación del mismo, con puertos de comunicaciones al “mundo exterior”. Ahora, todos los puertos de comunicaciones del sistema de diagnóstico son manejados externamente a cada elemento diagnosticado, para que del mismo no dependa la detección de las fallas.

Usando los mismos puertos de diagnóstico, el sistema detecta, configura, maneja la energía, y en especial la temperatura de todos los elementos. El avanzado sistema de manejo de energía de los procesadores POWER 5 usados en los sistemas p5 contínuamente apaga y enciende los subsistemas que no se están usando, de manera que, cuando se hayan en reposo ni consumen prácticamente energía y por consiguiente tampoco disipan calor.

Note que adicionalmente a todo, un sistema p puede funcionar con algunos de los elementos arriba mencionados totalmente desactivados por fallas. Lo normal es que el sistema de monitoreo automático apagará y virtualmente desconectará los elementos fallidos. Mientras uno de los sistemas operativos dependientes tenga recursos para continuar el sistema como un todo, proseguirá en operación; en muchos casos sin que los usuarios cliente sean conscientes de los hechos.


Note que un servidor POWER no funcionará si todos sus p r o c e s a d o r e s e s t á n desactivados por fallas.

Más aún, tanto los registros, como los bancos de caché, como las líneas internas de comunicaciones funcionan con ECC2 todo el tiempo. La memoria con ECC2 puede detectar fallas de hasta dos bits por byte, y corregir cambios de un bit por byte, automáticamente, sin concurso del sistema operativo o de hardware externo.

La memoria de acceso directo, RAM

IBM se ha caracterizado desde los inicios por notar que estos servidores sirven a una multitud de usuarios, de hecho centenares, tal vez miles. Esto hace que normalmente ejecutan múltiples procesos simultáneamente, y cada uno con un “lote de ejecución” (working set) grande, los servidores p, son capaces de:

Soportar la expansión a miles de gigabytes, en las ofertas actuales, hasta 2TB de RAM máxima. Este ofrecimiento es de los más grandes del mercado.

Soportar los chips de RAM de última tecnología, que permitan amplios anchos de banda. Los servidores actuales soportan DDR1 y DDR2 (double data rate), siendo ofrecidos siempre con DDR2, a menos que el cliente solicite más de 512GB de RAM, ya que las ofertas actuales de mercado no hacen posible “armar” 2TB de RAM con unos pocos chips DDR2.

Trabajar siempre con controladores de RAM, líneas de acceso y pastillas de memoria con detección y corrección automática de errores chip-kill. IBM usa y sólo soporta memoria con ECC2. Adicionalmente a esto, el sistema de detección y corrección de errores de hardware visualiza permanentemente la RAM, y en el caso de errores contínuos sobre un mismo SIPP de RAM, puede llegar a desactivarlo, sin que se pierda la pastilla completa. Este tipo de cambios son registrados en memoria no volátil (NVRAM) para que sobreviva a reinicios del sistema.

Soportar simultáneamente la comunicación de los múltiples procesadores y múltiples pastillas DDR sin generarse conflictos y bloqueos contínuamente. Esto como un ofrecimiento único del mercado, los servidores p5 incluyen una circuitería que implementa un switch de RAM de alta velocidad (high speed RAM switch), con un ancho de banda de entre 16GB/s y 270GB/s según el modelo, superior a todo lo otro en el mercado. Este switch permite la funcionalidad avanzada de los buses de RAM, que logra acceso simultáneo en paralelo de los procesadores, los controladores de memoria caché y los dispositivos con DMA sin conflictos.

Manejar tanto los controladores de RAM como los controladores de caché con “doble entrada” (dual ported), de manera, que en el caso de la RAM, puede ser accedida al tiempo por los procesadores (el controlador de caché realmente) y por las tarjetas adaptadoras con uso de DMA, sin conflictos; y, en el caso de los bancos de caché, puede ser accedida al tiempo por los procesadores y por la RAM, sin conflictos. Los


accesos además pueden ser de lectura o de escritura, simultáneamente, y sin problemas.

Los buses externos

Los servidores IBM p5 son diseñados con base en una jerarquía de buses jerarquizados, con corrección de errores ECC2 permanente, con zonas de intercambio de alta velocidad (buffers), y todos con una variante de PCI (Peripheral Component Interconnect). Los servidores p5 ofrecen:

Múltiples, realmente decenas, de buses PCI en diversas variantes, desde PCI estándar de 32bits y a 33MHz hasta los últimos PCI-X, de 64 bits y a 512MHz. Todos estos buses, con manejo de errores permanente, a través de puertos de detección, configuración, manejo de errores, y de energía independientes.

Acceso externo a todos los buses, es decir aquellos que incluyen ranuras para tarjetas adaptadoras, con función de desactivado, es de decir de apagado lógico.

Estos buses de acceso externo son armados de manera que soportan normalmente una única ranura por bus. Esto logra aislar los problemas, evitar la interferencia intertarjetas y facilita las funciones de particionamiento lógico dinámico (Dynamic Logical Partitioning, DLPAR).

Múltiples buses PCI Express con funciones de conectado y desconectado en caliente (hot plug). Esto, combinado con las funciones arriba mencionadas logra el mejor manejo de cambios de hardware en caliente de la industria para el segmento de los servidores intermedios.

Soporte a expansiones externas con conectividad a través de un bus externo intermedio de muy alta velocidad (2GB/s), adicionado con un bus de manejo de poder (RIO2-GX + SPCN). Las mencionadas expansiones hacen que se puedan agregar buses PCI (de diversas variantes) y que los mismos sean vistos como buses locales, externos, pero vistos y usables como si fueran internos.

Las características anteriores todas manejadas con configuración automática, usando el estándar que PCI incluye para ello.

Adicionalmente, los servidores p5 incluyen buses USB (Universal Serial Bus) versión 2, estándar de la industria, que soporta dispositivos de baja velocidad como teclados, ratos y disqueteras externas. Como es en las otras plataformas, USB no solo es de detección automática, si no de conectado y desconectado en caliente.

Para cerrar el círculo, los servidores POWER han sido diseñados para tener un ancho de banda amplio a los sistemas de almacenamiento, por ello estos mismos son o SCSI de última


RIO2 es sigla de Remote Input/Output, version 2, y SPCN de S y s t e m Po w e r C o n t r o l Network.

Tanto PCI como USB son e s t á n d a r e s d i s e ñ a d o s , implementados, y licenciados de Intel Corporation.

generación (actualmente UltraSCSI 320) o de canal de fibra de última generación (Fiber Channel de hasta 4Gb/s). Mientras que todo sistema de almacenamiento por bus SCSI es visto como una data store local, con detección y configuración automática de los componentes, los sistemas de almacenamiento FC pueden verse como una data store local o remota, pero en ambos casos, con detección y configuración automática. Igual que siempre, en ambos casos, con manejo dinámico de errores, usando las funciones que cada protocolo de hardware incluye e implementa.

Las comunicaciones externas

Como los sistemas p5 normalmente no son usados directamente, si no que prestan todos sus servicios a infinidad de usuarios a través de una o más redes, es crucial que se puedan implementar eficientemente las comunicaciones. Los servidores p5 ofrecen:

Dos puertos de red integrados en una sola tarjeta de redes ethernet con soporte a 10, 100 y 1000 Mb/s. Dicha tarjeta incluye una antememoria en hardware de 4MB, para evitar que las congestiones se den en la misma, además de que tiene acceso directo a la RAM, esto es, DMA. Como todas las tarjetas ethernet ofrecidas por IBM, tiene funciones de auto-crossover, es decir que detecta y selecciona automáticamente la polaridad de la señal del medio, así como la velocidad y el modo duplex/simplex.

Opciones de red ethernet adicionales, como tarjetas con soporte sólo a 10/100 Mb/s o con soporte a 10000 Mb/s.

Opciones para la descarga de la funcionalidad de chequeo de paquetes IP, de esta forma se elimina la tarea a la pila IP de sistema operativo esta tarea, aliviando la carga a el(los) procesador(es).

Tarjetas adaptadoras de red con la funcionalidad de IPSEC integrada, para eliminar esta tarea –igual que en el caso anterior- a la pila IP del sistema operativo.

Opciones de redes adicionales, como Token Ring, FDDI y ATM.

Adicionalmente, soportan “encendido a través de la red” (wake-up on lan).

El substrato electrónico

Las “tarjetas principales” (system planars o io planars en la documentación de IBM) de los servidores p5 son fabricados con tecnología de ocho capas. Esto permite más planos para la implementación de líneas de comunicaciones entre dispositivos. No es por capricho, es una decisión consciente, necesaria para la implementación de los canales de comunicaciones por donde se hace la detección, configuración, manejo del poder y de la temperatura de todos,


El funcionamiento auto-c r o s s o v e r q u e t i e n e n implementadas las tarjetas de red IBM sigue el estándar MDI-X

los dispositivos agregados. Note que la mayoría de los ofrecimientos de otros proveedores son creados con tecnología de cuatro o cinco capas, lo que dificulta la implementación de este tipo de esquemas en los ofrecimientos de la competencia.

El sistema de manejo de los recursos de hardware

Mientras que los ofrecimientos de terceros en este rango de mercado incluyen soporte a funcionalidad de manejo de los recursos de hardware, y de las fallas de los mismos, los servidores p5 de IBM van mucho más allá: incluyen un procesador POWER (específicamente PowerPC 405GT) corriendo de líneas de poder y software independientes, y con comunicaciones independientes con el mundo exterior. Este procesador, y otros chips adicionales de soporte se engloban en una funcionalidad denominada “procesador de servicio” (service processor, SP), el que tiene las funciones de:

Manejar el poder, es decir implementar las funciones de encendido y apagado del servidor, sus subsistemas y componentes. El procesador de servicio implementa la manera de “desconectar” buses PCI, para poder hacer la remoción y conexión sin riesgos de tarjetas adaptadoras en caliente.

Manejar la temperatura, es decir implementar los esquemas de revolución dinámica de los ventiladores internos. El procesador de servicio monitorea la temperatura interna y externa, y aumenta las revoluciones de los ventiladores cuando la temperatura interna aumenta, como cuando la carga en los subsistemas es alta o cuando alguno(s) de los ventiladores falla y hay que suplir su función.

Manejar los errores, es decir, monitorear los subsistemas y los componentes, aislar y desactivar los componentes fallidos, reportar los mismos al software que ejecuta “arriba”. El procesador de servicio implementa la función que desactiva automáticamente un componente (así sea un procesador) cuando el mismo falla de manera grave. El procesador de servicio publica unas interfaces de diagnóstico genéricas, que permiten usar herramientas aún cuando el sistema esté en funcionamiento pleno.

El procesador de servicio inicializa el hardware, y mientras lo hace reporta sus avances en una pantalla LCD disponible en todos los servidores llamada “panel de operador” (operator panel). La lista de los códigos relevantes al progreso, y a los errores, para cada modelo de servidor se incluye en los manuales anexados a cada sistema cuando se envía al cliente y también disponible en línea en la página de IBM relevante a este hardware.

Contínuamente el procesador de servicio monitorea todos los componentes del sistema, pudiendo, según el modelo de máquina, captar información de hasta tres cientos (300) puntos simultáneamente.


Finalmente, el procesador de servicio, junto con unos chips de apoyo implementa las funciones del “hipervisor” (hypervisor). El hipervisor implementa las funciones de “Micro Particionamiento Lógico Dinámico con Virtualización Avanzada POWER” (Dynamic Logical Micro Partitioning with Advanced Power Virtualization). Esta funcionalidad permite hacer, en un solo servidor físico la consolidación de múltiples servidores independientes, y que a pesar de ello sigan siendo “semi-independientes”:

Un servidor p5 puede dividirse en un cierto número –según el modelo- de servidores independientes, cada uno con sus “propios” procesadores, tarjetas controladoras de almacenamiento, tarjetas de comunicaciones de red y memoria RAM, además de su propia copia de sistema operativo y demás software.

Cada división, llamada “partición lógica dinámica” o LPAR, puede tener procesadores propios o porciones de procesadores de un pool de procesadores compartidos.

Cada LPAR tiene una cierta cantidad de memoria RAM asignada.

Cada división puede tener tarjetas adaptadoras controladoras propias, reales asignadas y no compartidas, o puede usar una representación en software de una o más de las mismas. La mencionada representación, llamada “tarjeta controladora SCSI virtual cliente” es el resultado de compartir una “tarjeta controladora virtualizada servidor” real, asignada, de otra LPAR.

Cada división puede tener tarjetas adaptadoras de red propias, asignadas y no compartidas, o puede usar una representación de software de una o más de las mismas. Puede también usar una “tarjeta controladora de red virtual cliente” que es el resultado de compartir una “tarjeta de red virtualizada servidor” real, asignada de otra LPAR.

Cada LPAR puede trabajar sus recursos según uno de varios “perfiles de recursos” definidos con anterioridad.

Es posible cambiar en un momento cualquiera la definición de la cantidad y cuáles son los recursos, esta característica es la que le da la connotación de “particionamiento dinámico”. Lo que significa que sin destruir o apagar las LPARs, pueden cambiarse sus asignaciones de procesador, RAM, y tarjetas. Cuán inmediatamente toman los cambios los sistemas operativos que corren en las particiones varía, dependiendo de cuál sistema operativo sea, y de cuál sea la versión.

Note que para funcionar, un servidor microparticionado o virtualizado es autocontenido, es decir no depende de adiciones externas, pero, para definir la configuración, es necesario un hardware y software adicional, adquirible como opción única llamada “Consola de Manejo de


Las funciones de Logical Micropartitioning dependen enteramente del hardware, pero la Advanced Dynamic P O W E R V i r t u a l i z a t i o n d e p e n d e n d e s o f t w a r e adicional licenciado de IBM.

Hardware” (Hardware Management Console). Esta consola se conecta a unos puertos ethernet propios e independientes del procesador de servicio para definir y guardar la configuración de particionamiento y virtualización.

Como se habrá observado y notado, en conjunto, las carácterísticas avanzadas de estos servidores p5 hacen un ofrecimiento al que difícilmente se acercan los productos y paquetes de la competencia en este segmento, mucho menos en el mismo rango de precios y con una integración tan completa.


Capacidades del software

En 1985, IBM adquirió acceso a, y derechos sobre el código fuente de UNIX, directamente del propietario original, es decir los laboratorios Bell de AT&T (American Telephone & Telegraph). A partir del mismo creó una versión que corriese sobre un hardware que planeaba lanzar al mercado. Posteriormente adquirió el acceso a software originado en la Universidad de California, Capítulo Berkeley (UCB), el software en mención, llamado “Distribución de Software de Berkeley” (BSD) era una variante de UNIX con características interesantes, entre ellas la integración con redes IP. Al integrar los dos, y derivar la versión para el hardware POWER, IBM logró su excelente variante de UNIX denominada Advanced Interactive Executive o AIX. Este sistema operativo ha ido evolucionando con el hardware de los servidores POWER, en sus variantes a través del tiempo (RS/6000, pSeries y ahora p5), y con ello a expandido su funcionalidad para hacer uso integral de las capacidades del hardware IBM.

Capacidades base (por ser UNIX)

AIX es una variante específica y de código cerrado de UNIX, y como tal ofrece:

Capacidades multitarea y multi-hilo, con manejo preferencial dinámico de las prioridades.

Capacidades integrales multiusuario.

Capacidades de manejo en tiempo real de las prioridades.

Confiable, administrable, servible

Estable, seguro –hasta cierto punto-.

Expansible –muchísimo-.

Por otro lado, dependiente en su totalidad de lo que IBM ofrece.

Capacidades logradas debido al hardware que soporta

Adicionalmente a lo que un UNIX tradicional ofrece, AIX agrega:

Soportar todo el hardware que IBM suministra para este segmento de mercado (a excepción de los servidores OpenPower, de procesador POWER 5, pero artificialmente limitados a soportar sólo Linux).

Detección y configuración automática de todo el hardware soportado, incluyendo el soporte al hardware virtual representado en las controladoras y tarjetas de comunicaciones cliente de virtualización. Adicionalmente el soporte a discos


Esta breve historia del origen de AIX invalida cualquier duda legal que le pueda generar al cliente el usar este sistema operativo.

duros virtuales, que son sólo la representación de porciones compartidas de discos duros reales.

Uso específico de las funciones de los procesadores. En especial AIX en p5 reconoce las funciones avanzadas de los procesadores, como la función SMT (Symmetrical Multi Threading), para, uno, activar el SMT desde el mismo inicio, dos, despachar eficientemente las tareas de manera que se puedan ejecutar en paralelo. Adicionalmente, cuando AIX ve que las tareas que constituyen las cargas son pocas despacha las mismas al mismo procesador, de manera que los demás no trabajen y así el sistema de manejo y ahorro de energía pueda ponerlos en suspenso (standby) para un real ahorro de energía y una disminución significativa en la disipación de calor –y menos ruido porque las revoluciones de los ventiladores también bajan-.

Detección y autoconfiguración según las porciones de máquina asignadas a la LPAR en la que está instalado y corriendo. Este decir que AIX asumirá, en caliente los cambios dinámicos en las asignaciones de CPU, de RAM, de ranuras PCI con tarjetas tan pronto como se hagan, sin necesidad de reinicios. Además de esto, puede ejecutar comandos que hagan, entre otras cosas cambios en la configuración del software que se ejecuta “encima” de AIX, para que el mismo también asuma los cambios.

Capacidades únicas

Manejo declarativo de las asignaciones de recursos por carga, a través de los servicios incluidos del “Manejador de Carga de Trabajo” (Workload Manager). Con este software se clasifican dinámicamente los procesos en clases, y según la clase se pueden imponer límites mínimos y máximos de asignación de CPU, de RAM y de ancho de banda de I/O. Con el WLM se puede hacer que ciertos servicios siempre tengan una preferencia, o que obtengan siempre una porción suficiente de los recursos que necesitan.

Manejo avanzado de las situaciones de software, a través del sistema “Manejo y Control de los Recursos” (Resource Management and Control). Con este software se puede preprogramar, para que cuando se de una situación, como un consumo en demasía de un sistema de archivos, el sistema ejecute automáticamente una respuesta, un comando predeterminado.

Manejo avanzado de las situaciones de hardware, en especial de los errores. El núcleo del sistema operativo recibe mensajes del sistema de manejo de errores del hardware y reacciona inmediatamente, al menos para reportarlo. El sistema operativo puede notar que un procesador está “fallando mucho” y no volverá a despachar tareas al mismo. Puede activarse la función de “revisado permanente


de la RAM” (memory scrubbing), y si algo de la misma está “fallando mucho” no volverá a usar las páginas de RAM relacionadas. El sistema operativo puede notar que un disco tiene problemas para escribir uno o más sectores de disco y puede reubicar los datos en otro lugar, predeterminado como reemplazo para salvar el dato antes de que se pierda definitivamente. Si el sistema operativo tiene configuradas “Direcciones IP Virtuales” (Virtual IP Addressing, VIPA), tendrá asociadas más de una tarjeta de red con una sola dirección IP; con una de las tarjetas “activa” y otra “en espera”. Si la tarjeta de red activa falla, se activará la tarjeta en espera, con la dirección IP y la dirección física asociadas –MAC address- con la VIPA. Si el sistema operativo tiene configurados “Canales Ethernet” (EtherChannels), tendrá asociadas más de una tarjeta de red con una sola dirección IP y con una sola dirección física, y todas las tarjetas de red activas, siendo “agregadas”. Cuando hay fallas en las tarjetas, el canal ethernet agregado sigue funcionando, como si estuviese completo.

En AIX se puede activar “Descubrimiento Automático del mejor MTU para una Ruta” (Automatic Path MTU Discovery), en donde, usando paquetes ICMP de tipo echo –pings-, AIX activamente analiza las rutas hasta todos sus clientes remotos, para descubrir el mejor MTU en esa ruta. El mejor MTU en este caso es el tamaño mayor de paquete en el que contínuamente no se pierden los mismos.

En AIX se pueden activar múltiples enrutadores predeterminados para: (i) si uno de los enrutadores predeterminados tiene menor “costo” siempre usarlo, a menos que se pierda la comunicación con el mismo por un tiempo. Cuando se deja de usar uno de los enrutadores predeterminados comenzará a comunicarse usando otro de los enrutadores predeterminados, que le siga en “costo”. Después de un tiempo, AIX intentará revisar si el enrutador de menor “costo” responde nuevamente –usando ecos ICMP, ping - y, si lo hace, volverá a trabajar permanentemente con el mismo.

(ii) Usar OSPF (Open Shortest Path First, protocolo de enrutamiento avanzado inventado por Cisco), y con el mismo determinará cómo balancear la carga en las comunicaciones por múltiples rutas, para no usar solamente una ruta o enrutador “preferido”.

En AIX están incluidos o se pueden usar (por ejemplo implementaciones descargables de Internet) los protocolos de comunicaciones y de seguridad que la industria ha preferido o estandarizado, para que el sistema se pueda considerar “realmente abierto”: IPv4, IPv6, ARP, RARP, TCP, UDP, ICMP, IGMP, RIP, OSPF, BGP, EGP, SMB, CIFS, SSL, SSH, Kerberos, LDAP, DHCP, DDNS, NFS v2/v3/v4, NIS, NIS+, SLIP, PPP, IPX/SPX, ATM, X.25, Frame Relay, y otros.

Con AIX se incluyen muchos paquetes de software de código


N o s e e s p e r a q u e u n EtherChannel siga funcionando cuando todas las tarjetas que lo componen deja de funcionar al tiempo.

abierto, siendo IBM patrocinador de tanto Linux como de paquetes base de la Internet actual, tales como Sendmail, Bind, RouteD, GateD, ISC DHCP, OpenSSL, OpenSSH, Samba, Apache.

AIX tiene uno de los mejores esquemas de manejo de inventario de paquetes de software que se puedan encontrar en cualquier tipo de plataforma, no sólo en UNIX.

AIX tiene integrado el software “Manejador de Volúmenes Lógicos” (Logical Volume Manager, LVM), hace más de una década. Con el LVM se hace el manejo del espacio en discos de manera flexible, poderosa, pero sobre todo, totalmente dinámico, y en donde casi todo se hace “en caliente”. Este software es tan reconocido que versiones anteriores son la base para los manejadores de espacio de otros sistemas operativos UNIX como Digital OSF/1 y HP-UX. IBM en 2000 regaló código fuente para que en Linux se pudiera implementar un LVM usable y funcional.

AIX puede usar (i) el software incluido IPSEC, para la seguridad IP. O (ii) se pueden definir reglas locales de cortafuegos (firewall) para que se controlen los protocolos que entran, salen, o se enrutan a través de la máquina.

Por último, AIX puede ser administrado por comandos de línea, por menús validados, por interfaz gráfica o por una página web, o a través de un cliente gráfico cliente/servidor instalable en Windows o Linux x86.


EtherChannel es el nombre comercial que usa Cisco, empresa que se inventó la función. En otros ambientes hacer lo mismo se denomina ethernet bonding o channel agregation

Sistemas Operativos UNIX

Historia, Terminología Definiciones

Los sistemas UNIX (oficialmente UNIX®) tienen una muy larga historia, siendo desarrollados inicialmente en las décadas de 1960s y 1970s, por un grupo de empleados de la compañía norteamericana AT&T, entre los que se destacan Ken Thompson, Dennis C. Ritchie y Douglas McIlroy. Los sistemas UNIX se han ido derivando en diversas ramas, desarrolladas a través del tiempo tanto por AT&T como por numerosas otras compañías comerciales. Desde comienzos de la década de 1990, también se han desarrollado variantes libres, creadas por grupos no muy unidos de desarrolladores diseminados a lo ancho del planeta.

Durante los finales de la década de 1970 y durante la década de 1980, la influencia de UNIX en los ámbitos académicos llevó a una la adopción en gran escala de UNIX en empresas incipientes (en especial de la variante BSD originada en la Universidad de California, sede

1970 1980 1990 2000

FreeBSD 8.1

NetBSD 4.4

OpenBSD 4.6

BSD (Berkeley Software Distribution)

SunOS (Stanford University) Solaris (Sun Microsystems) 11.0

NextStep

Mac OS XXenix

Bill Joy

3.2

6.4

SCO - Microsoft

GNURichard Stallman Linux

Linus Torvalds

2.6.26

MinixAndrew S. Tanenbaum

3.0

Unix Time Sharing System (Bell Labs) 10

Ken Thompson - Dennis Ritchie

HP-UX (Hewlett-Packard) 11

AIX (IBM) 6.1

UnixWare (Novell/Univel/SCO) 7.1

Irix (Silicon Graphics) 6.5

Darwin

GNU/Hurd

Apple

2010


El lenguaje C fue desarrollado por Brian Kernighan y Dennis C. Ritchie. El sistema UNIX fue desarrollado por Ken Thompson y Dennis C. Ritchie. El mismo!

Berkeley), de las cuales la más notable es Sun Microsystems. Hoy en día, adicionalmente a las variantes comerciales certificadas de UNIX (como IBM AIX) se han popularizado ambientes estilo UNIX como Linux y las versiones BSD libres.

Los sistemas UNIX son ampliamente usados como estaciones de trabajo y como servidores (especialmente con la reciente popularidad de los sistemas Linux). El ambiente UNIX y el modelo de programas cliente servidor fueron elementos esenciales en el desarrollo de la Internet y en la reforma de la computación centrada en las redes en vez de estar centrada en los sistemas de computadoras individuales.

Ambos, UNIX y el lenguaje C de programación fueron desarrollados en AT&T y distribuidos a numerosas organizaciones gubernamentales y académicas, causando que ambos fuesen portados a numerosas familias de sistemas, mucho más que otros sistemas operativos. Como resultado, UNIX se volvió sinónimo de “sistema abierto”.

UNIX fue diseñado para ser portable, multi-tarea y multi-usuario, en una configuración de “ejecución por tiempo compartido”. Los sistemas UNIX se caracterizan por varios conceptos: el uso de archivos de texto para almacenar datos; un sistema de archivado jerárquico; tratar los dispositivos y ciertos esquemas de comunicación entre procesos como archivos; y por el uso de una gran cantidad de programas pequeños que pueden encadenarse muy fácilmente a través de “tuberías” en un intérprete de comandos, en vez de tenerse programas grandes, poderosos, complejos y monolíticos que realicen de todo. Todo esto junto se denomina “la filosofía UNIX”.

Actualmente, una compañía o grupo de desarrolladores que deseen usar el nombre UNIX debería certificar su producto, que le da derecho –entre otras cosas- a usar el nombre UNIX. Qué compone a un UNIX, cómo se comporta y cómo funciona está estandarizado, según unos documentos actualmente llamados Single Unix Specification v3, o UNIX 03 para acortar. Este mismo estándar también es el estándar IEEE POSIX 1003.1 e ISO/IEC 9945. Es decir que usar UNIX no vuelve a la compañía o individuo totalmente dependiente de los caprichos y conveniencia de una compañía o grupo de desarrolladores.


La propiedad intelectual de los códigos fuentes originales de UNIX estuvieron en entredicho a principios del siglo XXI, debido a los alegatos de la compañía The SCO Group. A fortunadamente en los estrados judiciales se resolvió el asunto a favor de Novell Inc. en la segunda semana de agosto de 2007. Todos los d e r e c h o s i n t e l e c t u a l e s relacionados con el código original de UNIX son propiedad de Novell, compañía que ha asegurado públicamente que no va a demandar a nadie –nadie diferente de SCO Group- deb ido a su p rop iedad intelectual.

Componentes de un Sistema UNIX

Applicaciones

Núcleo

Hardware

SistemadeArchivado

Shells GUIs

Tarj

driver

Los sistemas UNIX modernos son muy modulares, permitiendo combinarse, descombinarse o recombinarse los módulos según sean las necesidades de la implementación. La mayoría consta de los siguientes módulos:

Núcleo del sistema o kernel

Sistema de archivado o file system

Intérprete de comandos o shell

Ambiente gráfico de escritorio o GUI

Editores de texto

Lenguajes de programación

Sistemas de control

Numerosas utilidades

Teniendo esta mentalidad, por ejemplo, la empresa canadiense QNX ofrece y vende una solución para instalar en sistemas de control de automóviles que es una versión de UNIX sin intérprete de comandos ni ambientes de escritorio, constando sólo del núcleo del sistema, del sistema de archivado y los sistemas de control; pero también vende una solución del mismo UNIX que incluye el resto de los módulos aquí mencionados, ofrecido como una solución integral para estaciones de desarrollo; y además vende otra solución del mismo que


incluye un ambiente gráfico como sistema de consola de conductor para vehículos modernos de lujo.

La mayoría de los UNIX están hechos de manera que algunos de los módulos pueden ser reemplazados por otros sin cambio fundamental en la funcionalidad, por ejemplo IBM AIX puede instalarse en sistemas de archivo JFS o JFS2; Solaris puede instalarse con ambiente gráfico Motif® o con ambiente gráfico Gnome; y Linux puede instalarse en PCs modernos con kernel de 32 o kernel de 64 bits.

En los siguientes apartes se describen y se explican con mayor detalle la función y particularidad de los módulos que componen a un sistema operativo típico UNIX, y cómo se relacionan entre sí.


El Kernel o Núcleo del Sistema Operativo

Applicaciones

Núcleo

Hardware

SistemadeArchivado

Shells GUIs

driver

tarjeta

Las principales tareas de un sistema operativo avanzado son:

Administración de la memoria

Control de los procesos

Administración de los sistemas de archivado

Control de la entrada y salida (I/O)

Estas tareas son llevadas a cabo a través de un conjunto de instrucciones dado por el sistema operaciones. Estas instrucciones son denominadas “llamados al sistema” (system calls), que son responsables de funcionar como interfaz para los programas de los usuarios y forman –en conjunto- lo que es conocido como el “núcleo” (kernel) del sistema operativo.

Mirándolo de esta manera, los sistemas operativos estilo UNIX no “corren”, si no que el conjunto de funciones que lo forman es usado o invocado por las aplicaciones que ejecutan “arriba”.


Sistemas de Archivos/de Archivado

Applicaciones

Núcleo

Hardware

Shells GUIs

driver

tarjeta

SistemadeArchivado

UNIX en un sistema operativo en el que, al igual que en DOS y MS Windows, la organización de los datos usables es en una estructura jerárquica de archivos, organizada en directorios, presentando una estructura de árbol invertido a los usuarios, en donde los directorios son ramas y los archivos son hojas.

A diferencia que en DOS y MS Windows, en los UNIX en un momento dado hay sólo un árbol, sin importar cuántos discos y unidades haya en el sistema, y de ése único árbol dependen toas las ramas-directorios. En principio se puede suponer que no existe una limitación en cuanto a amplitud y profundidad del árbol, pero en la práctica sí existen límites; límites que dependen de la clase de UNIX, de la versión, del espacio disponible, del formato, etc. En la práctica, en todos los UNIX modernos los limites son suficientemente grandes como para que el trabajo de todos los días pueda realizarse sin estar teniéndolos en cuenta.

Nomenclatura de archivos

En todo UNIX el concepto de archivo es básico. Toda la información del sistema está almacenada de alguna manera en archivos, donde cada uno tiene un apuntador único que usa el sistema operativo para llegar a los datos contenidos y al menos un nombre, que usan los usuarios para indicar al sistema operativo cual apuntador usar. Es clave reconocer que en un mismo sitio no pueden haber dos archivos con el mismo nombre, ni tampoco dos archivos diferentes con el mismo apuntador.


Conceptos: Directorios

En UNIX un directorio es un archivo con un formato interno especial que usa el sistema operativo como catálogo parcial de unos contenidos. Como dentro de un directorio pueden haber otros directorios y archivos, con éstos se arma la estructura que los usuarios ven como jerárquica. Como los directorios son archivos especiales todas las reglas que aplican para los archivos también aplican para los directorios. Note que en UNIX, los archivos sí ocupan espacio en disco.

Conceptos: Archivos

En UNIX un archivo es una entrada en un catálogo que se usa a través de un nombre. Dicha entrada le sirve al sistema para acceder a un apuntador, y con dicho apuntador las aplicaciones de los usuarios pueden acceder a la información –en bytes- que les interesa a los usuarios guardar o leer.

Los archivos que los usuarios normalmente usan en UNIX se llaman “archivos corrientes”, ya que hay otros –como los directorios- que no se usan como archivo, pero que realmente lo son. Toda la información en UNIX está guardada en archivos, y toda información puede manipularse manipulando archivos.

En UNIX los archivos comunes son considerados por el sistema operativo como sin estructura, son los programas los que los interpretan con una estructura. Este concepto es muy poderoso, por lo que -al menos en teoría- todo programa puede abrir y manipular cualquier archivo. Como para el sistema operativo los archivos no tienen una estructura implícita, el nombre del archivo no tiene ninguna relación forzosa con sus contenidos, ni los contenidos con el nombre. Qué implica esto último? Que una foto no tiene porqué tener nombre terminado en .JPG o un archivo cuyo nombre contiene MP3 no tiene porqué ser de música.

Adicionalmente, en todo UNIX los archivos tienen “dos partes”. Una parte es la que más les interesa a los usuarios, y es lo que comúnmente llamamos datos. Otra parte más le interesa al sistema, y es lo que comúnmente llamamos metadatos. Todos los archivos tienen metadatos, aún si se ven vacíos y no contienen datos, así que si un archivo existe ocupará por lo menos el espacio que ocupan sus metadatos básicos.

Conceptos: Archivos especiales nodo

Los sistemas operativos UNIX necesitan acceso a cierta información clave e importante para funcionar, información que no se almacena típicamente en disco, o que no está almacenada si no que es generada “en caliente”, dinámicamente. Y, como se supone que toda la información está en archivos, a los creadores de UNIX se les ocurrió que dicha información se accediera también usando archivos. Por lo anterior en UNIX existen unos archivos de los que


L a i d e a d e a r c h i v o s y directorios “dentro” de otros directorios en Windows viene de DOS, y en DOS viene de CP/M, que copió dicha idea parcialmente de UNIX –pero basándose más en VAX-.

lo único que importa son los metadatos, y por ello no tienen espacio en disco –ni reservado ni usable- para la parte de datos, sólo para los metadatos.

Estos archivos especiales están marcados particularmente en su área de metadatos –específicamente en su apuntador único- y hay de varios tipos según el fin. Existen:

Archivos especiales nodo para acceder al hardware del sistema como un archivo.

Archivos especiales de nodo para leer información dinámica del sistema como si ésta estuviera en archivos estáticos.

Archivos especiales del sistema para trabajar conexiones de red como si fueran archivos.

Archivos especiales del sistema para pasar información rápidamente entre programas locales, como si un programa guardara información y otro la leyera, pero ambos trabajando prácticamente al tiempo.


Los usuarios acostumbrados a trabajar en entorno gráfico reconocerán lo que se conoce como “propiedades” como los metadatos. En UNIX hay más metadatos que las propiedades fácilmente visibles.

Intérfaces de Usuario: Intérprete de Comandos (Shell)

Applicaciones

Núcleo

Hardware

SistemadeArchivado

GUIs

driver

tarjeta

Shells

Un intérprete de comandos es una aplicación que ejecuta como cualquier otra en el sistema operativo, pero que tiene una finalidad: presenta un indicador donde los usuarios pueden escribir instrucciones para que el sistema las ejecute. Lo especial del intérprete de comandos de UNIX es que desde siempre (casi cuarenta años) ha sido programada por desarrolladores para programadores, por lo que siempre se ha contado en UNIX con un método de programación fácil. De hecho todos los intérpretes de comandos de UNIX disponibles son e implementan un lenguaje de programación bastante completo todo el tiempo. Como cada uno de los intérpretes de comandos de UNIX implementa un lenguaje –y como lo dice el nombre interpretado, no compilado- pueden en todo momento hacerse programas, aún si no se guardan en un archivo si no que se digitan directamente en el indicador.

Intérprete de comandos original: sh

El intérprete de comandos estándar original de UNIX fue desarrollado por Stephen Bourne, un empleado de AT&T en 1977. Este intérprete de comandos no es muy cómodo de trabajar de manera interactiva porque no tiene manejo avanzado del teclado (menos de las teclas de cursor) y un manejo difícil del histórico de comandos previos. Sin embargo, como se desarrolló pensando en que fuera una herramienta de programación tiene muy buenas facilidades en su lenguaje, como variables, redirección, estructuras de control, funciones, y manejo de cadenas de texto sólo limitadas por la memoria. Este intérprete de comandos es tan funcional que fue


El “indicador de mandatos” de DOS (y de MS Windows) está l i g e r a m e n t e m o d e l a d o parecido a los intérpretes de comandos de UNIX, pero los lenguajes de programación de los intérpretes de UNIX son completos, a diferencia del lenguaje disponible en DOS.

estandarizado completamente en POSIX y por ello debe incluirse obligatoriamente en todo UNIX certificado.

IBM AIX y Sun Solaris incluyen Bourne Shell por si se necesita.

Intérprete de comandos de la Universidad de Berkeley: csh

A comienzos de la década de 1980 Bill Joy desarrolló un intérprete de comandos para la nueva variante de UNIX BSD. Como en UNIX normalmente se desarrollan las aplicaciones en lenguaje C Bill Joy hizo que el nuevo intérprete trabajara la programación con un lenguaje siguiera la sintaxis de este lenguaje de manera muy cerca, pero que al mismo tiempo no presentara problemas para el operador acostumbrado a operar interactivamente con sh.

Aunque este intérprete de comandos es más avanzado que el anterior sh, al no estar especificadas todas las construcciones de lenguaje, algunas sentencias se prestan para ser comprendidas por los programadores de manera diferente a como las interpreta el shell, por ello muchos desarrolladores evitan activamente el contacto con C Shell (algunos desarrolladores famosos han hecho “política” activa en contra del intérprete C).

IBM AIX incluye C Shell (/usr/bin/csh) por si se necesita. Sun Solaris incluye C Shell y es el intérprete predeterminado del usuario root pero no de los otros usuarios.

Intérprete de comandos comercial AT&T: ksh

El intérprete de comandos Korn Shell fue desarrollado por David Korn, un empleado de AT&T para ser usado como intérprete estandar de AT&T UNIX. Este software fue propietario y comercial pero estandarizado en 1988. La idea principal de este intérprete fue hacerlo totalmente compatible con los scripts desarrollados para Bourne Shell, y al mismo tiempo lograr que tanto el trabajo interactivo como las facilidades de programación aumentaran totalmente. Es de notar que David Korn logró las tres metas simultáneamente. La versión más común es ksh88, pero algunos UNIX incluyen también ksh93. Ambas versiones cumplen a cabalidad el estandar POSIX.

AT&T convirtió al Korn Shell en un proyecto de código fuente abierto en 2000.

IBM AIX incluye Korn Shell 88, y es el intérprete predeterminado para todos los usuarios; incluye Korn Shell 93 como /usr/bin/ksh93. Sun Solaris incluye Korn Shell 88 como /usr/bin/ksh88; incluye Korn Shell 93 y es el intérprete predeterminado para todos los usuarios diferentes de root.

Intérprete de comandos de código abierto: bash

El intérprete de comandos Bourne Again Shell es un proyecto de código fuente abierto creado como una mejora de las funcionalidades disponibles en Bourne Shell, C Shell y Korn


Tom Christiansen, el segundo hacker Perl más conocido escribió un documento muy f a m o s o t i t u l a d o “ L a Programación Csh Considerada Dañina” (Csh Programming Considered Harmful).

Shell. Este proyecto nació en 1987 y se ha popularizado mucho, tanto que es el intérprete predeterminado en los Linux y en Mac OS X. Desde el principio se planeó que fuera completamente compatible con Bourne Shell (el intérprete original) pero que al mismo tiempo sirviese para programar y fuese mucho más fácil de usar interactivamente que los anteriores. Bourne Again Shell (bash) es compatible con Bourne Shell, cumple el estándar POSIX y puede hacerse que funcione totalmente como Bourne Shell.

La gran diferencia de Bourne Shell con los otros intérpretes es el uso interactivo del teclado y las facilidades para completar comandos y nombres de archivos, directorios, máquinas y usuarios.

Bourne Again Shell se incluye como extra en Sun Solaris. Se incluye en el CD BonusPak de AIX; es el intérprete predeterminado en Linux y en Mac OS X.


Interfaces de Usuario: Ambientes de Escritorio Gráfico

Applicaciones

Núcleo

Hardware

SistemadeArchivado

Shells

driver

tarjeta

GUIs

Los UNIX modernos pueden usarse interactiva y gráficamente, es más, unos de los primeros sistemas operativos en contar con una interfaz gráfica fueron los UNIX, con la aparición del sistema X Window System, desarrollado en el MIT (Massachussets Institute of Technology) en 1984; y una variante, NeXTSTEP fue completamente gráfica desde el lanzamiento en 1989 (realmente desde las vistas previas en 1986). El esquema y protocolo actual llamado X11 es la base de los entornos gráficos de casi todos los UNIX (hay otros, como Photon en QNX Neutrino y Aqua en Mac OS X, pero ambos incluyen y soportan también X11).

Ahora, X11 no implementa un ambiente gráfico si no un esquema para la especificación de pixeles, coordenadas, colores, y eventos de teclado y Mouse entre otros, por lo que “encima” de X11 se desarrollan los verdaderos ambientes de escritorio gráfico. Ahora, como X11 es también un protocolo de red, las aplicaciones gráficos desarrolladas con base en X11 pueden y de hecho funcionan a través de una red.

Con base en X11 se han desarrollado múltiples ambientes de escritorio gráfico, siendo los más conocidos:


Gnome (GNU Network Object Model Environment)

Gnome es un proyecto internacional de código fuente abierto que produce dos ambientes: el ambiente de escritorio gráfico Gnome y el ambiente de desarrollo Gnome.

La idea del ambiente gráfico Gnome es la de implementar un ambiente de escritorio gráfico con ideas comunes a los otros ambientes populares, que sea fácil de usar, que sea completo y que se pueda traducir a todos los idiomas necesarios.

El proyecto Gnome fue iniciado por Miguel de Icaza y Federico Mena en agosto de 1997.

Gnome es actualmente el ambiente gráfico predeterminado de las distribuciones de Linux más conocidas (Red Hat Enterprise Linux y Ubuntu Linux) y de Sun Solaris 10. Está disponible en diversas plataformas de código abierto y comerciales como OpenBSD, FreeBSD, numerosos Linux, IBM AIX y hasta Apple Mac OS X. El patrocinador principal de Gnome es la compañía Red Hat.

En AIX está incluido en el CD BonusPak, en Solaris el ambiente gráfico predeterminado (Sun Java Desktop) es una variante de Gnome.


KDE (K Desktop Environment)

KDE es un proyecto internacional iniciado en 1996 por Matthias Ettrich para hacer un ambiente de escritorio gráfico basado en tecnologías de código abierto. KDE está basado en un juego de bibliotecas de funciones que a su vez se basan en Qt, un juego de bibliotecas de funciones desarrolladas en C++ por la compañía noruega Trolltech. KDE incluye además del ambiente de escritorio gráfico un juego de funcionalidades que permiten incluir numerosas aplicaciones en el proyecto: aplicaciones de ofimática, de multimedia, científicas y demás. KDE se centra todo alrededor de la integración de objetos, y así funciona muy bien: integrado. KDE es además transparente a la red, permitiendo que las aplicaciones hechas con KDE trabajen archivos locales y remotos que se acceden a través de los protocolos que el escritorio actual implementa, siendo típicamente más de una docena.

KDE tuvo un inicio muy lento, los desarrolladores iniciales se centraron en crear las bibliotecas de objetos y de funciones más necesarias y últimamente se han concentrado más en las aplicaciones. Con esto último, el desarrollo de todo el ambiente se ha acelerado y han logrado más y mejor compatibilidad y desempeño óptimo en más ambientes. Las ideas de KDE hacen que, con el reuso de clases y objetos el ambiente como un todo consuma menos recursos.

KDE es actualmente el entorno gráfico predeterminado de las distribuciones de Linux más conocidas en Europa (SuSE Linux y Mandriva). Está disponible en numerosas plataformas de código abierto y comerciales como OpenBSD, FreeBSD, numerosos Linux, IBM AIX y hasta Apple Mac OS X. El patrocinador principal de KDE es la compañía SuSE.


En AIX está incluido en el CD BonusPak, para Solaris es descargable de la página oficial de KDE.

La nueva versión 4 próxima a salir este año será lanzada simultáneamente para UNIX/Linux, Windows y Mac OS X sin necesidad de X11.

CDE (Common Desktop Environment)

CDE es un ambiente de escritorio gráfico propietario y comercial basado parcialmente en un juego de bibliotecas de funciones llamado Motif™. CDE salió de la “Iniciativa de Software Abierto Común” (COSE), un proyecto en conjunto de Hewlett-Packard, IBM, Novell y Sun Microsystems, iniciado en 1993. Para el 2000, CDE era considerado el estándar de hecho para las interfaces gráficas de los ambientes UNIX. En 2001, tanto HP como Sun decidieron cambiarse de CDE a Gnome como base del ambiente gráfico para HP-UX como para Sun Solaris, sin embargo, en 2003, HP decidió devolver HP-UX al ambiente CDE por considerar que Gnome no cumplía con los estándares de estabilidad y confiabilidad que necesitaba HP-UX.

Sun Microsystems continúa usando Gnome como base de Java Desktop System, el ambiente gráfico de Solaris, pero tanto como HP-UX y AIX centran sus ambientes gráficos predefinidos en CDE.


Aplicaciones generales en UNIX: Editores de Texto

Applicaciones

Núcleo

Hardware

SistemadeArchivado

GUIs

driver

tarjeta

Shells

Originalmente UNIX fue creado para desarrollar manuales técnicos –es decir texto-, y como el sistema apenas se estaba creando, había de desarrollar y programar las utilidades, a partir de código fuente para compilar –es decir texto-; por todo ello, las herramientas más centrales de los sistemas UNIX son las que procesan texto puro, y de ellas las más importantes son los editores de texto (a diferencia de otras plataformas donde el editor de texto es algo muy básico y casi despreciable). En UNIX siempre ha habido al menos un editor de texto poderoso, pero obvio, esto como todo ha ido evolucionando con el tiempo.

En un sistema UNIX moderno pueden encontrarse hoy en día editores de texto como:

ed

ex

vi

Emacs

inED

nano

Gedit

Kate

Como muchas cosas en UNIX, algunos de los editores arriba mencionados son estándares y otros no. En especial, de arriba, ed, ex, vi están estandarizados (en POSIX), y además son requeridos para que un UNIX pueda llamarse UNIX.


Editor ed

El editor ed es uno de los originales en UNIX, es una aplicación de desarrollo muy sencillo (pero no de uso muy sencillo), rápida y liviana. Es un programa editor de texto por comandos de línea, cómo se muestra en el ejemplo siguiente:

$ ed prog.c? prog.caint main(){ printf( “Hola mundo!\n” ); return 0;}.wq$

Esta secuencia de teclas crea el siguiente archivo:int main(){ printf( “Hola mundo!\n” ); return 0;}

guardándolo en prog.c, donde el primer comando confirma que se creará el nuevo archivo “prog.c”, y que se le agregará texto con el comando a (append), se termina de entrar texto en el comando a con un punto solo en una línea, se guarda el archivo con el comando w (write) y se sale del editor con el comando q (quit).

Aunque es muy útil, y se pueden hacer macros con ed, ya no es muy usado, estando los usuarios más acostumbrados a trabajar con editores de texto que tienen no comandos, si no interfaces. Pero, ed sigue siendo útil para desarrollar macros.

Editor vi

El editor vi (se supone que es Visual Editor) es un editor de texto modal estandarizado completamente en POSIX, incluido en IEEE Spec 1170. Es un editor de texto muy poderoso, pero por ser modal es un poco difícil de usar en un comienzo, pero dar los primeros pasos en él no es demasiado complicado. Aunque haya disponibles en todos los UNIX más editores de texto (tal vez de modo gráfico como dtpad, gedit, kate y más), este editor está incluido en el estándar UNIX’03 como obligatorio, por lo que todos los UNIX lo incluyen y vale la pena aprender a usarlo. vi es usable en los ambientes más inhóspitos (editar un archivo de configuración no es fácil a través de un acceso remoto de comandos a 9600bps). Los sistemas UNIX tienen vi disponible hasta en el modo de recuperación cuando el sistema no sube completo.


Aprenderemos a usar vi en todo un capítulo dedicado al mismo

Nota: Cuando se habla de modal se habla de la característica que tiene vi –así como otras aplicaciones de la época- de que las teclas funcionan y tienen significado según el modo en el que la aplicación esté.


Aplicaciones generales en UNIX: Ambientes de Desarrollo

Applicaciones

Núcleo

Hardware

SistemadeArchivado

GUIs

driver

tarjeta

Shells

Como el diseño original del sistema UNIX en AT&T se debió a la necesidad de que unos desarrolladores desarrollaran documentación técnica (realmente manuales de desarrollo) que no había como imprimir adecuadamente en el momento, el sistema UNIX original incluía las herramientas de desarrollo de manera estándar. También, cuando comenzó a popularizarse más UNIX fue cuando entró en la academia, donde la Universidad de California sede Berkeley (UCB) mejoró aún más las facilidades para los desarrolladores.

Por todo ello, UNIX tradicionalmente ha sido un ambiente “de programadores para programadores”, por lo que ha habido la fácil manera de hacer desarrollo en estos sistemas. Mientras un UNIX de código libre (open source) incluye todas las herramientas de desarrollo en los medios de instalación, es común que un UNIX comercial típico (como Sun Solaris o IBM AIX) NO incluya el ambiente de desarrollo para los lenguajes C y C++. De todas maneras lo común para el desarrollo en UNIX es:

Editor de texto sensible al contexto de desarrollo (o que al menos maneja la sintaxis). FreeBSD y OpenBSD ponen a disposición del administrador ambientes completos de desarrollo de código abierto como KDevelop. Apple incluye XCode en los medios originales de instalación, siendo éste es el ambiente integrado de desarrollo basado en GCC con el que se desarrolla todo el sistema operativo al interior de dicha compañía.

Facilidades para el manejo de versiones de código: CVS o al menos RCS. CVS es Concurrent Versions System y RCS es Revisions Control System. Es de notar que


otros ambientes de manejo de versiones están disponibles para UNIX, algunos gratis y de código abierto.

Compiladores e intérpretes: Todos los UNIX deben incluir algunos intérpretes de lenguajes porque están estandarizados por POSIX. Lo básico son los shells, que además de interpretar interactivamente los comandos también son intérpretes de lenguajes bastante completos –existen hasta librerías para desarrollo gráfico en ksh-. Adicionalmente los UNIX incluyen sed, awk, Perl y muchas veces Python. Los UNIX modernos incluyen también un ambiente de Máquina Virtual de Java (aquí se incluyen Mac OS X, AIX y Solaris). Algunos UNIX incluyen GCC, The GNU Compiler Collection en los medios originales, aunque no se instale de manera predeterminada (aquí se incluyen AIX y Mac OS X).

Adicionalmente, aunque cada compañía que produce un ambiente UNIX comercial –excepto Apple- tiene y vende su propio ambiente integrado de desarrollo, es posible conseguir y descargar GCC (The GNU Compiller Collection) para cada hardware y versión de UNIX específica.

IBM ofrece los ambientes de desarrollo XL (XL C, XL C++, XL Cobol, XL PL1, XL Fortran). IBM ofrece además la familia de soluciones Rational Rose, para modelado y desarrollo en Windows, Linux, AIX, Sun Solaris y HP-UX; con los ambientes IBM Rational Rose se puede modelar y desarrollar en C, C++, Java, ADA y Corba. Del editor/modelador original IBM Racional salió una herramienta de desarrollo de código abierto muy conocida llamada Eclipse.

Sun ofrece Sun Studio (para desarrollo C, C++ y Fortran), y Java Studio Creator y Java Studio Enterprise (para desarrollo Java obviamente). Java al fin y al cabo es un producto Sun.


Perfiles de Usuarios y de Grupos de Usuario

Los sistemas UNIX han sido casi desde el comienzo sistemas multiusuario, por lo que para trabajar con ellos no se necesita únicamente el hardware y el software, si no además un perfil de usuario.

Un perfil de usuario –más comúnmente llamada una cuenta de usuario- es una definición junto con un nombre y un método de acceso –y de control de acceso- que permiten conectarse, identificarse y autenticarse con un sistema UNIX para iniciar y ejecutar tareas y aplicaciones.

Cuando se hace la instalación predeterminada están creados en un sistema UNIX numerosos perfiles de usuario y perfiles de grupos de usuario, pero la mayoría de estas cuentas de usuario son para uso interno de los procesos del sistema operativo, no para el uso interactivo de los usuarios. En un sistema UNIX tradicional sólo una cuenta de usuario permite el uso interactivo, y esta cuenta lleva por nombre “usuario root”. Como esta cuenta de usuario trabaja con el identificador interno número cero (0) el sistema operativo no le forza controles de seguridad, por lo que típicamente puede ejecutar toda tarea sin limitaciones por permisos o controles de seguridad.

Los sistemas UNIX más modernos –en especial los basados en código fuente abierto- adicionalmente solicitan la creación de al menos un perfil de usuario adicional para bloquear el acceso directo a la cuenta de usuario ilimitada root –entre estos tenemos FreeBSD y Mac OS X-.

Como cualquiera que sepa cómo es el nombre de la cuenta podría usarla –en especial root siempre existe y está disponible en algunas variantes de UNIX como Solaris y AIX-, los sistemas multiusuario implementan alguna manera de autenticación, siendo la típica una contraseña. Teniendo ambos, el nombre de la cuenta y la contraseña correspondiente, hay ya como conectarse y trabajar con UNIX. Una manera típica si el ambiente es pequeño –estación de trabajo- es directamente en la consola, que comúnmente muestra un ambiente gráfico de entrada –XDM en AIX, GDM en Solaris y window_login en Mac OS X-. La otra manera típica si el ambiente es grande –servidores conectarse desde un cliente usando TELNET –en AIX y Solaris- o SSH –en OpenBSD, FreeBSD y Mac OS X-. Como este curso está orientado al uso remoto de servidores, el estudiante debe buscar la manera de obtener acceso a un indicador de comandos, que se obtiene localmente ejecutando la aplicación Terminal en Mac OS X, Gnome Terminal en Solaris y DtTerm en AIX.

Note que aunque Solaris, AIX y OpenBSD no obliguen a crear una cuenta de usuario no-root para el trabajo diario, es mejor crear una lo más pronto y trabajar directamente con ésta siempre.


Comandos Básicos de UNIX

Comandos Básicos de Sesión de Usuario

Como se mencionó antes, las primeras acciones de un usuario UNIX para trabajar en un sistema son conectarse, identificarse y autenticarse. Además debería conocer unos comandos mínimos, comandos que conoceremos a continuación.

Entrar al sistema

Para entrar al sistema primero hay que conectarse, comúnmente usando TELNET o SSH. El sistema preguntará un nombre de cuenta de usuario y luego de entrarse (y presionando ENTER) preguntará comúnmente una contraseña. Esto se llama identificarse (informar quién soy) y autenticarse (demostrar que sí soy). Note que es muy común que al escribir la contraseña no se vea nada:

Quién soy (qué usuario soy): whoami

Un comando básico que permite saber en qué cuenta (o bajo qué identidad de usuario) está trabajando un intérprete de comandos es whoami:

[YOU HAVE NEW MAIL]e@abe:e/> whoamiee@abe:e/>

Como se observa, sólo informa el nombre de la cuenta.


Quienes están en el sistema (qué usuarios están conectados): who

Para saber con quienes se comparte el trabajo interactivo con el mismo sistema existe estándar en UNIX el comando who:

e@abe:e/> whoroot pts/0 Aug 07 18:18e pts/1 Aug 07 18:24 (Moe.lan) root pts/2 Aug 07 18:27 (Moe.lan) e@abe:e/>

Hay dos usuarios conectados, pero un usuario (root) tiene dos sesiones. Como se observa el comando muestra:

El nombre de cada usuario por sesión. En este caso son root y e.

Cómo se llama el archivo que representa la ventana o conexión. En este caso son pts/X.

Cuándo inició la sesión. Muestra la fecha y la hora.

Desde dónde se inició la sesión. Si no muestra, típicamente es la consola gráfica de la máquina. Si muestra algo entre paréntesis es el nombre de red o dirección de red de la máquina cliente desde donde se inició la sesión.

A qué grupos pertenezco: groups

Como cada perfil de usuario está incluido o asociado a al menos un grupo –de usuarios- existe el comando groups, con el que se puede conocer a cuáles grupos pertenece la cuenta de usuario actual:

e@abe:e/> groupssystem staff adm security cron printq audit perf shutdowne@abe:e/>

El usuario del ejemplo pertenece a bastantes (9) grupos simultáneamente!

Cambiar mi contraseña: passwd

Cuando un administrador del sistema crea una nueva cuenta/perfil de usuario le asigna una primera contraseña. Como esta contraseña se la informa al nuevo propietario de la cuenta para que pueda conectarse, son dos personas las que conocen dicha contraseña, y como un secreto que conocen dos personas ya no es secreto, una de las primeras acciones que debería realizar un usuario después de conectarse la primera vez es cambiar la contraseña de su cuenta a algo que sólo el usuario conozca. Para cambiar la propia contraseña se usa el comando passwd:

e@abe:e/> passwdChanging password for "e"e's Old password: e's New password:


Enter the new password again:e@abe:e/>

Salir y desconectarse de la sesión: logout

Todo lo que se haga o se ejecute desde una cuenta de usuario se reconoce en el sistema como viniendo de dicho usuario. Si un usuario deja una sesión abierta y se realizan operaciones negativas, perjudiciales o dañinas lo más seguro es que se responsabilice al usuario, por ello, debería cerrar su sesión apenas termine de trabajar con la misma. Hay varias maneras de cerrar la sesión. Con el comando simple logout, con el comando simple exit o con la combinación de teclas ctrl d –estas dos últimas sólo funcionan si es la única instancia del intérprete de comandos que ha iniciado el usuario.

Cuando un usuario entra a un UNIX, el subsistema de autenticación del sistema operativo le busca dos atributos –entre otros-, para llevar a cabo un par de cosas:

Busca un atributo “directorio personal o inicial de la cuenta de usuario”. Si encuentra dicho atributo el sistema primero se para en tal directorio para continuar. Si el directorio no se encuentra típicamente al usuario se lo ubica en /usr/guest o en /.

Es posible hacer que más de un usuario compartan un mismo directorio inicial –ya no directorio personal-, pero esta práctica no es muy común.

Busca un atributo “programa inicial de la cuenta de usuario”. Si encuentra dicho atributo el sistema ejecuta al programa inicial como si fuera el usuario. Si el programa inicial no se encuentra, el usuario es expulsado inmediatamente entre correctamente su contraseña.

Es común que sistemas sin mucha personalización “dejen” a los usuarios en algún ambiente intérprete de comandos, ya que es la configuración básica y predeterminada de los sistemas.

‣ AIX preconfigura a los usuarios para que inicien con /usr/bin/ksh (el Korn Shell 88), incluso al usuario root.

‣ Solaris preconfigura a los usuarios para que inicien con /usr/bin/ksh (el Korn Shell 93), pero con /usr/bin/csh (el C Shell) para el usuario root.

‣ Mac OS X preconfigura a los usuarios para que sus sesiones de texto sean con /usr/bin/bash (el Bourne Again Shell), y no permite el acceso al usuario root –el usuario root ni siquiera tiene contraseña para acceder-.

‣ FreeBSD preconfigura a los usuarios para que sus sesiones de texto sean con /usr/bin/bash (el Bourne Again Shell), y /usr/bin/sh (Bourne Shell original) para el usuario root.


‣ OpenBSD preconfigura a los usuarios para que inicien con /usr/bin/ksh (el Korn Shell 93), incluso para el usuario root.



Los UNIX no tienen un estándar de todos los comandos, pero sí cumplen obligatoriamente un e s t á n d a r c o m a n d o p o r comando para la mayoría de los comandos.

En este punto es donde más se diferencia Apple Mac OS X de los otros Unix. El formato predeterminado de disco de Mac OS X no es sensible a las mayúsculas, entonces los nombres de los comandos tampoco.

Estructura “estandar” de los comandos

Aunque los UNIX no tienen un estándar que deban seguir todos los comandos, sí hay un “estándar de hecho” que siguen casi todos los comandos:comando –opciones argumentos

Básicamente lo que hay que observar es que primero se escribe el comando, segundo –posiblemente- se escriben las opciones, y de último los argumentos.

Acerca de los comandos

La mayoría de los comandos en UNIX son programas-archivo ejecutables, que el sistema operativo busca por nombre en unas ubicaciones estandarizadas pero configurables en disco. Como la mayoría de formatos de disco de la mayoría de los UNIX diferencian entre mayúsculas y minúsculas en los nombres, entonces los comandos se diferencian entre mayúsculas y minúsculas.

Unos comandos son internos de cada intérprete de comandos (aquí se llaman builtins), y en este caso también cumplen con el formato y la sensibilidad a las mayúsculas, incluso en sistemas como Apple Mac OS X que no es sensible por lo general.

Note que los comandos son en inglés o abreviaturas del inglés sin importar como esté configurado un sistema UNIX –realmente un sistema UNIX no está instalado en un idioma, está configurado con al menos un idioma-.

Siguiendo una “antigua tradición” los comandos en los sistemas UNIX son abreviaturas muy cortas de nombres obvios de operaciones (por ejemplo para copiar archivos se usa cp, abreviatura de la operación copy en inglés!).

Acerca de las opciones

Las opciones son switches que cambian “algo” en el funcionamiento de un comando, y, como no siempre se quiere cambiar el funcionamiento básico de un comando, son pues, opcionales. La mayoría de las veces las opciones son letras individuales que casi siempre deben llevar un prefijo – cuando se escriben “sueltas” y que no llevan un prefijo – cuando no se escriben sueltas.

Un ejemplo: el comando cp puede preguntar si se copia archivo por archivo cuando se le especifican varios, pero normalmente no lo hace, a menos que se incluya la opción i, y normalmente no quiere destruir archivos si se pudiese pero los permisos dicen que no, pero se le puede dar la opción f. Si se quieren usar ambas opciones se puede usar cp –i –f … o se puede usar cp –if …

Nótese también que casi nunca el órden de las opciones afecta, pero sí la diferenciación entre mayúsculas y minúsculas. Se verá comando por comando conforme sea el caso.



Las primeras máquinas donde se usaron los conceptos de “servidor” y de “cliente/servidor” fueron UNIX. Nótese también que TCP/IP fue desarrollado en los ambientes UNIX de la familia BSD.

Comandos relacionados con la fecha y la hora

El tiempo (la fecha y la hora) es un ítem muy importante en un servidor, en especial notando que muchos usuarios acceden a los servicios del servidor al mismo tiempo, y que UNIX está muy asociado con el concepto de “servidor”. Note que los sistemas UNIX siempre están anotando ciertos eventos en algún tipo de registro cronológico de eventos –casi siempre un simple archivo de texto-.

Como los sistemas UNIX tienen muy buenas capacidades de trabajo para el acceso remoto, y que a muchos de estos sistema se ingresa desde múltiples países/husos horarios, cuál será la hora que aplica para los eventos? Pues la hora en el servidor!

Qué fecha y hora es en el servidor: date

El comando date sin parámetros muestra la hora del servidor, en un formato estandarizado y teniendo en cuenta la ubicación geográfica y de horario de verano. Adicionalmente tiene unas opciones que permiten seleccionar cómo quiere que se muestra la fecha y o la hora.

Lo más sencillo, sin opciones:e@abe:e/> who am iroot pts/0 Aug 13 20:11 (moe.lan) e@abe:e/> dateMon Aug 13 21:06:42 EST 2007e@abe:e/>

Y ahora, con opciones:e@abe:e/> dateMon Aug 13 21:07:21 EST 2007e@abe:e/> date +"%Y-%m-%d %H:%M:%S"2007-08-13 21:07:38e@abe:e/> date +"%Y-%m-%d %H:%M:%S"2007-08-13 21:07:46e@abe:e/>

Note que los sistemas UNIX son muy precisos en llevar la hora exacta, pero sólo si se mantienen encendidos, y que, adicionalmente, en UNIX se “inventaron” un protocolo para el mantenimiento de una hora sincronizada con una central a través de la red hace un par de décadas.

Cuánto se demora una tarea: time

Muchas veces es necesario conocer cuánto se demora una tarea o comando. En los sistemas UNIX no hay que buscar un cronómetro y esforzar el pulso, sólo hay que conocer el comando adecuado: time.


La suma de user mas sys no es igual a real porque el sistema es multitarea, así que aparte de nuestra tarea también hace otras tareas.

Cuando se antepone el comando time a un comando o juego de comandos, el sistema ejecuta el comando o juego de comandos, y al final reporta tres contadores:

Cuánto se demoró el comando ejecutando instrucciones dentro del núcleo del sistema –en UNIX se llama tiempo de kernel o sys time-,

cuánto se demoró el comando ejecutando instrucciones dentro del propio programa o comando –en UNIX se llama tiempo unprivileged o user time-,

cuánto se demoró el comando ejecutando para el usuario, o “tiempo de reloj de pared” –en UNIX se llama wall clock time o real time-.

Un ejemplo:e@abe:e/> time nslookup www.interfacelift.comServer: dsldevice.lanAddress: 192.168.1.254

Non-authoritative answer:Name: www.interfacelift.comAddress: 209.85.64.50

real 0m0.21suser 0m0.01ssys 0m0.01se@abe:e/>

Calendario: cal

Como los seres humanos contamos más los días, las semanas y los meses que los minutos y los segundos, todos los sistemas UNIX incluyen el comando cal, que sirve para ver o revisar de manera sencilla un calendario. El comando tiene tres posibles maneras de uso:

El comando sólo, sin opciones ni argumentos,

El comando con un único número,

El comando con dos números.

Cuando se usa el comando sólo, cal muestra un calendario representando el mes actual real:e@abe:e/> cal August 2007 Sun Mon Tue Wed Thu Fri Sat 1 2 3 4 5 6 7 8 9 10 1112 13 14 15 16 17 1819 20 21 22 23 24 2526 27 28 29 30 31


Cuando se usa cal con un único número, muestra el calendario del año dado el número, sin hacer ningún tipo de corrección de siglo, es decir ni 7 ni 07 representan 2007, 7 indica el año séptimo a partir de Cristo!.

e@abe:e/> cal 2007 2007

January February Sun Mon Tue Wed Thu Fri Sat Sun Mon Tue Wed Thu Fri Sat 1 2 3 4 5 6 1 2 3 7 8 9 10 11 12 13 4 5 6 7 8 9 1014 15 16 17 18 19 20 11 12 13 14 15 16 17……23 24 25 26 27 28 29 28 29 30 3130 November December Sun Mon Tue Wed Thu Fri Sat Sun Mon Tue Wed Thu Fri Sat 1 2 3 1 4 5 6 7 8 9 10 2 3 4 5 6 7 811 12 13 14 15 16 17 9 10 11 12 13 14 1518 19 20 21 22 23 24 16 17 18 19 20 21 2225 26 27 28 29 30 23 24 25 26 27 28 29 30 31

Cuando se usa el comando cal con dos números, el comando muestra un calendario del mes del primer número en el año segundo número:

e@abe:e/> cal 5 1974 May 1974 Sun Mon Tue Wed Thu Fri Sat 1 2 3 4 5 6 7 8 9 10 1112 13 14 15 16 17 1819 20 21 22 23 24 2526 27 28 29 30 31

Trivia: Quién sabe qué pasa con el calendario de 1752?


Comunicación con otros usuarios

UNIX y las comunicaciones

Desde los meros comienzos –no exactamente desde el inicio, la verdad- UNIX ha sido multi-usuario, por lo que ha tenido buenas facilidades de comunicación con otros usuarios del mismo o de diferente sistema.

Mientras en otros sistemas han ido evolucionando, muchas de las cosas que han sido novedad en los últimos años, los usuarios de UNIX las dan por sentado porque las han tenido de alguna manera por décadas. En UNIX es muy fácil cuando se conoce que TCP/IP nació en UNIX, siendo BSD el primer ambiente con una implementación funcionando, y siendo las ideas de sockets de TCP/IP desarrolladas para BSD el estándar de hecho como se programan todas las implementaciones de TCP/IP en todos los otros sistemas en la actualidad.

En UNIX siempre ha habido correo, en UNIX nació TCP, nació TCP/IP, nació TELNET, FTP, SMTP, POP, IMAP, y muchísimos protocolos más. En NeXTSTEP -un UNIX - se inventaron HTTP y se hizo la primera implementación de un navegador (browser) y de un servidor de páginas, y en el mismo sistema operativo se implementó HTML!. En UNIX se inventaron CGI y JavaScript. En UNIX se inventaron las direcciones de correo buzón@dominio, y en UNIX se inventaron el chat centralizado y el distribuido por TCP/IP. Sin UNIX no existiría la Internet global como existe hoy en día. Por algo Sun Microsystems en el más grande auge de sus máquinas con Solaris acuñó “The network Is the computer”. Tan importante es UNIX en la Internet, que el modo de transmisión de datos “nativo de la red” es el modo como escribe UNIX texto dentro de un socket.



El usuario debe finalizar el mensaje presionando ctrl d

Mensajes directos a la sesión: write

Una manera sencilla de comunicarse con otro usuario actualmente presente en el sistema es usando mensajes directos escritos con el comando write. La sintaxis básica es muy sencilla: write nombreUsuario. Como este comando sólo envía mensajes directos a la ventana de sesión –a la terminal realmente-, el que escribe/envía debería verificar primero que el usuario al que le va a enviar el mensaje está conectado en el sistema –y que tiene una sesión interactiva de sistema operativo.

Ejemplo:

Un usuario en su sesión:0 root@abe:/> whoroot pts/0 Aug 14 19:18 (moe.lan) e pts/1 Aug 14 19:36 (moe.lan) 0 root@abe:/> write eHola usuario!0 root@abe:/>

y el otro usuario en su sesión:e@abe:e/> Message from root on abe (pts/0) [Tue Aug 14 19:37:50 EST 2007] ...Hola usuario!<EOT>

Como puede observarse, el comando write no muestra un indicador al usuario que lo usa para mostrarle que ya puede escribir, pero de hecho, sí le recibe al usuario y sí envía el mensaje. El usuario al que le envían un mensaje no tiene una manera para responder el mensaje según la herramienta, es decir, esta no es una herramienta interactiva. Si el usuario que recibe un mensaje quiere responder debería usar lo mismo: write otroUsuario.

Los mensajes que se envían usando write aparecen “encima” del texto que esté observando en su sesión el usuario destinatario, así que dicho texto no tiene nada que ver con el texto del archivo si el destinatario está trabajando un archivo en un editor de texto. Ahora, como puede ser incómodo, el usuario puede controlar si recibe o no los mensajes de otros usuarios, usando el comando mesg, pero, estos controles no funcionan si quien envía es el usuario todopoderoso root.

Ejemplo:

Un usuario se “bloquea”:2 root@abe:/> mesg n1 root@abe:/>

El otro usuario intenta comunicarse:e@abe:e/> write rootwrite: 0803-031 Permission denied.


Y si el usuario no puso “bloqueos”:1 root@abe:/> mesg y0 root@abe:/>

El otro usuario puede enviar:e@abe:e/> write rootHola super usuario!Soy e

Al otro usuario le aparece:0 root@abe:/> Message from e on abe (pts/1) [Tue Aug 14 19:52:04 EST 2007] ...Hola super usuario!Soy e<EOT>

El comando write puede usarse también para comunicarse instantáneamente con otros usuarios en otros sistemas si en ambos sistemas está corriendo el servicio writesrv –o equivalente-. Es muy raro hoy en día encontrar sistemas de éstos. Si se tienen disponibles se usaría write usuario@sistema, donde aplica la misma regla, el usuario debe estar conectado en ése momento y no debe haber bloqueado la recepción de mensajes.


Coversación (Chat) con otros usuarios: talk

Xxx


Mensajes a todo el mundo: wall

Como el comando write es específico, envía mensajes a un único usuario que debe estar conectado a la máquina en el momento del envío de los mensajes, no es muy práctico para “hacer anuncios”. Afortunadamente los sistemas UNIX incluyen un comando para “hacer anuncios”, este comando es wall (write all), que envía un –mismo- mensaje a todos los usuarios que en el momento estén conectados con una sesión interactiva.

El uso del comando wall es muy sencillo: se usa wall, sin parámetros, y en la nueva línea que aparece se escribe el texto a “anunciar”, la cantidad de líneas que sean necesarias, y se finaliza con ctrl d, solo, en una línea. El mensaje será recibido por todos los usuarios conectados interactivamente que no hayan bloqueado la recepción de los mensajes –al igual que write, los mensajes que root envía no se pueden bloquear-.

Ejemplo:

El usuario que envía,e@abe:e/> wall Esta alguien ahi???^D

Broadcast message from e@abe (pts/1) at 21:15:30 ...

Esta alguien ahi???

y uno de tantos posibles usuarios,1 root@abe:/>

Broadcast message from e@abe (pts/1) at 21:15:30 ... Esta alguien ahi???

La verdad, es muy sencillo.


Correo electrónico: mail

El concepto de correo electrónico, como lo conocemos en Internet es el mismo de los sistemas UNIX, ya que el correo de Internet –básicamente SMTP- es el correo inter-sistemas como se lo inventaron en UNIX. Ahora, antes del correo inter-sistemas, UNIX tuvo y tiene correo intra-sistema, para la comunicación entre los usuarios de un mismo sistema, y para la comunicación del sistema operativo y las aplicaciones que ejecuta con los usuarios en el mismo servidor.

Para ambos usos se usa el mismo comando: mail –también hay otros comandos-.

Modo interactivo y lectura del correo electrónico

El primer modo se usa para leer el correo en el buzón de entrada, para ello simplemente se ejecuta el comando mail sin parámetros u opciones.

Ejemplo:e@abe:e/> mail Mail [5.2 UCB] [AIX 5.X] Type ? for help."/var/spool/mail/e": 1 message 1 new>N 1 root Fri Jun 8 18:38 23/822 "diagela message from abe"?

Cuando así se ejecuta el comando muestra el buzón de entrada del usuario actual (normalmente es /var/spool/mail/nombreUsuario, pero realmente no es importante). Luego de mostrar encabezados de correos suficientes para llenar la pantalla, el programa mail muestra un indicador, a la espera de comandos.

La “pantalla” inicial del programa mail muestra:

La versión del programa y del sistema operativo

El nombre del buzón de entrada, cuántos mensajes tiene y cuántos sin leer.

La lista de los mensajes en el buzón, así:

o El “mensaje actual” se indica con un símbolo >

o El estado del mensaje

o El número ordinal del mensaje de correo en el buzón

o El remitente del mensaje de correo

o La fecha de recepción del mensaje

o El número de líneas/el número de caracteres en el mensaje. Estos contadores incluyen los encabezados de correo.

o El título o “asunto” del correo.


El indicador de comandos del programa mail, ?

Dentro de los “estados” de mensaje se encuentran:

N Un mensaje nuevo

P Un mensaje preservado en un buzón de sistema

U Mensaje sin leer, es decir un mensaje que no se leyó en las anteriores invocaciones del programa mail, y que tampoco se ha leído en esta.

* Un mensaje guardado en un archivo o buzón

Un mensaje sin símbolo de estado es un mensaje que ya ha sido leido pero que no ha sido guardado.

Dentro de los comandos posibles –hay muchos- están:

‣delete listaMensajes (d) Marca el mensaje actual o los de la lista de mensajes para que sean borrados cuando se salga del buzón actual. Pueden desmarcarse para borrado mientras no se salga de la sesión o el buzón actual.

‣dt Marca para borrar el mensaje actual y muestra el siguiente mensaje.

‣exit (ex o x) Sale de mail sin cambiar los contenidos originales del buzón de correo.

‣file nuevoBuzón (folder) Se cambia a un nuevo buzón de correo. Todos los cambios en el buzón de correo actual son aplicados. Debe darse el nombre completo del nuevo buzón o alguna de las abreviaturas:o # Buzón previoo % Buzón del sistema (normalmente /var/spool/mail/nombreUsuario)o & Buzón personal (normalmente /home/nombreUsuario/mbox)o +Nombre Un archivo dentro del directorio de buzones

‣folders Listar buzones en su directorio de buzones

‣headers listaMensajes (h) Lista los encabezados del grupo de mensajes actual del buzón de correo o de la lista de mensajes especificada.

‣hold listaMensajes (ho) Marca el mensaje actual o los dados por la lista de mensajes para que sean mantenidos en el buzón de sistema (normalmente /var/spool/mail/nombreUsuario).

‣mail listaDirecciones (m) Abre el editor para crear un nuevo mensaje para enviar a los destinos dados por la lista de direcciones.


‣mbox listaMensajes Marca el mensaje actual o los dados por la lista de mensajes para que sean movidos al buzón personal (normalmente /home/nombreUsuario/mbox).

‣new listaMensajes Marca el mensaje actual o los dados por la lista de mensajes como “no leídos”.

‣next (n) Muestra el siguiente mensaje, seleccionándolo como “mensaje actual”

‣quit (q) Deja el buzón actual y se sale del programa mail. Todos los cambios pendientes al buzón son aplicados: Los mensajes leídos pero no borrados ni grabados son movidos al buzón personal, los mensajes marcados para eliminación son perdidos definitivamente, los mensajes marcados con hold son mantenidos en el buzón de sistema.

‣reply mensaje (r) Permite responder al remitente y a todos los destinatarios del correo actual, o al mensaje dado.

‣Reply mensaje (R) Permite responder al remitente del mensaje actual o al del mensaje dado.

‣undelete listaMensajes (u) Marca el mensaje actual, o los especificados, como “no borrados” para que no se pierdan al salir del buzón actual.

‣unread listaMensajes (U) Marca el mensaje actual, o los especificados, como “no leídos”.

‣z+ (z) Muestra el siguiente grupo de encabezados de mensajes.

‣z- Muestra el anterior grupo de encabezados de mensajes.

Modo directo y envío de nuevos mensajes de correo electrónico

El segundo modo se usa únicamente para enviar correos, este modo invoca usando el comando mail con argumentos –posiblemente con opciones también-, en donde el comando mail asume que los argumentos son buzones destinatarios de correo.

Ejemplo:e@abe:e/> mail -s "Mensaje prueba Nro 1" [email protected]

Este es un mensaje de prueba que muestra que el correo de UNIX es el mismo correo de Internet.Este correo sólo contiene texto.

No es más..Cc: e@abe:e/>


Como se observa, puede incluirse la opción s con un texto entre comillas para darle un título o asunto al mensaje de correo. Cuando inicia en este modo el programa mail entra inmediata y automáticamente en modo “redacción de correo” que finaliza cuando se escribe un carácter punto (.) sólo en una línea. Al final del mensaje el programa mail solicita unos destinatarios de copia opcionales y luego de poner el mensaje en el “buzón de salida” termina la ejecución.


En DOS/Windows el separador de nombres de directorios es \, en el antiguo MacOS era :, pero en UNIX (incluso el nuevo Mac OS X) es /.

Archivos y Directorios: Manejo de Directorios

El concepto de directorio es muy importante, tan importante que es algo con lo que se relacionan los usuarios de las computadoras típicas desde los primeros días: los que en UNIX llamamos “directorio” en otros ambientes se llama “carpeta”. En los ambientes de computadoras más populares (es decir Microsoft Windows y Apple Mac OS X) se usa el término “carpeta” cuando se habla de operaciones en ambiente gráfico, y se usa el término “directorio” cuando se habla de operaciones en ambiente de comandos. Los directorios en Mac OS X son los directorios de los que se hablará en este apartado ya que Mac OS X es un UNIX. Los directorios en Windows son básicamente los que se mencionarán aquí porque son los que ha usado Windows heredado de DOS, y DOS los heredó de CP/M y CP/M los heredó de UNIX, con un toque de VAX/VMS.

La diferencia fundamental para un usuario que viene del ambiente de MS Windows, es que en esos ambientes y todos los relacionados hay un árbol de directorios que inicia en “una raíz” por cada unidad de disco –siendo unidad básicamente un dispositivo físico de almacenamiento de acceso directo-. En UNIX hay un único directorio raíz de donde lógicamente –no físicamente- se desprende toda una jerarquía de directorios, unos “contenidos” dentro de otros.

Directorios

Los directorios son archivos especiales en UNIX. Realmente son archivos –dentro de las estructuras grabadas en disco- pero tienen una finalidad especial en el sistema: con los directorios se arma el concepto de árbol jerárquico de contenidos a los que estamos acostumbrados en muchas plataformas –además de los UNIX -. Los directorios en UNIX realmente son archivos especiales catálogo que contienen/son una tabla de nombres y números de índice de lo que está “contenido dentro de” el directorio.

Como son especiales los directorios se trabajan con unos comandos diferentes de los que se permiten para los “archivos comunes”.

Los directorios son tan archivos en UNIX que cumplen las mismas reglas que cumplen los archivos:

Los directorios pueden tener casi cualquier nombre de entre uno (1) y dos cientos cincuenta y cinco caracteres (255), en un UNIX moderno. El único carácter que no se permite en los nombres es /

Dos directorios o dos archivos o un directorio y un archivo no pueden tener el mismo nombre completo.


Los directorios tienen la misma estructura de índice que tiene todo archivo, sólo que están marcados con una d, para reconocerlos como directorio. Como la estructura de índice de archivos incluye dueño, permisos y fechas y horas, los directorios también tienen estos atributos.

Los directorios ocupan espacio, que mínimo es lo que ocupa la tabla que lista sus “contenidos”. En un UNIX moderno el tamaño de un directorios es un múltiplo exacto de una unidad de espacio de disco y nunca es cero.

Nótese que en UNIX los programas –todos- ejecutan bajo el concepto de directorio actual, que es muy importante para el programa y para el sistema en sí. Es necesario que el usuario sepa cuál es el directorio actual, porque es dónde los programas típicamente buscan la información. Como muchas veces –así es la configuración predeterminadas- el usuario no sabe a simple vista en qué directorio “actual” está trabajando, los UNIX incluyen el comando pwd (print working directory), que simplemente muestra en cuál directorio estoy trabajando actualmente:

e@abe:e/> pwd/home/e


Listar contenidos de directorio: ls

Uso básico del comando “listar contenidos del directorio”

Lo más básico que necesita uno conocer de los directorios –siendo básicamente una tabla de contenidos- es “qué contiene”. Esta lista de contenidos se obtiene usando el comando ls (list). Cuando se usa así, sin argumentos ni opciones muestra la lista de sólo nombres de lo contenidos en el directorio actual. El comando ls, a menos que se le indique (realmente casi todos los comandos) ignora y no lista los archivos –lo que incluye a los directorios- cuyos nombres comiencen por punto (.) –así en UNIX archivo oculto es aquel cuyo nombre comienza con punto-.

Ejemplo:

e@abe:e/> lsLitteFile SubDir_2 smit.log smit.transactionMadRamon 1.png fecha actual.txt smit.script subdir1

Como se observará, muestra los nombres de lo contenido en el directorio actual, sin diferenciar qué son, es más sin incluir más información aparte del nombre de cada ítem.

Listar contenidos de “otro directorio”

Si se necesita obtener la lista de lo contenido dentro de “otro directorio” diferente del directorio actual, y no queremos o no podemos movernos a dicho otro directorio se puede agregar como argumento al comando ls. Es más, puede indicarse que se listen los contenidos de varios directorios a la vez si se le dan como argumentos independientes al comando ls.

Ejemplo:e@abe:e/> ls /WebSM.pref home smit.scriptWebSM.pref_wsmmonitoring.data image.data smit.transactaudit lib tftpbootbin lost+found tmpbosinst.data lpp ucdrom mnt unixcluster opt usrdev proc varetc sbin websm.scriptgetinfo.sh smit.log wsmcustomtool

Como se observa, incluye sólo los nombres, pero mostró lo de otro directorio sin tener que irnos al mismo.


Listar incluyendo los “archivos normalmente ocultos”

Muchos directorios contienen archivos que normalmente están ocultos porque ls y muchos otros comandos los ignoran. Puede hacerse que ls incluya dichos archivos en sus listados si se agrega la opción A.

Ejemplo:e@abe:e/> lsLitteFile SubDir_2 smit.log smit.transactionMadRamon 1.png fecha actual.txt smit.script subdir1e@abe:e/> ls -A.Xauthority .ssh SubDir_2 smit.script.profile LitteFile fecha actual.txt smit.transaction.sh_history MadRamon 1.png smit.log subdir1e@abe:e/>

Si se observa detenidamente se notará que muchos ítems son los mismos, pero como en la segunda invocación se especificó que había que incluir los ocultos en los listados, pues, aparecen más, todos con nombres que inician con punto (.). Nota cuáles son?


Recuerde: los directorios en UNIX sí ocupan espacio!

Listar contenidos de directorio con detalles: ls –l

Todos los archivos –incluso los directorios porque también son archivos- tienen unas propiedades –llamadas metadatos en UNIX -. Estas propiedades pueden revisarse muy fácilmente con el comando ls cuando se le agrega la opción l (long listing).

Ejemplo:

e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.pngdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 2 e system 256 Aug 14 23:17 subdir1e@abe:e/> ls -l /total 856-rw-r--r-- 1 root system 6892 Apr 16 13:14 WebSM.pref-rw-r--r-- 1 root system 84 Apr 16 13:11 WebSM.pref_wsmmonitoring.datadrwxr-x--- 2 root audit 256 Jan 10 2006 auditlrwxrwxrwx 1 bin bin 8 Apr 10 07:57 bin -> /usr/bin-rw-r--r-- 1 root system 5793 Apr 18 22:01 bosinst.datadrwxr-xr-x 2 root system 256 Apr 11 12:43 cdromdrwxr-xr-x 3 root system 256 Jul 11 23:39 clusterdrwxrwxr-x 5 root system 8192 Aug 14 15:00 devdrwxr-xr-x 27 root system 8192 Aug 12 13:48 etc-rwxr-xr-x 1 root system 2287 Jun 08 18:43 getinfo.shdrwxr-xr-x 7 bin bin 256 Jun 18 21:57 home-rw-r--r-- 1 root system 8062 Apr 18 22:02 image.datalrwxrwxrwx 1 bin bin 8 Apr 10 07:57 lib -> /usr/libdrwx------ 2 root system 256 Apr 10 07:57 lost+founddrwxr-xr-x 45 bin bin 4096 Aug 09 22:13 lppdrwxr-xr-x 2 bin bin 256 Jan 10 2006 mntdrwxr-xr-x 11 root system 4096 Apr 13 00:37 optdr-xr-xr-x 1 root system 0 Aug 14 23:32 procdrwxr-xr-x 3 bin bin 256 Apr 10 20:06 sbin-rw-r--r-- 1 root system 304408 Aug 14 19:34 smit.log-rw-r--r-- 1 root system 11526 Aug 14 19:34 smit.script-rw-r--r-- 1 root system 22352 Aug 14 19:34 smit.transactiondrwxrwxr-x 2 root system 256 Apr 10 08:21 tftpbootdrwxrwxrwt 9 bin bin 8192 Aug 14 23:32 tmplrwxrwxrwx 1 bin bin 5 Apr 10 07:57 u -> /homelrwxrwxrwx 1 root system 21 Apr 10 10:55 UNIX -> /usr/lib/boot/unix_64drwxr-xr-x 36 bin bin 4096 Jun 18 21:43 usr


Note que ls lista el nombre del item dado como argumento si es un archivo, pero lista los nombres de los contenidos si el argumento es un directorio!

Los “enlaces simbólicos” son a rch ivos espec ia les que apuntan a otro ítem. Son algo parecido a un “acceso directo” de Windows o un “alias” de Mac.

drwxr-xr-x 30 root system 4096 Aug 09 12:31 var-rw-r--r-- 1 root system 11806 Apr 16 13:13 websm.script-rw-r--r-- 1 root system 1152 Apr 16 13:12 wsmcustomtools.data

Es un listado largo y complejo. Hay mucha información, a saber:

El primer ejemplo muestra el uso de ls con la opción l, pero sin argumentos, es decir, un listado con detalles del directorio actual.

El segundo ejemplo muestra el uso de ls con la opción l y con argumento, es decir, un listado con detalles de un directorio específico.

Qué incluye el listado?

Una primera columna con el tipo y los permisos de cada uno de los ítems. De los permisos se hablará más adelante.

El número de nombres que tiene en total cada ítem –sí los archivos y directorios en UNIX pueden tener varios nombres simultáneamente-.

El nombre o número interno del usuario dueño de cada ítem.

El nombre o número interno del grupo de usuarios que tiene acceso a cada ítem.

El tamaño en bytes de cada ítem. Ciertos ítems –archivos especiales- no tienen tamaño, para ellos el listado incluye otra información en esta columna.

La fecha y hora de última modificación, de forma mes día hora si la última modificación sucedió hace máximo seis meses; de forma mes día año si la última modificación sucedió hace más de seis meses.

El nombre del ítem. Si el ítem es un “enlace simbólico” muestra el nombre -> nombreDelItemApuntado.

El tipo de un ítem archivo es un carácter o letra. Define qué puede contener y cómo lo interpreta el sistema operativo. Define también qué operaciones son válidas.

Dentro de los tipos de archivos se encuentran:

‣ - Aparece un guión (-) en los archivos comunes.

‣ d Se muestra para los directorios únicamente.

‣ l Enlace simbólico. Tratar de usar un enlace simbólico (excepto por “eliminar” y “mover”) lleva a usar el archivo o ítem al que “apunta” el enlace simbólico.

‣ b Especial. Es un ítem que existe para usar una pieza de hardware como archivo.

‣ c Especial. Es un ítem que existe para usar una pieza de hardware o el resultado de una función de software como archivo.


E n U N I X . . e s u n subdirectorio que existe dentro de cada directorio y que mágicamente apunta a l directorio que contiene al presente!

Y más!

Moverse entre directorios: cd

Como en un sistema UNIX típico hay muchísimos directorios (tal vez miles), una operación muy importante es moverse o cambiarse de directorio. Para cambiarse o moverse de directorio se usa el comando cd, que tiene cuatro modos de sintaxis diferentes:

‣ cd nombreDirectorio Si se le da un nombre de directorio el comando CD mira dos casos: si el nombre dado comienza con el símbolo / entonces el nombre es “absoluto” y el comando cd intenta buscar el directorio a partir de la raíz absoluta de la jerarquía de directorios; si el nombre dado comienza con otra cosa el comando cd intenta buscar el directorio destino a partir del directorio actual, como si fuera un subdirectorio de donde el usuario está ubicado presentemente.

‣ cd ~ Si se le da como argumento el símbolo ~, el comando cd averigua cuál es el directorio inicial o personal del usuario que lo está invocando, e intenta moverse a dicho directorio personal.

‣ cd - Si se le da el símbolo -, el comando cd averigua cuál fue el último directorio donde el usuario estaba antes de moverse al actual e intenta moverse a dicho directorio “previo”.

‣ cd Si se usa el comando cd sin argumentos, el comando asume que se invocó cd ~ y busca el directorio personal o inicial del usuario que lo está invocando, para intentar moverse allí.

Ejemplos:

e@abe:e/> pwd/home/e (el usuario inicia en su directorio personal)e@abe:e/> cd /homee@abe:home/> pwd/home (el usuario ahora está en un directorio que se buscó desde la raíz)e@abe:home/> cd ..e@abe:/> pwd/ (el usuario ahora está en un nivel superior)e@abe:/> cd usre@abe:usr/> pwd/usr (el comando buscó a partir del directorio donde estaba ubicado)e@abe:usr/> cd /home/ee@abe:e/> pwd/home/e (el comando puede navegar varios niveles en un solo paso)e@abe:e/> cd -/usr (reporta a dónde llevará, como se verificará)e@abe:usr/> pwd/usr (el comando cambió al usuario a donde estaba antes)e@abe:usr/> cd


e@abe:e/> pwd/home/e (el comando solito lleva al directorio personal)

Nota: Siendo un sistema multiusuario con una arquitectura de seguridad, los permisos de los directorios definen qué usuarios pueden “entrar” o “deambular” por cada uno.


Crear directorios: mkdir

Como cada usuario quiere organizar su información de la manera que más práctica le parece, existe el comando para crear nuevos directorios. Es un comando muy sencillo con el que se pueden crear directorios donde se tengan permisos, y en un UNIX típico no se manejan permisos “poder crear directorios”, sólo se manejan “poder escribir en un directorio”, con éste último es suficiente para poder crear directorios!.

El comando es sencillo:mkdir nuevoDirectorio

También se le puede decir que cree varios nuevos directorios:mkdir nuevoDirectorio1 nuevoDirectorio2 …

Como todos los comandos, si el nombre del nuevo directorio no comienza con el símbolo / el comando intentará crear el nuevo como subdirectorio del directorio actual. Adicionalmente, con ésas sintaxis, si al comando se le da toda una ruta o camino jerárquico, sólo intentará crear como directorio el último elemento de toda la ruta, todo lo otro ya deberá existir.

Ejemplo:

e@abe:e/> ls LitteFile SubDir_2 smit.log smit.transactionMadRamon 1.png fecha actual.txt smit.script subdir1e@abe:e/> mkdir NuevoSubDire@abe:e/> ls LitteFile SubDir_2 smit.scriptMadRamon 1.png fecha actual.txt smit.transactionNuevoSubDir smit.log subdir1e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.pngdrwxr-xr-x 2 e system 256 Aug 15 21:05 NuevoSubDirdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 2 e system 256 Aug 14 23:17 subdir1e@abe:e/>

Otro ejemplo más:

e@abe:e/> mkdir /tmp/ejemplo/mi_dirmkdir: 0653-357 Cannot access directory /tmp/ejemplo./tmp/ejemplo: A file or directory in the path name does not exist.e@abe:e/> mkdir /tmp/ejemplo /tmp/ejemplo/mi_dire@abe:e/> ls -ld /tmp /tmp/ejemplo /tmp/ejemplo/mi_dir


drwxrwxrwt 10 bin bin 8192 Aug 15 21:08 /tmpdrwxr-xr-x 3 e system 256 Aug 15 21:08 /tmp/ejemplodrwxr-xr-x 2 e system 256 Aug 15 21:08 /tmp/ejemplo/mi_dire@abe:e/>

El uso de la opción d del comando ls es nuevo en esta guía, no se había mencionado. Cuando se usa el comando ls con un directorio como argumento, el mismo no lista al directorio si no lo contenido en el directorio. Si se agrega la opción d al comando ls el mismo lista los directorios, no sus contenidos. Como se está usando también la opción l, entonces el comando muestra un listado completo de propiedades de los directorios, no de los contenidos de los directorios.

Crear toda una estructura de directorios: mkdir –p

Como se ve en el ejemplo, cuando al comando simple mkdir se le da toda una ruta de directorios asume sólo que se necesita crear el último elemento de la ruta (asi con mkdir /uno/dos/tres/cuatro asume que uno, dos y tres existen y que sólo hay que crear cuatro). Como muchas veces se necesita todo el camino, existe una variante de mkdir para que cree los elementos de una ruta que hagan falta:

mkdir –p /undir/segdir/tercdir/cuartodir …

Ejemplo:e@abe:e/> mkdir dirA/dirB/dirCmkdir: 0653-357 Cannot access directory dirA/dirB.dirA/dirB: A file or directory in the path name does not exist.e@abe:e/> mkdir -p dirA/dirB/dirCe@abe:e/> ls -ld dirA dirA/dirB dirA/dirB/dirCdrwxr-xr-x 3 e system 256 Aug 15 22:19 dirAdrwxr-xr-x 3 e system 256 Aug 15 22:19 dirA/dirBdrwxr-xr-x 2 e system 256 Aug 15 22:19 dirA/dirB/dirC


Cambiar nombre de directorio (o mover): mv

A veces no se tiene una estructura jerárquica de directorios y subdirectorios como se desearía. Si se necesita cambiar el nombre de un directorio (o de un archivo) se puede usar el comando “mover”, simplemente se usa un nuevo nombre que no exista. Si se necesita mover un directorio para que esté en otro sitio dentro del mismo sistema, sólo hay que usar también el comando “mover”, pero en este caso el nombre destino existe y es un directorio donde se pueda “meter” el directorio original.

En resumen:

Para renombrar, asumiendo que nuevoNombre no existe:mv elDirectorio nuevoNombre

Para mover, asumiendo que nombreContenedor sí existe y sí es un directorio:mv elDirectorio nombreContenedor

Como se observará, es el mismo comando con la misma sintaxis, la diferencia radica en si el segundo nombre dado como argumento existe y es directorio.

Ejemplo:

e@abe:e/> lsLitteFile SubDir_2 smit.scriptMadRamon 1.png fecha actual.txt smit.transactionNuevoSubDir smit.log subdir1e@abe:e/> mv NuevoSubDir Antiguo_SubDire@abe:e/> lsAntiguo_SubDir SubDir_2 smit.scriptLitteFile fecha actual.txt smit.transactionMadRamon 1.png smit.log subdir1e@abe:e/> mv Antiguo_SubDir subdir1 e@abe:e/> ls LitteFile SubDir_2 smit.log smit.transactionMadRamon 1.png fecha actual.txt smit.script subdir1e@abe:e/> ls subdir1Antiguo_SubDire@abe:e/>



En el comando, … quiere decir que no sólo se pueden escribir dos nombres, si no cuántos n o m b r e s u n o q u i e r a o necesite.

Remover directorios: rmdir

Así como se crean nuevos directorios, pueden borrarse los que ya no se necesiten. Toca cumplir condiciones: deben tenerse los permisos suficientes, y además, el comando rmdir sólo sabe borrar directorios vacíos:rmdir directorioVacío …

Ejemplo:

e@abe:e/> rmdir dirArmdir: 0653-611 Directory dirA is not empty.e@abe:e/> rmdir dirA/dirB/dirCe@abe:e/> ls -ld dirA dirA/dirBdrwxr-xr-x 3 e system 256 Aug 15 22:19 dirAdrwxr-xr-x 2 e system 256 Aug 15 22:23 dirA/dirB

Remover una jerarquía de directorios: rmdir –p

Así como puede crearse toda una jerarquía de directorios, unos dentro de otros, puede también borrarse toda una jerarquía de directorios si se usa la opción p del comando rmdir:rmdir –p /undir/segdir/tercdir/cuartodir …

Ejemplo:

e@abe:e/> ls -ld dirA dirA/dirB dirA/dirB/dirCdrwxr-xr-x 3 e system 256 Aug 15 22:19 dirAdrwxr-xr-x 3 e system 256 Aug 15 22:25 dirA/dirBdrwxr-xr-x 2 e system 256 Aug 15 22:25 dirA/dirB/dirCe@abe:e/> rmdir -p dirA/dirB/dirCe@abe:e/> ls -ld dirA dirA/dirB dirA/dirB/dirCls: 0653-341 The file dirA does not exist.ls: 0653-341 The file dirA/dirB does not exist.ls: 0653-341 The file dirA/dirB/dirC does not exist.e@abe:e/>


Archivos y Directorios: Manejo de Archivos

Otro concepto que manejan los usuarios de otras plataformas como se maneja en UNIX es el concepto de “archivo”. En UNIX, parecido a lo que se maneja en otras plataformas un “archivo” es un conjunto de bytes que se usan a través de un nombre, que físicamente no necesariamente están contiguos, pero que lógicamente se usan como si estuvieran contiguos, uno seguido del otro.

En UNIX es donde se comenzó a manejar el concepto de archivo como se maneja ahora en la mayoría de las plataformas, pero hay diferencias.

Archivos

En UNIX un archivo siempre se considera –desde el punto de vista del sistema operativo- como una secuencia de bytes sin estructura. En UNIX un archivo se encuentra y se accede a través de una estructura especial de disco por fuera del archivo que se llama “nodo índice” o más comúnmente inodo. En este inodo se encuentran los metadatos de cada archivo, así, en disco, para UNIX el inodo tiene una estructura pero el archivo no.

Hay unas cosas que hacen especial el tratamiento de los archivos en UNIX:

En cada inodo hay un marcador de tipo, lo que define tipos de archivo. Ya se ha mencionado, por ejemplo, que los directorios son un tipo de archivo.

Un archivo está “atado” a su inodo, y para un dado archivo no cambia jamás, hasta que se elimine del todo el archivo. Un archivo tiene un único inodo y un inodo da acceso (podría decirse “apunta a”) un único archivo.

El nombre de un archivo está registrado en alguna (o algunas) tablas directorio, donde hay una relación de algún inodo con algún nombre, para cada archivo “contenido en” el directorio. Un archivo puede tener –de hecho muchos tienen típicamente- más de un nombre, en un mismo o en más de un directorio. En cada inodo hay un contador de cuántos nombres tiene el archivo al que el inodo apunta, sin incluir o mencionar cuáles son esos nombres ni dónde están. Temporalmente un archivo puede existir sin nombre, pero no es usable por las aplicaciones mientras así esté.

Existen archivos especiales en donde el inodo realmente se usa para apuntar y dar acceso a piezas de hardware y funciones de software, pero que no apuntan a archivos que guardan datos. Estos “archivos especiales” se usan exactamente como se usan otros archivos.

Esta última particularidad es una característica única y muy poderosa de UNIX: los diseñadores originales intentaron que todo en el sistema pudiera accederse como se usan


los “archivos normales”. Así, en UNIX si se tienen los permisos se puede trabajar la memoria del sistema como un archivo, los discos, las cintas de copias de respaldo, los puertos, etc., como si fueran archivos comunes.

Nombres de los archivos

En general los sistemas UNIX son muy, muy liberales en cuanto a los nombres de los archivos. Hay pocas reglas:

No pueden haber dos o más archivos con el mismo nombre en el mismo directorio, independientemente del tipo de los archivos.

La mayoría de los UNIX soportan nombres de archivos –sin importar el tipo- muy largos, de al menos 255 caracteres UNICODE. La mayoría de las veces las restricciones existen en los formatos de disco que almacenan a los archivos.

Todos los UNIX soportan nombres con casi cualquier carácter, lo único en común es que no puede incluirse el símbolo /. Tanto Mac OS X, como Solaris, como AIX soportan todo tipo de caracteres: espacios, símbolos, caracteres nacionales localizados (como á o ñ), puntos, etc.

La mayoría de las restricciones a los nombres no las impone el sistema operativo en la mayoría de los UNIX, si no el formato de disco donde se almacenan los archivos –y sus nombres-. Por ejemplo, muchos UNIX entienden el formato de disco básico de Windows (FAT), en el que hay muchas más restricciones a los nombres de los archivos que las mencionadas aquí. Casi todos los formatos de disco de UNIX diferencian los nombres en mayúsculas de los en minúsculas. Si así es, entonces para el sistema operativo habrá diferencia!

Los UNIX no manejan el concepto de “extensión de nombre”, así que no se necesita un sufijo al final de los archivos (en especial no un sufijo de tres letras después de un punto). Un nombre de archivo puede contener varias veces el carácter punto (.) o ningún punto.

Como los UNIX son liberales con los nombres, y los contenidos de los archivos son bytes únicamente para el sistema operativo, el nombre y el contenido de los archivos no tienen relación directa. Un archivo no tiene que tener nombre terminado en .exe para ser programa o en .jpg para ser imagen.

En cada directorio hay una tabla –interna- que tiene los nombres cortos de los archivos –sin ruta- que contiene, relacionados con el inodo que apunta a lo que en realidad es el archivo.

Muchos caracteres en el intérprete de comandos de modo texto tienen significado especial, por ello es mejor evitar usarlos en los nombres a menos que se esté dispuesto a expresarle al shell “remueva el significado especial de esto”.


Nombres por ruta absoluta y por ruta relativa

Cuando en el sistema operativo se menciona un archivo, se puede mencionar de dos maneras:

Por ruta absoluta es cuando en algún programa o en el sistema operativo se menciona un archivo dando la ruta completa para poder ubicarlo. Las rutas absolutas son nombres que incluyen directorios y subdirectorios y que comienzan con el símbolo slash (/), es decir que a partir de la raíz de todo se siguen los directorios y subdirectorios uno a uno hasta encontrar el archivo.

Ejemplo://home/juancho/foto_vaca.jpg

Por ruta relativa es cuando en algún programa o en el sistema operativo se menciona un archivo dando un nombre que no comienza con el símbolo /. Las rutas relativas pueden ser el nombre únicamente (como archivo.txt) o pueden ser con ruta parcial (como subdir/archivo.txt). Cuando se usa una ruta relativa el sistema tiene en cuenta el directorio actual, usándolo como prefijo de nombre, y uniéndolo al nombre dado con un símbolo / intermedio.

Ejemplo:

Si el usuario juancho está ubicado en su directorio personal y mencionafoto_vaca.jpg

el sistema entiende /home/juancho/foto_vaca.jpg


Listar archivos: ls

El comando ls (list) realmente no lista archivos, lista directorios que lo que más contienen son archivos:

[255 e@Moe ~] lsDesktop Library Pictures dlmgr_.proDocuments Movies Public drbd.confDownloads Music Sites

Es claro que la mayoría de las “cosas dentro de” un directorio son archivos, y que lo otro, que casi siempre son directorios también son archivos.

Ahora, si se lista un archivo, a menos que se diga otra cosa, el comando lista el nombre del archivo dado:

[0 e@Moe ~] ls drbd.confdrbd.conf


Listar archivos con detalles: ls –l

El comando ls cuando tiene la opción l presenta un listado largo, que incluye muchos detalles de los archivos dados o contenidos en el directorio especificado (o contenidos en el directorio actual si no se especifica nada).

Ejemplo:

e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.pngdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 3 e system 256 Aug 15 21:15 subdir1

Es fácil reconocer del listado cuáles ítems son archivos comunes: la primera columna tiene un menos (-) como primer carácter. También se puede notar:

La segunda columna es un número, es el número de nombres (oficialmente the link count). Casualmente en el listado superior, todos los archivos comunes tienen un único nombre, como es típico.

Todo archivo tiene un dueño, casi siempre quién creó originalmente al archivo. Es lo que aparece en la columna tres (3) del listado.

Todo archivo tiene un grupo, casi siempre el grupo principal del usuario dueño. Es lo que aparece en la columna cuatro (4) de un listado como el de arriba.

Los archivos comunes y los directorios tienen tamaño. En los listados de ls –l aparecen en bytes.

El sistema maneja tres “marcas de tiempo” con fecha y hora por cada archivo (en cada inodo):

o Fecha y hora de último uso, sin importar cuál uso. Se llama oficialmente “fecha de último acceso” o atime.

o Fecha y hora de la última modificación de los contenidos. Se llama oficialmente “fecha de última modificación” o mtime.

o Fecha y hora de la última modificación de los metadatos. Se llama oficialmente “fecha de último cambio” o ctime.

Como no está especificado en el estándar, la mayoría de los UNIX no mantienen una “fecha de creación”, aunque muchos creen que sí, ya que el nombre ctime es fácil confundirlo con “creation time”.


De manera predeterminada el comando ls –l muestra en la “sexta columna” la fecha de la última modificación. Si se usa la opción c con ls –l se muestra la fecha de los últimos cambios al inodo, y se usa la opción u con ls –l se muestra es la fecha del último uso.


Crear archivo vacío: touch

Como para los sistemas UNIX un archivo es sólo una secuencia de bytes sin un significado especial, el sistema no incluye en sí un comando “crear archivo nuevo”. Los archivos normalmente se crean con la misma aplicación que después se usará para leer y/o procesar la información que contienen. Así para crear un nuevo archivo de audio se usa una aplicación de grabado o edición de audio, para crear un documento hoja de cálculo se usa una aplicación de hojas de cálculo y así.

Sin embargo… en el sistema viene un comando que cambia las fechas de los archivos (la de último acceso, la de último cambio o de último cambio del inodo), que casualmente si se le da como argumento algún nombre de archivo que no existe, lo crea nuevo, archivo común, sin contenidos y le cambia la fecha –puede invocarse de manera que no cree archivos si se desea-.

Para crear un nuevo archivo puede usarse:touch nombreNuevo

y si el nombreNuevo no corresponde con ningún archivo, lo crea nuevo, vacío.

Ejemplo:

e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.pngdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 3 e system 256 Aug 15 21:15 subdir1e@abe:e/> touch NuevoVacio.txte@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.png-rw-r--r-- 1 e system 0 Aug 16 17:22 NuevoVacio.txtdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 3 e system 256 Aug 15 21:15 subdir1



IMPORTANTE: Si al comando cp se le da como segundo nombre el de un archivo e x i s t e n t e , s i p u e d e sobreescribe tal archivo sin consultar o advertir!

Copiar archivos: cp

Una operación lo más de común: Se tienen uno o más archivos y se necesita tener copias de los mismos, para tener otros nuevos con exactamente los mismos contenidos.

En UNIX, para copiar unos archivos se usa el comando cp (copy) que tiene varios modos de uso, usos que se describen a continuación.

Uso de cp para hacer una copia sencilla de un archivo

Para hacer una copia sencilla de un archivo simplemente se da a cp como argumento el nombre del archivo original a copiar y el nombre como quiere que se llame la copia nueva. Dependiendo de como se use la ruta del segundo argumento, puede hacerse la copia en algún otro lado.

Ejemplos:

cp archivoOriginal archivoNuevo (ahora existe un nuevo archivo que contiene exactamente lo que contiene archivoOriginal)cp archivoOriginal /ruta/archivoOriginal (ahora hay una copia de un archivo del directorio actual que está ubicada en otro directorio pero que lleva el mismo nombre)cp archivoOriginal /ruta/ (lo mismo que en el último ejemplo, pero se escribe menos)cp archivoOriginal /ruta/nuevoNombre (ahora hay una copia del archivo original, pero el nombre es otro y está en otro directorio)cp /ruta/archivoOriginal . (ahora hay una copia del archivo original en el directorio actual, la copia tiene el mismo nombre que el original)

Uso de cp para copiar varios archivos

Para hacer copias de varios archivos –en una sola operación- se dan los nombres de cada uno, como argumentos, separados por espacios, y además el nombre de un directorio destino, también separado por espacios de los otros argumentos. Note que lo último debe ser un directorio, si no lo es, el comando termina, reportando un error: cp arch1 arch2 arch3 … /dir/destino

Ejemplos:e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.png-rw-r--r-- 1 e system 0 Aug 16 17:22 NuevoVacio.txtdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 3 e system 256 Aug 15 21:15 subdir1e@abe:e/> cp "MadRamon 1.png" smit.log LitteFilecp: LitteFile: The system call does not exist on this system.


e@abe:e/> cp "MadRamon 1.png" smit.log LitteFile subdir1e@abe:e/> ls subdir1Antiguo_SubDir LitteFile MadRamon 1.png smit.log

Uso del comando cp para copiar directorios completos: cp -R

El comando cp puede usarse también para copiar directorios completos, lográndose duplicados de la estructura completa de sus contenidos. Hay dos modos de uso:

Si se usa dando como destino un nombre que no existe se crea una estructura copia del original. La copia lleva como nombre el segundo argumento dado.

Si se usa dando como destino un nombre de un directorio preexistente se crea una copia con la estructura completa, con el mismo nombre del original, pero como subdirectorio del nombrado como segundo argumento –“dentro” del segundo-.

Ejemplos:e@abe:e/> cp -R subdir1 subdir2e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.png-rw-r--r-- 1 e system 0 Aug 16 17:22 NuevoVacio.txtdrwxr-xr-x 2 e system 256 Aug 14 23:17 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 3 e system 256 Aug 16 17:37 subdir1drwxr-xr-x 3 e system 256 Aug 16 17:59 subdir2e@abe:e/> cp -R subdir2 SubDir_2e@abe:e/> ls -ltotal 88-rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile-rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.png-rw-r--r-- 1 e system 0 Aug 16 17:22 NuevoVacio.txtdrwxr-xr-x 3 e system 256 Aug 16 18:00 SubDir_2-rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt-rw-r--r-- 1 e system 10181 Apr 10 16:02 smit.log-rw-r--r-- 1 e system 544 Apr 10 16:00 smit.script-rw-r--r-- 1 e system 291 Apr 10 16:00 smit.transactiondrwxr-xr-x 3 e system 256 Aug 16 17:37 subdir1drwxr-xr-x 3 e system 256 Aug 16 17:59 subdir2e@abe:e/>


IMPORTANTE: Si al comando mv se le da como segundo nombre el de un archivo e x i s t e n t e , s i p u e d e sobreescribe tal archivo sin consultar o advertir!

Mover o renombrar archivos: mv

Otras dos operaciones muy comunes en todos los ambientes son “renombrar” un ítem, y “mover” de sitio un ítem. Ambas operaciones son lo mismo en UNIX, y por ello ambas se hacen con el mismo comando, mv (move).

El uso de mv es básicamente el mismo de cp, pero siendo otro, éste no deja copia.

Uso de mv para renombrar un archivo

Para hacer una copia sencilla de un archivo simplemente se da a mv como argumento el nombre del archivo original a renombrar y el nombre como quiere que se llame definitivamente. Dependiendo de como se use la ruta del segundo argumento, puede moverse a algún otro lado.

Ejemplos:

mv archivoOriginal archivoNuevo (ahora existe el archivo, pero ya no se llama

archivoOriginal, se llama archivoNuevo) mv archivoOriginal /ruta/archivoOriginal (se movió el archivo del directorio actual a un nuevo sitio, sigue teniendo el mismo nombre)

mv archivoOriginal /ruta/ (lo mismo que en el último ejemplo, pero se escribe menos)

mv archivoOriginal /ruta/nuevoNombre (ahora el archivo está en otro sitio, y no tiene el mismo nombre, ahora es nuevoNombre)

mv /ruta/archivoOriginal . (ahora se trae el archivo de donde estaba al directorio actual, sigue con el mismo nombre, archivoOriginal)

Uso de mv para mover varios archivos

Para hacer movimiento de varios archivos –en una sola operación- se dan los nombres de cada uno, como argumentos, separados por espacios, y además el nombre de un directorio destino, también separado por espacios de los otros argumentos. Note que lo último debe ser un directorio, si no lo es, el comando termina, reportando un error: mv arch1 arch2 arch3 … /dir/destino



IMPORTANTE: Si al comando ln se le da como segundo nombre el de un archivo e x i s t e n t e , s i p u e d e sobreescribe tal archivo sin consultar o advertir!

Agregar nombres a archivos: ln

En UNIX hay una operación que no es posible hacer con los archivos en la mayoría de los otros sistemas: agregarle nombres a los archivos. La operación es semejante a la de “copiar archivos”, pero en este caso lo que queda no es un nuevo archivo con los mismos contenidos, queda un nuevo nombre por el que se puede acceder a un archivo –por eso parece una copia, pero el archivo es uno solo-. UNIX no maneja casos especiales de “primer nombre” o “último nombre”, así que todos los nombres son equivalentes y ninguno es “principal”.

Agregarle un nuevo nombre a un archivo individual

Se usa el comando ln (link) para agregarle nombres (oficialmente en UNIX se llaman links), cuya sintaxis es muy parecida a la de cp y mv:

ln nombreOriginal nombreNuevo

Dependiendo de cómo se usen los argumentos, los dos nombres pueden estar en el mismo o en diferentes directorios, pero, los UNIX por lo general necesitan que ambos estén en el mismo “contenedor físico”. Como ambos nombres son un mismo archivo y un archivo tiene un único inodo, ambos nombres llevan al mismo inodo.

Como el sistema operativo usa esta operación para mantener la estructura de árboles para directorios, este comando no puede ponerle nombres adicionales a directorios.

Ejemplo:

e@abe:e/> ls -litotal 48 72 -rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile 180 -rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.png 179 -rw-r--r-- 1 e system 0 Aug 16 17:22 NuevoVacio.txt12320 drwxr-xr-x 3 e system 256 Aug 16 18:00 SubDir_2 177 -rw-r--r-- 1 e system 29 Aug 14 23:15 fecha actual.txt12288 drwxr-xr-x 3 e system 256 Aug 16 17:37 subdir112292 drwxr-xr-x 3 e system 256 Aug 16 17:59 subdir2e@abe:e/> ln "fecha actual.txt" "dato viejo"e@abe:e/> ls -litotal 56 72 -rw-r--r-- 1 e system 0 Aug 14 23:15 LitteFile 180 -rw-r--r-- 1 e system 17804 Aug 14 23:16 MadRamon 1.png 179 -rw-r--r-- 1 e system 0 Aug 16 17:22 NuevoVacio.txt12320 drwxr-xr-x 3 e system 256 Aug 16 18:00 SubDir_2 177 -rw-r--r-- 2 e system 29 Aug 14 23:15 dato viejo 177 -rw-r--r-- 2 e system 29 Aug 14 23:15 fecha actual.txt12288 drwxr-xr-x 3 e system 256 Aug 16 17:37 subdir112292 drwxr-xr-x 3 e system 256 Aug 16 17:59 subdir2


Con la opción i del comando ls se logra que éste genere listados donde se incluye el número del inodo de cada item. Como se ve en el ejemplo, dato viejo y fecha actual.txt tienen el mismo inodo, por lo que trabajar uno es exactamente lo mismo que trabajar el otro.

Si se intenta borrar un archivo que tiene varios nombres hay que borrar todos los nombres que tenga, ya que mientras al archivo le quede al menos un nombre se podrá usar por ése nombre que quede y no será borrado. Cuando ya no tenga ni un nombre, y tampoco está abierto por ninguna aplicación el sistema desconectará al archivo de su ínodo y ya no podrá ni accederse a él ni recuperarse.


Agregar enlaces simbólicos: ln –s

Como no se pueden tener dos nombres al mismo archivo en diferente contenedor físico de almacenamiento ni se pueden hacer enlaces tradicionales a directorios entonces en UNIX hay otro estilo de enlace que se puede usar en todos los casos. Este otro estilo de enlace se llama “enlace simbólico” y es realmente un nuevo archivo, de tipo especial l que realmente apunta al nombre del archivo original. Como es otro archivo ocupa espacio aparte y tiene su propio inodo.

Cuando se crea un enlace simbólico a un archivo no se le aumenta al archivo original la cuenta de nombres que se almacena en el inodo. Cuando se borra un archivo enlace simbólico tampoco se afecta el original, pero cuando se borra el archivo original el enlace simbólico no sirve, porque sigue apuntando al nombre del archivo original que ya no existe.

Por otro lado, usar un enlace simbólico realmente hace que el sistema operativo redirija la operación y los programas realmente usan el archivo original.

Agregarle un enlace simbólico a un archivo individual

Se usa el comando ln con la opción s para agregarle enlaces simbólicos (oficialmente en UNIX se llaman symbolic links pero tradicionalmente se usa symlinks), cuya sintaxis es muy parecida a la de cp y mv:

ln –s nombreOriginal nombreNuevo

Dependiendo de cómo se usen los argumentos, los dos nombres pueden estar en el mismo o en diferentes directorios, o en áreas totalmente diferentes del sistema.

Si el archivo original está en algún otro lado puede obviarse el segundo nombre, lo que hace un enlace simbólico nuevo en el directorio actual, que cuando se use haga acceso al archivo original en algún otro lado:

ln –s /ruta/nombreOriginal

Agregarle enlaces simbólicos a múltiples archivos a la vez

Si se quieren tener en un directorio múltiples enlaces simbólicos de manera que cada uno apunte a algún archivo diferente simplemente se usa:

ln –s /ruta1/archivo1 /ruta2/archivo2 … /directorio/destino

Comando que un una sola operación crea un enlace simbólico llamado /directorio/destino/archivo1 apuntando a /ruta1/archivo1, uno llamado /directorio/destino/archivo2 apuntando a /ruta2/archivo2, y así sucesivamente.

Ejemplos:

e@abe:e/> dateThu Aug 16 23:00:45 EST 2007


e@abe:e/> date > actual.txte@abe:e/> ls -l actual.txt-rw-r--r-- 1 e system 29 Aug 16 23:00 actual.txte@abe:e/> cat actual.txtThu Aug 16 23:00:53 EST 2007e@abe:e/> ln -s actual.txt hoy.txte@abe:e/> ls -l actual.txt hoy.txt-rw-r--r-- 1 e system 29 Aug 16 23:00 actual.txtlrwxrwxrwx 1 e system 10 Aug 16 23:01 hoy.txt -> actual.txte@abe:e/> cat hoy.txtThu Aug 16 23:00:53 EST 2007e@abe:e/> date > hoy.txte@abe:e/> cat hoy.txtThu Aug 16 23:02:33 EST 2007e@abe:e/> cat actual.txtThu Aug 16 23:02:33 EST 2007

Se nota cómo editar los contenidos de actual.txt o de hoy.txt resulta en lo mismo, los contenidos de actual.txt son los que cambian, pero se nota cómo no son el mismo archivo, es más actual.txt mide 29 bytes, pero hoy.txt mide 10 bytes (el nombre actual.txt son 10 caracteres).


Hay que recordar que un archivo realmente se borra cuando se queda sin nombres.

Remover archivos y nombres de archivos: rm

Como el espacio se va acabando pronto, es necesario un comando que borre lo que ya no se necesita para liberar el espacio para otras cosas. Es casi una ley: no importa de cuánto espacio se disponga, pronto se acaba. En UNIX hay que tener mucho cuidado con lo que se borra, ya que si se trabaja en modo texto no hay protección: el archivo borrado es muy muy difícil de recuperar, no hay “trashcan”, y como funcionan los sistemas operativos no hacen muy fácil el desarrollo de utilidades estilo Undelete.

El comando “borrar” o “eliminar” se llama rm (remove) y es muy sencillo (demasiado) de usar. Sólo hay que darle como argumentos los nombres que se quieren borrar. Si se tienen suficientes permisos como para borrar los archivos el comando ni siquiera valida o confirma, simplemente borra.

Ejemplos:

e@abe:e/> lsLitteFile SubDir_2 fecha actual.txt subdir2MadRamon 1.png actual.txt hoy.txtNuevoVacio.txt dato viejo subdir1e@abe:e/> rm fecha\ actual.txt hoy.txte@abe:e/> rm SubDir_2rm: 0653-603 Cannot remove directory SubDir_2.e@abe:e/> lsLitteFile NuevoVacio.txt actual.txt subdir1MadRamon 1.png SubDir_2 dato viejo subdir2

Remoción de directorios

Hay que notar que para borrar directorios se usa el comando rmdir, pero que éste sólo borra directorios que estén vacíos. Por eso el comando rm tiene una función adicional: la posibilidad de remover directorios con todo lo que contienen –es decir que borra aunque no estén vacíos-. Este es un comando muy peligroso, por favor fíjese antes de enviar el comando: rm –R item1 item2

Ejemplo:

e@abe:e/> ls subdir2Antiguo_SubDir LitteFile MadRamon 1.png smit.loge@abe:e/> rm -R subdir2e@abe:e/> ls subdir2ls: 0653-341 The file subdir2 does not exist.


Determinar tipo de archivo: file

Como el nombre y los contenidos de un archivo en UNIX no tienen relación directa, en UNIX hay disponible que un comando que revisa los contenidos y haciendo un análisis intenta reportar qué clase de archivo es cada uno de los nombrados como argumentos. El comando se llama file, y es de muy sencillo uso.

Ejemplos:

e@abe:e/> file LitteFile actual.txtLitteFile: emptyactual.txt: ascii texte@abe:e/> file subdir1subdir1: directorye@abe:e/> file /tmp/tmp: directory



A mediados de los setentas –por la época en que apareció vi- se usaba mucho un editor de texto avanzado con una infinidad de combinaciones de t e c l a s y c a s i c u a l q u i e r secuencia de caracteres como comandos. Su nombre es TECO.

Edición de Archivos de Texto: vi

Archivos de Texto

Desde el comienzo UNIX se planeó para trabajar texto, grandes cantidades de texto, por ello, desde siempre ha habido muchas utilidades para el manejo de texto. De todas las utilidades para el manejo de texto la central es la herramienta de creación de contenido –y de edición-: el editor de texto.

Editores de Texto: vi

En UNIX se cuenta con múltiples editores de texto, que varían de plataforma a plataforma, pero hay unos que están estandarizados en los libros POSIX y en la especificación UNIX oficial (la última siendo Single UNIX Specification v3 o UNIX 03), de éstos el más importante es vi. Este editor, llamado por el comando que lo invoca toma el nombre de un editor anterior llamado ex, que era una versión “moderna” de otro anterior con el cual mantiene la compatibilidad –llamado ed-. En ex, usar el comando vi lleva al modo “visual” de edición –normalmente se trabaja a través de comandos, parecidos a las actuales macros de los editores de ambiente gráfico-. El modo visual de ex es exactamente el actual comando vi. Es más hoy en día son el mismo programa (son dos links o nombres del mismo archivo), y si se invoca ex inicia en modo comandos, y si se invoca vi inicia en modo visual.

Modos de vi

vi es un editor de texto modal, y qué es modal? que vi sea modal significa que las teclas que se presionen tienen un efecto diferente del modo en que está trabajando vi en el momento.

Cuando vi está en modo inserción de texto las letras y símbolos del teclado simplemente insertan los caracteres de las teclas en el archivo que se esté editando; pero, cuando vi está en modo comando muchas letras y símbolos del teclado realizan funciones, funcionan como comandos.

Esto puede verse raro, pero tiene un razonamiento directo:

El teclado de la terminal donde se desarrolló vi no tenía muchas teclas, en especial no tenía teclas de función, básicamente la tecla shift y la tecla control.

Si se usan las teclas básicas para los comandos no hay que usar combinaciones especiales de teclas, por lo que las manos del usuario se estresan menos –el principal origen del síndrome del tunel del Carpio-.


Editar archivos existentes con vi

Editar archivos de texto ya existentes con vi es muy sencillo, simplemente se puede abrir uno con vi nombreArchivo o se pueden abrir varios simultáneamente dándolos todos como argumentos –como siempre, separados por espacios-:vi archivo1 archivo2 archivo3

vi los abrirá todos, en diferentes “pantallas”. Siendo un programa de terminal de texto no hay manera de cambiar la apariencia de las “pantallas”. vi simplemente los abrirá todos y mostrará en la “primera” pantalla el primero de los archivos.

Como se observa, vi muestra en la última línea información de estado:

Nombre del archivo, entre comillas dobles

Si el archivo no puede ser guardado muestra [Read only]

El número de líneas de texto

El número de caracteres

Para cambiarnos de pantalla simplemente se usa el comando :n (sí, dos puntos n).

Para salir de vi, si únicamente se está editando un archivo se usa el comando :q (dos puntos q), pero si se está editando más de un archivo se usa :q! (dos puntos q admiración). Este último comando funciona para todos los casos.

Si se intenta salir con :q y hay varios archivos abiertos, vi reportará en la línea de estado There are x more files to edit. En cambio, si se intenta cambiar al siguiente archivo


cuando ya está en el último archivo (no hay siguiente) vi mostrará en la línea de estado No more files to edit.


Creación de nuevos archivos de texto

Crear nuevos archivos de texto con vi es muy sencillo, se hace de la misma manera como se abren archivos existentes, simplemente se nombra o nombran en la línea de comandos, y si vi nota que no existe –cada uno- se prepara para crearlo, nuevo. Ahora vi realmente no crea el archivo si no en el momento que se guarde.vi nombreNuevo

Como se observa, vi muestra una pantalla llena de símbolos ~, donde cada símbolo ~ representa una línea no existente en el archivo. También vi muestra información en la línea de estado:

Nombre del nuevo archivo a crear, entre comillas dobles

El texto informativo [New file]

Para salir del archivo o los archivos se usa el mismo comando que antes :q (dos puntos q)

Ahora, como los archivos nuevos no existen realmente si no cuando se guarden en disco, hay que guardar, y esta operación se realiza con el comando :w (dos puntos w) por archivo. Cuando vi guarda un archivo, reporta en la línea de estado el nombre del archivo guardado, entre comillas dobles, el número de caracteres y el número de líneas en el archivo recién guardado. Ahora, si el usuario puede sobreescribir un archivo –por ejemplo es el dueño del archivo- pero los permisos del mismo dicen que debería estar protegido, cuando se intente guardar vi reportará The file has read permission only, pero podrá escribirse de todas maneras sobre el archivo si se usa el comando :w! (dos puntos w admiración).


Muchas veces el usuario está trabajando un archivo y quiere terminar de trabajar, por ello necesita guardar y salir de vi. Estas dos operaciones pueden llevarse a cabo con:

Comando :w y el comando :q

Comando combinado :wq

Comando :x

Todos los tres comandos son sinónimos.

Ahora, si el usuario ha hecho cambios en un archivo y desea salir, pero no desea mantener los cambios, es decir le interesa salir sin guardar vi no se lo permitirá, reportando No write since the file was last change. Si el usuario realmente desea salir de vi sin guardar deberá usar entonces el comando :q! (dos puntos q admiración).


Como es posible sacar a vi del modo comando y que los comandos aquí mencionados no funcionen deberá recordar que para entrar a modo comando se puede presionar escape las veces necesarias (hasta que vi pite!)

Moverse dentro de un archivo

vi tiene numerosas maneras de moverse dentro de un archivo, dependiendo de lo que el usuario necesite y del modo en el que vi esté. Lo más básico es que si se tiene una terminal moderna –o un programa cliente con una muy buena emulación- se pueden usar las teclas flecha de movimiento de cursor . También podrán usarse las téclas AvPágina y RetrPágina.

Moverse de a líneas

Ahora, cuando vi inicia normalmente está en modo comando, y en este modo funcionan también:

‣ h, suprimir o control h para moverse un carácter a la izquierda. Equivalente a la tecla .

‣ l o espacio para moverse un carácter a la derecha. Equivalente a la tecla .

‣ k o control p para moverse una línea arriba. Equivalente a la tecla .

‣ j, control j o control n para moverse una línea abajo. Equivalente a la tecla .

‣ + para moverse a la siguiente línea, ubicándose en el primer carácter visible (en esa línea).

‣ - para moverse a la línea anterior, ubicándose en el primer carácter visible (en esa línea).

Moverse de a páginas o pantallas

Cuando vi está en modo comando funcionan:

‣ control f para avanzar una pantalla completa. Equivalente AvPágina.

‣ control b para retroceder una pantalla completa. Equivalente a RetrPágina.

‣ control d para avanzar media pantalla.

‣ control u para retroceder media pantalla.

‣ control e para desplazar una línea hacia arriba la pantalla.

‣ control y para desplazar una línea hacia abajo la pantalla.

‣ shift h para llevar el cursor a la primera línea de la pantalla.

‣ shift m para llevar el cursor a la línea en la mitad de la pantalla.

‣ shift l para llevar el cursor a la última línea en la pantalla.


Moverse según el contexto

Según el modo en que está trabajando vi las siguientes teclas varían en su funcionamiento, pero si el archivo que se trabaja es un archivo de texto sencillo, y se está en modo comando funcionan:

‣ 0 para moverse al inicio de la línea actual.

‣ $ para moverse al final de la línea actual.

‣ ) para moverse al inicio de la siguiente frase.

‣ ( para moverse al inicio de la anterior frase.

‣ } para moverse a justo antes del siguiente párrafo.

‣ { para moverse a justo antes del actual párrafo.


Inserción de nuevos contenidos de texto (en vi)

Entrar nuevo texto en vi es muy fácil. Existen varias maneras, dependiendo de dónde se esté y de dónde se quiere que aparezca el nuevo texto agregado. En modo comando funcionan:

‣ i para insertar texto justo antes de la posición del cursor. Agrega texto si se está al final de una línea.

‣ a para agregar texto justo después de la posición del cursor.

‣ shift i para insertar texto al comienzo de la línea sin importar dónde esté el cursor en la línea.

‣ shift a para agregar texto al final de la línea sin importar dónde esté el cursor en la línea.

‣ o para agregar una línea en blanco después de la actual.

‣ shift o para agregar una línea en blanco antes de la actual.

Todos estos comandos cambian el modo de vi, apenas se usen vi se cambia a modo inserción de texto y así permanecerá. Puede cambiarse al modo comando usando la tecla escape.


Comandos básicos de edición de texto (de vi)

vi tiene unos comandos sencillos para modificar texto, son necesarios en las operaciones del día a día con texto. Funcionan cuando se está en modo comando:

‣ x para borrar el carácter debajo del cursor. Borra el carácter a la izquierda del cursor si se está al final de la línea.

‣ X para borrar el carácter anterior al cursor. Borra el carácter debajo del cursor si se está al comienzo de la línea.

‣ r y un carácter para reemplazar el carácter debajo del cursor por el que se escriba a continuación.

‣ R y texto para sobreescribir un texto original. Si se escriben n caracteres se sobrescribirán los n caracteres a partir de la posición del cursor. Se termina la sobreescritura presionando escape.

‣ . para repetir la última operación, sin importar cuál operación de edición haya sido.

‣ u para deshacer el último cambio o edición hecha.

‣ U para deshacer todos los cambios hechos en la línea actual.

‣ >> para indentar la línea actual.

‣ << para de-indentar la línea actual.

‣ ~ para cambiar el carácter debajo del cursor de minúsculas a mayúsculas y viceversa.

‣ shift j para unir la línea que sigue con la actual, para que no sea la línea que sigue sino una parte al final de la línea actual.

Ninguno de estos comandos deja a vi en modo inserción, vi permanece en modo comando.


Buscar y reemplazar textos contenidos (dentro de vi)

vi es muy poderoso, y aunque a primera vista se ve primitivo, tiene comandos de búsqueda y movimiento muy poderosos. Mientras se está en modo comando funcionan:

‣ control g para que vi muestre en la línea de estado el nombre del archivo (dentro de comillas dobles), si el archivo es de sólo lectura (muestra [Read Only]), si el archivo ha recibido cambios (muestra [Modified]), muestra en qué línea en el archivo se está, cuántas son y la posición porcentualmente cuánto es.

‣ shift g para ir a la última línea del archivo.

‣ número shift g para ir a la línea con la posición número. Así para ir a la primera línea se dará 1G cuando se está en modo comando. Si el archivo no tiene la línea número vi reporta con una alarma sonora.

‣ /texto para ir a la próxima línea que contenga el texto dado (busca hacia adelante o abajo). Si el texto no se encuentra vi reporta The pattern does not exists.

‣ ?texto para ir a la previa línea que contenga el texto dado (busca hacia atrás o arriba). Si el texto no se encuentra vi reporta The pattern does not exists.

‣ n después de una búsqueda para que vi vuelva a buscar en el mismo sentido. Así si se hizo una búsqueda con / vi volverá a buscar hacia adelante.

‣ N después de una búsqueda para que vi vuelva a buscar pero ahora en el sentido contrario. Así si se hizo una búsqueda con ? vi volverá a buscar, pero ahora hacia adelante.

‣ /texto/+número para que vi busque un texto hacia adelante y se ubique número líneas después de la que contiene el texto.

‣ /texto/-número para que vi busque un texto hacia adelante y se ubique número líneas antes de la que contiene el texto.

‣ ?texto?+número para que vi busque un texto hacia atrás y se ubique número líneas después de la que contiene el texto.

‣ ?texto?-número para que vi busque un texto hacia atrás y se ubique número líneas antes de la que contiene el texto.

‣ :%s/original/reemplazo/ para que vi reemplace en todas las líneas del archivo el texto original por el reemplazo la primera vez que aparezca en cada línea. Normalmente vi diferencia las mayúsculas de las minúsculas. vi reporta cuántas líneas sufrieron modificaciones.


‣ :%s/original/reemplazo/g para que vi reemplace en todas las líneas del archivo el texto original por el reemplazo todas las veces que aparezca en cada línea. Normalmente vi diferencia las mayúsculas de las minúsculas. vi reporta cuántas modificaciones hizo y en cuántas líneas.


Recuerde que las presiones de tecla o combinaciones de control sólo funcionan en modo comando. Para llegar al modo comando se usa la tecla escape.

Tableros de recortes: Cortar, copiar y pegar

vi como los editores de texto más modernos tiene un “tablero de recortes” o “portapapeles” (oficialmente se llama el undo buffer), pero a diferencia de la mayoría de los editores modernos tiene “tableros nombrados”. Todos sirven para copiar, cortar y pegar. Mientras vi está en modo comando funcionan:

‣ dw corta desde donde está el cursor hasta el final de la palabra actual.

‣ número dw corta las número palabras a partir de las palabra actual.

‣ d$ corta desde donde está el cursor hasta el final de la línea actual.

‣ d0 corta desde donde está el cursor hasta el inicio de la línea actual.

‣ dd corta la línea actual.

‣ número dd corta las número líneas a partir de la línea actual.

‣ d) corta desde donde está el cursor hasta el final de la frase actual.

‣ d} corta desde donde está el cursor hasta el final del párrafo actual

‣ yw copia desde donde está el cursor hasta el final de la palabra actual.

‣ número yw copia las número palabras a partir de la palabra actual.

‣ y$ copia desde donde está el cursor hasta el final de la línea actual.

‣ y0 copia desde donde está el cursor hasta el inicio de la línea actual.

‣ yy copia la línea actual.

‣ número yy copia las número líneas a partir de la línea actual.

‣ y) copia desde donde está el cursor hasta el final de la frase actual.

‣ y} copia desde donde está el cursor hasta el final del párrafo actual.

‣ p pega los contenidos del “tablero de recortes” justo después de donde está el cursor. Si son líneas pega justo después de la línea actual.

‣ P pega los contenidos del “tablero de recortes” justo antes de donde está el cursor. Si son líneas pega justo antes de la línea actual.



Recuerde que las presiones de tecla o combinaciones de control sólo funcionan en modo comando. Para llegar al modo comando se usa la tecla escape.

Editar y trabajar con más de un archivo de texto

Aparte de poder dar a vi más de un archivo de texto en la línea de comandos original como ya se ha visto, desde dentro de una sesión se pueden trabajar varios archivos aún si no se cargaron originalmente con la invocación. Hay varias invocaciones que podrán interesar. Estando en modo comando funcionan:

‣ :w graba el archivo que se está editando en la pantalla, con el nombre que ya tiene. Si el archivo no ha sido modificado o no tiene permisos de escritura no lo intenta guardar.

‣ :w! graba el archivo que se está editando en la pantalla, con el nombre que ya tiene, aunque no haya sido modificado o el archivo no tiene permisos de escritura. Si el sistema operativo no permite las modificaciones obviamente no se podrá grabar el archivo.

‣ :w nuevoNombre graba el archivo que se está editando con un nuevo nombre (básicamente la función Guardar como… que se encuentra disponible en los editores modernos)

‣ :w! nuevoNombre graba el archivo que se está editando con un nuevo nombre, aunque no se hayan hecho modificaciones o no tenga permisos de escritura.

‣ :e otroArchivo abre para edición el archivo mencionado en el comando.

‣ :e! re-abre para edición el archivo actual, descartando todos los cambios hechos que no hayan sido guardados

‣ :e+ otroArchivo abre para edición el archivo mencionado, y automáticamente se ubica al final del mismo (se abre el archivo para agregar contenido).

‣ :e+número otroArchivo abre para edición el archivo mencionado, y automáticamente se ubica en la línea número especificada. Si otroArchivo puede abirse pero no tiene tantas líneas como para ubicarse en la línea especificada lo abre pero reporta Not that many lines exist in the file.

‣ :e# vuelve a abrir “el otro archivo”, el último que se estaba editando.

‣ :r otroArchivo importa otro archivo en el que se está editando, es decir lee las líneas del otroArchivo y las inserta justo después de la línea actual en el archivo que se está editando.

‣ :r !unComando ejecuta unComando, y las líneas de texto producidas por el comando las inserta justo después de la línea actual en el archivo que se está editando.


Personalización del editor de texto vi

El editor de texto vi tiene una serie de opciones que gobiernan cómo funciona. Estas opciones gobiernan cómo reacciona a los comandos, como muestra contenido en la pantalla y cómo se manipulan las líneas de texto.

Para ver las opciones actualmente en efecto en vi se usa el comando :set all como se muestra a continuación:

Como puede apreciarse, hay muchas opciones, pero no todas son de uso común. Entre las más útiles están:

‣ autoindent (ai) opción que activa la indentación automática de las nuevas líneas de texto, para alinearlas con las inmediatamente anteriores. Para desactivar la función se usa noautoindent o noai.

‣ autowrite (aw) opción que activa el grabado automático de un archivo antes de cambiarse al siguiente en una sesión. Para desactivar la función se usa noautowrite o noaw.

‣ beautifying text (bf) opción que activa la protección de los archivos para que no se puedan insertar caracteres de control en el mismo. Para desactivar la función se usa nobf.

‣ ignorecase (ic) opción que hace que el editor ignore la diferencia entre mayúsculas y minúsculas en las búsquedas y los reemplazos. Para desactivar la función se usa noignorecase o noic.


‣ list opción que hace que el editor muestre los caracteres tabulador dentro del archivo como ^I y los finales de línea como $. Para desactivar la función se usa nolist.

‣ number (un) opción que hace que el editor muestre el número de cada línea en la primera columna de la pantalla. Para desactivar la función se usa nonumber o nonu.

‣ shiftwidth (sw=) opción con la que se le define a vi cuántos caracteres de ancho ocupa un tabulador inicial o la indentación automática. El valor predeterminado es sw=8.

‣ showmatch (sm) opción con la que se activa la muestra automática del carácter pareja de (, ), {, }. La función se desactiva con noshowmatch o nosm.

‣ showmode (smd) opción con la que se activa el aviso en la última línea cuando vi esté en modo inserción de texto. La función se desactiva con noshowmode o nosmd.

‣ tabstop (ts=) opción con la que se le define a vi cuántos caracteres espacio debe usar para presentar en un archivo cada carácter tabulador. El valor predeterminado es ts=8.

‣ wrapmargin (wm=) opción con la que se activa la definición del ancho flexible de página. Con esta opción la presentación de una línea mayor que el margen fluye a la siguiente línea de pantalla. El valor predeterminado es wm=0 con lo que el texto no fluye.

‣ wrapscan (ws) opción con la que se activa que las búsquedas reinicien en la primera línea del archivo cuando pasen de la última. La opción se desactiva con nowrapscan o nows.

‣ wraptype (wt=) opción con la que se configura cómo corta y fluye las líneas vi cuando una línea sea más larga que el margen especificado con wm=. Tiene cuatro posibles valores general, word, rigid, y flexible.

A todas estas opciones pueden dársele valor en cualquier momento, usando :set opción o tal vez :set opción=valor. Cuando así se usa, la opción sólo aplica para la sesión actual de edición, es decir, que si se sale del editor vuelven a aplicar los valores predeterminados.

Si se desea que vi tenga una cierta configuración y que dicha configuración aplique para todas las invocaciones del editor hay que guardarlas en un archivo de configuración. vi nunca guarda las opciones automáticamente, el archivo debe ser creado.

Cuando vi se ejecuta, a menos que se le de la opción para que no lo haga, busca el archivo /etc/.exrc, si lo encuentra carga las opciones de configuración que allí encuentre; luego busca el archivo .exrc en el directorio personal o inicial del usuario, si lo encuentra carga las


opciones de configuración que allí encuentre; y por último busca un archivo .exrc en el directorio actual de invocación del comando, y si lo encuentra carga las opciones que allí encuentre.

Uso práctico de los archivos de opciones de vi

Ahora, cómo se usa en la práctica esto?

Como /etc es un directorio único en el sistema, y todos los usuarios tienen derecho a buscar cosas allí, si hay un archivo .exrc éste aplicará para todos los usuarios del sistema, así que en este archivo deberán configurarse opciones de vi que aplique para todos los usuarios –usarios que usen vi, claro está-.

Como el directorio personal es como el nombre lo indica, propio de cada usuario, si hay un archivo .exrc en el directorio personal, las opciones que allí se encuentren aplicarán para todas las invocaciones de vi de usuario, pero sólo para el usuario.

Si se necesitan trabajar unos archivos de texto que están en algún otro directorio y la configuración típica de vi no aplica, puede crearse un archivo .exrc con las opciones, y éstas sólo aplicarán mientras se esté trabajando el directorio.

Formato de un archivo de opciones de configuración de vi

Un archivo de opciones de vi es muy sencillo, es simplemente un archivo de texto que tiene líneas con las opciones como se escriben en el modo comando de vi, pero sin el carácter : (dos puntos) como prefijo. vi ignora las líneas en blanco y las líneas que comienzan con el carácter “ (comillas dobles).

Un archivo válido de opciones de vi podría ser:“no diferenciar mayúsculas de minúsculasset ignorecase“mostrar números de líneaset number“avisar cuando esté en modo inserciónshowmode

Recuerde que como el archivo debe llamarse .exrc normalmente no aparecerá en los listados (el nombre comienza con punto).


El ambiente de trabajo: procesos y variables

El ambiente de trabajo

1=init

env

3128=cron

env

41329=telnetd

env

33571=ksh

env

132231=ksh

env

5739=inetd

env

132231=ksh

env

51301=dbmgr

env

hijode

hijode

hijode

hijode

hijode

hijode

hijode

Los sistemas operativos UNIX tienen todos una arquitectura de ejecución donde cada instancia de comando o programa que se ejecuta en el sistema obtiene una “vista” de un “universo virtual”, donde él es el único programa en ejecución. Ahora, en la realidad todos los UNIX son sistemas multitarea y multiusuario, y por ello, dentro de esa arquitectura hay, por cada programa en ejecución –que oficialmente se llama proceso- un espacio que se llama “el ambiente”.

El mencionado “ambiente” es un área de memoria que existe dentro del “universo virtual” de cada proceso. En dicho ambiente escribe el “cargador de procesos” unos valores que definen cómo reacciona el programa al “universo virtual” y cómo reacciona el sistema operativo ante lo que el proceso le solicita. Lo que hay en el ambiente son valores guardados a manera de variables, aunque no todos los valores que allí se encuentra se consideran variables en sí. Como cada proceso ve al sistema como todo para sí, ya que lo que tiene es una vista que le arma un “universo virtual” propio, no hay manera de hacer que un proceso directamente altere los valores que hay en el ambiente de otro proceso.

Algunos de los valores que están en el ambiente –oficialmente llamado environment- de un proceso son fáciles de revisar por el proceso, ya que están en “casillas nombradas” con nombre y con valores que se consideran texto. Estos pares se llaman variables de


ambiente y permiten que de cierta manera un proceso le “pase” información a otro proceso mientras sea un nuevo proceso hijo que el proceso original inicie.

Adicionalmente –adicionales a las variables de ambiente- en el ambiente de cada proceso hay:

Un número único –único dentro del sistema- que identifica al proceso. Oficialmente se llama “identificador de proceso” o process ID (PID). Este es un número entero positivo siempre.

El número identificador de proceso del otro proceso que ordenó el inicio o armó la ejecución del proceso. Oficialmente se llama “identificador de proceso padre” o parent process ID (PPID).

El número identificador del usuario que ordenó el inicio o invocó el proceso, así sea indirectamente. Oficialmente se llama “identificador del usuario real” o real user ID (RUID).

El número identificador del usuario con el que se le maneja toda la seguridad a las operaciones que realice el proceso; y, casi siempre es el mismo identificador del usuario real. Oficialmente se llama “identificador del usuario efectivo” o effective user ID (EUID).

Una lista de números identificadores de grupos a los que el usuario que ordenó la invocación del proceso pertenece. Oficialmente se llama “identificadores de grupos reales” o real group IDs (RGIDs).

Una lista de número identificadores de grupos con los que se le maneja la seguridad a las operaciones que realiza el proceso; y casi siempre es la misma lista de grupos que está en RGIDs.

El momento exacto en el tiempo en que se inició el proceso. Oficialmente se llama “tiempo de inicio” o starting time (STIME).

Cuánto lleva ejecutando el proceso en total, teniendo en cuenta que se ejecuta por períodos muy cortos porque casi siempre tiene que compartir las CPUs del sistema con muchos otros procesos. Oficialmente se llama “tiempo de ejecución” o execution time (TIME).

Uno o más números para el manejo de prioridades. Comúnmente son dos números, una base y un variable.

El directorio actual donde está trabajando el proceso. Comúnmente es el directorio desde donde se invocó el proceso. Oficialmente se llama “directorio actual de trabajo” o current working directory (CWD).


Procesos

Como cada proceso es una instancia de un programa o comando en ejecución, cada proceso en el sistema necesita de algo de CPU (por lo menos uno turnos cuando no “consume” mucho), cierta cantidad de RAM, y hace ciertas operaciones de I/O. Todo proceso en el sistema afecta en algo, entonces puede al usuario interesarle:

Sus propios procesos cuánto afectan a los demás.

Cuán afectado se ven sus propios procesos afectados por lo que hacen los procesos de los demás.

Nótese que cómo afectan a los demás y cómo son afectados por los demás es el resultado indirecto de estar en el mismo sistema, no es algo directo porque los UNIX son un ambiente protegido de ejecución, que no permite que un proceso pueda manipular directamente el ambiente donde otro proceso existe y se ejecuta.

Iniciar y detener procesos

Como un proceso es una instancia de programa y comando en ejecución, iniciar un proceso es simplemente invocar un comando o iniciar un programa. Este sólo hecho inicia al menos un proceso –algunos programas cuando inician ejecutan otros programas accesorios que necesitan para funcionar-. Detener oficialmente un proceso en UNIX es decirle a un programa que termine de la manera que al programa se le dice. Por ejemplo: la mayoría de lo que uno llama comando es un programa que realiza una tarea sencilla, y cuando el programa termina dicha tarea el sólo programa termina, sin necesidad de solicitarle. Como un proceso es un programa en ejecución, si un programa termina, el proceso que lo representa desaparece de la lista de procesos. Por otro lado, programas como vi, que trabaja interactivamente necesita que se le diga “termine” usando algún tipo de comando interno o menú; en el caso de vi, se le dice usando el comando escape :q! o escape :x!



El comando ps es uno de los pocos importantes que no e s t á n t o t a l m e n t e estandarizados en todos los UNIX. Hay dos variaciones en la información que muestra ps y en lo que significan las opciones de ps. Una variante, que aplica para AIX y para Solaris deriva del UNIX original de AT&T y otra variante aplica para Mac OS X deriva de los UNIX BSD.

Listar procesos

Listado básico de procesos: ps

Para listar procesos se usa un comando muy sencillo llamado ps (process status). Este es un comando increíblemente variado, donde casi todas las letras del alfabeto son opción. Afortunadamente la ejecución más sencilla, sin opciones, es usable:

[0 e@Moe ~] ps PID TT STAT TIME COMMAND 8009 p1 S 0:00.03 -bash

La ejecución del comando ps sin opciones sólo obtiene un listado de los procesos del usuario que lo invoca, en la ventana de sesión actual y sin muchos detalles. Muestra, a saber:

Una línea con títulos de columnas (PID, TT, STAT, TIME, COMMAND)

Para cada proceso una línea o renglón de texto.

El número identificador único de cada proceso debajo del título PID.

El nombre corto de la ventana de sesión debajo del título TTY .

Unas letras que describen el estado del proceso que la línea representa.

Un tiempo en minutos:segundos.fracción, que acumula todo el tiempo que el proceso a usado dentro de la(s) CPU(s) del sistema bajo el título TIME.

El nombre del proceso, derivado del nombre del comando. Note que como cada proceso tiene acceso a su ambiente, un proceso puede cambiar el título que aquí se muestra, bajo el título de columna COMMAND.

Listado de todos los procesos: ps –e

Cuando se necesite listar la información de todos los procesos del sistema –exceptuando los miniprocesos internos del núcleo o kernel- se puede usar la opción e del comando ps. Esta opción hace que ps muestra las columnas seleccionadas según el caso (si no se dan más opciones el identificador de proceso o PID, la terminal de control o TTY, el tiempo acumulado en ejecución de CPU o TIME, y el nombre del comando. Si al comando ps –e se le agregan otras opciones, se mostrará lo que las otras opciones seleccionen, pero para todos los procesos.

Listado largo (técnico) de los procesos: ps –l

Si se necesita información detallada acerca de los procesos, puede usarse tal vez la opción l del comando ps que presenta unas columnas con detalles más técnicos acerca de los procesos seleccionados (sólo de la sesión actual sin más opciones, procesos de un usuario con u o todos los procesos con e). El comando muestra, varias columnas, a saber:


UID Esta columna muestra el usuario que inició o bajo cuya identidad está corriendo cada proceso.

PID Esta columna muestra el identificador único de cada proceso mostrado.

PPID Esta columna muestra el proceso padre desde donde se inició el proceso.

C Esta columna muestra el porcentaje aproximado actual de turnos de CPU que está usando cada proceso.

STIME Esta columna muestra cuándo se inició cada proceso. Si el proceso inició hoy muestra la hora (en formato HH:MM:SS, la horas de 00 a 23), y si se inició antes, muestra la fecha.

TTY Esta columna muestra la terminal de control del proceso. Cuando el proceso no está relacionado con una terminal muestra ?.

TIME Esta columna muestra el tiempo acumulado de CPU, con el total de consumo de CPU sumando los turnos de ejecución desde que el proceso inició.

CMD Esta columna muestra el nombre de cada proceso como está registrado en la memoria. Muchas veces muestra el nombre completo del archivo ejecutable del procesos, pero como esta información está en el ambiente de cada proceso y los mismos pueden escribir en su propio ambiente puede mostrar otra información o información incompleta.

Listado completo (full) de información de los procesos: ps –f

Si se necesita información detallada acerca de los procesos, puede usarse tal vez la opción f del comando ps que presenta unas columnas con detalles más técnicos acerca de los procesos seleccionados (sólo de la sesión actual sin más opciones, procesos de un usuario con u o todos los procesos con e). El comando muestra, varias columnas, a saber:

UID Esta columna muestra el nombre del usuario que inició -o bajo el que se inició- el cada proceso.

PID Como siempre, esta columna muestra el número identificador único del proceso.

PPID Esta columna muestra el número identificador del proceso padre de cada uno de los procesos.

C Esta columna muestra el consumo promedio porcentual -redondeado a entero- de cada uno de los procesos.

STIME Esta columna muestra cuándo se inició cada uno de los procesos. Si el proceso inició hoy mismo muestra la hora, pero si no, muestra la fecha únicamente.


TTY Esta columna muestra la terminal de control del proceso. Cuando el proceso no está relacionado con una terminal muestra ?

TIME Esta columna muestra muestra el tiempo acumulado de ejecución, contando la suma de los turnos de procesador que ha consumido cada proceso desde el momento del inicio.

CMD Esta columna muestra, si es posible, el comando que constituye el proceso, con todo y la sintaxis de inicio.

Ejemplo:0 root@abe:/> ps -f UID PID PPID C STIME TTY TIME CMD root 135342 249876 1 00:30:24 pts/0 0:00 ps -f root 249876 172188 3 00:30:22 pts/0 0:00 -bash

Variantes BSD - Listado extendido de procesos: ps –U nombreUsuario

Si se quiere o se necesita la información acerca de todos los procesos en un sistema iniciados por o relacionados con un usuario puede usarse el comando ps –U nombreUsuario. Este comando es muy común en ambientes de servidor dedicado –donde un sistema básicamente fue adquirido para ejecutar una aplicación y lo demás es accesorio. Esta versión del comando muestra, a saber:

El identificador único de cada proceso, bajo la columna PID, como siempre.

El nombre de la terminal de control o de interacción con el proceso, bajo el título de columna TT.

El estado del proceso bajo la columna STAT. De los estados se hablará más adelante.

El tiempo acumulado de ejecución, en minutos:segundos.fracción.

El nombre largo del programa/proceso, lo más completo posible.

Ejemplo:[0 e@moe:~] ps -U e PID TT STAT TIME COMMAND 115 ?? Ss 0:29.51 /System/Library/Frameworks/ApplicationServices.framew 122 ?? Ss 0:23.59 /System/Library/CoreServices/loginwindow.app/Contents 133 ?? Ss 0:00.58 /System/Library/CoreServices/pbs 138 ?? S 0:13.01 /System/Library/CoreServices/Dock.app/Contents/MacOS/ 139 ?? S 0:00.37 aped 141 ?? S 6:54.35 /System/Library/CoreServices/SystemUIServer.app/Conte


142 ?? S 1:07.88 /System/Library/CoreServices/Finder.app/Contents/MacO 147 ?? S 0:14.01 /Library/PreferencePanes/Growl.prefPane/Contents/Reso 148 ?? S 0:01.23 /Applications/iCal.app/Contents/Resources/iCalAlarmSc 149 ?? S 1:48.19 /System/Library/PreferencePanes/UniversalAccessPref.p

Puede obtenerse un listado donde se muestre completa la última columna –el nombre completo del programa/proceso- si se agrega la opción w al comando ps:

[0 e@moe:~] ps -wU ePID TT STAT TIME COMMAND 115 ?? Ss 0:29.86 /System/Library/Frameworks/ApplicationServices.framework/Frameworks/ATS.framework/Support/ATSServer 122 ?? Ss 0:23.67 /System/Library/CoreServices/loginwindow.app/Contents/MacOS/loginwindow console 133 ?? Ss 0:00.58 /System/Library/CoreServices/pbs 138 ?? S 0:13.05 /System/Library/CoreServices/Dock.app/Contents/MacOS/Dock -psn_0_393217 139 ?? S 0:00.37 aped 141 ?? S 7:02.79 /System/Library/CoreServices/SystemUIServer.app/Contents/MacOS/SystemUIServer -psn_0_524289

Listado extra extendido de procesos, en BSD: ps –aux

Si se quiere o necesita la información de todos los procesos del sistema, puede usarse –entre otros- el comando ps con opciones:

La opción a solicita que el comando ps muestre todos los procesos de todos los usuarios –incluidos los propios- independiente de la ventana de sesión desde donde se controlan.

La opción u solicita que el comando ps muestre información adicional acerca de los procesos. Incluye información: PID, usuario, porcentaje promedio de CPU consumido, porcentaje promedio de RAM consumida, tamaño virtual del proceso, tamaño residente del proceso, terminal de control, estado, tiempo de inicio, tiempo acumulado de CPU, y nombre del comando.

La opción x solicita al comando ps que muestre información de los procesos que no tienen una terminal de control.

Ejemplo:[0 e@Moe ~] ps -auxUSER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMANDe 7987 2.5 -5.2 391148 108204 ?? S 7:01AM 4:24.98 /Applications/Microsoft Office 2004/Microsoft Word -psn_0_39452673e 3901 1.1 -0.4 246928 8292 ?? S Sat08PM 5:36.87 /Applications/Utilities/Terminal.app/Contents/MacOS/Terminal -psn_0_3932161


windowse 3830 1.0 -4.4 835992 91932 ?? Ss Sat08PM 55:17.99 /System/Library/Frameworks/ApplicationServices.framework/Frameworks/CoreGraphics.framework/Resources/WindowServer -daemone 3845 0.4 -0.6 262328 13264 ?? S Sat08PM 15:00.64 /System/Library/CoreServices/SystemUIServer.app/Contents/MacOS/SystemUIServer -psn_0_655361e 4010 0.3 -1.8 308184 36992 ?? S Sat09PM 38:04.42 /Applications/iTunes.app/Contents/MacOS/iTunes -psn_0_7864321e 8009 0.1 -0.0 27892 948 p1 S 7:17AM 0:00.14 -bashe 3890 0.1 -11.5 602380 240140 ?? S Sat08PM 31:15.49 /Applications/Safari.app/ Contents/MacOS/Safari -psn_0_3145729root 40 0.1 -0.1 30248 1912 ?? Ss Sat10AM 3:44.29 /usr/sbin/configdroot 41 0.0 -0.1 33144 1836 ?? Ss Sat10AM 0:06.13 /usr/sbin/coreaudiodroot 42 0.0 -0.1 27780 1132 ?? Ss Sat10AM 0:05.27 /usr/sbin/diskarbitrationdroot 44 0.0 -0.0 28320 508 ?? Ss Sat10AM 0:00.17 /usr/sbin/memberd -xroot 45 0.0 -0.0 27864 392 ?? Ss Sat10AM 0:01.73 /usr/sbin/notifydroot 46 0.0 -0.1 29204 1660 ?? Ss Sat10AM 0:01.72 /usr/sbin/securitydroot 48 0.0 -0.0 27672 852 ?? Ss Sat10AM 0:12.89 /usr/sbin/distnotedroot 49 0.0 -0.1 31456 2124 ?? Ss Sat10AM 0:05.36 /usr/sbin/DirectoryServiceroot 52 0.0 -0.0 27248 172 ?? Ss Sat10AM 3:52.75 /usr/sbin/updateroot 63 0.0 -0.1 38280 2368 ?? S Sat10AM 0:08.28 /usr/sbin/bluedroot 64 0.0 -1.2 71476 25204 ?? Ss Sat10AM 1:29.30 /System/Library/ CoreServices/coreservicesde 71 0.0 -0.6 98476 11580 ?? Ss Sat10AM 1:34.34 /System/Library/ Frameworks/ApplicationServices.framework/Frameworks/ATS.framework/Support/ATSServerroot 82 0.0 -0.0 27768 104 ?? Ss Sat10AM 0:00.01 /usr/libexec/crashreporterdroot 114 0.0 -0.3 47288 5740 ?? Ss Sat10AM 1:49.11 /System/Library/ Frameworks/CoreServices.framework/Frameworks/Metadata.framework/Versions/A/Support/mdsroot 132 0.0 -0.2 30600 3520 ?? Ss Sat10AM 0:10.09 /usr/sbin/cupsd -Lroot 150 0.0 -0.0 27508 260 ?? Ss Sat10AM 0:10.92 ntpd -f /var/run/ntp.drift -p root 164 0.0 -0.0 29308 60 ?? Ss Sat10AM 0:00.00 nfsiod -n 4…

Como se puede observar la lista puede llegar a ser muy grande –habiéndose extraído la información de una estación de trabajo –básicamente con un único usuario-.

Acerca de las columnas: %CPU

La columna %CPU del comando ps -aux muestra un promedio porcentual de lo consumido en turnos de CPU por cada proceso desde el momento en que se inició. Como cada proceso inicia –y consume CPU- desde un momento del tiempo diferente, los porcentajes no se refieren a los mismos momentos del tiempo y por ello las sumatorias o cualquier otro cálculo no tienen que sumar un valor específico. Adicionalmente, si un proceso lleva días de iniciado y casi nunca ha consumido pero ahora último consume bastante el promedio no lo indicará. Así que esta columna no es un indicador definitivo de cuáles procesos afectan ahora más en el sistema. Adicionalmente, en algunos UNIX la cantidad de CPU en un sistema es un


valor lógico, virtual o físicamente cambiable, y este comando –no siendo consciente de esto- no tiene en cuenta estos factores de cambio, por lo que la información mostrada es sólo un indicador guía, no un valor realmente exacto.

Acerca de las columnas: %MEM

La columna %MEM del comando ps –aux muestra un promedio porcentual de lo consumido en páginas de memoria por cada proceso desde el momento en que se inició. Igual que en el punto anterior, como cada proceso inicia –y ocupa memoria- desde un momento diferente del tiempo, los porcentajes no se refieren a los mismos momentos del tiempo y por ello las sumatorias o cualquier otro cálculo no tienen que sumar un valor específico. Adicionalmente, si un proceso lleva días de iniciado y casi nunca ha consumido pero ahora último consume bastante el promedio no lo indicará. Así que esta columna no es un indicador definitivo de cuáles procesos afectan ahora más en el sistema. Adicionalmente, en algunos UNIX la cantidad de RAM en un sistema es un valor lógico, virtual o físicamente cambiable, y este comando –no siendo consciente de esto- no tiene en cuenta estos factores de cambio, por lo que la información mostrada es sólo un indicador guía, no un valor realmente exacto.

Acerca de las columnas: STATE

La columna STAT o STATE del comando ps –aux o ps –U o ps –w muestra dos caracteres que resumen el estado actual del proceso –actual cuando se ejecutó el comando ps-. Básicamente muestra:

‣ I para los comandos “inactivos” (idle). Estos procesos llevan durmiendo, sin hacer nada más de veinte (20) segundos.

‣ R es el indicador para un proceso “en ejecución”, no necesariamente en CPU cuando se ejecutó el comando ps. La letra indica runnable.

‣ S es el indicador para los procesos “durmientes” (sleeping). Este carácter se usa para los procesos que llevan durmiendo máximo unos veinte (20) segundos.

‣ T es el indicador para los procesos “forzosamente detenidos” (stopped). Estos procesos están en el mencionado estado debido a una señal externa a ellos. Estos procesos no recontinuarán a menos que externamente se les señale.

‣ U es el indicador para los procesos que están en una espera no interrumpible. Estos procesos casi siempre están a espera de una respuesta de I/O o de hardware y no pueden ser detenidos en medio de la operación.

‣ Z es el indicador para los residuos de procesos terminados que no han sido “recolectados” por los procesos padre. El carácter resume al estado zombie.


Procesos de fondo

Los UNIX son sistemas multitarea y multiusuario, por ello, aunque no lo parezca al usuario desprevenido, pueden aún desde una única ventada de terminal o de sesión, iniciarse múltiples procesos, aunque normalmente no visibles simultáneamente como se puede en un ambiente gráfico multi-ventanas.

Ejecución de procesos “de fondo” (en background)

La manera más fácil de iniciar procesos que se ejecuten mientras se trabaja con otras cosas en la línea de comandos es usando el símbolo & (and) al final de un comando.

Ejemplo:

Si se necesita probar la conectividad –con ping- mientras se hace otra cosa en la línea de comandos se puede intentar:

[0 e@Moe ~] ping -q localhost &[1] 1106 nótese lo que reporta el &PING localhost (127.0.0.1): 56 data bytes esta es salida del comando[127 e@Moe ~] telnet localhost 22Trying ::1...Connected to localhost.Escape character is '^]'.SSH-1.99-OpenSSH_4.5

Mientras todo sigue, el comando terminado en & se ejecuta sin acceder a la terminal (ni teclado ni control de pantalla). Nótese que los sistemas UNIX pondrán a un proceso de fondo en pausa automáticamente si y cuando intente controlar la terminal de sesión (por ejemplo especificando posición, colores o atributos a un aviso de texto) o si intenta leer de la terminal (el teclado se mantiene ocupado con lo que el usuario esté trabajando interactivamente).

Listar procesos de fondo

Para listar los procesos de fondo asociados con trabajos iniciados desde ventana de sesión actual se usa el comando jobs. Es muy sencillo:

[0 e@Moe ~] ping -q localhost &[1] 1158[PING localhost (127.0.0.1): 56 data bytes esta es salida del comando[0 e@Moe ~] jobs[1]- Running ping -q localhost &[2]+ Stopped vi[0 e@Moe ~]

Como se observa, de manera predeterminada muestra tres (3) columnas: La primera columna muestra el número del trabajo (entre símbolos []). Esta

columna tiene anexa además un más (+) o un menos (-). El símbolo se usa para


La mencionada aquí no es la única manera de hacer manejo de sesiones y de procesos multitarea en UNIX. Otra manera es el uso del comando screen.

indicar cuáles trabajos son usables para el cambio rápido con los comandos fg, bg y kill que se mencionarán más adelante.

La segunda columna muestra el estado del proceso que es representado por la tarea (job). El estado Running aplica para jobs cuyo proceso tiene estado R como se ha mencionado en la descripción del comando ps. El estado Stopped aplica para jobs cuyo proceso tiene estado T en la descripción del comando ps.

La tercera columna describe el comando ejecutado que constituye el trabajo.Aunque no se usa mucho, si se tienen muchos trabajos en una ventana de sesión, es útil conocer que con jobs %número puede listarse sólo un trabajo de fondo, y que con jobs %texto pueden listarse todos los trabajos de fondo cuyo comando comienza con el texto especificado.

Manejo de las tareas de fondo con fg y con bg

La idea principal de tener tareas de fondo es la posibilidad de hacer provecho de la multitarea de UNIX aunque se tenga una única terminal de sesión de modo texto. Cuando se tienen trabajos multitarea que aparecen en los listados del comando jobs se puede:

Llevar el intérprete del shell al fondo, y traer una de las tareas de fondo a sesión interactiva. El comando fg o fg %+ trae la última tarea, que es la que normalmente aparece con un símbolo de + después del número de tarea en los listados de jobs. Si el proceso está detenido (Stopped) además de traerlo a la sesión interactiva el proceso es recontinuado. El comando fg %- trae la penúltima tarea. El comando fg %número trae la tarea listada con dicho número en jobs.

Hacer que una tarea que aparece con estado Stopped reinicie –si se puede- pero mientras continúa trabajando en el fondo con el comando bg. El comando bg o bg %+ hace continuar la tarea que se lista con el símbolo + junto a su número de tarea en el comando jobs. Puede hacerse continuar la penúltima tarea con bg %- o puede seleccionarse cualquiera con bg %número también.

Señales a procesos: combinaciones de tecla y el comando kill

Como se diseñó la arquitectura de protección de procesos de los sistemas UNIX. Un proceso cualquiera no puede intervenir fácilmente en lo que sucede en cualquier otro proceso –o el ambiente de otro proceso. Hay oficialmente unas maneras como se un proceso puede interactuar con otro. Una manera es a través del uso de señales. Las señales son mensajes sencillos que un proceso puede enviar a otro, o que el sistema envía a procesos automáticamente como respuesta a ciertos eventos, como el uso de ciertas combinaciones de tecla.


Note especialmente que las señales generadas automáticamente por el sistema siempre son a un grupo de procesos, no a un único proceso.

Note que un proceso o tarea puede programarse para que ignore ciertas señales que se le envíen, pero no todas las señales son ignorables.

Un grupo de procesos es el conjunto de programas iniciado en alguno específico y que contiene los procesos hijos y los hijos de los hijos –y así sucesivamente-.

El comando básico para el envío de señales a procesos es kill. Este comando de desafortunado nombre se usa para enviar señales específicas a procesos o trabajos especificados. Como se ha diseñado en UNIX, el comando no interactúa con el proceso o procesos destino, el comando solicita al proceso maestro init que envíe la señal al proceso o procesos destino.

Algunas combinaciones de teclas como control c, control z, control \ hacen que el núcleo del sistema envíe señales idénticas a las de kill a todo un grupo de procesos.

Sintaxis del comando kill

El primer uso del comando kill es el de poder listar las posibles señales que se pueden enviar. No todas las señales están estandarizadas a través de toda la amplia gama de sistemas en la familia UNIX. Para listar qué señales están disponibles para enviar en el sistema actual se usa kill –l:

[1 e@Moe ~] kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGEMT 8) SIGFPE 9) SIGKILL 10) SIGBUS 11) SIGSEGV 12) SIGSYS13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGURG17) SIGSTOP 18) SIGTSTP 19) SIGCONT 20) SIGCHLD21) SIGTTIN 22) SIGTTOU 23) SIGIO 24) SIGXCPU25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH29) SIGINFO 30) SIGUSR1 31) SIGUSR2

Para enviar una señal se usa kill –señal númeroProceso … o para enviar una señal a una tarea se usa kill –señal %númeroTarea. Para enviar una señal a todo un grupo de procesos se usa kill –señal –númeroGrupo.

Las señales, en el comando kill, pueden especificarse usando el número obtenido del listado, el nombre completo (también obtenido del listado) o el nombre cortado, sin el prefijo SIG.

Acerca de las señales

Algunas de las señales son típicas o están estandarizadas:

La señal 1, HUP o SIGHUP (hang up) es enviada automáticamente por el sistema a todos los procesos del grupo relacionados con una ventana de sesión que ha sido


cerrada, desconectada o que ha sufrido desconexión en las comunicaciones. Como muchos de los procesos que implementan servicios en los ambientes UNIX son procesos que no están relacionados con ventanas de sesión, esta señal se reusa mucho para señalar a un proceso de servicio que reinicie o que recargue su configuración.

La señal 2, INT o SIGINT (interrupt) es enviada automáticamente –generalmente- por el sistema a el proceso interactivo actual cuando se presiona la combinación de teclas control c.

La señal 3, QUIT o SIGQUIT es enviada automáticamente por el sistema a el proceso interactivo actual cuando se presiona una combinación de teclas predefinida. Comúnmente se usa la tecla control \ para esta señal. Normalmente esta señal hace que el proceso que la recibe termine pero que al terminar genere un archivo de depuración core.

La señal 9, KILL o SIGKILL es enviada únicamente a través de un comando, típicamente el del mismo nombre, kill. Esta señal no es ignorable y al proceso destino no se le da tiempo para haga los pasos de limpieza necesarios para un cierre ordenado, por lo que el proceso que la recibe termina inmediatamente e irrevocablemente.

La señal 10, BUS o SIGBUS (bus error) es una señal que genera y envía el sistema a un proceso o tarea cuando se dan ciertos errores de hardware o cuando hay corrupción en un archivo ejecutable en ejecución. Esta señal siempre termina un proceso inmediatamente –a menos que el proceso esté bloqueando estas señales-.

La señal 11, SEGV o SIGSEGV (segment violation) es una señal que genera y envía el sistema a un proceso cuando encuentra que el mismo ha intentado acceder a una dirección de memoria por fuera de su entorno virtual de ejecución. Esta señal siempre termina irremediablemente al proceso.

La señal 15, TERM o SIGTERM (termination) es una señal con la que se le solicita a un proceso su terminación. El proceso que la recibe puede ignorarla, y si no la ignora puede hacer un cierre ordenado. Esta es la señal predeterminada del comando kill, así usar kill númeroProceso hace el envío de esta señal TERM.

La señal 17, STOP o SIGSTOP es una señal con la que se solicita al proceso maestro init que “congele” a un proceso o grupo de procesos y los deje en estado Stopped. Esta señal no es ignorable ni bloqueable por los procesos. Esta señal es generada y enviada automáticamente por el sistema cuando se presiona una combinación de teclas. Comúnmente se usa la combinación control z para hacer envío de esta señal.


La señal 19, CONT o SIGCONT (continue) es una señal con la que se le solicita al proceso maestro init que “descongele” a un proceso o grupo de procesos para que dejen de estar Stopped. Como los procesos están congelados –realmente no están en ejecución- no es ignorable ni bloqueable. Los comandos fg y bg usan esta señal para hacer que un trabajo de fondo que está en estado Stopped sigue en ejecución.


Variables de ambiente

Muchos procesos en UNIX necesitan de los valores en las variables de ambiente para funcionar o simplemente para hacer lo correcto o lo que se espera; adicionalmente, muchos de los programas en UNIX necesitan invocar subprogramas sencillos para realizar su labor (el editor vi no sabe corregir ortografía o imprimir, por ejemplo). La manera más sencilla de pasar información en estos casos es una manera estandarizada en UNIX: un proceso puede seleccionar la información inicial del ambiente de con la que todos sus procesos hijos inician –prácticamente no se puede seleccionar la información relacionada directamente con la seguridad-.

Cuando se trata del intérprete de comandos shell –un programa que casi lo único que hace es invocar subprogramas-, hay cómo fácilmente revisar las variables del ambiente donde está trabajando y cómo seleccionar la información que copia a sus subprogramas hijos.

Una variable de ambiente como se ha mencionado es un valor –limitado básicamente por la memoria disponible en el sistema- considerado como texto, manejado a través de una etiqueta o nombre de variable. Como muchísimas otras cosas en UNIX, se diferencia entre mayúsculas y minúsculas.

Listar las variables de ambiente del intérprete shell

Si el intérprete que se está usando es Bourne, Bourne Again o Korn, para revisar las variables de ambiente se usa el comando set:

[0 e@Moe ~] setBASH=/bin/bashBASH_VERSINFO=([0]="2" [1]="05b" [2]="0" [3]="1" [4]="release" [5]="powerpc-apple-darwin8.0")BASH_VERSION='2.05b.0(1)-release'CDPATH=.:/Users/e/:/Users/e/Documents:/CLICOLOR=1COLUMNS=80DIRSTACK=()DISPLAY=:0.0EUID=501GROUPS=()HISTFILE=/Users/e/.bash_historyHISTFILESIZE=500HISTIGNORE='*rot*'HISTSIZE=500HOME=/Users/eHOST=MoeHOSTNAME=Moe.localHOSTTYPE=powerpcIFS=$' \t\n'LANG=en_US.UTF-8…


Ahora, como el shell no todas las variables las copia a los subprocesos hijos, existe otro comando que muestra de las variables del ambiente cuáles se copiarán a los subprocesos hijos. Este último comando es export:

[0 e@Moe ~] exportdeclare -x CDPATH=".:/Users/e/:/Users/e/Documents:/"declare -x CLICOLOR="1"declare -x DISPLAY=":0.0"declare -x HISTIGNORE="*rot*"declare -x HOME="/Users/e"declare -x HOST="Moe"declare -x HOSTNAME="Moe.local"declare -x LANG="en_US.UTF-8"

…

Como puede observarse las variables de ambiente que se copian a los procesos hijos son un subconjunto de las variables de ambiente del shell. Esta no es la situación para los otros programas.

Definición de nuevas variables en el intérprete shell

Para crear una nueva variable de ambiente en el intérprete shell se usa una sintaxis muy sencilla:

nombreVar1=valor1

Como se observa simplemente se nombra una variable y se una con un valor por medio de un símbolo de igual (=) sin espacios alrededor. La variable asume un valor único, por lo que únicamente se puede asignar un valor. Si se necesita insertar un valor multi-palabra en una variable se ponen comillas sencillas o dobles –dependiendo exactamente de lo que se necesite hacer- alrededor de los valores múltiples, para que se entienda como un único valor:

nombreVar1=”valor multi palabras”

Note que si la variable nombrada con nombreVar1 no existe se crea con la ejecución de la sentencia anterior, pero si la variable previamente existía simplemente se reusa pero se le define un nuevo valor, con lo que el valor anteriormente guardado en la variable se pierde definitivamente.

Las variables del intérprete shell existen únicamente en memoria, con lo que el límite de lo que se puede almacenar en una variable está limitado por la memoria disponible en el sistema, y además, los valores almacenados en las variables se pierden cuando se cierre el intérprete shell o termine la sesión.


Note que siempre se menciona “copias de variable”. Los procesos hijos reciben copias que pueden modificar con libertad sin que se afecten las variables en el proceso padre shell.

Paso de variables entre grupos de procesos

41329=telnetd

env

envhijode

Para que un proceso pase variables a otros procesos deberá cumplirse una única condición: como los sistemas UNIX son de memoria protegida lo único factible es pasar copias de ciertas variables de ambiente a los procesos hijo nuevos, justo en el momento de la creación –de los procesos hijo-. Cuando se trata del intérprete de comandos shell se especifica qué subconjunto de las variables del ambiente del shell se copiarán a los comandos ejecutados, comandos que inician procesos hijo. Existen dos maneras:

Una copia de cada una de las variables de la lista de exportadas es recibida en el ambiente por cada uno de los procesos hijos de intérprete o shell.

Puede especificarse un juego de variables con valor en la línea de comandos que inicia un nuevo proceso. Estas variables son insertadas en el ambiente del nuevo proceso aunque no hacen parte del ambiente del intérprete de comandos.

Uso del comando export

El comando export es muy sencillo. Si una variable existe puede usarseexport nombreVariable …

para que la misma quede marcada como “de copia al ambiente de todos los procesos hijos nuevos, de aquí en adelante”. Si la variable no existe el intérprete shell define el nombre, para que cuando una variable con el nombreVariable sea definida, automáticamente se trate como de copia a los procesos hijos.

Puede también definirse una variable, asignársele valor y definirla como de copia a los procesos hijo, todo en una sola operación con

export nombreVar1=valor1 nombreVar2=”valor múltiple 2” …


Las variables del intérprete shell se remueven de la memoria con unset. Remover con unset una variable definida como de copia a los procesos hijos la remueve también de la lista de copia, y si se vuelve a definir como variable no nace nuevamente como variable definida de copia a los procesos hijos. Para remover una variable de la memoria –y al mismo tiempo de la lista de copia- se usa:

unset nombreVariable …

Note que las variables no exportadas sólo existen en el ambiente del intérprete y por eso ningún otro proceso o comando tiene acceso a las mismas o los valores contenidas en ellas.

Paso de variables nuevas no preexistentes en el intérprete

Si necesita insertar una o algunas variables en el ambiente de un nuevo proceso desde el intérprete shell sin que hagan parte del ambiente del shell se usa una sintaxis muy clara:

nombreVar1=valor1 nombreVar2=”valor múltiple2” … comandoNuevo

como se observa, simplemente se usa la sintaxis como tradicionalmente se define una variable en el shell –las que no se copian a los procesos hijos- pero al final de la línea se incluye el comando que se necesita que se ejecute como proceso hijo. Esta sintaxis indica al intérprete shell que cree o haga una copia modificada de unas variables únicamente para ser insertadas en el ambiente del nuevo proceso hijo iniciado con la ejecución del comandoNuevo.

Note que las variables nuevas o las copias modificadas como se ven el último comando anterior sólo existen durante la ejecución del nuevo proceso hijo. No existen como se ve en el intérprete shell, no existen después de la línea que inicia al nuevo proceso, no existen en ninguno de los otros procesos del sistema.


El proceso init no envía señales a procesos a menos que el originador y el destino ejecuten bajo un mismo usuario o el originador sea el usuario root.

Paso de Señales entre Grupos de Procesos

41329=telnetd

env

131271=ksh

envhijode

1=init

env

27525=kill

env

favorenviarseñal

señalentregada

señalentregada

1

2

3

Dada la arquitectura de procesos de los sistemas Unix, todas las señales (las mencionadas cuando se habló del comando kill) que se envían a un proceso líder de grupo son enviadas no solo al proceso líder, si no que son directamente heredadas por sus procesos hijos.

Así, cuando un usuario tiene una sesión de terminal remota usando SSH contra un servidor Unix. y en la misma inicia al editor vi, tiene no un proceso, si no un grupo de procesos:

Un proceso SSHD que recibe la conexión en el servidor requerida por el cliente SSH remoto.

Un intérprete de comandos en el servidor UNIX.

Una instancia del editor vi, en la misma sesión de terminal.

Si en la máquina cliente se cierra la ventana de terminal remota, como el sistema detecta la falla en la conexión TCP/IP, genera y envía una señal hang up o SIGHUP al proceso líder de grupo, en este el sshd que recibe la sesión en el servidor. Como es todo un grupo de procesos, la señal SIGHUP se le envía también al intérprete de comandos y al editor de texto, todo simultáneamente.

Uso del comando kill para el envío de señales a grupos de procesos

Para enviar señales a todo un grupo de procesos se usa la sintaxis:kill –s nombreSeñal –procesoLíder

o kill –númeroSeñal –procesoLíder

okill -- -procesoLíder


La primera sintaxis envía la señal seleccionada por nombre con la opción s a todos los procesos de un grupo, iniciando con su procesoLíder, y a todos sus descendientes, simultáneamente.

La segunda sintaxis envía una señal seleccionada dado su número a todo un grupo, iniciando con un proceso líder, y a todos sus descendientes, simultáneamente.

La tercera sintaxis envía la señal predeterminada 15 o TERM al líder de un grupo y a todos sus descendientes, simultáneamente.


Seguridad y permisos de archivos

Arquitectura de Seguridad de UNIX®

PID=142U=juanG=it

PID=3001U=rootG=system

arch1

dir1

arch1

u=rw-g=r--

u=juang=bog

u=rw-g=r--

u=anag=it

u=rw-g=r--

u=joseg=barr

X

Cada “instancia” de un programa en ejecución es una tarea diferente. Cada una de esas tareas se denomina “proceso”, y cada proceso está compuesto en memoria por varias secciones. Una de esas secciones, a manera de encabezado de proceso se llama ambiente (environment). Dentro de el ambiente del proceso hay numerosas variables que afectan cómo funciona el proceso en sí.

Desde el punto de vista de la seguridad, para controlar qué puede y qué no puede hacer un proceso se tienen dentro del ambiente de cada uno unas variables críticas: una variable tiene el número interno del usuario bajo el que el proceso está en ejecución, y otra variable tiene una lista de números internos de grupos a los que está “afiliado” el proceso porque cuando inició el usuario estaba “afiliado” a los mencionados grupos. Cada llamado a sistema, como “abrir archivo”, “leer archivo”, “escribir en archivo”, “enviar paquete”, “pedir memoria”, “cambiar la hora”, tiene unas características que definen quién puede usar dichos llamados a función. Con este esquema el funcionamiento multitarea “con permisos y privilegios” está asegurado y funciona.

Aunque puede verse un poco complicado en la teoría y en el esquema, en la práctica es sencillo y se mostrará cómo se usa más adelante. Sólo hay que tener en cuenta:

Todo el esquema de seguridad se basa en números: número de usuario, números de grupo, no en los textos que son el nombre de un usuario y los nombres de los grupos.


Existe un usuario, de número cero (0), llamado root al que los controles de seguridad y/o permisos no le aplican.

Ningún usuario en general puede “entrometerse” con los procesos que están corriendo con la identidad de otro usuario. Esta regla no aplica para el usuario número 0, es decir root.

Todos los archivos del sistema tienen un juego triple de permisos, que controlan qué usuarios pueden acceder. Como muchos dispositivos de hardware se representan y usan a través de un archivo en el directorio /dev se pueden controlar los permisos del hardware. Esta regla no aplica para el usuario número 0, es decir root.

Todos los usuarios y grupos tienen propiedades. Las propiedades de un usuario pueden cambiarse dinámicamente, pero generalmente los cambios los toma el usuario la próxima vez que se conecte al sistema.

Para conectarse al sistema hay primero que identificarse comúnmente escribiendo el nombre de usuario, que es una palabra sencilla, y luego que autenticarse, también comúnmente usando una contraseña, que casi siempre es también una palabra, pero no tan sencilla.

Los métodos de identificación y de autenticación en el sistema son flexibles, cambiables, parametrizables y extensibles.


Procesos y Permisos

PID=142U=juanG=it

PID=3001U=rootG=system

arch1

dir1

arch1

u=rw-g=r--

u=juang=bog

u=rw-g=r--

u=anag=it

u=rw-g=r--

u=joseg=barr

X

Cuando un proceso trata de ejecutar un “llamado a sistema” se validan dos cosas: si es una función común y sin limitaciones o si es una función restringida; o si es una función que accede a algo que tiene permisos.

Algunas funciones se consideran restringidas y sólo están disponibles a los procesos que se ejecutan bajo la identidad del usuario root únicamente. Dentro de estas funciones están –pero no siendo una lista exhaustiva-:

Conectarse a un puerto TCP o UDP local que tenga número inferior a 1024.

Enviar o recibir paquetes IP con transportes diferentes de TCP y de UDP (OSPF, ICMP, etc).

Manipular la fecha, hora o el huso horario del sistema.

Hacer más prioritario un proceso, propio o ajeno.

Manipular cualquier información de un proceso de otro usuario.

Acceder al hardware directamente.

Ejecutar un proceso con la identidad de otro usuario sin conocer la contraseña del mismo.

Ninguno de los llamados a función del sistema mencionados arriba es ajustable o parametrizable para que su seguridad se maneje diferente. Siempre se manejan tal como se describen.


Ahora, muchas otras funciones del sistema están restringidas por permisos, y así, dependen de la herramienta que se use, y de los archivos y directorios que en el momento intente acceder y de los permisos de los mismos. Estas funciones entonces sí son parametrizables.


Usuarios y Grupos de Usuarios

Jerarquíadeusuarios

Usuario0=root

Usuariosprotegidosadmin=true

Grupo0=system

Jerarquíadegrupos

Gruposfuncionales

Otrosgrupos

security

printq

perf

audit

shutdown

staff

Cuando un sistema es instalado –y después, cuando se configuran más paquetes de software y cuentas de usuario-, hay un sinnúmero de cuentas de usuario en teoría usables. Esas cuentas de usuario además están –posiblemente- agrupadas en “grupos de usuario”.

Todo usuario tiene:

Un nombre único de usuario, denominado el username.

Un número único de usuario, denominado el userid o UID.

Una lista de hasta treinta y dos (32) grupos a los que pertenece. De todos los grupos a los que pertenece, uno se denomina “grupo primario” o primary group.

Cada grupo tiene:

Un nombre único de grupo, denominado el groupname.

Un número único de grupo, denominado el groupid o GID.

Adicionalmente cada usuario puede “estar protegido” por un atributo mal llamado “atributo admin”.

De todos los usuarios del sistema hay sólo uno que es especial, ése usuario es el de UID igual a cero (0) siempre, independientemente del nombre de usuario (username) que tenga. A este usuario el sistema nunca le forza el cumplimiento de los permisos, sus procesos pueden invocar cualquier llamado a función del sistema y puede intervenir en lo que hacen los procesos de cualquier otro usuario. La cuenta del usuario cero no se bloquea automáticamente por intentos fallidos de autenticación.

Existe un grupo en el sistema que puede invocar numerosos llamados a función del sistema, aunque no puede saltarse la seguridad. Este grupo de número cero ya está creado cuando el sistema es instalado, puede administrar numerosas cosas en el sistema y lleva por nombre system. Cuando el sistema está recién instalado, sólo un usuario pertenece al grupo system,


este usuario es root. Los usuarios que pertenecen al grupo system pueden instalar, actualizar y desinstalar software –y drivers de dispositivos de hardware-, y pueden administrar dispositivos y pueden administrar el espacio del sistema a través del LVM (volúmenes por ejemplo).

Pre-creados en el sistema hay otros grupos, denominados “funcionales”. Los usuarios que se asignen a estos grupos pueden realizar ciertas labores de operación y administración, por ello, en sistemas grandes, es bueno tener usuarios comunes que colaboran, sin acceder ni conocer la contraseña del usuario root, si no que trabajan porque por pertenecer a algún grupo funcional tienen el “privilegio” de usar ciertas funciones de administración. Entre estos grupos funcionales están:

Grupo security: Los usuarios asignados a este grupo pueden listar, crear, cambiar y borrar cuentas de usuario y cuentas de grupo. Pueden cambiar políticas y contraseñas. No pueden editar directamente los archivos que tienen que ver con la seguridad del sistema, ni pueden administrar los usuarios que tienen el atributo de protección admin en true. Inicialmente este grupo está vacío.

Grupo audit: Los usuarios asignados a este grupo pueden configurar el sistema de auditoría de seguridad, y pueden hacer todo tipo de reportes a partir de la información que este sistema genera. Inicialmente este grupo está vacío.

Grupo printq: Los usuarios asignados a este grupo pueden administrar las colas de impresión y los dispositivos impresoras administrados a las mismas. Pueden manipular los trabajos de impresión, inclusive los ajenos. Inicialmente este grupo está vacío.

Grupo perf: Los usuarios de este grupo pueden ejecutar todo tipo de comandos relacionados con la toma de estadísticas y cifras de desempeño, inclusive los que al invocarlos perjudican el mismo desempeño. Inicialmente este grupo está vacío.

Grupo shutdown: Los usuarios asignados a este grupo pueden “bajar el sistema” por medio del uso de comandos como shutdown, reboot, fasthalt, fastboot y halt. Inicialmente este grupo está vacío.

Grupo adm: Los usuarios asignados a este grupo pueden tomar estadísticas básicas del sistema, pueden ver los reportes generados por la ejecución del sistema de contabilidad de comandos y pueden manipular la programación de tareas y a cron. Inicialmente este grupo está vacío.

Grupos internos: Existen otros grupos para uso interno del sistema. A estos grupos –como el grupo bin- no deben asignarse usuarios porque se compromete la integridad del sistema.


Adicionalmente existe creado en el sistema desde el comienzo un grupo llamado staff, sin ningún tipo de privilegios al que se asigna todo usuario que se cree y al que específicamente no se le asigne un grupo.

Todo grupo adicional que se cree en el sistema se considera sin privilegios por parte del sistema operativo.


Permisos de Archivos: ls -l

- rwx rwx rwx archivousuario grupo

permisosqueaplicanaesteusuario

cuandointentaaccederaestearchivo

permisosqueaplicanaestegrupo

cuandointentaaccederaestearchivo

permisosqueaplicanatodoslosotrosusuariosygrupos

archivo!

Para revisar los permisos de unos archivos se usa el comandols –l nombres

Cuando se usa el comando, la primera columna incluye un campo de diez caracteres que si inician en guión (-), este renglón es efectivamente un archivo.

Los permisos de un archivo se interpretan de la siguiente manera:

Si en la terna de permisos que aplica para el proceso hay una r, el proceso sí tiene permisos para leer los contenidos del archivo en cuestión. Si no hay una r si no un guión en la primera posición, el proceso no tiene permisos para leer los contenidos.

Si en la terna de permisos que aplica para el proceso hay una w, el proceso sí tiene permisos para escribir o cambiar los contenidos del archivo en cuestión. Si no hay una w si no un guión en la segunda posición, el proceso no tiene permisos para escribir en los contenidos.

Si en la terna de permisos que aplica para el proceso hay una x, el proceso sí tiene permisos para usar el archivo y sus contenidos como si fuera un programa, es decir invocar o “ejecutar” el archivo. Si no hay una x si no un guión en la tercera posición, el proceso puede usar al archivo como datos únicamente.

Las propiedades externas de un archivo, que se ven con el comando ls –l archivo –a excepción del nombre- son cambiables únicamente si la identidad con la que está ejecutando el proceso en cuestión es la misma que la que tiene el archivo. Es decir las propiedades sólo las manipula el dueño de un archivo independientemente de los permisos que tenga.

Para saber cuál de la terna de permisos aplica a un proceso se sigue el siguiente razonamiento:


Si la identidad del proceso que intenta acceder al archivo y el propietario –usuario- que tenga marcado el archivo son la misma se le aplica la primera terna de permisos del archivo y no se miran las otras dos ternas. La primera terna de permisos se llama de “usuario”.

Si el grupo que tiene marcado el archivo está dentro de la lista de grupos que tiene en el ambiente el proceso que intenta acceder al tal archivo se le aplica la segunda terna de permisos del archivo y no se miran las otras dos ternas. La segunda terna de permisos se llama de “grupo”

Si el usuario bajo el que corre un proceso no es el que tiene marcado el archivo, ni el grupo que tiene marcado el archivo está dentro de la lista del ambiente del proceso se mira la tercera terna de permisos únicamente. La tercera terna de permisos se llama de “otros”.


Permisos de Directorios: ls -ld

d rwx rwx rwx directoriousuario grupo

permisosqueaplicanaesteusuario

cuandointentaaccederaestedirectorio

permisosqueaplicanaestegrupo

cuandointentaaccederaestedirectorio

permisosqueaplicanatodoslosotrosusuariosygrupos

directorio!

Para revisar los permisos de unos archivos se usa el comandols –ld nombres

Cuando se usa el comando, la primera columna incluye un campo de diez caracteres que si inician en la letra d, este renglón es efectivamente un directorio.

Los permisos de un directorio se interpretan de la siguiente manera:

Si en la terna de permisos que aplica para el proceso hay una r, el proceso sí tiene permisos para listar lo que hay en el directorio en cuestión. Si no hay una r si no un guión en la primera posición, el proceso no tiene permisos para listar los contenidos del directorio.

Si en la terna de permisos que aplica para el proceso hay una w, el proceso sí tiene permisos para cambiar el listado que es el directorio. Si no hay una w si no un guión en la segunda posición, el proceso no tiene permisos para modificar el listado que es el directorio. Poder cambiar los listados que constituyen al directorio implica crear, renombrar, borrar archivos y directorios contenidos en el directorio en cuestión.

Si en la terna de permisos que aplica para el proceso hay una x, el proceso sí tiene permisos para “pararse” dentro del directorio con el comando cd (o equivalente), o para “pasar” por él para llegar a un subdirectorio. Si no hay una x si no un guión en la tercera posición, el proceso no puede ni “pararse” en el directorio ni “pasar” por él para llegar a un subdirectorio.

Las propiedades externas de un directorio, que se ven con el comando ls –ld archivo –a excepción del nombre- son cambiables únicamente si la identidad con la que está ejecutando el proceso en cuestión es la misma que la que tiene el directorio. Es decir las propiedades sólo las manipula el dueño de un directorio independientemente de los permisos que tenga.

Para saber cuál de la terna de permisos aplica a un proceso se sigue el siguiente razonamiento:


Si la identidad del proceso que intenta acceder al archivo y el propietario –usuario- que tenga marcado el directorio son la misma se le aplica la primera terna de permisos del directorio y no se miran las otras dos ternas. La primera terna de permisos se llama de “usuario”.

Si el grupo que tiene marcado el directorio está dentro de la lista de grupos que tiene en el ambiente el proceso que intenta acceder al tal directorio se le aplica la segunda terna de permisos del directorio y no se miran las otras dos ternas. La segunda terna de permisos se llama de “grupo”

Si el usuario bajo el que corre un proceso no es el que tiene marcado el directorio, ni el grupo que tiene marcado el directorio está dentro de la lista del ambiente del proceso se mira la tercera terna de permisos únicamente. La tercera terna de permisos se llama de “otros”.


Sólo el dueño de un archivo o directorio tiene el privilegio de poder modificar sus permisos, independientemente de los permisos que ya tenga.

Cambiar Permisos: chmod

- rw- r-- --- archivousuario grupo

- rwx r-- --- archivousuario grupo

chmodu+xarchivo

- rwx r-x r-x archivousuario grupo

chmodgo+rxarchivo

Para cambiar los permisos de un archivo o directorio –o de varios a la vez- se usa el comando chmod. La sintaxis del mismo es sencilla:

Para agregar unas letras de permisos a un(os) archivo(s) o directorio(s)chmod ternas+permisos archivo …

Para remover unas letras de permisos a un(os) archivo(s) o directorio(s)chmod ternas-permisos archivo …

Para especificar con qué letras de permisos debe quedar un(os) archivo(s) o directorio(s)chmod terna=permisos archivo …

Intentar agregar una letra de permisos que ya tiene o intentar una letra de permisos que un archivo no tiene no es error.

Así, como en el ejemplo, si un archivo tiene permisos –rw-r----- y se usa chmod u+x, agregará una x en la terna del usuario y quedará –rwxr-----.



Un usuario puede conocer a qué grupos está asignado invocando el comando sencillo groups.

Cambiar Propietario: chown

- rw- r-- --- archivousuario grupo

- rwx r-- --- archivootrousu grupo

chownotrousuarchivo

- rwx r-x r-x archivootrousu otrogru

chgrpotrogruarchivo

comandoparasóloroot

comandoparaeldueño

- rwx r-x r-x archivousuario grupo

chownusuario.grupoarchivo comandoparasóloroot

Para cambiar el propietario de un archivo o directorio (o de varios a la vez) se usa el comando chown. La sintaxis es muy sencilla:

chown nuevoDueño archivo …

Para cambiar el dueño y el grupo de un archivo al mismo tiempo se usachown nuevoDueño.nuevoGrupo archivo …

Para cambiar el grupo de un archivo (o de varios a la vez) se usa el comando chgrp. La sintaxis es muy sencilla también:

chgrp nuevoGrupo archivo …

Nótese que el comando chown sólo puede ser invocado por el usuario root, no puede ser usado ni por el dueño actual del archivo en UNIX. Es decir, la propiedad de un archivo no puede ser entregada, sólo root puede cambiarla.

Nótese que el comando chgrp puede ser invocado por el usuario dueño de un archivo, pero que el grupo que se vaya a asignar debe ser uno de los asignados al usuario dueño. Cuando el usuario root usa chgrp para cambiar el grupo, puede asignar un grupo cualquiera –hasta uno inexistente- aún uno no asignado al dueño del archivo en cuestión.


Cambiar Identidad de Usuario: su

Si se necesita acceder a unas funciones del sistema sólo por un momento y se conoce la contraseña de la cuenta de otro usuario que sí tiene permiso para ejecutar dichas funciones del sistema no es necesario desconectarse.

Todo sistema UNIX –inclusive AIX- incluye la función “sustituir usuario” a través del comando su. Éste es fácil de usar.

Si se invoca el comando su usuarioDestino

el mismo solicita la autenticación del usuario –normalmente la contraseña- y si ésta es correcta se obtienen las credenciales de seguridad de usuarioDestino.

Si se invoca el comandosu – usuarioDestino

juancho@abe:/home/juancho> whoamijuanchojuancho@abe:/home/juancho> ls –l /etc/securityls: /etc/security: The file access permissions do not allow the specified …juancho@abe:/home/juancho> suroot’s password: ********* (texto escrito no visible)juancho@abe:/home/juancho> whoamirootjuancho@abe:/home/juancho> iduid=501(juancho) gid=0(system) groups=1(staff),7(security),9(printq),10(audit)juancho@abe:/home/juancho> ls –l /etc/securitytotal 6656-rw------- 1 root security 14 Jan 31 12:23 .ids-rw-rw---- 1 root security 254 Jun 21 2004 .profile…juancho@abe:/home/juancho> exitjuancho@abe:/home/juancho> whoamijuanchojuancho@abe:/home/juancho> su –root’s password: ******** (texto escrito no visible)root@abe:/> whoamirootroot@abe:/> iduid=0(root) gid=0(system) groups=2(bin),3(sys),7(security),8(cron),10(audit)root@abe:/> exitjuancho@abe:/home/juancho


el comando solicita igualmente la autenticación del usuario –normalmente la contraseña- y si ésta es correcta se obtienen las credenciales de seguridad del usuarioDestino, y además, se ejecuta el archivo de inicialización de dicho usuario, por lo que también se obtienen las variables de configuración del usuario en el ambiente.

El comando su no obliga a especificar un usuario, si no se especifica el comando asume que el usuario está intentando convertirse –u obtener las credenciales de- en root.


Uso efectivo del intérprete de comandos

El intérprete de comandos

El –realmente los- intérpretes de comandos son quizás la herramienta más avanzada que tienen los UNIX. Los intérpretes shell son muy poderosos debido a que:

Implementa un lenguaje de programación completo.

Interpreta comodines de nombre de archivo, para que los programas no tengan que hacer la interpretación.

Es multitarea –como ya se observó anteriormente-, permite manejar múltiples tareas con una sola invocación, una sola sesión y un solo indicador de comandos.

Tiene características avanzadas que se verán en este aparte –como redirección y ejecución condicional-.

Implementa muchos de los comandos más básicos, para no depender del sistema operativo y no tener que ejecutar otro proceso en esos casos.

El intérprete de comandos y el uso de la multitarea

Como ya se observó en el aparte Procesos de Fondo del capítulo Procesos y Variables, el intérprete shell estándar permite un uso multitarea, con comandos y combinaciones de tecla para el cambio de tareas, listar, terminar. Todo comienza con el uso del símbolo &, pero como se vió, hay mucho más.

Es de notar –ya que no se mencionó en el capítulo Procesos y Variables- que los trabajos de fondo están asociados a la sesión del shell –de hecho el shell en esos casos es líder del grupo de procesos-, por lo que el usuario no puede desconectar su sesión, ya que, aunque de pronto los procesos de fondo no son directamente visibles, sí están y son dependientes del shell. Si un usuario quiere desconectarse de una sesión usando el comando exit pero tiene jobs en ejecución el shell no se lo permitirá y le mostrará un mensaje:

root@ibmserver1:/> jobs[2] + Running sleep 600[1] - Stopped (SIGTSTP) vi /.profileroot@ibmserver1:/> exitThere are stopped jobs.root@ibmserver1:/>

El intérprete de comandos y los metacaracteres

El intérprete de comandos cada vez que recibe la tecla que le indica “iniciar ejecución” -la tecla ENTER cuando no se le impide la interpretación- simplemente no se dedica a iniciar la


ejecución no más: hace todo un ciclo de interpretación de lo que se entró en la línea o líneas de comandos, y dependiendo de lo que se obtenga, inicia la ejecución.

Una de las primeras cosas que logra el intérprete de comandos shell es el de reemplazar, cuando los encuentra en la o las líneas de comandos, unos caracteres que considera especiales. Estos caracteres especiales tienen “un significado más allá de ser simples caracteres de texto” por eso reciben el nombre de metacaracteres.

Los metaracteres en los intérpretes de comandos que cumplen con Posix son:

$, { y } Para el uso e interpretación de variables de ambiente

$, (, ), ` Para el uso de expansión de comandos

>, <, &, | Para la redirección y las tuberías

*, ?, [, -, !, ] Para el reemplazo de caracteres de nombre (comodines)

! Para el manejo de la historia de comandos

‘, “, y \ Para evitar el uso de los significados especiales de los otros metacaracteres

; Como separador de comandos

Básicamente en este capítulo aprenderemos el uso de estos símbolos para alcanzar las funciones especiales que tienen los intérpretes de comandos POSIX.


Por el uso que tienen, algunos comandos como find, tar, cpio sí interpretan comodines!

Comodines (de nombres)

El intérprete de comandos interpreta ciertos caracteres como comodines para facilitarle al usuario expresar conceptos como “todos los archivos”, “todos los archivos que terminan en .c”, “los archivos MP3 que cuyo nombre comienza con Depeche”. Es posible que los usuarios estén algo familiarizados con el uso sencillo de comodines en el intérprete de comandos de MS-DOS o MS-Windows, o con el uso más básico de los comodines en Unix.

Es de notar que en muchos otros ambientes los comandos que interpretan los comodines son los comandos de manipulación masiva de archivos, como comandos de copia, movimiento, copias de respaldo y compresión; pero en UNIX, los comodines son interpretados donde es más conveniente: en la línea de comandos del intérprete de mandatos shell.

Por qué es más conveniente que los comodines los interprete el shell? Porque el shell siempre los interpreta y porque así la mayoría de los comandos no tienen entonces que hacerlo!

Así, puede uno ahorrar escribir un nombre largo como pl-insert_new_student.sql cuando haya que editarlo si uno usa algo como vi *new_st*sql, o si uno sabe que sólo hay un nombre parecido simplemente vi *student.sql. Y esto notando que vi no interpreta comodines en la línea de comandos, el shell siempre interpreta los comodines antes de iniciar la ejecución de lo que unos escribe!

Los comodines en el intérprete estándar Posix, como ya se mencionó son:* ? [ - ! ]

Comodín básico ? (cualquier un caracter del nombre)

El comodín más básico es el símbolo ?. Este se interpreta al usarlo dentro de un nombre de archivo existente como “un caracter cualquiera del nombre”, exceptuando por el punto inicial que denota un archivo oculto.

Ejemplos:

e@abe:e/> lsLitteFile archivoZ.txt fileA.txt fileHMadRamon 1.png archivoaB.txt fileB fileINuevoVacio.txt archivoab.txt fileC nuevoArchiv2.txtactual.txt dato viejo fileD procesos.txtarchivoA.txt fechaActual.txt fileE ramon.txtarchivoAB.txt fileA.c fileF subdir1archivoE.txt fileA.cob fileGe@abe:e/> ls archivo?.txtarchivoA.txt archivoE.txt archivoZ.txte@abe:e/>


Como se observa, el símbolo ? permite seleccionar los nombres de los archivos sin especificar un único caracter en una posición. En el caso del ejemplo, ls Archivo?.txt significa “ls ArchivoCualquierCaracter.txt”, así que se listan los archivos cuyo nombre es Archivo, un caracter cualquiera, un punto y txt. Se observa que sólo toma los nombres que existen, así que aparecen los nombres con las letras que existen -no se incluyen por ejemplo ArchivoB.txt o ArchivoC.txt, porque esos archivos no existen-.

Note que la interpretación siempre la hace el shell, no ls. Se usa ls únicamente porque es útil como comando sin efectos negativos colaterales.

Comodín amplio * (cualesquiera caracteres del nombre)

El segundo comodín más básico es el símbolo *. Este se interpreta al usarlo dentro de un nombre de archivo existente como “cualesquiera caracteres del nombre”, incluyendo no caracteres, y exceptuando el punto inicial del nombre de los archivos ocultos.

Ejemplos:e@abe:e/> lsLitteFile archivoA.txt fileA.c fileGMadRamon 1.png archivoAB.txt fileA.cob fileHNuevoVacio.txt archivoE.txt fileA.txt fileIactual.txt archivoZ.txt fileB nuevoArchiv2.txtarchivo A.txt archivoaB.txt fileC procesos.txtarchivo.part.txt archivoab.txt fileD ramon.txtarchivo.txt dato viejo fileE subdir1archivo23.txt fechaActual.txt fileFe@abe:e/> echo file*fileA.c fileA.cob fileA.txt fileB fileC fileD fileE fileF fileG fileH fileIe@abe:e/> echo archivo*.txtarchivo A.txt archivo.part.txt archivo.txt archivo23.txt archivoA.txt archivoAB.txt archivoE.txt archivoZ.txt archivoaB.txt archivoab.txte@abe:e/>

Como puede observarse, con la primera ejecución se especifica “seleccionar todos los archivos cuyo nombre comienza con file y el resto del nombre puede ser cualquier cosa -incluso nada-”; en este ejemplo aparecen archivos que tienen una letra en la parte seleccionada por *, pero también archivos que tienen una letra un punto y un sufijo variable; en el segundo ejemplo se especifica “seleccionar todos los archivos cuyo nombre comienza con archivo luego tiene un * para indicar que pueden ser cualquier cantidad de cualesquiera caracteres -incluso nada- y luego un punto y el sufijo txt”, en este ejemplo aparecen archivos que no tienen nada entre archivo y .txt -este es el caso de archivo.txt-, y que tienen diferentes letras entre archivo y .txt, mayúsculas, minúsculas, números, y hasta caracteres como espacio y punto.


Comodín [xyz] (cualquier un caracter de la lista)

Parecido al comodín ? existe la posibilidad de indicar que deben seleccionarse los archivos que tienen algo en una posición, pero no cualquier cosa como el símbolo ?, si no uno de unos cuantos caracteres dados. Para esta especificación se usa una lista de opciones, que se incluye entre símbolos [ y ], como se muestra en los siguientes ejemplos.

Ejemplos:LitteFile archivoA.txt fileA.c fileGMadRamon 1.png archivoAB.txt fileA.cob fileHNuevoVacio.txt archivoE.txt fileA.txt fileIactual.txt archivoZ.txt fileB nuevoArchiv2.txtarchivo A.txt archivoaB.txt fileC procesos.txtarchivo.part.txt archivoab.txt fileD ramon.txtarchivo.txt dato viejo fileE subdir1archivo23.txt fechaActual.txt fileFe@abe:e/> echo file[BFD]fileB fileD fileFe@abe:e/> echo archivo[aA2]*txt archivo23.txt archivoA.txt archivoAB.txt archivoaB.txt archivoab.txt

En el primer caso de los ejemplos se indicó que se debían seleccionar los archivos cuyo nombre comiencen con file y luego tengan un caracter seleccionado de B, F o D, únicamente. En el segundo caso se indicó que se seleccionaran los archivos cuyo nombre comienza con archivo y luego tienen un caracter seleccionado de a, A y 2, luego tienen cualquier cosa -incluso nada- y finalmente el nombre termina en txt. Este segundo ejemplo muestra como el shell interpreta todos los símbolos comodín indistintamente, y se pueden combinar.

Comodín [!xyz] (cualquier caracter que no esté en la lista)

Muy semejante al comodín de lista [xyz], que selecciona un caracter del nombre que esté en la lista, existe el comodín lista negada [!xyz], que selecciona un caracter del nombre que no esté en la lista. Note que como casi cualquier caracter puede ser usado en los nombres de los archivos en UNIX, es posible que la lista haya que sobre-especificarla, porque de lo contrario, de pronto, selecciona mucho.

Ejemplos:e@abe:e/> lsLitteFile archivoA.txt fileA.c fileGMadRamon 1.png archivoAB.txt fileA.cob fileHNuevoVacio.txt archivoE.txt fileA.txt fileIactual.txt archivoZ.txt fileB nuevoArchiv2.txtarchivo A.txt archivoaB.txt fileC procesos.txtarchivo.part.txt archivoab.txt fileD ramon.txtarchivo.txt dato viejo fileE subdir1archivo23.txt fechaActual.txt fileF


Note que si el idioma en que está trabajando el usuario es inglés el caracter ñ no está entre la n y la o; ni las vocales con tilde están junto a las vocales sin tilde!

e@abe:e/> echo archivo[!aA2]*txtarchivo A.txt archivo.part.txt archivo.txt archivoE.txt archivoZ.txte@abe:e/> echo [!af]*.txtNuevoVacio.txt nuevoArchiv2.txt procesos.txt ramon.txt

En el primer caso del ejemplo se indica que se seleccionen los archivos cuyo nombre comience con archivo y luego tengan un caracter que no sea ni a, ni A ni tampoco 2, y que luego tengan cualquier cosa y finalmente el nombre termine en txt; se nota como selecciona archivos cuyo nombre es archivo luego un espacio o archivo y luego un punto, o archivo luego E o Z, pero en ningún caso a, A o 2. En el segundo caso del ejemplo se indica que se seleccionen archivos cuyo nombre termine en .txt, y que casi nada del nombre importa, mientras no comience ni con a ni con f; se obserca como se seleccionan archivos .txt cuyos nombres comienzan con N, con n, con p o con r, nunca con a ni con f.

Comodín [x-z] (cualquier caracter que esté en un rango)

Muy parecido al comodín [xyz] donde se indica que se seleccione un único caracter de una lista de posibilidades dada posibilidad por posibilidad existe otra sintaxis para indicarle al shell que debe seleccionar archivos cuyos nombres concuerdan en una posición con un caracter dado un rango ascendente. La sintaxis es simplemente escribir [, el caracter donde comienza el rango, un símbolo menos (-), el caracter donde termina el rango, y el símbolo ]. Note que el caracter inicio del rango debe ser numéricamente menor (debe aparecer primero) que el de fin del rango en el código de página de representación del texto en el idioma que está configurado el usuario.

Ejemplos:e@abe:e/> lsLitteFile archivoA.txt fileA.c fileGMadRamon 1.png archivoAB.txt fileA.cob fileHNuevoVacio.txt archivoE.txt fileA.txt fileIactual.txt archivoZ.txt fileB nuevoArchiv2.txtarchivo A.txt archivoaB.txt fileC procesos.txtarchivo.part.txt archivoab.txt fileD ramon.txtarchivo.txt dato viejo fileE subdir1archivo23.txt fechaActual.txt fileFe@abe:e/> echo file[C-F]*fileC fileD fileE fileF

En el anterior muy sencillo ejemplo se indicó seleccionar los archivos cuyo nombre inicia con file, y que luego tienen un caracter cualquiera del rango que va de C a F, es decir C, o D, o E o F.

Comodín [!x-z] (cualquier caracter que no esté en el rango

De manera semejante al comodín [x-z] que permite seleccionar archivos existentes dado un caracter de una lista de opciones donde se indica el inicio de un rango que arma la lista y


Note pueden combinarse listas y rangos en una especificación. Pregunte cómo!

donde se indica donde termina el rango donde termina la lista existe otra sintaxis donde se especifica que debe seleccionarse un único caracter que no está en un rango dado. Igual que en el caso del rango, el primer caracter usado debe ser numéricamente menor (debe aparecer primero) que el de fin del rango en el código de página de representación del texto en el idioma que está configurado el usuario.

Ejemplos:e@abe:e/> lsLitteFile archivoA.txt fileA.c fileGMadRamon 1.png archivoAB.txt fileA.cob fileHNuevoVacio.txt archivoE.txt fileA.txt fileIactual.txt archivoZ.txt fileB nuevoArchiv2.txtarchivo A.txt archivoaB.txt fileC procesos.txtarchivo.part.txt archivoab.txt fileD ramon.txtarchivo.txt dato viejo fileE subdir1archivo23.txt fechaActual.txt fileFe@abe:e/> echo file[!C-F]*fileA.c fileA.cob fileA.txt fileB fileG fileH fileI

Note que este ejemplo también es muy sencillo: se indica al shell que debe seleccionar los archivos existentes cuyo nombre comienza con file y que luego tienen un caracter que no está en el rango C a F -es decir el caracter no es C, ni D, ni E ni F- y que luego el nombre tiene cualquier cosa.



El código de retorno de una secuencia de comandos es el código de retorno del último de los comandos únicamente.

Ejecución de Comandos en Secuencia

Muy a menudo necesitamos ejecutar en UNIX varios comandos en secuencia, donde no necesariamente unos dependen de otros. Por esta razón existe en los intérpretes de comandos la sintaxis comando ; comando donde se entran los comandos inmediatamente, en una sola línea, pero los comandos se ejecutan en secuencia, donde el segundo comando sólo se ejecuta cuando el primero termine, y sin importar si el primer comando –o el segundo- termina bien o mal.

Ejemplo:

root@ibmserver1:/> sleep 60 ; who ; who am iroot lft0 Sep 03 10:05 root pts/0 Sep 03 10:05 (:0.0) root pts/1 Sep 04 13:46 (192.168.0.12) root pts/3 Sep 04 13:55 (192.168.0.12) root pts/3 Sep 04 13:55 (192.168.0.12)root@ibmserver1:/>

En la línea arriba mostrada, se entraron tres comandos en línea, pero sólo el primero (sleep 60) comienza ejecución. Tan pronto como el primero termine el segundo (who) comienza ejecución; y, cuando el segundo termine, el tercero (who am i) se ejecutará. Sólo cuando el último termine volverá a aparecer el indicador de mandatos del intérprete para recibir más comandos.

Nótese como el intérprete no separa de manera alguna la ejecución –o lo que muestra la ejecución- de un comando de otro. En el ejemplo la última línea “root” parece repetida porque la última línea de who es casualmente la que muestra el comando who am i.


Ejecución Condicional de Comandos

A veces, se quieren ejecutar varios comandos en secuencia, pero con condiciones:

Ejecutar un comando pero sólo si el comando anterior terminó perfectamente.

Ejecutar un comando pero sólo si el comando anterior no terminó perfectamente.

En UNIX se manejan muy fácilmente estas secuencias, pero hay que introducir un concepto en el que estos casos se basan: códigos de retorno.

Códigos de Retorno de una Ejecución

Todos los programas en UNIX o son hechos directamente en lenguaje C o son hechos indirectamente en lenguaje C. Este último caso es el de muchos programas: no son hechos en C pero sí en algún otro lenguaje de programación que fue hecho en C; esta es la situación de los programas hechos en Java, Perl, Python, AWK, Oracle PL/SQL, y muchos más.

En C hay una sentencia clave con la que deberían terminar todos los programas: return. Esta sentencia recibe como parámetro un número entero que se supone recibe el sistema operativo. Como el diseño y desarrollo de UNIX y de C son muy cercanos, los sistemas UNIX siempre capturan el número entero que los programas en C entregan. Este valor en UNIX lleva el nombre de código de retorno, y puede leerlo tanto el sistema operativo como el programa padre que invoca a cada proceso.

En el caso de los intérpretes de comandos como bash y ksh, cada ejecución de comandos guarda en la variable ? el código de retorno de la última invocación. Como esta variable ? no es una lista o arreglo, sólo un número entero, solo guarda el número entero retornado por la última invocación, y cualquier valor anterior se pierde definitivamente.

En el caso del ejemplo mostrado en el apartado Ejecución de Comandos en Secuencia, como son tres comandos, los dos primeros códigos de retorno –de los comandos sleep y who- se pierden y sólo queda guardado el código de retorno del comando who am i.

Ejecución Condicional: Ejecución sólo si el anterior ejecuta sin error

Para poder ejecutar un comando si el comando anterior se ejecuta sin error primero hay que conocer que para los intérpretes Bourne (sh), Korn (ksh) y Bourne Again (bash) una ejecución se considera sin error si cuando termina un comando devuelve un cero (0) en la variable ?.

Para ejecutar un comando2 únicamente si el comando1 termina sin error se usa:comando1 && comando2


De las variables del intérprete se hablará más adelante en este libro, muy pronto. Pero puede notarse que las variables como ? se consideran del a m b i e n t e , t e m a y a considerado.

Nótese que el comando1 puede tener opciones y argumentos, y el comando2 posiblemente también, la sintaxis sólo depende de los símbolos &&.

Ejemplo:root@ibmserver1:/> whoami && echo "Ese soy yo!"rootEse soy yo!root@ibmserver1:/>

Como se observa, como el comando whoami se ejecuta sin error el comando echo ejecuta inmediatamente –inmediatamente termina whoami-.

Ejecución Condicional: Ejecución sólo si el anterior ejecuta con error

Para ejecutar un comando si el comando anterior se ejecuta con error primero hay que conocer que para los mismos sh, ksh y bash, una ejecución se considera con error si cuando termina un comando devuelve un número cualquiera diferente de cero (0) en la variable ?.

Para ejecutar un comando2 únicamente si el comando1 termina con error se usa:comando1 || comando2

Nótese que igual que con &&, el comando1 puede tener opciones y argumentos, y el comando2 posiblemente también, la sintaxis sólo depende de los símbolos ||.

Ejemplo:root@ibmserver1:/> rmdir /tmp || echo "No pudo borrarse /tmp!"rmdir: 0653-611 Directory /tmp is not empty.No pudo borrarse /tmp!root@ibmserver1:/>

Nótese cómo se ejecutó arriba el segundo comando (echo) debido a que el primer comando (rmdir) terminó con un error.


Leer directamente del teclado no t iene sent ido s i un programa corre en un sistema multi-tarea y multi-usuario. Quién puede decir quién tiene el teclado en un momento dado?

Hay programas que necesitan leer directamente del teclado o de una virtualización del teclado, y que necesitan escribir en la pantalla de texto, o a l m e n o s e n u n a virtualización de texto. Se dice que estos programas no usan o la entrada estándar o no usan la salida estándar.

Redirección: Archivos

En UNIX hay un concepto muy poderoso: casi todo o es un archivo o puede trabajarse como un archivo. Por esta razón muchos programas fueron programados para que no asuman que reciben entrada -en especial texto- desde el teclado directamente, si no desde una especie de “archivo virtual individual” llamado la entrada estándar, y para que no escriban lo que producen -en especial texto- a la pantalla, si no a una especie de “archivo virtual individual” llamado la salida estándar.

Archivos estandar: “entrada estandar”, “salida estandar”, “salida de errores estandar”

Como se viene mencionando, la mayoría de los programas en Unix que necesitan información textual de entrada no leen directamente del teclado, si no que leen de un “archivo virtual individual” llamado “la entrada estandar” o, en inglés stdin. Este “archivo” es de lectura secuencial, no recibe escritura, y los programas asumen que está abierto antes de comenzar. Este “archivo” normalmente lo abre y lo pone a disposición de los programas que siguen el programa que recibe la conexión del usuario (en modo texto casi siempre es un proceso llamado getty, y para las conexiones remotas inetd o sshd).

Los programas tampoco asumen que tienen una pantalla a disposición, si no que escriben sus avisos y el texto en general que producen en un “archivo virtual individual” llamado “la salida estandar” o, en inglés stdout. Este “archivo” es de escritura secuencial, no permite la lectura, y los programas asumen que está abierto antes de comenzar. Igual que con “la entrada estándar”, este archivo normalmente lo abre y lo pone a disposición de los programas que siguen el programa que recibe la conexión del usuario.

Los programas tampoco asumen que deben mandar los mensajes de error a un archivo -aunque algunos sí-, mientras que algunos no muy bien diseñados mezclan los mensajes de aviso, alerta o error con los demás textos en “la salida estándar”, la mayoría en UNIX escribe dichos textos adicionales en otro “archivo virtual individual” llamado “la salida estándar de errores”, o en inglés stderr. Este archivo, como “la salida estándar”, es de escritura secuencial, no permite la lectura, y los programas asumen que está abierto antes de comenzar. Igual que con los otros, este archivo normalmente lo abre y lo pone a disposición de los usuarios el programa que recibe la conexión del usuario.

Ahora... en conjunto de qué se trata esto?

Cuando un usuario se conecta de manera local, y en modo texto, un programa como getty “conecta” la entrada estándar con una “virtualización” del teclado local -para permitir la multitarea-, conecta la salida estándar con una “virtualización” de la pantalla textual local -


Note que no puede usar un m i s m o a r c h i v o p a r a l a redirección de la entrada estándar y de la salida estándar simultáneamente!

para permitir la multitarea y la multiplexación con los mensajes urgentes del sistema-, y conecta la salida de errores estándar con una “virtualización” de la pantalla textual local -para permitir también la multitarea, la multiplexación con los mensajes de error del sistema, y para poder usar el mismo dispositivo físico que la salida estándar-. Al final del proceso, los programas locales de modo texto “parecen” estar leyendo lo que uno les escribe en el teclado, y parecen estar escribiendo mensajes directamente en la pantalla, tanto su salida normal como sus mensajes y avisos de error.

Cuando un usuario se conecta de manera remota, y en modo texto, un programa como inetd o sshd “conecta” la entrada estándar con una “virtualización” de un socket de TCP/IP, de manera que un texto que llega dentro de paquetes generados por un cliente sea recibido como texto en la entrada del programa -que parece estar leyendo del teclado remoto-. Adicionalmente el mismo programa “conecta” la salida estándar con una “virtualización” de un socket de TCP/IP -casi siempre el mismo de la entrada- de manera que el texto que los programas que siguen sea “empacado” en un paquete de red y pueda aparecer en una pantalla en el cliente remoto. De igual manera se hace con la salida estándar de errores.

Redirección de la entrada desde un archivo

Muchas veces hay que darle o mucho texto a un programa para que lo procese -y no se desea tener que escribirlo todo directamente, o hay que darle como entrada de texto lo que hay en un archivo. Para ambos casos se inventó la redirección de la entrada estándar.

Para hacer redirección de la entrada estándar en el intérprete shell simplemente se agrega < nombre_archivo a la sintaxis del comando que debe leer de un archivo y no de la virtualización del teclado. Note que el archivo debe existir antes de que inicie el comando, ya que la redirección la hace el shell antes de iniciar el comando, y además es el shell quien debe poder encontrar y abrir el archivo nombre_archivo para lectura.

Ejemplo:e@abe:e/> write root < MiNombre.txt

Message from e on abe (pts/0) [Sun Sep 9 21:21:33 EST 2007] ...Ramon Barrios Lascar<EOT>e@abe:e/> cat MiNombre.txtRamon Barrios Lascar

En el ejemplo se puede notar como el comando write no tuvo que esperar a que el usuario escribiera el mensaje directamente -y lo terminara con control d-, si no que leyó, pero el shell ya le había preparado que lo que leería sería el archivo MiNombre.txt.



Note que no puede usar un m i s m o a r c h i v o p a r a l a redirección de la entrada estándar y de la salida estándar de errores simultáneamente!

Redirección de la salida hacia un archivo

Más común que darle a un comando la entrada almacenada previamente en un archivo es necesitar almacenar lo que muestra -comúnmente texto- en un archivo, para poder revisarlo con calma, reportarlo a otro o simplemente porque aparece tan rápidamente en la ventana de texto que no es posible leerlo mientras va a apareciendo.

Para hacer redirección de la salida estándar de un comando se usa una sintaxis muy sencilla que de pronto es conocida ya por los usuarios de otros ambientes: simplemente se agrega > nombre_archivo a la sintaxis del comando al que se le quiere redirigir la salida. Note que igual que con los otros casos, es el shell el que abre el archivo aún antes de ejecutar el comando al que se le redirige la salida.

Atención: el shell abre el archivo para salida con la opción O_CREAT, lo que hace que si no existe lo crea, pero si ya existe lo destruye y luego lo crea nuevo!

Ejemplos:[0 e@Moe ~] ps -uUSER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMANDe 4971 0.1 0.1 27892 944 p1 S 9:47AM 0:00.07 -bash[0 e@Moe ~] ps -u > datos.txt[0 e@Moe ~] cat datos.txt USER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMANDe 4971 0.0 0.1 27892 944 p1 S 9:47AM 0:00.10 -bash[0 e@Moe ~] dateMon Sep 10 09:48:04 COT 2007[0 e@Moe ~] date > datos.txt[0 e@Moe ~] cat datos.txt Mon Sep 10 09:48:08 COT 2007

En los ejemplos se observa cómo lo que genera un comando se almacena en un archivo -en el ejemplo datos.txt-, y en el segundo ejemplo se muestra cómo sin aviso el shell crea nuevo el archivo datos.txt, perdiéndose los contenidos anteriores del mismo.

Redirección de los mensajes de error hacia un archivo

Común tambien es la necesidad de almacenar los avisos de alerta, advertencia o mensajes de error que algunos comandos generan. En muchos casos sirve almacenar todo el texto generado por la ejecución de un comando en un único archivo, pero si el texto general generado por un comando es mucho, de pronto se necesita que los textos de los mensajes de error estén registrados en un archivo aparte.

Para hacer la redirección de la salida estándar de errores de un comando se usa una sintaxis sencilla también: se agrega 2> nombre_archivo a la sintaxis normal del comando del



que se quieren “capturar” los mensajes de errores y almacenarlos en el archivo seleccionado. Note que igual que con los otros casos, es el shell el que abre el archivo aún antes de ejecutar el comando al que se le redirige la salida estándar de errores.

Atención: el shell abre el archivo para salida con la opción O_CREAT, lo que hace que si no existe lo crea, pero si ya existe lo destruye y luego lo crea nuevo!

Ejemplos:[0 e@Moe ~] rm /etc/hostsoverride rw-r--r-- root/wheel for /etc/hosts? yrm: /etc/hosts: Permission denied[1 e@Moe ~] rm /etc/hosts 2> mensajes.txtn[0 e@Moe ~] cat mensajes.txt [0 e@Moe ~] r--r-- root/wheel for /etc/hosts?

En el ejemplo se observa cómo los mensajes no se muestran en la ventana de sesión del usuario, pero sí quedan almacenados en el archivo seleccionado mensajes.txt.

Redirección de la entrada desde archivos “here”

A veces, es necesario hacer que un comando lea la entrada estándar, pero no se quiere estar presente a la hora del comando para escribir del teclado dicha entrada estándar. Para esta situación, que la verdad no es tan común como las dos anteriores, existe la redirección de entrada desde “archivos here”. Para redirigir la entrada estándar de un comando, y que no la tome de un archivo, si no que la tome del comando escrito se usa la siguiente sintaxis:

comando << TERMINADORlinea1 de textolinea2 de texto...TERMINADOR

Ejemplo:[0 e@Moe /Volumes] wc -l << FIN> Primera linea> Segunda linea> Tercera linea> Cuarta linea> FIN 4

En el ejemplo, el comando wc -l cuenta el número de líneas en un archivo, o en la entrada estándar, y en este caso la entrada estándar es todo lo escrito hasta que en una línea aparezca únicamente el texto indicado como terminador -en el ejemplo el texto FIN-.


Redirección de la salida sin destruir

Muy a menudo se necesita captura la salida de varios comandos, pero si se usa la redirección tradicional > lo que el último comando genere como salida será lo único que quede en el archivo. Para capturar acumulando o agregando, la salida estándar de un comando en un archivo simplemente en el shell se agrega a la sintaxis del comando >> nombre_archivo, donde nombre_archivo es donde se quiere guardar la salida, archivo que si no existe es creado nuevo antes de iniciar la ejecución del comando redirigido, o al que se le agrega al final del contenido si existía previamente.

Ejemplos:[0 e@Moe /Volumes] ls nuevoRegistro.txtls: nuevoRegistro.txt: No such file or directory[1 e@Moe /Volumes] ps -u >> nuevoRegistro.txt[0 e@Moe /Volumes] cat nuevoRegistro.txt USER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMANDe 4971 0.0 0.1 27892 896 p1 S 9:47AM 0:01.00 -bash[0 e@Moe /Volumes] date >> nuevoRegistro.txt [0 e@Moe /Volumes] cat nuevoRegistro.txt USER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMANDe 4971 0.0 0.1 27892 896 p1 S 9:47AM 0:01.00 -bashMon Sep 10 18:20:30 COT 2007

Como se puede observar en el ejemplo, el se crea el archivo nuevoRegistro.txt con la ejecución del primer comando -el ps-, y con la ejecución del segundo obtiene nuevos contenidos, pero no se pierde lo ya guardado con el primer comando.

Redirección de los mensajes de error sin destruir

De igual manera como se pueden guardar los textos de salida estándar de los comandos, acumulando al final del archivo, sin perder lo anteriormente guardado, se puede redirigir la salida estándar de errores, también sin perder lo anteriormente guardado. Para redirigir la salida estándar de errores sin sobreescribir el archivo simplemente en el shell se agrega a la sintaxis del comando 2>> nombre_archivo, donde nombre_archivo es un archivo de texto que si no existe es creado antes de iniciar la ejecución del comando, pero si existe se abre para escritura en modo O_APPEND (agregar al final).

Ejemplo:[0 e@Moe /Volumes] rm archivo1.txt 2>> ~/mensajes.txt[1 e@Moe /Volumes] rm archivo2.txt 2>> ~/mensajes.txt[1 e@Moe /Volumes] cat ~/mensajes.txt rm: archivo1.txt: No such file or directoryrm: archivo2.txt: No such file or directory

Como se nota en el ejemplo, con la ejecución del primer comando -rm archivo1.txt- se crea el archivo mensajes.txt, y con la ejecución del segundo comando se agregan contenidos al mismo. Si se observa el archivo generado mensajes.txt, sólo hay texto de mensajes de error


(como se recordará, el comando rm genera texto con los errores, con la ejecución normal no muestra ni un solo mensaje).

Combinaciones de redirecciones

Todos los tipos de redirección se pueden combinar -mientras tenga sentido-, y en muy pocos casos el órden como se combine importa, pero, no puede mencionarse un mismo archivo más de una vez.

Para enviar la salida estándar de un comando a un archivo, y para, al mismo tiempo enviar la salida estándar de errores al mismo archivo se agrega a la sintaxis del comando

> nombre_archivo 2>&1

Lo anterior debe interpretarse como “redirigir la salida a nombre_archivo, y los errores al primero”. Nótese que como se usa >, la ejecución destruye nombre_archivo porque lo crea nuevo.

Para enviar la salida estándar de un comando a un archivo, sin destruirlo, y para, al mismo tiempo, enviar la salida estándar de errores al mismo archivo se agrega a la sintaxis del comando

>> nombre_archivo 2>>&1


Note que hay más estilos de sust itución de variables, pregunte al instructor cuáles!

Note que los sistemas Unix diferencian las mayúsculas de las minúsculas en los nombres de las variables de ambiente!

Substitución de Variables

Se ha mencionado más de una vez que las variables del ambiente de un proceso afectan cómo hace un proceso ciertas tareas. En especial ciertas variables de ambiente afectan cómo funciona el -los?- intérprete de comandos, cómo ejecuta los comandos que se le dan y la apariencia que tiene. En un capítulo anterior titulado Ambiente de Trabajo: Procesos y Variables se mencionó cómo se listaban, creaban, modificaban y borraban variables del ambiente del shell. También se vió en dicho capítulo cómo se hace para “publicar” las variables de ambiente para que los procesos hijos -del shell- tengan unas copias.

Las variables de ambiente existen en el shell, pero no hemos visto aún cómo se pueden usar directamente en el shell!

Para usar el valor de una variable en el shell se escribe ${nombre_variable} en donde quiera el valor que contiene la variable en el intérprete. Si el nombre no se presta para confusiones puede usarse simplemente $nombre_variable; así si se tiene una variable llamada Host, y se quiere obtener o usar el valor en el momento se escribe ${Host} o simplemente $Host. A la hora de la ejecución el shell usará el valor dentro de la variable, y no la variable.

Ejemplos:

0 root@abe:/> echo $Host

0 root@abe:/> Host=abe.iknow.com0 root@abe:/> echo Mi servidor es ${Host}Mi servidor es abe.iknow.com0 root@abe:/> printf "La maquina usada en los ejemplos es $Host\n"La maquina usada en los ejemplos es abe.iknow.com

En el ejemplo se puede observar que la variable Host inicialmente es nula. Usar una variable inexistente o una variable nula en el intérprete de comandos no es error a menos que así se configure el shell. Como segundo paso se crea -o se llena, no lo sabemos- la variable con un nuevo valor y se usa primero con la sintaxis ${variable} y luego se usa con la sintaxis $variable. Aunque lo más común es usar $variable, la sintaxis completa ${variable} existe porque las sustuciones de variables son literales y en algunos casos se presta para confusiones:

0 root@abe:/> MES=Sept 0 root@abe:/> echo Estamos en ${MES}iembreEstamos en Septiembre0 root@abe:/> echo Estamos en $MESiembreEstamos en

Si se observa en detalle el ejemplo, cuando la variable no tiene texto alrededor el shell no tiene problemas en identificar el nombre de la misma y por ello extrae el valor y lo usa, pero después, como se usó la sintaxis sencilla, el shell cree que la variable es MESiembre -ya que es


un nombre válido de variable- y como la variable no existe la reemplaza en la ejecución por un nulo.

Variables de ambiente importantes en el shell

Existen ciertas variables importantes que modifican cómo hace su trabajo el shell y cómo interpreta lo que el usuario le escribe. Entre esas variables importantes se encuentran:

HOME Esta variable es ajustada por el proceso que hace la autenticación del usuario cuando se conecta -normalmente login-. Contiene la ruta al directorio inicial o personal del usuario.

LOGNAME Contiene el nombre del usuario con el que se autenticó el usuario actual -comúnmente lo mismo que retorna whoami, pero no siempre-.

PATH Esta variable debe contener una lista de directorios separados por : (dos puntos) donde deben buscarse los comandos entrados en el shell sin ruta.

CDPATH Esta variable puede contener una lista de directorios separados por : (dos puntos) donde deben buscarse directorios dados como parámetros a cd sin ruta.

PS1 Esta variable puede contener un texto o expresión que el shell usará como indicador de mandatos de primer nivel -lo que muestra casi siempre para solicitar instrucciones-.

PS2 Esta variable puede contener un texto o expresión que el shell usará como indicador de mandatos de segundo nivel -lo que muestra cuando hay una instrucción de control sin completar, o una expresión sin terminar, como cuando hay que cerrar unas ’ o unas ”.

ENV El shell ksh busca esta variable cada vez que inicia -sea porque el usuario apenas se conecta o porque el usuario inicia ksh a mano. Si es un archivo ejecutable el shell ksh lo ejecuta justo apenas inicia.

1..9.. El shell almacena en la variable 1 el primer parámetro que se le pase, en la variable 2 el segundo parámetro que se le pase, y así sucesivamente.

0 El shell almacena en la variable 0 el nombre del programa actual -el shell-. Si se está dentro de un shell script contiene el nombre del programa actual también, pero esta vez es el shell script.

TERM En esta variable se debe almacenar el nombre de la emulación de terminal actual. Con este valor los programas que controlan el cursor y hacen uso de atributos de pantalla encuentran -en un directorio específico en cada UNIX- los archivos necesarios para dicho control de cursor y de atributos de pantalla.


MANPATH Con esta variable se puede indicar al comando man dónde encontrar la documentación de los comandos. Debe ser una lista de directorios separados por : (dos puntos).

IFS Con esta variable el shell sabe como separar las palabras (tokens) que componen la instrucción justo entrada. Es una lista de caracteres simplemente. De manera estándar inicia en espacio, tabulador, retorno de carro.

? En esta variable el shell almacena el entero código de retorno del último comando ejecutado.

RANDOM Cada vez que se usa esta variable (que se obtienen sus contenidos) el shell genera un número pseudo-aleatorio entero pequeño.

SECONDS En esta variable el shell almacena el número de segundos que han pasado desde que inició -el shell-.

Ejemplos:0 root@abe:/> echo $HOME/0 root@abe:/> echo $LOGNAMEroot0 root@abe:/> echo $PATH/usr/bin:/etc:/usr/sbin:/usr/ucb:/usr/bin/X11:/sbin:/usr/java14/jre/bin:/usr/java14/bin:/usr/local/bin:/opt/freeware/bin:/usr/local/sbin:/usr/local/bin:/opt/freeware/sbin:/opt/freeware/bin:/usr/local/sbin:/usr/local/bin0 root@abe:/> echo $CDPATH

0 root@abe:/> echo $PS1$? $LOGNAME@$HOST:$PWD>0 root@abe:/> echo $PS2...0 root@abe:/> echo $ENV//.kshrc0 root@abe:/> echo $1

0 root@abe:/> echo $0-bash0 root@abe:/> echo $TERMxterm0 root@abe:/> echo $MANPATH:/usr/share/man:/opt/freeware/man0 root@abe:/> echo $IFS

0 root@abe:/> echo $RANDOM301510 root@abe:/> echo $SECONDS8454



Note que la substitución de comandos no usa la entrada o la salida estándar del comando que necesita información de o t r o . E l s h e l l c a p t u r a i n f o r m a c i ó n y h a c e u n reemplazo de texto literal.

Substitución de Comandos

Gran parte del enorme poder que tienen los sistemas UNIX está basado en una idea sencilla: cada herramienta o comando debería hacer una sola cosa pero hacerla lo mejor posible, así el comando listar usuarios no debería ordenarlos según un criterio, pero debería haber un comando ordenar que puede ordenar lo mejor posible cualquier cantidad de ítems, y debería haber una manera de combinarlos. Esta es la base de la filosofía Unix y es como trabajan todos los UNIX en general.

Una manera de combinar comandos es a través de la “sustitución de comandos”. De qué se trata? de obtener los textos generados por algún comando y usarlos como parte de la sintaxis de otro comando.

Para sustituir los textos generados por un comando y usarlos como parte de la sintaxis de otro comando se agrega a la sintaxis del segundo comando, en el sitio donde se necesita el texto del primer comando, la construcción `primer comando .̀ Note que la “comilla inversa” o acento grave es el símbolo a la izquierda del 1 en un teclado qwerty en inglés. Como este símbolo en algunos teclados es algo complicado de obtener, puede usarse la construcción $(primer comando) en el mismo sitio de la sintaxis del segundo comando, y así obtener lo mismo.

Este tipo de sustitución es más clara con unos ejemplos:

Ejemplo: El usuario necesita todos los días crear un archivo de registro .log que contenga lo del día únicamente, por eso sería mejor que el archivo llevase dentro del nombre la fecha. La mejor manera es usando un comando que automáticamente obtenga la fecha y la “convierta” en un nombre de archivo. Note que la redirección no aplica porque el comando no necesita ni recibe entrada estándar -por ejemplo-.

e@abe:e/> ls *logls: 0653-341 The file *log does not exist.e@abe:e/> touch app_$(date +'%Y%m%d').log e@abe:e/> ls *logapp_.log app_20070913.log

En el ejemplo se observa cómo se aprovecha que puede usarse el comando date para obtener la fecha en el momento de ejecución y en algún formato práctico. Se usa substitución de comandos para “capturar” el texto generado por date y usarlo como parte de la sintaxis del comando touch. Podría haberse usado date +'%Y%m%d', usar las facilidades para “copiar y pegar” y luego escribir el comando touch con la sintaxis adecuada. Si se usa substitución de comandos el shell ejecuta en varias fases:

Ejecuta primero lo que está entre $( ) o ` ,̀ capturando el texto.

Reemplaza en lo escrito por el usuario $( ) o ` ̀y lo que lleva dentro por los textos capturados.


Ejecuta el comando transformado.

Nótese que pueden “anidarse” varias ejecuciones con substitución de comandos, pero usando las “comillas inversas” es difícil, usando $( ) es fácil.

Pregunta: Cómo puedo guardar el directorio actual en una variable?


Nótese: algunos comandos no reciben por entrada estándar f á c i l m e n t e , p e r o e n l a d o c u m e n t a c i ó n p u e d e n informar cómo. Muchos usan una sintaxis de “abrir archivo” con el “archivo” -

Note que algunos teclados no tienen | si no un símbolo de barra “cortada” ¦. Si el teclado no tiene la barra completa el símbolo de barra cortada es totalmente equivalente y se puede usar.

Redirección: Tuberías

En algunos casos se necesita que un comando procese directamente los datos generados por otro (algo semejante a la substitución de comandos), pero los datos los puede usar el segundo comando -el procesador- tomándolos de un archivo, o mejor, de la entrada estándar. Este es el caso mencionado en querer una lista ordenada de los usuarios del sistema; hay un comando que genera la lista sin ordenar, y hay un comando que ordena cualesquiera ítems. Estos casos en general traducen a “conectar la salida estándar de un comando directamente a la entrada estándar de otro comando”.

Para conectar la salida estándar de un primer comando con la entrada estándar de otro comando se usa la construcción primer comando | segundo comando. En los intérpretes shell Posix el símbolo de barra vertical (llamado comúnmente en inglés pipe) conecta la salida estándar del comando justo antes de él con la entrada estándar del comando justo después.

Ejemplo:

e@abe:e/> echo "Hola super usuario" | write root

Message from e on abe (pts/0) [Wed Sep 19 00:41:51 EST 2007] ...Hola super usuario<EOT>e@abe:e/> echo "Cuerpo del mensajeMore...de correoMore...More...Ramon Barrios Lascar” | mail -s “Mensaje 2007-09-19" [email protected]

Note que en el intérprete shell los dos comandos se ejecutan inmediata y simultáneamente para poder hacer la conexión del archivo salida estándar de uno con el archivo entrada estándar del segundo. No use comandos que tengan alguna dependencia temporal.

Comandos filtro

En Unix se dice que un comando es un filtro cuando dicho comando lee o puede leer texto de la entrada estándar y cuando bota o puede botar “texto producido” por la salida estándar. Estos comandos se supone que de alguna manera transforman -como un paso de una cadena de producción- lo que reciben y lo pasan al siguiente comando de una cadena.

Un comando que es filtro puede estar al comienzo de una secuencia de tuberías, en la mitad, o al final de una cadena de tuberías. Algunos comandos pueden usarse sólo para iniciar o terminar una secuencia de tuberías, pero entonces no se les denomina filtros.


mailto:[email protected]

mailto:[email protected]

Unix no asume que lo que pasa de un comando a otro en una combinación de comandos por tubería es texto, no hace transformaciones, por lo que puede no ser texto y funciona, aunque la mayoría de los comandos lo que procesan y generan -al menos en las tuberías- es texto.


Escapes

Como se ha observado, el shell hace una interpretación bastante extensa del texto que se escribe en la línea de comandos, haciendo reemplazos contínuamente basándose principalmente en ciertos símbolos, por esa razón cuando se quieren usar los símbolos como parte de un comando hay el problema de hacer que el intérprete shell no los reemplace. El caso más común es el uso de los espacios.

El caracter espacio es el separador de ítems usado principalmente, buscando éste el shell separa lo que se da después del nombre del comando en opciones, argumentos, y cada uno de los argumentos los distingue de los otros porque se separan por espacios. En especial la sintaxis para guardar un valor dentro de una variable de ambiente es variable=valor, pero qué si el valor que se necesita dentro de una variable está compuesta de varias variables?

Cuando se usa el término “escape” dentro de esta sección se quiere decir “hacer que el significado no sea el común”; así que “escapar un espacio” es hacer que el espacio no tenga el significado como separador de ítems que normalmente tiene; “escapar un símbolo de pesos” es hacer que el símbolo pesos no signifique “usar valor de variable” que normalmente tiene, y así.

En UNIX -realmente en el intérprete shell POSIX- hay tres maneras de hacer que un o unos caracteres no tengan el significado que normalmente tienen, es decir de “escaparlos”.

Escape de un único caracter: símbolo \

Para quitarle el significado especial a un único caracter o símbolo -o lo contrario, para darle significado especial a un caracter que normalmente no tiene- se usa el caracter símbolo \ (en inglés backslash). Este símbolo cuando se antepone a un caracter especial le quita su significado especial y lo convierte en un caracter de texto simple: un * ya no significará “todos los caracteres posibles en un nombre de archivo”, significará simplemente “asterisco”. Algunos caracteres normales se convierten en especiales cuando no lo son pero se les antepone un símbolo \ -estos son los escapes del lenguaje C-.

Ejemplos A:

e@abe:e/> echo *LitteFile MadRamon 1.png MiNombre.txt NuevoVacio.txt actual.txt app_.log app_20070913.log archivo A.txt archivo.part.txt archivo.txt archivo23.txt archivoA.txt archivoAB.txt archivoE.txt archivoZ.txt archivoaB.txt archivoab.txt dato viejo fechaActual.txt fileA.c fileA.cob fileA.txt fileB fileC fileD fileE fileF fileG fileH fileI nuevoArchiv2.txt procesos.txt ramon.txt subdir1e@abe:e/> echo \**e@abe:e/> echo La variable con mi directorio es $HOME


Note que pocos caracteres tienen significado especial cuando llevan como prefijo a \. Deberá consultarse una guía de C para saber cuáles son todos.

La variable con mi directorio es /home/ee@abe:e/> echo La variable con mi directorio es \$HOMELa variable con mi directorio es $HOME

En el primer ejemplo se usa el símbolo * y como no se toma ningún cuidado especial el shell lo interpreta con su significado de siempre “todos los caracteres posibles en los nombres de los archivos” y como está sólo termina significando “todos los archivos”. Como echo repite simplemente el texto que se le de como argumentos simplemente muestra los nombres de todos los archivos. En el segundo ejemplo se le quita el significado especial al asterisco, usando \*, y como echo simplemente repite escribiendo a la salida estándar los argumentos que se le den, la salida obtenida es un simple *.

En el tercer ejemplo se usa $HOME que normalmente obtiene el contenido de una variable -en este caso HOME-, que se da a echo, que muestra el texto, incluyendo el contenido de la variable. En el cuarto ejemplo se varía un poquito simplemente agregando \ al símbolo $, lo que logra que $ no sea especial -donde significa “obtener valor contenido en la variable que sigue”-, así que un $ es un simple $, por lo que al lado de un nombre de una variable no obtiene el valor de la variable, así que echo simplemente repite un texto, un símbolo pesos y un texto que casualmente es el nombre de una variable.

Ejemplo B:e@abe:e/> echo "Texto compuesto de\ndos lineas"Texto compuesto dedos linease@abe:e/> echo "Mostrar es un backslash es especial: \\"Mostrar es un backslash es especial: \

En este nuevo ejemplo se usa \ a la inversa: el caracter n que normalmente no tiene nada de especial al tener un escape como prefijo se convierte en un símbolo especial -porque tiene un significado especial dentro de una cadena de texto en lenguaje C-, en este caso en un cambio a siguiente línea. El ejemplo termina mostrando dos líneas porque a mitad, un caracter del texto significa “cambio a siguiente línea”. En el segundo caso mostrado se demuestra cómo obtener un backslash que no tenga significado especial -donde “especial” quiere decir “hacer escape al caracter que sigue”-, hay que usar un backslash para quitare el significado especial al backslash que sigue!

Escape de todos los significados especiales: '

Si son varios los símbolos o textos a los que se le quiere remover todo tipo de significados especiales tal vez sea más sencillo usarlos en otra sintaxis: encerrarlos entre un par de símbolos “comilla recta sencilla no tipográfica”, es decir hacer una construcción como 'texto'. Cuando un texto en la línea de comandos está encerrado entre ' ' todos los caracteres dentro del par de ' ' pierden su significado especial. Cuando se indica “todos” es todos, ni aún el símbolo \ tiene significado especial dentro de un par de ' '.


Note que no hay la manera de obtener unas ' dentro de texto encerrado en ' '.

Ejemplos:e@abe:e/> echo 'Texto comun y especial \*'Texto comun y especial \*e@abe:e/> echo 'Texto menos especial'Texto menos especiale@abe:e/> Variable='Varias palabras en una variable'e@abe:e/> echo $VariableVarias palabras en una variablee@abe:e/> echo '$Variable'$Variable

Se observa cómo el comando echo muestra \* cuando éstos símbolos están encerrados en ' ya que ni \ ni * son especiales cuando así están encerrados. Como se ve en el segundo caso del ejemplo, los caracteres sin significado especial siguen siendo caracteres comunes cuando están dentro de las comillas rectas no tipográficas. En el tercer caso de los ejemplos se muestra cómo hacer que un texto de varias palabras se tome como un único ítem. Dentro de las comilla ' ni los espacios son especiales, en ése ejemplo, lo que se guarda en la variable es un único ítem, el que tenga espacios no tiene nada de especial. En el el último caso se muestra como la sustitución de variables no tiene efecto dentro de las comillas simples no tipográficias, porque el símbolo de pesos como cualquier otro caracter está sin significado especial mientras está dentro de ' '.

Escape de no todos los significados especiales: "

Cuando son varios los símbolos dentro de un texto que se entra en el indicador de mandatos del shell pero se quieren hacer ciertas excepciones se puede usar otro tipo de escape. Este otro tipo de escape del que se hace mención es el encerrar el texto entre " ". Cuando se encierra un texto entre " " la mayoría de los símbolos y caracteres pierden su significado especial, exceptuando por !, $, ‘, \, {, }. Así, ni los espacios, ni ?, ni *, ni ‘ tienen significado especial, son simples símbolos. Los caracteres que cuando tienen un prefijo \ toman significado especial dentro de las comillas dobles " " siguen convirtiéndose en especiales cuando tienen ese prefijo.

Ejemplos:e@abe:e/> echo "Esta es una comilla ' verdad?"Esta es una comilla ' verdad?e@abe:e/> echo "Contenidos de \$HOME: $HOME"Contenidos de $HOME: /home/ee@abe:e/> echo "Para decir \"Todos los nombres\" se usa *"Para decir "Todos los nombres" se usa *

En el primer caso de los ejemplos se nota cómo una comilla sencilla ‘ no tiene significado especial dentro de un par de comillas dobles (" "). En el segundo caso de los ejemplos se nota cómo el backslash (\) sigue teniendo dentro de " " el significado de siempre: hacer que lo que sigue no tenga significado especial si normalmente lo hace, hacer que lo que siga tenga significado especial si normalmente no lo hace. Se muestra en el tercer caso de los


ejemplos cómo obtener unas comillas literales (") dentro de un par de comillas " ", usando backslash. Se muestra también cómo el * no tiene significado especial dentro del par de " ".


Utilidades de Texto

El Concepto

Cuando inició el diseño y desarrollo de UNIX, por allá en la prehistoria de finales de la década de los sesentas lo imperativo en AT&T era que se obtuviera un sistema para procesar ingentes cantidades de texto que finalmente se convertirían en manuales técnicos de servicio. Por esta razón única, desde el comienzo se pensó en que UNIX tuviese múltiples comandos de manipulación de texto que pudieran combinarse para obtener lo que AT&T necesitaba -y lo que los usuarios querían hacer-. Un UNIX típico termina entonces siendo un sistema con ingentes cantidades de comandos cuyo “producido” es texto, casi siempre texto plano sin formato (inicialmente ASCII, pero después interpretable con “códigos de página”), y textos que pueden pasarse y mandarse de un comando a otro, en secuencias y cadenas.

En un UNIX normal, sin instalaciones adicionales o agregados se dispone de centenares de comandos, muchos de ellos -decenas- son y existen únicamente para procesar texto. Estos comandos existen y han existido por décadas, y han sido optimizados a través del tiempo, por lo que es difícil encontrar implementaciones para lo mismo que sean tan o más eficientes.

Dentro de lo que veremos en este capítulo están:

Cómo ordenar texto -y archivos de texto-.

Cómo filtrar texto -y archivos de texto-.

Cómo cortar texto, juntar, combinar.

Otras operaciones con texto -y archivos de texto-.


Volcar texto a la salida estándar: cat

cat

Para volcar un texto a la salida estándar en UNIX normalmente hay simplemente que redirigirla, pero en muchos casos es práctico tener un comando. Este comando lleva por nombre cat (catenate), que lee la entrada estándar o los archivos dados como argumento y vuelca, sin pausa ni separación los contenidos de todos a la salida estándar.

La sintaxis de cat es muy sencilla:cat [ -r ] [ -v [ -e ] [ -t ] ] [ archivo ... ]

Donde:

Los símbolos [ y ] indican que las opciones y los argumentos son opcionales, no hacen parte de la sintaxis.

La opción r se usa para que cat reemplace en la salida varias líneas en blanco consecutivas por una sola.

La opción v se usa para que cat reemplace en la salida los caracteres de control por ^octal donde octal es el número de tres octales que representa al caracter de control. Al mismo tiempo cat reemplaza en la salida otros caracteres no mostrables por M-x donde x es un caracter ASCII que resulta de apagar el bit más significativo del caracter no mostrable por un 0. Cuando se usa la opción v también se pueden usar las opciones e y t.

La opción e se usa para que cat muestre un símbolo $ para representar el fin de cada línea.

La opción t se usa para que cat reemplace en la salida el caracter tabulador por un ^I.

Ejemplos:0 root@abe:/etc> cat passwd


root:!:0:0::/:/usr/bin/bashdaemon:!:1:1::/etc:bin:!:2:2::/bin:sys:!:3:3::/usr/sys:adm:!:4:4::/var/adm:uucp:!:5:5::/usr/lib/uucp:guest:!:100:100::/home/guest:nobody:!:4294967294:4294967294::/:lpd:!:9:4294967294::/:lp:!:11:11::/var/spool/lp:/bin/falseinvscout:!:6:12::/var/adm/invscout:/usr/bin/kshsnapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappdipsec:!:201:1::/etc/ipsec:/usr/bin/kshnuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucicosshd:!:202:201::/var/empty:/usr/bin/kshj:!:505:0:Ramon Barrios Lascar:/home/j:/usr/bin/kshldapdb2:!:205:14::/home/ldapdb2:/usr/bin/kshe:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh0 root@abe:/etc> cat -vte passwdroot:!:0:0::/:/usr/bin/bash$daemon:!:1:1::/etc:$bin:!:2:2::/bin:$sys:!:3:3::/usr/sys:$adm:!:4:4::/var/adm:$uucp:!:5:5::/usr/lib/uucp:$guest:!:100:100::/home/guest:$nobody:!:4294967294:4294967294::/:$lpd:!:9:4294967294::/:$lp:!:11:11::/var/spool/lp:/bin/false$invscout:!:6:12::/var/adm/invscout:/usr/bin/ksh$snapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappd$ipsec:!:201:1::/etc/ipsec:/usr/bin/ksh$nuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucico$sshd:!:202:201::/var/empty:/usr/bin/ksh$j:!:505:0:Ramon Barrios Lascar:/home/j:/usr/bin/ksh$ldapdb2:!:205:14::/home/ldapdb2:/usr/bin/ksh$e:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh$

Como se notará, en el primer caso de los ejemplos cat vuelca los contenidos del archivo a la salida estándar, sin hacer más. En el segundo caso de los ejemplos cat muestra los caracteres especiales como símbolos -el archivo no contiene caracteres especiales- y los fines de línea con unos símbolos $.


Note que el comando wc tiene aún más opciones, opciones que puede revisar en la documentación.

Contar caracteres, palabras, líneas: wc

wc 20

Contar texto es una de las operaciones más básicas. Uno de los comandos cuenta líneas, palabras y caracteres, y puede decírsele que cuente y reporte cualesquiera de los tres.

Para todo lo mencionado se usa el comando wc (word count), que no sólo cuenta palabras -como indicaría el nombre en inglés-. La sintaxis es muy sencilla:

wc [ -c | -w | -l ] [ archivo ... ]

Donde:


El símbolo | indica “posibilidad”, se usa para mostrar las posibles opciones, no hace parte de la sintaxis.

Pueden dársele entre cero y tres opciones.

Pueden dársele cero o más archivos. Cuando no se dan archivos wc lee de la entrada estándar.

La opción c es para que cuente y reporte los caracteres en la entrada estándar o los archivos dados.

La opción w es para que cuente y reporte las palabras en la entrada estándar o los archivos dados.

La opción l es para que cuente y reporte las líneas en la entrada estándar o los archivos dados.

Si no se dan archivos cuenta y reporta lo leído por entrada estándar.

Si se dan archivos no lee de la entrada estándar.


Si se dan varios archivos cuenta y reporta por cada archivo y reporta un total al final del reporte.

Ejemplos:0 root@abe:/etc> wc sudoers 29 98 604 sudoers0 root@abe:/etc> wc -l /etc/passwd /etc/group 18 /etc/passwd 29 /etc/group 47 total0 root@abe:/etc> who | wc -l 1

El primer caso del ejemplo muestra cómo cuando no se dan opciones reporta tres números: el número de líneas, el número de palabras y el número de caracteres, en ése orden. El segundo caso de los ejemplos muestra cómo puede solicitarse una única estadística, en este caso el número de líneas, y como se indicaron dos archivos como argumentos primero se reporta por archivo y al final un total. El tercer caso de los ejemplos muestra cómo pueden reportarse estadísticas de un texto que no está en un archivo, en este caso, como no se indicaron argumentos el comando wc lee de la entrada estándar, que termina siendo la salida estándar del comando anterior, que se conectó con el símbolo |.


Note que el comando nl tiene aún más opciones, opciones que puede revisar en la documentación.

Numerar líneas de texto: nl

nl

1

2

3

4

5

6

7

8

9

10

A menudo hay que listar archivos -o texto que no necesariamente está en un archivo-. Esta operación a veces se usa para indicar dónde lógicamente se ubica algo, y es más fácil si se reporta usando números de línea. La manera más fácil de listar texto con las líneas numeradas es usando el comando nl (number lines). Este comando toma un archivo o si no se da el archivo la entrada estándar, y lo muestra con las líneas numeradas, posiblemente según unas opciones dadas. La sintaxis puede parecer complicada -por el número de opciones- pero la verdad es muy sencilla:

nl [-b modo] [-n formato] [-s separador] [-w número] [-l número] [ archivo ]

Donde:


Pueden dársele cero o más opciones.

Pueden dársele ninguno o un archivo. Cuando no se indica archivo el comando nl lee el texto de la entrada estándar.

La opción b se usa para escoger el modo como se numeran las líneas. El modo a indica que se numeran todas las líneas, el modo t indica que se numeran las líneas que sean visibles -no contaría las líneas vacías o de sólo blancos y/o tabuladores, el modo ppatrón numera sólo las líneas que cumplen con un patrón -el patrón es una expresión regular-. El modo predeterminado es el modo t.

La opción n se usa para escoger el modo como se muestran los números de líneas. El modo ln muestra los números justificados a la izquierda, y sin ceros a la izquierda, el modo rn muestra los números justificados a la derecha, y sin ceros a la izquierda, el modo rz muestra los números con un ancho fijo, completados con ceros a la izquierda. El modo predeterminado es el modo rn.


La opción s se usa para especificar un separador entre los números y las líneas de la entrada. El separador predeterminado es un caracter tabulador.

La opción w se usa para escoger un ancho de columna para los números de línea. El ancho de columna predeterminado es 6.

La opción l se usa para indicar que varias líneas en blanco cuentan como una sola, así si se usa -l 3 el comando nl contaría hasta tres líneas en blanco seguidas como una sola. El valor predeterminado de la opción l es 1.

Ejemplos:0 root@abe:/etc> nl passwd 1 root:!:0:0::/:/usr/bin/bash 2 daemon:!:1:1::/etc: 3 bin:!:2:2::/bin: 4 sys:!:3:3::/usr/sys: 5 adm:!:4:4::/var/adm: 6 uucp:!:5:5::/usr/lib/uucp: 7 guest:!:100:100::/home/guest: 8 nobody:!:4294967294:4294967294::/: 9 lpd:!:9:4294967294::/: 10 lp:!:11:11::/var/spool/lp:/bin/false 11 invscout:!:6:12::/var/adm/invscout:/usr/bin/ksh 12 snapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappd 13 ipsec:!:201:1::/etc/ipsec:/usr/bin/ksh 14 nuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucico 15 sshd:!:202:201::/var/empty:/usr/bin/ksh 16 j:!:505:0:Jorge Valbuena:/home/j:/usr/bin/ksh 17 ldapdb2:!:205:14::/home/ldapdb2:/usr/bin/ksh 18 e:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh0 root@abe:/etc> nl passwd group 1 root:!:0:0::/:/usr/bin/bash 2 daemon:!:1:1::/etc: 3 bin:!:2:2::/bin: 4 sys:!:3:3::/usr/sys: 5 adm:!:4:4::/var/adm: 6 uucp:!:5:5::/usr/lib/uucp: 7 guest:!:100:100::/home/guest: 8 nobody:!:4294967294:4294967294::/: 9 lpd:!:9:4294967294::/: 10 lp:!:11:11::/var/spool/lp:/bin/false 11 invscout:!:6:12::/var/adm/invscout:/usr/bin/ksh 12 snapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappd 13 ipsec:!:201:1::/etc/ipsec:/usr/bin/ksh 14 nuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucico 15 sshd:!:202:201::/var/empty:/usr/bin/ksh 16 j:!:505:0:Jorge Valbuena:/home/j:/usr/bin/ksh 17 ldapdb2:!:205:14::/home/ldapdb2:/usr/bin/ksh 18 e:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh1 root@abe:/etc> nl -w 2 -s\)\ -n ln passwd


1 ) root:!:0:0::/:/usr/bin/bash2 ) daemon:!:1:1::/etc:3 ) bin:!:2:2::/bin:4 ) sys:!:3:3::/usr/sys:5 ) adm:!:4:4::/var/adm:6 ) uucp:!:5:5::/usr/lib/uucp:7 ) guest:!:100:100::/home/guest:8 ) nobody:!:4294967294:4294967294::/:9 ) lpd:!:9:4294967294::/:10) lp:!:11:11::/var/spool/lp:/bin/false11) invscout:!:6:12::/var/adm/invscout:/usr/bin/ksh12) snapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappd13) ipsec:!:201:1::/etc/ipsec:/usr/bin/ksh14) nuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucico15) sshd:!:202:201::/var/empty:/usr/bin/ksh16) j:!:505:0:Jorge Valbuena:/home/j:/usr/bin/ksh17) ldapdb2:!:205:14::/home/ldapdb2:/usr/bin/ksh18) e:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh

En el primer caso de los ejemplos se muestra cómo es el listado predeterminado del comando nl. Se da un único archivo. En el segundo caso de los ejemplos se muestra cómo el comando nl ignora los archivos dados después del primero -puede compararse con el primer caso-. En el tercer caso de los ejemplos se muestra cómo los números de línea ocupan menos espacio porque se indicó que van en una columna de dos caracteres de ancho -con la opción w2-, se separan con un paréntesis y un espacio -con la opción s) -, y que los números se justifican a la izquierda -con la opción nln-.


Paginar Texto: pg

Para leer textos en un archivo o en la entrada estándar no siempre se usa vi. En especial vi no puede leer texto que no esté en un archivo -no puede leer textos de la entrada estándar-. Más flexible y rápido -y sin peligro de editar inadvertidamente el archivo- es usar el comando pg (paginate) que lee textos y los muestra por salida estándar (casi siempre por pantalla) por páginas que llenan la pantalla y luego se detiene para esperar comandos. La sintaxis de pg es:

pg [ +número | +/patrón/ ] [ -e ] [ -f ] [ -s ] [ archivo ... ]

Donde:



Pueden dársele cero o más opciones.

Pueden dársele cero o más archivos. Cuando no se le dan archivos el comando pg lee de la entrada estándar.

Con +número se indica que el comando pg debe comenzar a mostrar en cierto número de línea.

Con +/patrón/ se indica que el comando pg debe comenzar a mostrar a partir de la primera línea que contenga el patrón de texto.

Con la opción e se indica que el comando pg no debe esperar un Enter entre archivo y archivo.

Con la opción f se indica que el comando pg no debe partir las líneas que no caben en la pantalla.

Con la opción s se indica que el comando debe resaltar todos los mensajes e indicadores en la última línea de la pantalla.

Ejemplos:

Para mostrar un archivo reporte.txt por páginas se usaría: pg reporte.txt

Para mostrar un archivo reporte.txt por páginas, comenzando con Agosto (estando este texto en una línea con las mayúsculas tal cual) se usaría:

pg +/Agosto/ reporte.txt

El comando pg es interactivo, con numerosos comandos mientras está funcionando. Este comando tiene un indicador de comandos en la última línea de la pantalla, donde recibe:


Un número, lo que hace que pg se salte a la página de ese número.

+número, lo que hace que pg avance en el texto actual número páginas.

-número, lo que hace que pg retroceda en el texto actual número páginas.

l hace que pg avance una línea (el comando es una ele).

númerol hace que pg salte a una parte del texto donde la línea número está de primera en la pantalla (el comando es número ele).

+númerol hace que pg avance número líneas en el texto (el comando es mas número ele).

-númerol hace que pg retroceda número líneas en el texto (el comando es menos número ele).

$ hace que pg vaya a la última página del texto. No funciona cuando pg está leyendo la entrada estándar.

/texto/ hace que pg busque avanzando texto.

número/texto/ hace que pg busque avanzando texto, y se ubique en la número ocurrencia que encuentre.

?texto? hace que pg busque retrocediendo texto.

número?texto? hace que pg busque retrocediendo texto, y se ubique en la número ocurrencia que encuentre.

n hace que pg muestre el siguiente archivo de los argumentos. Puede usarse númeron para que muestre el número archivo siguiente (este modo es número ene).

p hace que pg muestre el anterior archivo de los argumentos. Puede usarse númerop para que muestre el número archivo siguiente (este modo es número pe).

s archivo hace que pg guarde el texto actual en el archivo nombrado.


Obtener primeras líneas de texto: head

head

Muchas veces interesan de un texto sólo unas pocas líneas del inicio del mismo -por ejemplo es un listado de los usuarios que más consumen un recurso y nos interesan los más consumidores únicamente-. Para obtener las primeras líneas de un texto se usa el comando sencillo head. La sintaxis es de verdad sencilla:

head [ -número | -n número | -c número ] [ archivo ... ]

Donde:



Debe darse una opción.

Pueden dársele cero o más archivos. Cuando no se dan archivos head lee de la entrada estándar.

Cuando a head se le dan varios archivos muestra las primeras líneas del texto combinado de los archivos, no muestra las primeras líneas de cada texto.

Cuando se usa -número el comando head muestra las primeras número líneas del (de los) archivo(s). Esta es la sintaxis “antigua” del comando.

Cuando se usa -n número el comando head muestra lo mismo, las primeras número líneas del archivo.

Cuando se usa -c número el comando head muestra los primeros número caracteres del archivo.


Ejemplos:0 root@abe:/etc> cat passwdroot:!:0:0::/:/usr/bin/bashdaemon:!:1:1::/etc:bin:!:2:2::/bin:sys:!:3:3::/usr/sys:adm:!:4:4::/var/adm:uucp:!:5:5::/usr/lib/uucp:guest:!:100:100::/home/guest:nobody:!:4294967294:4294967294::/:lpd:!:9:4294967294::/:lp:!:11:11::/var/spool/lp:/bin/falseinvscout:!:6:12::/var/adm/invscout:/usr/bin/kshsnapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappdipsec:!:201:1::/etc/ipsec:/usr/bin/kshnuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucicosshd:!:202:201::/var/empty:/usr/bin/kshj:!:505:0:Jorge Valbuena:/home/j:/usr/bin/kshldapdb2:!:205:14::/home/ldapdb2:/usr/bin/kshe:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh0 root@abe:/etc> head -n 5 passwdroot:!:0:0::/:/usr/bin/bashdaemon:!:1:1::/etc:bin:!:2:2::/bin:sys:!:3:3::/usr/sys:adm:!:4:4::/var/adm:0 root@abe:/etc> head -c 50 passwdroot:!:0:0::/:/usr/bin/bashdaemon:!:1:1::/etc:bi

En los ejemplos primero se muestra el archivo completo, usando cat. El segundo caso muestra el uso típico, con la opción n para obtener sólo algunas de las primeras líneas. El tercer caso de los ejemplos usa la opción c para obtener sólo algunos de los caracteres del inicio del texto, puede observarse que la tercera línea del texto no aparece completa.


Obtener últimas líneas de texto: tail

tail

Así como muchas veces sólo nos interesan las primeras líneas de un texto -para lo que se usa head- otras muchas veces sólo nos interesan las últimas líneas de un texto. Para esto otro existe el comando tail, que muestra las últimas líneas de un texto o las líneas a partir de una posición hasta las última. La sintaxis de tail es parecida a la del comando head:

tail [ -n signúmero | -c signúmero | -k signúmero ] [ -f ] [archivo ... ]

o también:tail -r [ -n número ] [ archivo ... ]

Donde:



Puede darse cero o una opción.

Pueden dársele cero o más archivos. Cuando no se dan archivos tail lee de la entrada estándar.

Cuando se dan varios archivos tail muestra los últimos contenidos de la combinación de todos los archivos, no muestra los últimos contenidos de cada archivo.

El parámetro signúmero es un número individual, o +número o -número. Cuando se da un número individual tail muestra las últimas número unidades del texto (sean líneas, caracteres o kilobytes). Cuando se da +número el comando tail muestra las últimas unidades del texto a partir de la número unidad entrada (sean


líneas, caracteres o kilobytes). Cuando se da -número el comando muestra las últimas número unidades del texto (igual que cuando no se usa signo).

La opción n se usa para que las unidades sean líneas, así que el comando tail mostrará las últimas líneas del texto.

La opción c se usa para que las unidades sean caracteres, así que el comando tail mostrará los últimos caracteres del texto.

La opción k se usa para que las unidades sean kilobytes, así que el comando tail mostrará los últimos kilobytes del texto.

La opción f se usa para que tail no termine, se quedará leyendo indefinidamente y si encuentra más contenido en el final del texto irá mostrándolo.

La opción r se usa para que las últimas líneas las muestre en sentido inverso. Sólo puede mostrar máximo los últimos 20KB del texto.

Cuando no se dan opciones tail funciona como si se hubiera indicado -n10, es decir mostrará las últimas diez líneas del texto.

Ejemplos:0 root@abe:/etc> cat passwdroot:!:0:0::/:/usr/bin/bashdaemon:!:1:1::/etc:bin:!:2:2::/bin:sys:!:3:3::/usr/sys:adm:!:4:4::/var/adm:uucp:!:5:5::/usr/lib/uucp:guest:!:100:100::/home/guest:nobody:!:4294967294:4294967294::/:lpd:!:9:4294967294::/:lp:!:11:11::/var/spool/lp:/bin/falseinvscout:!:6:12::/var/adm/invscout:/usr/bin/kshsnapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappdipsec:!:201:1::/etc/ipsec:/usr/bin/kshnuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucicosshd:!:202:201::/var/empty:/usr/bin/kshj:!:505:0: Jorge Valbuena:/home/j:/usr/bin/kshldapdb2:!:205:14::/home/ldapdb2:/usr/bin/kshe:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh0 root@abe:/etc> tail -n 5 passwdnuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucicosshd:!:202:201::/var/empty:/usr/bin/kshj:!:505:0:Ramon Barrios Lascar:/home/j:/usr/bin/kshldapdb2:!:205:14::/home/ldapdb2:/usr/bin/kshe:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh0 root@abe:/etc> tail -n +5 passwdadm:!:4:4::/var/adm:uucp:!:5:5::/usr/lib/uucp:


guest:!:100:100::/home/guest:nobody:!:4294967294:4294967294::/:lpd:!:9:4294967294::/:lp:!:11:11::/var/spool/lp:/bin/falseinvscout:!:6:12::/var/adm/invscout:/usr/bin/kshsnapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappdipsec:!:201:1::/etc/ipsec:/usr/bin/kshnuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucicosshd:!:202:201::/var/empty:/usr/bin/kshj:!:505:0:Jorge Valbuena:/home/j:/usr/bin/kshldapdb2:!:205:14::/home/ldapdb2:/usr/bin/kshe:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/ksh

En los ejemplos el primer caso muestra el archivo completo. El segundo caso de los ejemplos muestra cómo se usa tail para obtener las últimas líneas de un archivo (con la opción n número). El tercer caso muestra cómo se usa tail para obtener las líneas de un archivo desde la número dado hasta la última (con la opción n +número).



Note que el comando cut no corta -como se pensaría dado el nombre-, realmente lo que hace es seleccionar.

Obtener columnas de texto: cut

cut

Otra necesidad en el procesamiento de texto que a veces surge es la de obtener una o más de las columnas de un texto -o quitar una de las columnas-. Para hacer algo así no se necesita una herramienta de programación, se necesita tan sólo conocer una utilidad sencilla de UNIX que lleva por nombre cut. Con cut se pueden obtener columnas de texto dado un separador -de columnas- o dadas las posiciones exactas de los caracteres. Cuando al comando cut se le indican unas columnas esas son las que se copiarán de la entrada -o de los archivos- a la salida estándar, las demás se ignoran. La sintaxis del comando cut es sencilla:

cut [ -c columnas ] | [ -f columnas [ -d separador ] [ -s ] ] [ archivo ... ]

Donde:



Debe darse una de las opciones c o f.

Pueden dársele cero o más archivos. Cuando no se dan archivos cut lee de la entrada estándar.

Las columnas que se especifican son las que aparecen en la salida estándar.

Las columnas pueden especificarse como número individual -así 5 indica la quinta columna-; pueden especificarse como una lista de números separados por comas (,) -así 5,7,9 indican la columna quinta, séptima y novena-; pueden especificarse como un rango de números, donde 5-9 indican las columnas de la quinta a la novena, inclusive; y pueden usarse combinaciones. Cuando se usa un rango de columnas y no se indica el inicio el comando cut asume que se deben copiar desde la primera columna -así que -5 indica las columnas hasta la quita-, y cuando


se usa un rango pero no se especifica la última el comando cut asume que se deben copiar hasta la última -así que 5- indica las columnas desde la quinta hasta la última-.

La opción c indica al comando cut que las columnas se están especificando por posición exacta de caracteres en el texto. El primer caracter del texto está en la posición 1.

La opción f indica al comando cut que las columnas se están especificando visualmente, donde una columna se separa de la siguiente por exactamente un separador. El separador predeterminado es un tabulador. Cuando se usa la opción f pueden usarse las opciones d y s.

La opción d se usa para indicar al comando cut cuál es el caracter separador de columnas.

La opción s se usa para indicar al comando cut que no debe copiar a la salida las líneas del texto que no tienen el separador de columna en ninguna parte.

Ejemplos:e@abe:e/> cat /etc/passwdroot:!:0:0::/:/usr/bin/bashdaemon:!:1:1::/etc:bin:!:2:2::/bin:sys:!:3:3::/usr/sys:adm:!:4:4::/var/adm:uucp:!:5:5::/usr/lib/uucp:guest:!:100:100::/home/guest:nobody:!:4294967294:4294967294::/:lpd:!:9:4294967294::/:lp:!:11:11::/var/spool/lp:/bin/falseinvscout:!:6:12::/var/adm/invscout:/usr/bin/kshsnapp:!:200:13:snapp login user:/usr/sbin/snapp:/usr/sbin/snappdipsec:!:201:1::/etc/ipsec:/usr/bin/kshnuucp:!:7:5:uucp login user:/var/spool/uucppublic:/usr/sbin/uucp/uucicosshd:!:202:201::/var/empty:/usr/bin/kshj:!:505:0:Jorge Valbuena:/home/j:/usr/bin/kshldapdb2:!:205:14::/home/ldapdb2:/usr/bin/kshe:!:501:0:Ramon Barrios Lascar:/home/e:/usr/bin/kshe@abe:e/> cut -f1 -d: /etc/passwdrootdaemonbinsysadmuucpguestnobodylpdlp


invscoutsnappipsecnuucpsshdjldapdb2ee@abe:e/> ps -ef | head -n8 | cut -c-15,49- UID PID CMD root 1 /etc/init root 69832 /usr/sbin/rsct/bin/rmcd -a IBM.LPCommands -r root 73906 /usr/sbin/syslogd root 82038 /usr/sbin/syncd 60 root 86030 /usr/ccs/bin/shlap64 root 94314 /usr/lib/errdemon root 114794 /usr/sbin/hostmibd

En el primer caso de los ejemplos se usa cat para volcar a la pantalla el archivo completo. En el segundo caso de los ejemplos se usa cut para obtener sólo la primera columna del texto (con la opción f1, pero el texto tiene columnas separadas por el símbolo : se indica esto a cut con d:, ya que de manera predeterminada busca un tabulador). En el tercer caso de los ejemplos usa cut para obtener un listado parcial de procesos; en este caso como el texto generado por ps viene con columnas armadas con ancho exacto se usa cut con la opción c para indicar dichas columnas: primero hasta cierta posición, y luego desde cierta posición hasta el final.

Nótese que cut no es usable fácilmente con columnas de ancho variable y que separan columna de columna usando algo variable; para estos casos es mejor usar otra herramienta.


Combinar texto en columnas: paste

paste

Con el comando cat pueden combinarse dos o más textos o archivos de manera que queden uno seguido del otro, pero qué se usa cuando hay que combinar unos textos uno “al lado” del otro? Tampoco hay que usar una compleja herramienta de programación, hay que usar una herramienta sencilla que conoceremos enseguida: el comando paste. Este comando “junta” dos o más textos o archivos y los copia a la salida estándar de manera que los de la entrada se convierten en “columnas” de la salida estándar. La sintaxis del comando paste es:

paste [ -d lista ] [ -s ] [ archivo1 archivo2 ... ]

Donde:


Pueden dársele cero o más archivos. El comando paste es útil de verdad con al menos dos archivos.

Cualesquiera de los archivos de la entrada pueden ser reemplazados por -. El argumento - se usa para indicar dónde debe ir -en las columnas- el texto leído de la entrada estándar.

La opción d se usa para dar una lista de caracteres individuales que deban usarse como separadores de columna. Así el primer caracter de la lista se usará para separar la primera columna de la segunda -de la salida-, el segundo caracter de la lista se usará para separar la segunda columna de la tercera -de la salida-. Si hay más caracteres en la lista que columnas en la salida los caracteres sobrantes se ignoran. Si hay menos caracteres en la lista, las últimas columnas son separadas usando repetidamente el último caracter de la lista.

La opción s se usa para que paste no arme las columnas tomando igual cantidad de líneas de cada columna de texto, si no que arme las columnas tomando líneas


del primer archivo de texto hasta el final, luego tomando líneas del segundo archivo de texto hasta el final, y así sucesivamente.

Ejemplos:e@abe:e/> cat Numeros.txt123456789101112131415e@abe:e/> cat Romanos.txtiiiiiiivvviviiviiiixx

Los dos primeros casos de los ejemplos simplemente muestran cómo son los contenidos de los archivos Numeros.txt y Romanos.txt. Se usa cat para volcar los contenidos a la salida.

e@abe:e/> paste Numeros.txt Romanos.txt1 i2 ii3 iii4 iv5 v6 vi7 vii8 viii9 ix10 x11 12 13 14 15


El tercer caso de los ejemplos muestra el funcionamiento predeterminado de paste: junta lado a lado los archivos dados, separando los contenidos con un tabulador intermedio.

e@abe:e/> paste -d"|" Numeros.txt Romanos.txt | head -n 51|i2|ii3|iii4|iv5|v

El cuarto caso de los ejemplos muestra cómo usar la opción d del comando paste para que el listado combinado generado tenga las columnas separadas por medio de otro caracter. Note cómo hay que escapar el símbolo | para que no tenga el significado de redirección tradicional.


Combinar Texto en Columnas: join

En los sistemas UNIX está disponible un comando que muchos usuarios ni siquiera imaginan que podría existir. El comando join de los sistemas Unix hace el equivalente a las sentencias SQL SELECT ... INNER JOIN, SELECT ... RIGHT OUTER JOIN, SELECT ... LEFT OUTER JOIN. Este comando combina archivos usando campos que estén presentes en los dos archivos que se usan como entrada. La sintaxis del comando join es:

join [ -1 campo ] [ -2 campo ] [ -a núm | -v núm ] [ -e texto ] [ -o campos ] [ -t sep ] archivo1 archivo2

Donde:



Deben darse dos archivos ordenados.

Uno de los archivos puede reemplazarse por un argumento -. Cuando uno de los argumentos es - el comando join lee la entrada estándar y lo combina con el otro argumento, que se asume es un archivo.

La opción 1 necesita un número de campo o columna, columna que se usará como llave para hacer el join en el primer archivo, es decir en archivo1. Se supone que los valores en esta columna se encuentran también como valores en una columna del segundo archivo, es decir archivo2. El comando join asume que el archivo1 está ordenado según esta columna o campo.

La opción 2 necesita un número de campo o columna, columna que se usará como llave para hacer el join en el segundo archivo, es decir en archivo2. Se supone que los valores en esta columna se encuentran también como valores en una columna del primer archivo, es decir archivo1. El comando join asume que el archivo2 está ordenado según esta columna o campo.

La opción t se usa para especificar cuál es el caracter separador de columnas en ambos archivos de entrada (archivo1 y archivo2) y en la salida estándar generada. Si este caracter se repite seguido el comando join asume que hay columnas con campos vacíos.

La opción e se usa para especificar un texto que se usará para presentar en la salida para reeemplazar -en caso de que se desee- los valores nulos en las columnas de la salida.


La opción o se usa para indicar cuáles de las columnas de los archivos de entrada se incluirán en la salida generada por join. Cada columna deberá especificarse como 1.número o 2.número, donde 1.número indica que el comando join deberá copiar la columna númeroésima del primer archivo a la salida, y 2.número indica que el comando join deberá copiar la columna númeroésima del segundo archivo a la salida.

La opción a se usa para hacer un OUTER JOIN, donde en la salida se incluirán líneas de uno de los archivos de entrada que no tienen campos comunes adicionales a las líneas que se incluyen que son las que tienen campos comunes. La opción a necesita un argumento 1 o 2, indicando de cuál de los archivos se toman las líneas adicionales.

La opción v se usa para que en la salida se filtren las líneas de los archivos de entrada que tienen los campos comunes del join. La opción v no genera líneas para las líneas con campos comunes del join. La opción v necesita un argumento 1 o 2 que le indique las líneas de cuál de los archivos se copiarán a la salida. Si se incluyen la opciones v y a, como la opción v es más fuerte, se ignora la a.

Ejemplos:e@abe:~> cat Celulares.listRamón Barrios (315)313-7269Jorge Valbuena (313) 571-6462Jairo E. Soler (315) 797-1397Carlos Castilla (313) 433-7386Jorge Molina M. (315) 344-8150Alessio Di Mare (311) 688-1162Jorge Russo X. (311) 818-8709Omar Villalba (313) 388-7017Yeimy Fontalvo (300) 817-4126e@abe:~> cat Empresas.txtAlessio Di Mare RedsisJairo E. Soler Net.SolutionsJorge Molina M. SENAJorge Russo RedsisJorge Valbuena iKnowRamón Barrios iKnowYasser Barrios SupraImpresoresYeimy Fontalvoe@abe:~> join -11 -21 -t' ' -e 'N/D' Empresas.txt Celulares.txt Alessio Di Mare Redsis (311) 688-1162Jairo E. Soler Net.Solutions (315) 797-1397Jorge Molina M. SENA (315) 344-8150Jorge Russo Redsis (311) 818-8709Jorge Valbuena iKnow (313) 571-6462Ramón Barrios iKnow (315)313-7269Yeimy Fontalvo N/D (300) 817-4126e@abe:~> join -t' ' -e '***' -o 0,2.2,1.2 Empresas.txt Celulares.txt Alessio Di Mare (311) 688-1162 Redsis


Jairo E. Soler (315) 797-1397 Net.SolutionsJorge Molina M. (315) 344-8150 SENAJorge Russo (311) 818-8709 RedsisJorge Valbuena (313) 571-6462 iKnowRamón Barrios (315)313-7269 iKnowYeimy Fontalvo (300) 817-4126 ***

Los primeros dos casos de los ejemplos simplemente muestran los archivos como son. El primer archivo tiene dos columnas, está ordenado por la primera -nombre-, y tiene como separador un tabulador. El segundo archivo tiene dos columnas, está ordenado por la primera -nombre-, y tiene como separador también un tabulador.

El tercer caso del ejemplo muestra un join usando la primera columna del primer archivo (-1 1), y la primera columna del segundo archivo (-2 1), indica que se use como separador un tabulador (el argumento de la opción t), y que los campos de las columnas de la salida que estén nulos se completan con N/D (el argumento de la opción e).

En el caso cuarto de los ejemplos se muestra cómo no hay necesidad de indicar la primera columna en los archivos porque es el valor predeterminado para las opciones 1 y 2; también se dice que el separador es tabulador aunque es el valor predeterminado para la opción t; se escoge unas columnas -y un orden- para la salida (la columna del join, con el valor mágico 0, la segunda columna del segundo archivo con 2.2, y la segunda columna del primer archivo con 1.2); también se indicó que los campos nulos se muestren como *** (el valor de la opción e).



Expresiones regulares son un cruce entre expresiones matemáticas y un lenguaje de programación basado en autómatas celulares.

Filtrar líneas de texto: grep

grep

xyz

xyz

xyz

xyz

xyz

xyz

Una de las operaciones más comunes al trabajar con textos son las búsquedas. Muchas de esas búsquedas se hacen para efectos de filtrado: a veces se busca para filtrar lo que no contiene lo que se busca, a veces se busca para filtrar lo que sí contiene lo que se busca. En los sistemas UNIX hay múltiples maneras de hacer filtrados de texto, dentro de editores de texto, y a través de comandos de línea, es decir, por fuera de los editores. Una de las maneras es usando alguno de los comandos de una familia basada en “expresiones regulares”. El primero y central de la familia de comandos lleva por nombre grep (general regular expression print), comando que busca texto y filtra, para mostrar sólo líneas de texto que cumplan con la expresión regular dada. El comando grep tiene una sintaxis base sencilla, pero el primero de los argumentos debe ser una expresión regular que puede llegar a ser bastante complicada. La sintaxis de grep es:

grep [-i] [-v] [-c] [-l] [-q] [-w] [-x] [ -e expr ] [ expr ] [ archivo ... ]

Donde:


Pueden dársele a grep cero o más archivos. Si a grep no se le dan archivos leerá de la entrada estándar.

En la sintaxis expr es una expresión regular básica. Si en la sintaxis no se usa la opción e entonces la expresión es obligatoria, asumiéndose como la expresión regular al primer argumento.

La opción i se usa para que grep ignore la diferencia entre mayúsculas y minúsculas (hace a grep case insensitive).

La opción v se usa para que grep filtre negativamente, así seleccionará las líneas que no cumplan con la expresión regular.


La opción c se usa para que en vez de copiar a la salida estándar las líneas que cumplen la expresión regular, simplemente reporta en la salida estándar cuántas de las líneas concuerdan o cumplen la expresión regular. Si se usa la opción v reportará cuántas líneas no cumplen la expresión regular.

La opción l se usa para que grep reporte en la salida estándar los nombres de los archivos que contienen alguna línea -al menos- que cumple la expresión regular, y no reporte las líneas.

La opción q se usa para que grep no reporte ni las líneas que cumplen, ni los archivos que las contienen. Con esta opción grep sólo reporta “verdadero” o “falso” como código de retorno. Como siempre, verdadero en el intérprete “verdadero” es un código de retorno cero (0) y “falso” es un código de retorno diferente de cero.

La opción w se usa para que grep asuma que la expresión es una palabra, no una expresión regular.

La opción x se usa para que grep asuma que la línea completa debe cumplir la expresión regular, no una parte de la misma únicamente para ser reportada.

Ejemplos A:0 root@abe:/home/e> cat Empresas.txt Alessio Di Mare RedsisJairo E. Soler Net.SolutionsJorge Molina M. SENAJorge Russo RedsisJorge Valbuena V. iKnowRamón Barrios Lascar iKnowYasser Barrios Lascar SupraImpresoresYeimy Fontalvo 0 root@abe:/home/e> grep iknow Empresas.txt 1 root@abe:/home/e> grep iKnow Empresas.txt Jorge Valbuena V. iKnowRamón Barrios Lascar iKnow0 root@abe:/home/e> grep -i iknow Empresas.txt Jorge Valbuena V. iKnowRamón Barrios Lascar iKnow

En el primer caso de los ejemplos A se muestra el archivo completo, simple, con cat. El segundo caso de los ejempos A muestra cómo se hace una búsqueda o filtrado sencillo, con texto literal, usando grep. Se da como primer argumento el texto iknow, y como no se dan opciones, grep hace una búsqueda donde una línea completa se copiará a la salida estándar si en alguna parte aparece el texto literal dado como primer argumento. Como no se dan opciones grep diferenciará las mayúsculas de las minúsculas, y por ello el texto no se encuentra, y así no se muestra ni una línea en la salida.


El tercer caso de los ejemplos A muestra el resultado de una búsqueda literal donde el texto sí se encuentra: las líneas se copian a la salida estándar tal como aparecen en el archivo dado.

El cuarto caso de los ejemplos A muestra el uso de la opción i, que hace las búsquedas insensibles a las mayúsculas, entonces en este caso se da el primer argumento todo en minúsculas, pero como no importa lo encuentra aunque está un poquito diferente y las líneas se copian como están en el archivo.

Ejemplos B:0 root@abe:/home/e> grep -iv iknow Empresas.txt Alessio Di Mare RedsisJairo E. Soler Net.SolutionsJorge Molina M. SENAJorge Russo RedsisYasser Barrios Lascar SupraImpresoresYeimy Fontalvo 0 root@abe:/home/e> grep -ni iknow Empresas.txt 5:Jorge Valbuena V. iKnow6:Ramón Barrios Lascar iKnow

En el primer caso de los ejemplos B muestra el uso combinado de las opciones i (para que no diferencie las mayúsculas de las minúsculas) y v (para hacer una búsqueda negada). Como a grep se le indica que la expresión es el literal iknow, sin diferenciar, pero usando la opción v, copiará a la salida las líneas que no cumplen con el patrón de búsqueda, así que se muestran las líneas que no contienen iknow.

El segundo caso de los ejemplos B muestra el uso de la opción n, y como también se incluye la opción i la búsqueda será indiferente a las mayúsculas y minúsculas. En este caso se muestra el número de línea como prefijo de cada línea que cumple con el patrón de búsqueda (se muestra en número como prefijo, con un símbolo de dos puntos (:) como separador.

Ejemplos C:1 root@abe:/home/e> grep -e Mar -e Al *.tsv Celulares.tsv:Alessio Di Mare (311) 688-1162Empresas.tsv:Alessio Di Mare Redsis

En el caso de los ejemplos C se muestra el uso de la opción e: se da una única expresión de búsqueda, pero pueden darse varias veces la opción e. Cuando se usa varias veces se asume AND, es decir que para ser copiada a la salida una línea debe cumplir con todos los patrones de búsqueda simultáneamente. En el ejemplo se muestran las líneas que cumplen ambos patrones, sin importar el orden en que los cumplen. En el ejemplo también se puede notar cómo la presentación de los resultados en la salida estándar cambia cuando a grep se le dan como argumentos más de un archivo -en el ejemplo grep recibe dos archivos:


Celulares.tsv, y Empresas.tsv-. Cuando grep recibe más de un archivo de entrada como argumentos, a cada línea mostrada le agrega como prefijo el nombre del archivo de donde salió la línea, separándolo -el nombre- de la línea mostrada con un símbolo dos puntos (:).


Expresiones regulares son unes expresiones concisas que describen una porción de texto.

Expresiones Regulares Básicas (en grep)

Las expresiones regulares son un lenguaje muy rico, pero a la vez pueden hacer cosas bastante complejas. Por ello, algunas herramientas -en este caso grep- implementan un subconjunto de las mismas, de manera que no se conviertan en algo demasiado complejo de usar. En el tópico anterior vimos unos ejemplos donde se usaban unos de los casos más básicos: los caracteres alfabéticos son parte de la simbología de las expresiones regulares básicas.

A continuación se define la simbología usada en las expresiones regulares básicas.

Un símbolo punto (.) representa un caracter único cualquiera, por ejemplo una letra, un número, un símbolo visible, aún un espacio; excepto un caracter de fin de línea o retorno de carro.

Un símbolo asterisco (*) representa una secuencia del caracter o grupo inmediatamente anterior. La secuencia puede tener cero o más caracteres del inmediatemente precedente.

Un símbolo acento circunflejo (^) si aparece al inicio de una expresión representa un anclaje al inicio de una línea o cadena de texto.

Un símbolo pesos ($) si aparece al final de una expresión representa un anclaje al final de una línea o cadena de texto.

Una lista de caracteres encerrada en [ ] representa un único caracter cualquiera de la lista de caracteres encerrada.

Un rango de caracteres encerrado en [ ] representa un único caracter cualquiera del rango de caracteres encerrado. Un rango de caracteres comienza con un caracter, sigue con un símbolo menos (-), y termina con un caractere numéricamente superior o posterior al que comienza el rango.

Una lista de caracteres encerrada en [^ ] representa un único caracter cualquiera que no esté en la lista de caracteres encerrada.

Un rango de caracteres encerrado en [^ ] representa un único caracter cualquiera que no esté en el rango de caracteres encerrado. Un rango de caracteres comienza con un caracter, sigue con un símbolo menos (-), y termina con un caractere numéricamente superior o posterior al que comienza el rango.

Los símbolos ., *, $, pierden su significado especial cuando están encerrados dentro de [ ]. El símbolo ̂no tiene el significado especial negativo dentro de [ ] si no es el primer caracter inmediatamente después de [. El símbolo menos


(-) que se usa para definir una lista no tiene dicho significado especial dentro de [ ] si está de primero o de último en los caracteres encerrados.

Cuando se encierra una parte de la expresión regular entre pares  la parte encerrada queda memorizada en un registro numerado, contando desde la izquierda los pares $. Los registros numerados se recuperan o usan con \número.

Note que como algunos -muchos?- de los símbolos de las expresiones regulares tienen significado especial en el shell, es mejor encerrarlos en ‘ ‘ ya que así el shell no los interpreta con el significado que normalmente les da.

Ejemplos:0 root@abe:/home/e> cat Celulares.tsvAlessio Di Mare (311) 688-1162Carlos Castilla V. (313) 433-7386Jairo E. Soler (315) 797-1397Jorge Molina M. (315) 344-8150Jorge Russo (311) 818-8709Jorge Valbuena V. (313) 571-6462Omar Villalba (313) 388-7017Ramón Barrios Lascar (315)313-7269Yeimy Fontalvo (300) 817-41260 root@abe:/home/e> grep '.R' Celulares.tsvJorge Russo (311) 818-87090 root@abe:/home/e> grep '^R' Celulares.tsvRamón Barrios Lascar (315)313-72690 root@abe:/home/e> grep '\(.$\1' Celulares.tsvAlessio Di Mare (311) 688-1162Carlos Castilla V. (313) 433-7386Jorge Molina M. (315) 344-8150Jorge Russo (311) 818-8709Omar Villalba (313) 388-7017Ramón Barrios Lascar (315)313-7269Yeimy Fontalvo (300) 817-41260 root@abe:/home/e> grep -v '[09]' Celulares.tsvAlessio Di Mare (311) 688-1162Carlos Castilla V. (313) 433-7386Jorge Valbuena V. (313) 571-6462

En el primer caso de los ejemplos simplemente se usa cat para volcar a la salida todo el archivo Celulares.tsv.

En el segundo caso de los ejemplos se indica a grep que debe copiar a la salida estándar las líneas que tienen un caracter cualquiera (.) y luego una R. Si se observa bien hay otra línea con una R, pero no tiene antes un caracter porque está al comienzo de la línea.

En el tercer caso de los ejemplos se busca un caracter cualquiera, y al mismo tiempo se le memoriza -como es el primer grupo “capturado” entonces está en la memoria -oficialmente “registro”- número 1, seguido de los contenidos de la memoria -registro- número 1; esta construcción busca dos caracteres repetidos; y como muestra lo listado, efectivamente


funciona. El caso del cuarto ejemplo busca líneas que tengan un caracter que puede ser cero (0) o puede ser nueve (9), y con la opción v, lista las otras líneas, las que no cumplen. Esta sintaxis y construcción lista las líneas que no tienen “cero o nueve”, que según la lógica son las líneas que no tienen un cero y que no tienen un nueve.


Filtrado avanzado de líneas de texto: egrep

egrep

xyz

xyz

xyz

xyz

xyz

xyz

xyzxyz

Como algunas de las búsquedas posibles matemáticamente no son posibles con el juego de expresiones regulares básicas que grep soporta, y como no es conveniente complicar al comando grep, se creó un comando que soporta lo que se llama “expresiones regulares extendidas”, que permiten cosas que con las básicas no son posibles, y que además facilita lo que con grep es simplemente difícil. El comando lleva por nombre egrep (extended general regular expression print).

Sintaxis del comando egrep:egrep [-h] [-i] [-l] [-n] [-s] [-v] [-w] [-x] [-f arch1] [-e expr] [ expr ] [ archivo ... ]

Donde:


Pueden dársele a egrep cero o más archivos. Si no se le dan archivos egrep lee de la entrada estándar.

En la sintaxis expr es una expresión regular básica. Si en la sintaxis no se usa la opción e entonces la expresión es obligatoria, asumiéndose como la expresión regular al primer argumento. Como muchas de las expresiones incluyen caracteres especiales que pueden ser interpretados por el shell la expresión debería encerrarse entre ‘ ‘ .

La opción i se usa para que egrep ignore la diferencia entre mayúsculas y minúsculas (hace a egrep case insensitive).

La opción v se usa para que egrep filtre negativamente, así seleccionará las líneas que no cumplan con la expresión regular.


La opción c se usa para que en vez de copiar a la salida estándar las líneas que cumplen la expresión regular, simplemente reporta en la salida estándar cuántas de las líneas concuerdan o cumplen la expresión regular. Si se usa la opción v reportará cuántas líneas no cumplen la expresión regular.

La opción l se usa para que egrep reporte en la salida estándar los nombres de los archivos que contienen alguna línea -al menos- que cumple la expresión regular, y no reporte las líneas.

La opción q se usa para que egrep no reporte ni las líneas que cumplen, ni los archivos que las contienen. Con esta opción egrep sólo reporta “verdadero” o “falso” como código de retorno. Como siempre, verdadero en el intérprete “verdadero” es un código de retorno cero (0) y “falso” es un código de retorno diferente de cero.

La opción w se usa para que egrep asuma que la expresión es una palabra, no una expresión regular.

La opción x se usa para que egrep asuma que la línea completa debe cumplir la expresión regular, no una parte de la misma únicamente para ser reportada.

La opción f se usa para que egrep lea las expresiones regulares de un archivo dado su nombre (el argumento arch1 de la opción f). La o las expresiones regulares dentro del archivo deberán estar en líneas individuales cada una.

La opción e permite dar una expresión regular con la que se intentará probar cada línea de cada uno de los archivos dados como argumentos. La opción sólo permite una expresión regular extendida, pero puede darse múltiples veces la opción e. Esta opción no es realmente necesaria, pero es práctica cuando se quieren dar varias expresiones simultáneamente o cuando la expresión regular a usar inicia con el símbolo menos (-).

Ejemplos A:0 root@abe:/home/e> cat Empresas.txt Alessio Di Mare RedsisJairo E. Soler Net.SolutionsJorge Molina M. SENAJorge Russo RedsisJorge Valbuena V. iKnowRamón Barrios Lascar iKnowYasser Barrios Lascar SupraImpresoresYeimy Fontalvo 0 root@abe:/home/e> egrep iknow Empresas.txt 1 root@abe:/home/e> egrep iKnow Empresas.txt Jorge Valbuena V. iKnowRamón Barrios Lascar iKnow0 root@abe:/home/e> egrep -i iknow Empresas.txt Jorge Valbuena V. iKnow


Ramón Barrios Lascar iKnow

En el primer caso de los ejemplos A se muestra el archivo completo, simple, con cat.

El segundo caso de los ejempos A muestra cómo se hace una búsqueda o filtrado sencillo, con texto literal, usando egrep. Se da como primer argumento el texto iknow, y como no se dan opciones, egrep hace una búsqueda donde una línea completa se copiará a la salida estándar si en alguna parte aparece el texto literal dado como primer argumento. Como no se dan opciones egrep diferenciará las mayúsculas de las minúsculas, y por ello el texto no se encuentra, y así no se muestra ni una línea en la salida.

El tercer caso de los ejemplos A muestra el resultado de una búsqueda literal donde el texto sí se encuentra: las líneas se copian a la salida estándar tal como aparecen en el archivo dado.

El cuarto caso de los ejemplos A muestra el uso de la opción i, que hace las búsquedas insensibles a las mayúsculas, entonces en este caso se da el primer argumento todo en minúsculas, pero como no importa lo encuentra aunque está un poquito diferente y las líneas se copian como están en el archivo.

Ejemplos B:0 root@abe:/home/e> egrep -iv iknow Empresas.txt Alessio Di Mare RedsisJairo E. Soler Net.SolutionsJorge Molina M. SENAJorge Russo RedsisYasser Barrios Lascar SupraImpresoresYeimy Fontalvo 0 root@abe:/home/e> egrep -ni iknow Empresas.txt 5:Jorge Valbuena V. iKnow6:Ramón Barrios Lascar iKnow

En el primer caso de los ejemplos B muestra el uso combinado de las opciones i (para que no diferencie las mayúsculas de las minúsculas) y v (para hacer una búsqueda negada). Como a grep se le indica que la expresión es el literal iknow, sin diferenciar, pero usando la opción v, copiará a la salida las líneas que no cumplen con el patrón de búsqueda, así que se muestran las líneas que no contienen iknow.

El segundo caso de los ejemplos B muestra el uso de la opción n, y como también se incluye la opción i la búsqueda será indiferente a las mayúsculas y minúsculas. En este caso se muestra el número de línea como prefijo de cada línea que cumple con el patrón de búsqueda (se muestra en número como prefijo, con un símbolo de dos puntos (:) como separador.

Ejemplos C:1 root@abe:/home/e> egrep -e Mar -e Al *.tsv


Celulares.tsv:Alessio Di Mare (311) 688-1162Empresas.tsv:Alessio Di Mare Redsis

En el caso de los ejemplos C se muestra el uso de la opción e: se da una única expresión de búsqueda, pero pueden darse varias veces la opción e. Cuando se usa varias veces se asume AND, es decir que para ser copiada a la salida una línea debe cumplir con todos los patrones de búsqueda simultáneamente. En el ejemplo se muestran las líneas que cumplen ambos patrones, sin importar el orden en que los cumplen. En el ejemplo también se puede notar cómo la presentación de los resultados en la salida estándar cambia cuando a grep se le dan como argumentos más de un archivo -en el ejemplo grep recibe dos archivos: Celulares.tsv, y Empresas.tsv-. Cuando grep recibe más de un archivo de entrada como argumentos, a cada línea mostrada le agrega como prefijo el nombre del archivo de donde salió la línea, separándolo -el nombre- de la línea mostrada con un símbolo dos puntos (:).


Expresiones Regulares Extendidas (en egrep)

Las expresiones regulares extendidas son un lenguaje aún más rico, con las que se pueden hacer búsquedas y comparaciones bastante complejas. Algunos de los comandos de Unix implementan las expresiones regulares básicas, pero algunas otras herramientas implementan las expresiones regulares extendidas (por ejemplo uno que no hemos revisado, sed), pero en especial el comando ya mencionado egrep.

A continuación se define la simbología usada en las expresiones regulares extendidas.

Un símbolo punto (.) representa un caracter único cualquiera, por ejemplo una letra, un número, un símbolo visible, aún un espacio; excepto un caracter de fin de línea o retorno de carro.

Un símbolo asterisco (*) representa una secuencia del caracter o grupo inmediatamente anterior. La secuencia puede tener cero o más caracteres del inmediatemente precedente.

Un símbolo interrogación (?) indica que el caracter o ítem inmediatamente anterior puede aparecer cero o una vez, máximo.

Un símbolo más (+) indica que el caracter o ítem inmediatamente anterior puede aparecer una o más veces.

Un símbolo acento circunflejo (^) si aparece al inicio de una expresión representa un anclaje al inicio de una línea o cadena de texto.

Un símbolo pesos ($) si aparece al final de una expresión representa un anclaje al final de una línea o cadena de texto.

Una lista de caracteres encerrada en [ ] representa un único caracter cualquiera de la lista de caracteres encerrada.

Un rango de caracteres encerrado en [ ] representa un único caracter cualquiera del rango de caracteres encerrado. Un rango de caracteres comienza con un caracter, sigue con un símbolo menos (-), y termina con un caractere numéricamente superior o posterior al que comienza el rango.

Una lista de caracteres encerrada en [^ ] representa un único caracter cualquiera que no esté en la lista de caracteres encerrada.

Un rango de caracteres encerrado en [^ ] representa un único caracter cualquiera que no esté en el rango de caracteres encerrado. Un rango de caracteres comienza con un caracter, sigue con un símbolo menos (-), y termina con un caractere numéricamente superior o posterior al que comienza el rango.


Los símbolos ., *, $, pierden su significado especial cuando están encerrados dentro de [ ]. El símbolo ̂no tiene el significado especial negativo dentro de [ ] si no es el primer caracter inmediatamente después de [. El símbolo menos (-) que se usa para definir una lista no tiene dicho significado especial dentro de [ ] si está de primero o de último en los caracteres encerrados.

Cuando se encierra una parte de la expresión regular entre pares ede paréntess ( ) la parte encerrada se considera una subexpresión, que básicamente se trata como un ítem o elemento único.

El símbolo barra vertical (|) dentro de las expresiones regulares extendidas sirve para indicar “alternativas”, de las cuales es posible escoger o concordar con una.

Se pueden indicar cuántas repeticiones de un item se permiten o deben darse en una expresión regular si se usa la construcción {min,max} como sufijo de un item. Por ejemplo, a{2,5} indica que se necesita para concordancia un mínimo de dos aes y un máximo de cinco. Si se omite el primer número egrep asume cero (0), si se omite el segundo número no se asume un máximo. Así ? es equivalente a {0,1} o {,1}, + es equivalente a {1,}, y * es equivalente a {0,}.

Ejemplos:e@abe:e/> cat Celulares.tsvAlessio Di Mare (311) 688-1162Carlos Castilla V. (313) 433-7386Jairo E. Soler (315) 797-1397Jorge Molina M. (315) 344-8150Jorge Russo (311) 818-8709Jorge Valbuena V. (313) 571-6462Omar Villalba (313) 388-7017Ramón Barrios Lascar (315)313-7269Yeimy Fontalvo (300) 817-4126e@abe:e/> egrep '3.[15]' *.tsvCelulares.tsv:Alessio Di Mare (311) 688-1162Celulares.tsv:Jairo E. Soler (315) 797-1397Celulares.tsv:Jorge Molina M. (315) 344-8150Celulares.tsv:Jorge Russo (311) 818-8709Celulares.tsv:Ramón Barrios Lascar (315)313-7269e@abe:e/> egrep '8[^-]' *.tsvCelulares.tsv:Alessio Di Mare (311) 688-1162Celulares.tsv:Carlos Castilla V. (313) 433-7386Celulares.tsv:Jorge Molina M. (315) 344-8150Celulares.tsv:Jorge Russo (311) 818-8709Celulares.tsv:Omar Villalba (313) 388-7017Celulares.tsv:Yeimy Fontalvo (300) 817-4126e@abe:e/> egrep '(^|[^a-zA-Z])[a-zA-Z]{5} ' *.tsv Celulares.tsv:Jairo E. Soler (315) 797-1397Celulares.tsv:Jorge Molina M. (315) 344-8150Celulares.tsv:Jorge Russo (311) 818-8709


Celulares.tsv:Jorge Valbuena V. (313) 571-6462Celulares.tsv:Yeimy Fontalvo (300) 817-4126Empresas.tsv:Jairo E. Soler Net.SolutionsEmpresas.tsv:Jorge Molina M. SENAEmpresas.tsv:Jorge Russo RedsisEmpresas.tsv:Jorge Valbuena V. iKnowEmpresas.tsv:Yeimy Fontalvo

El primer caso de los ejemplos simplemente muestra cómo es el archivo Celulares.tsv (usando cat).

El segundo caso de los ejemplos usa egrep para buscar números celulares que sean 315 o 310, pero realmente no se fija en el segundo dígito, sólo en el primero y el tercero. Usa un tres (3) literal para la concordancia, luego un punto (.) para indicar “cualquier cosa”, note que no dice “cualquier dígito”, y usa [15], para indicar o un 1 o un 5.

El tercer caso usa egrep para buscar los números ocho (8) que no esté seguidos por un menos (-), así que usa una algo artificial construcción 8[^-] es decir “ocho seguido de un caracter que no está en una lista, pero la lista sólo tiene un menos”.

El cuarto y último de los casos de ejemplo busca una palabra de cinco letras, sea en mayúsculas o minúsculas; auque la construcción es como artificial se explica enseguida: [a-zA-Z] significa “una letra minúscula o mayúscula cualquiera”, siendo letra sólo lo válido en inglés. {5} significa “cinco repeticiones de lo inmediatamente anterior”. [a-zA-Z]{5} significa “cinco letras minúsculas o mayúsculas”. [a-zA-Z]{5} significa “cinco letras minúsculas o mayúsculas seguidas de un espacio”. (^|[^a-zA-Z]) significa “inicio de línea o algo que no es letra minúscula o mayúscula”. (^|[^a-zA-Z])[a-zA-Z]{5} significa “cinco letras minúsculas o mayúsculas al comienzo de línea o precedidas de algo que no es letra y seguidas de un espacio”.


Ordenar líneas de texto: sort

sort

1

2

3

4

5

6

7

8

9

10

8

3

4

1

10

6

5

9

2

7

Quizás después de las búsquedas la operación más necesitada dentro de lo que se denomina “procesamiento de datos” (data processing) es lo que se llama ordenamiento. Es tan profundo el tema que aunque hay diversos algoritmos siempre hay gente trabajando en mejorar los algoritmos.

Para ordenar texto columnar en UNIX se incluye un comando obviamente denominado sort. Es un comando sencillo muy potente que puede llegar a consumir -como cualquier rutina de ordenamiento- bastante CPU y bastante RAM. La sintaxis estándar de sort es:

sort [ -A ] [ -b ] [ -c ] [ -d ] [ -f ] [ -i ] [ -k Llave ] [ -n ] [ -r ] [ -t separador ] [ -u ] [ archivo ... ]

Donde:


A sort pueden dársele cero o más archivos. Si no se le dan archivos sort lee la entrada estándar.

La opción A indica a sort que debe usar únicamente los valores ASCII de los caracteres para hacer el ordenamiento.

La opción b indica a sort que debe ignorar los espacios y tabuladores para buscar la primera o última columna de un campo.

La opción c se usa para que sort no ordene, sólo reportará verdadero o falso, indicando si los archivos de entrada están ya ordenados según indiquen las opciones. Como siempre, el valor verdadero en el intérprete de comandos shell es un código de retorno cero (0).


La opción d se usa para que sort ordene según diccionario. En estos ordenamientos sólo se tienen en cuenta las letras, números y espacios.

La opción f indica a sort que debe pasar todas las letras a comparar a mayúsculas.

La opción i se usa para que sort ignore todo caracter no visible en las comparaciones.

La opción k es la más importante ya que con la misma se define la llave de ordenamiento. Esta opción puede usarse múltiples veces. La opción k necesita una definición de campos y columnas así:

[inicioCampo[.inicioColumna]][ModifInic][,[finCampo[.finColumna]]ModifFin]]

Donde la llave inicia con un campo (dado el número inicioCampo), posiblemente en un caracter de ese campo (dado el número inicioColumna), tal vez con algún modificador (dado ModifInic). La llave termina con un campo (dado el número finCampo), posiblemente en un caracter de ese campo (dado el número finColumna), tal vez con un modificador (dado ModifFin). Los modificadores son los b, c, f, n, i, r, con el mismo significado que las opciones de la mismas letras.

La opción n se usa para que sort haga un ordenamiento numérico. Los campos pueden tener espacios o tabuladores iniciales, pueden tener signos, decimales o radicales.

La opción r se usa para que sort haga un ordenamiento en orden inverso, según digan las otras opciones.

La opción t se usa para indicar a sort cuál es el separador de campo.

La opción u (unique) indica a sort que debe reportar sólo una de las líneas iguales según la llave de ordenamiento.

Ejemplos:e@abe:e/> cat Empresas.tsvAlessio Di Mare RedsisJairo E. Soler Net.SolutionsJorge Molina M. SENAJorge Russo RedsisJorge Valbuena V. iKnowRamón Barrios Lascar iKnowYasser Barrios Lascar SupraImpresoresYeimy Fontalvo

Se muestra en este caso simplemente cómo son los contenidos del archivo Empresas.tsv.e@abe:e/> sort -c Empresas.tsv && echo "Empresas.tsv está ordenado!"Empresas.tsv está ordenado!


Se usa la opción c en este segundo caso para decir a sort que revise si el archivo Empresas.tsv está ordenado. Como no muestra salida deberán usarse las facilidades del shell para revisar el código de retorno.

e@abe:e/> sort -rA Empresas.tsvYeimy Fontalvo Yasser Barrios Lascar SupraImpresoresRamón Barrios Lascar iKnowJorge Valbuena V. iKnowJorge Russo RedsisJorge Molina M. SENAJairo E. Soler Net.SolutionsAlessio Di Mare Redsis

En este tercer caso se usa la opción r para que el ordenamiento sea inverso. Se usó la opción A para que el ordenamiento no use la definición del idioma del Unix donde sort está corriendo.

e@abe:e/> sort -t' ' -k 2 Empresas.tsvYeimy Fontalvo Jairo E. Soler Net.SolutionsAlessio Di Mare RedsisJorge Russo RedsisJorge Molina M. SENAYasser Barrios Lascar SupraImpresoresJorge Valbuena V. iKnowRamón Barrios Lascar iKnow

En este cuarto caso se define que el separador de campos es un caracter tabulador, y se define como llave de ordenamiento la columna 2 (según el separador definido). Se nota como sort ordena primero las columnas en blanco, luego las columnas que inician en mayúscula y luego las columnas que inician en minúscula.

e@abe:e/> sort -f -t' ' -k 2 Empresas.tsvYeimy Fontalvo Jorge Valbuena V. iKnowRamón Barrios Lascar iKnowJairo E. Soler Net.SolutionsAlessio Di Mare RedsisJorge Russo RedsisJorge Molina M. SENAYasser Barrios Lascar SupraImpresores

En este quinto caso se define que el separador de campos es un caracter tabulador, y se define como llave de ordenamiento la columna 2 (según el separador definido), también se indica usando la opción f que deben convertirse a mayúsculas las minúsculas antes de las comparaciones. Se nota como ordena primero las columnas en blanco, luego un ordenamiento alfabético, sin importar las minúsculas o mayúsculas.

e@abe:e/> sort -f -t' ' -k 2 -u Empresas.tsvYeimy Fontalvo


Jorge Valbuena V. iKnowJairo E. Soler Net.SolutionsAlessio Di Mare RedsisJorge Molina M. SENAYasser Barrios Lascar SupraImpresores

En este sexto caso se muestra el resultado de la opción u. Sólo se diferencia del caso quinto en la inclusión de la opción u. En este caso se hace que sort sólo muestre la primera de las líneas que incluya el campo que se usa como llave de ordenamiento.

e@abe:e/> sort -t' ' -k1.2 Empresas.tsvJairo E. Soler Net.SolutionsRamón Barrios Lascar iKnowYasser Barrios Lascar SupraImpresoresYeimy Fontalvo Alessio Di Mare RedsisJorge Molina M. SENAJorge Russo RedsisJorge Valbuena V. iKnow

En este caso séptimo se hace un ordenamiento usando la segunda letra del primer campo (k1.2) , definiendo de paso que el separador de campos es un caracter tabulador.

e@abe:e/> cat Numeros.txt123456789101112131415

El caso octavo simplemente muestra los contenidos de un nuevo archivo Numeros.txt usando cat.

e@abe:e/> sort Numeros.txt1101112131415234


56789

El caso noveno muestra cómo el ordenamiento predeterminado de sort no es el adecuado para números de longitud variable.

e@abe:e/> sort -n Numeros.txt123456789101112131415

El caso décimo muestra cómo la opción n es lo comúnmente más adecuado cuando sort tiene que comparar campos numéricos para hacer un ordenado.


Transliterar caracteres: tr

trpassword p455w0rd

A veces es necesario reemplazar -o eliminar- caracteres individuales de un texto. Para esta operación sencilla se usa el comando estándar tr (transliterate) que lee de la entrada estándar, reemplaza unos caracteres individuales por otros y el resultado lo genera en la salida estándar. La sintaxis del comando sencillo tr es:

tr [ -c | -cds | -cs | -C | -Cds | -Cs | -ds | -s ] [ -A ] caracteres1 caracteres2

o tambiéntr { -cd | -cs | -Cd | -Cs | -d | -s } [ -A ] caracteres

Donde:

Los símbolos [ y ] indican que las opciones y los argumentos son opcionales, no hacen parte de la sintaxis. Si se dan dos cadenas de caracteres como argumentos no es obligatorio dar alguna opción.

Los símbolos { y } indican que las opciones y los argumentos son opcionales, no hacen parte de la sintaxis. Si se dan una cadena de caracteres como argumento es obligatorio dar alguna opción.


A tr pueden dársele una o dos cadenas -secuencias- de caracteres. Como tr entiende un subconjunto de las expresiones regulares extendidas las cadenas deberían estar encerradas entre ‘ ‘.

La opción A se usa para indicar que tr debe usar ordenamiento puramente ASCII cuando se le den rangos de caracteres, no debe tener en cuenta los ordenamientos según el idioma en que está funcionando el UNIX donde corre.

La opción C se usa para indicar que tr no debe tomar el valor de la cadena caracteres1 si no que debe tomar el valor del complemento de caracteres1. El complemento se define como los otros caracteres que componen el conjunto nacional según el idioma definido por la variable de ambiente LC_COLLATE.

La opción c se usa para indicar que tr no debe tomar el valor de la cadena de caracteres1 si no que debe tomar del valor del complemento de caracteres1. El complemento se define como los otros caracteres que componen el juego de caracteres ASCII.


La opción d hace que tr no reemplace caracteres si no que elimine caracteres al copiar la entrada estándar a la salida estándar. Cuando se usa junto con la opción c o la opción C no elimina de la entrada estándar los caracteres de caracteres1 si no los caracteres que no están en caracteres1.

La opción s hace que tr reemplace toda una secuencia de caracteres por el primero de la secuencia (dados por caracteres1). Cuando se dan dos argumentos junto con la opción s se reemplazará toda una secuencia de caracteres (dados por caracteres1) por un caracter (tomado de caracteres2).

Los valores en caracteres1 y caracteres2 pueden ser: un texto literal alfanumérico; o c1-c2, donde c1 aparece primero que c2 en el ordenamiento de texto según el idioma del UNIX donde se ejecuta tr; [C*número], equivalente a la repetición número veces del caracter C; [C*] cuando se usa en caracteres2 para hacer que esta secuencia de caracteres tenga la misma longitud que caracteres1; [:clase:] especifica uno cualquiera de todos los caracteres contenidos en una clase de alnum, alpha, blank, cntrl, digit, graph, lower, print, punct, space, upper, xdigit; [=C=] especifica uno cualquiera de todos los caracteres de una clase de caracteres idiomática, así en español [=e=] incluye e y é; \CarControl especifica un caracter de control de alert (\a), backspace (\b), form feed (\f), new line (\n), carriage return (\r), tab (\t), vertical tab (\v), backslash (\\); o un [ literal con \[ o un menos (-) literal con \-.

Ejemplos:e@abe:e/> cat Celulares.tsvAlessio Di Mare (311) 688-1162Carlos Castilla V. (313) 433-7386Jairo E. Soler (315) 797-1397Jorge Molina M. (315) 344-8150Jorge Russo (311) 818-8709Jorge Valbuena V. (313) 571-6462Omar Villalba (313) 388-7017Ramón Barrios Lascar (315)313-7269Yeimy Fontalvo (300) 817-4126

En este primer caso simplemente se muestran los contenidos del archivo Celulares.tsv usando el comando cat.

e@abe:e/> tr -d 3 < Celulares.tsvAlessio Di Mare (11) 688-1162Carlos Castilla V. (1) 4-786Jairo E. Soler (15) 797-197Jorge Molina M. (15) 44-8150Jorge Russo (11) 818-8709Jorge Valbuena V. (1) 571-6462Omar Villalba (1) 88-7017Ramón Barrios Lascar (15)1-7269


Yeimy Fontalvo (00) 817-4126

En este segundo caso de los ejemplos se muestra primero el uso adecuado de tr: No lee archivos, únicamente lee de la entrada estándar. Se usa la opción d para indicar que tr debe buscar el caracter 3 y no incluirlo en la salida.

e@abe:e/> tr -d 83 < Celulares.tsvAlessio Di Mare (11) 6-1162Carlos Castilla V. (1) 4-76Jairo E. Soler (15) 797-197Jorge Molina M. (15) 44-150Jorge Russo (11) 1-709Jorge Valbuena V. (1) 571-6462Omar Villalba (1) -7017Ramón Barrios Lascar (15)1-7269Yeimy Fontalvo (00) 17-4126

En este tercer caso de los ejemplos se usa la opción d con una cadena de dos caracteres, lo que indica que debe borrar de la salida cualquier aparición de cualquiera de los dos caracteres, aunque la cadena completa 83 no aparece en le texto origen. tr toma los caracteres individuales.

e@abe:e/> tr '0123456789' 'OI2EAS6TB9' < Celulares.tsvAlessio Di Mare (EII) 6BB-II62Carlos Castilla V. (EIE) AEE-TEB6Jairo E. Soler (EIS) T9T-IE9TJorge Molina M. (EIS) EAA-BISOJorge Russo (EII) BIB-BTO9Jorge Valbuena V. (EIE) STI-6A62Omar Villalba (EIE) EBB-TOITRamón Barrios Lascar (EIS)EIE-T269Yeimy Fontalvo (EOO) BIT-AI26

En este cuarto caso de los ejemplos se usan dos argumentos de igual longitud, así cada vez que se encuentre en la entrada el primer caracter del argumento1 se reemplaza por el primer caracter del argumento2 en la salida (0 se reemplaza por O), cada vez que se encuentre en la entrada el segundo caracter del argumento1 se reemplaza por el segundo caracter del argumento2 (1 se reemplaza por I), y así.

e@abe:e/> tr '[:lower:]' '[:upper:]' < Celulares.tsvALESSIO DI MARE (311) 688-1162CARLOS CASTILLA V. (313) 433-7386JAIRO E. SOLER (315) 797-1397JORGE MOLINA M. (315) 344-8150JORGE RUSSO (311) 818-8709JORGE VALBUENA V. (313) 571-6462OMAR VILLALBA (313) 388-7017RAMÓN BARRIOS LASCAR (315)313-7269YEIMY FONTALVO (300) 817-4126

En este quinto caso de los ejemplos se usan clases de caracteres para que tr reemplace los caracteres en minúsculas en la entrada por los equivalentes en mayúsculas en la salida. tr no


“conoce” las mayúsculas adecuadas de cada caracter en minúsculas. Pero la a minúscula aparece en la clase :lower: en la misma posición que la A mayúscula aparece en la clase :upper:.

e@abe:e/> tr '[:digit:]' 'abcde' < Celulares.tsvAlessio Di Mare (dbb) 688-bb6cCarlos Castilla V. (dbd) edd-7d86Jairo E. Soler (db5) 797-bd97Jorge Molina M. (db5) dee-8b5aJorge Russo (dbb) 8b8-87a9Jorge Valbuena V. (dbd) 57b-6e6cOmar Villalba (dbd) d88-7ab7Ramón Barrios Lascar (db5)dbd-7c69Yeimy Fontalvo (daa) 8b7-ebc6e@abe:e/> tr '[:digit:]' 'abcde*' < Celulares.tsvAlessio Di Mare (dbb) 688-bb6cCarlos Castilla V. (dbd) edd-7d86Jairo E. Soler (db*) 797-bd97Jorge Molina M. (db*) dee-8b*aJorge Russo (dbb) 8b8-87a9Jorge Valbuena V. (dbd) *7b-6e6cOmar Villalba (dbd) d88-7ab7Ramón Barrios Lascar (db*)dbd-7c69Yeimy Fontalvo (daa) 8b7-ebc6

En estos dos casos se muestra cómo funciona tr cuando la segunda secuencia de caracteres de los argumentos es más corta que la primera: sólo una parte de la clase -en los ejemplos- es reemplazada en la salida.

e@abe:e/> tr '[:digit:]' 'abcd[e*]' < Celulares.tsvAlessio Di Mare (dbb) eee-bbecCarlos Castilla V. (dbd) edd-edeeJairo E. Soler (dbe) eee-bdeeJorge Molina M. (dbe) dee-ebeaJorge Russo (dbb) ebe-eeaeJorge Valbuena V. (dbd) eeb-eeecOmar Villalba (dbd) dee-eabeRamón Barrios Lascar (dbe)dbd-eceeYeimy Fontalvo (daa) ebe-ebce

Es este otro caso se usa [C*] para que la segunda cadena de caracteres de los argumentos tenga la misma longitud de la primera, repitiéndo los últimos caracteres las veces que sea necesario.

e@abe:e/> tr -s '[:digit:]' < Celulares.tsv Alessio Di Mare (31) 68-162Carlos Castilla V. (313) 43-7386Jairo E. Soler (315) 797-1397Jorge Molina M. (315) 34-8150Jorge Russo (31) 818-8709Jorge Valbuena V. (313) 571-6462Omar Villalba (313) 38-7017Ramón Barrios Lascar (315)313-7269


Yeimy Fontalvo (30) 817-4126

Este otro caso muestra cómo hacer que los caracteres que se repitan en de la cadena de los argumentos en la entrada sean reemplazados por sólo uno en la salida, usando la opción s (squeeze) del comando tr.


Utilidades avanzadas de archivos y directorios

Utilidades, más utilidades

Aunque en la línea de comandos del intérprete shell de UNIX hay unas tareas u operaciones que son más difíciles de hacer que en la interfaz gráfica cuando sólo hay que hacerlas o repetirlas una o dos veces, la mayoría de las tareas que haya que repetir muchas veces es muchísimo más fácil y rápido hacerlas combinando comandos. Así un UNIX típico o estándar incluye muchos, muchísimos comandos para todo.

Como la entidad central que contiene datos en un UNIX es el archivo, la mayoría de los comandos de UNIX operan sobre archivos. En este apartado trataremos algunos de los muchos comandos necesarios para hacer operaciones sobre archivos, en especial sobre múltiples archivos.


Búsqueda de archivos: find

Dentro de toda la cantidad de herramientas con las que cuenta un operador Unix hay una que tienen reconocimiento especial ya que se le denomina “la navaja suiza del administrador UNIX”, esta herramienta lleva el nombre de find.

El comando find navega recursivamente árboles de directorios y selecciona archivos y directorios según una serie de criterios que se le den, a los archivos y directorios seleccionados puede hacerle una serie de acciones que indique quien lo invoca. La sintaxis general de find es muy sencilla:

find directorio ... -criterio ... -acción ...

Donde:

Sólo directorio es obligatorio según el estándar POSIX. En algunos sistemas UNIX ni un directorio como argumento es obligatorio, asumiendo en este caso el directorio actual.

Pueden darse uno o más directorios, usando rutas relativas o absolutas. Como cada directorio es un argumento, deberán separarse por espacios como todo argumento en el shell -realmente deben separarse por $IFS-.

find navega recursivamente -usando método infijo- cada uno de los directorios que se den como argumento. find no sigue los enlaces simbólicos.

Los criterios son “de selección”, que indican cuáles de los archivos y directorios se seleccionarán para realizar en ellos, uno a uno las acciones. Como el criterio predeterminado es “todos” si no se da un criterio de selección find llevará a cabo las acciones para todos y cada uno de los archivos y directorios encontrados al navegar recursivamente cada uno de los directorios argumento.

Las acciones indican qué hay que hacer con cada uno de los archivos y directorios seleccionados al navegar recursivamente los directorios iniciales dados, según los criterios de selección dados. La acción predeterminada, cuando no se dan las acciones es -print.

Criterios de selección en find

El comando find tiene muchísimos criterios posibles de selección, que, como se pueden observar, no necesitan de abrir o leer los archivos para revisar sus contenidos, porque todos usan los atributos externos visibles o legibles. Como ya se mencionó, el criterio predeterminado en find es “todos”. Los criterios se listan a continuación:

‣ Criterio -inum númeroInodo evalúa verdadero si el archivo o directorio que se está evaluando tiene númeroInodo como su inodo en disco.


‣ Critero -type tipo evalúa verdadero si el tipo de lo que se está evaluando -según los contenidos de su inodo- concuerdan. Los tipos son f (archivo), d (directorio), l (enlace simbólico), p (tubería), s (socket), b (dispositivo de bloque), c (dispositivo de caracter).

‣ Criterio -links número evalúa verdadero si el archivo o directorio que se está evaluando tiene el número exacto de nombres o enlaces fuertes. El criterio -links -número evalúa verdadero si el archivo o directorio que se está evaluando tiene menos nombres o enlaces que número. El criterio -links +número evalúa verdadero si el archivo o directorio que se está evaluando tiene más nombres o enlaces que número.

‣ Criterio -user unUsuario evalúa verdadero si el archivo o directorio que se está evaluando tiene como propietario a unUsuario. El criterio -user puede ser usado con un número como parámetro si es un entero y no se resuelve como usuario en el sistema.

‣ Criterio -nouser evalúa verdadero si el archivo o directorio que se está evaluando tiene como propietario algo que no puede ser resuelto en el sistema -no tiene un dueño válido definido-.

‣ Criterio -group unGrupo evalúa como verdadero si el archivo o directorio tiene como grupo a unGrupo. El criterio -group puede ser usado con un número como parámetro si es un entero y no se resuelve como grupo en el sistema.

‣ Criterio -nogroup evalúa verdadero si el archivo o directorio tiene como grupo algo que no puede ser resuelto en el sistema -no tiene un grupo válido definido-.

‣ Criterio -perms númeroOctal evalúa verdadero si el archivo o directorio tiene exactamente los permisos númeroOctal. El criterio -perms -númeroOctal evalúa verdadero si el archivo o directorio tiene activos al menos los permisos equivalentes a númeroOctal.

‣ Criterio -perms modo evalúa verdadero si el archivo o directorio tiene exactamente los permisos modo, como se usan en el comando chmod. El criterio -perms -modo evalúa verdadero si el archivo o directorio tiene activos al menos los permisos que están en modo como se usan en el comando chmod.

‣ Criterio -size bloques evalúa verdadero si el tamaño del archivo o directorio cuando se redondea a bloques de 512 bytes -redondeo hacia arriba- es igual a bloques. El criterio -size -bloques evalúa verdadero si el tamaño del archivo o directorio cuando se redondea a bloques de 512 bytes -redondeo hacia arriba- es menor que bloques. El criterio -size +bloques evalúa verdadero si el tamaño


del archivo o directorio cuando se redondea a bloques de 512 bytes -redondeo hacia arriba- es mayor que bloques.

‣ Criterio -size bytesc evalúa verdadero si el tamaño del archivo o directorio es exactamente bytes Bytes. El criterio -size -bytesc evalúa verdadero si el tamaño del archivo o directorio es menor que bytes Bytes. El criterio -size +bytesc evalúa verdadero si el tamaño del archivo o directorio es mayor que bytes Bytes.

‣ Criterio -atime n evalúa verdadero si el tiempo de acceso del archivo o directorio menos el momento actual dividido entre 86400 (descartando residuos) es n. Note que 86400 segundos son 24 horas. Si el UNIX donde se use find no cumple con UNIX03 entonces -atime n evalúa verdadero si el tiempo de último uso del archivo o directorio está entre n-1 y n múltiplos de 24 horas.

‣ Criterio -ctime n evalúa verdadero si el tiempo de cambio de inodo del archivo o directorio menos el momento actual dividido entre 86400 (descartando residuos) es n. Note que 86400 segundos son 24 horas. Si el UNIX donde se use find no cumple con UNIX03 entonces -ctime n evalúa verdadero si el tiempo de cambio de inodo del archivo o directorio está entre n-1 y n múltiplos de 24 horas.

‣ Criterio -mtime n evalúa verdadero si el tiempo de modificación del archivo o directorio menos el momento actual dividido entre 86400 (descartando residuos) es n. Note que 86400 segundos son 24 horas. Si el UNIX donde se use find no cumple con UNIX03 entonces -mtime n evalúa verdadero si el tiempo de modificación del archivo o directorio está entre n-1 y n múltiplos de 24 horas.

‣ Criterio -amin n evalúa verdadero si el tiempo de acceso del archivo o directorio está entre n y n-1 minutos. El criterio -amin -n evalúa verdadero si el tiempo de acceso del archivo o directorio es menor a n minutos. El criterio -amin +n evalúa verdadero si el tiempo de acceso del archivo o directorio es mayor a n minutos.

‣ Criterio -cmin n evalúa verdadero si el tiempo del último cambio del inodo del archivo o directorio está entre n y n-1 minutos. El criterio -cmin -n evalúa verdadero si el tiempo del último cambio del inodo del archivo o directorio es menor a n minutos. El criterio -cmin +n evalúa verdadero si el tiempo del último cambio del inodo del archivo o directorio es mayor a n minutos.

‣ Criterio -mmin n evalúa verdadero si el tiempo de modificación del archivo o directorio está entre n y n-1 minutos. El criterio -mmin -n evalúa verdadero si el tiempo de modificación del archivo o directorio es menor a n minutos. El criterio -mmin +n evalúa verdadero si el tiempo de modificación del archivo o directorio es mayor a n minutos.


‣ Criterio -newer archivo evalúa verdadero si el tiempo de modificación del archivo o directorio es posterior al de modificación del archivo de referencia dado como archivo.

‣ Criterio -name ‘especificación’ evalúa verdadero si el archivo o directorio lleva por nombre o su nombre cumple con la evaluación de shell ‘especificación’. Oficialmente especificación no va entre comillas sencillas, pero como se usan los mismos comodines que en el shell lo común es evitar que éste último los interprete encerrándolos en comillas sencillas ‘ ‘.

‣ “Criterio” -depth hace que find navegue recursivamente los directorios a la manera posfija, evaluando primero los contenidos de los directorios, antes que el directorio mismo.

‣ Criterio -fstype tipoFs evalúa verdadero si el archivo o directorio está contenido en un sistema de archivos de tipo tipoFs.

‣ Criterio -prune evalúa siempre verdadero. Hace que find detenga la recursividad si el argumento como parámetro es un directorio.

‣ “Criterio” -xdev hace que find navegue recursivamente sin cambiarse de sistema de archivos y se mantenga en el mismo sistema de archivos que cada uno de los parámetros.

Acciones en find

El comando find tiene muchas menos acciones que criterios. Acciones son “lo que puede hacer find con cada uno de los archivos o directorios seleccionados”. La acción predeterminada -cuando no se indican acciones- en find es -print. Las acciones se listan a continuación:

‣ La acción -print hace que find reporte en la salida estándar los nombres de los archivos o directorios que va seleccionando. Si el argumento de directorio inicial está dado como una ruta absoluta -print listará nombres como rutas absolutas, de lo contrario usará nombres como rutas relativas.

‣ La acción -ls hace que find reporte en la salida estándar los nombres de los archivos o directorios que va seleccionado, con detalles adicionales. Si el argumento de directorio inicial está dado como una ruta absoluta -ls listará nombres como rutas absolutas, de lo contrario usará nombres como rutas relativas. El comando find reporta, en orden, el número de inodo, el tamaño en Kilobytes, los permisos, el número de nombres, el usuario, el grupo, el tamaño en Bytes, el tiempo de última modificación y el nombre.


‣ La acción -exec ComandoCompleto hace que find ejecute ComandoCompleto con cada archivo seleccionado. ComandoCompleto debería terminar en \; o ‘;‘ para evitar la interpretación del shell. Si dentro de ComandoCompleto se encuentra el par {} el comando find reemplazará el nombre del archivo o directorio seleccionado para hacer la ejecución del comando. Devuelve verdadero si ComandoCompleto pudo ejecutarse y terminó con código de retorno cero (0) por lo que puede usarse como un criterio.

‣ La acción -ok ComandoCompleto hace que find pregunte si ejecuta ComandoCompleto para cada archivo seleccionado. ComandoCompleto debería terminar en \; o ‘;‘ para evitar la interpretación del shell. Si dentro de ComandoCompleto se encuentra el par {} el comando find reemplazará el nombre del archivo o directorio seleccionado para hacer la ejecución del comando. Devuelve verdadero si ComandoCompleto pudo ejecutarse y terminó con código de retorno cero (0) por lo que puede usarse como un criterio.

Operadores lógicos en find

Además de tener infinidad de criterios de selección y acciones sobre los archivos y directorios seleccionados, find tiene operadores lógicos, que permiten combinar los criterios de selección. Se tienen:

‣ Operador lógico -a (AND). Evalúa a verdadero si ambos criterios (el de antes de -a y el de después de -a) evalúan a verdadero. El segundo criterio nunca ejecuta si el primero evalúa a falso.

‣ Operador lógico -o (OR). Evalúa a verdadero si alguno de los criterios (el de antes de -o y el de después de -o) evalúa a verdadero. El segundo criterio nunca ejecuta si el primero evalúa a verdadero.

‣ Operador lógico ! (NOT). Evalúa a verdadero si el criterio que le sigue evalúa a falso.

‣ Paréntesis de agrupación $ y $.

Ejemplos:e@abe:e/> find .../.profile./.sh_history./procesos.txt./actual.txt./dato viejo./LitteFile./.ssh./ramon.txt./MadRamon 1.png


./.Xauthority

./subdir1

./subdir1/Antiguo_SubDir

./subdir1/MadRamon 1.png

./subdir1/smit.log

./subdir1/LitteFile

./nuevoArchiv2.txt

./fechaActual.txt

./NuevoVacio.txt

./archivoAB.txt

./archivoA.txt

./fileA.txt

./fileA.c

...

Este primer caso de los ejemplos simplemente muestra cómo listar recursivamente una estructura de árbol en UNIX usando find. Sólo se le da un directorio inicial, en este caso el actual (.).

e@abe:e/> find . -ls 64 4 drwxr-xr-x 4 e system 4096 Sep 16 20:34 . 65 1 -rw-r--r-- 1 root system 248 Apr 11 08:53 ./.profile 66 9 -rw------- 1 e system 8770 Sep 18 09:23 ./.sh_history 182 3 -rw-r--r-- 1 e system 2413 Aug 18 21:40 ./procesos.txt 67 1 -rw-r--r-- 1 e system 29 Aug 16 23:02 ./actual.txt 177 1 -rw-r--r-- 1 e system 29 Aug 14 23:15 ./dato viejo 72 0 -rw-r--r-- 1 e system 0 Aug 14 23:15 ./LitteFile 4 1 drwxr-xr-x 2 e system 256 Aug 14 19:18 ./.ssh 183 1 -rw-r----- 1 e system 760 Aug 18 23:09 ./ramon.txt 180 18 -rw-r--r-- 1 e system 17804 Aug 14 23:16 ./MadRamon 1.png 185 1 -rw------- 1 e system 147 Aug 19 17:02 ./.Xauthority12288 1 drwxr-xr-x 3 e system 256 Aug 16 17:37 ./subdir112352 1 drwxr-xr-x 2 e system 256 Aug 15 21:05 ./subdir1/Antiguo_SubDir12289 18 -rw-r--r-- 1 e system 17804 Aug 16 17:37 ./subdir1/MadRamon 1.png12290 10 -rw-r--r-- 1 e system 10181 Aug 16 17:37 ./subdir1/smit.log12291 0 -rw-r--r-- 1 e system 0 Aug 16 17:37 ./subdir1/LitteFile 68 1 -rw-r--r-- 1 e system 1 Aug 18 21:31 ./nuevoArchiv2.txt

...

En este segundo caso de los ejemplos se nota el uso de la acción -ls que incluye los detalles de los archivos seleccionados, como se mencionó en las notas acerca del comando. Como no se da un criterio de selección, el comando find muestra todos los archivos y directorios del inicial hacia abajo (recursivamente).

e@abe:e/> find . -inum 211 -ls 211 1 -rw-r--r-- 1 e system 31 Sep 14 09:13 ./Romanos.txt


Este tercer caso de los ejemplos muestra el uso de la opción de selección -inum que selecciona un archivo o directorio dado su número de inodo -único por sistema de archivos-.

e@abe:e/> find . -type d -print../.ssh./subdir1./subdir1/Antiguo_SubDir

Este cuarto caso muestra el uso de la opción de selección -type, que con el argumento d hace que find sólo seleccione los directorios. También se agrega la opción de acción -print que muestra los nombres de lo seleccionado. Como es la acción predeterminada en esta situación no cambia para nada la salida del comando find.

e@abe:e/> find . -perm -111 -ls 64 4 drwxr-xr-x 4 e system 4096 Sep 16 20:34 . 4 1 drwxr-xr-x 2 e system 256 Aug 14 19:18 ./.ssh12288 1 drwxr-xr-x 3 e system 256 Aug 16 17:37 ./subdir112352 1 drwxr-xr-x 2 e system 256 Aug 15 21:05 ./subdir1/Antiguo_SubDir

...

Este quinto caso de los ejemplos muestra el uso de la opción de selección -perm, que cuando se le da un número debe ser octal, y si se le da con un símbolo menos (-) asumirá “al menos estos permisos, tal vez otros adicionales”. Como se le da 111 el comando find entiende --x--x--x, que con el menos (-) asume “que al menos tenga --x--x--x”. Lista con detalles lo seleccionado y se nota que éstos sí cumplen con el criterio.

e@abe:e/> find /tmp /home -links +2/tmp/tmp/bosfind: 0652-081 cannot change directory to </tmp/lost+found>: : The file access permissions do not allow the specified action.find: 0652-081 cannot change directory to </tmp/wsmdata.196726>: : The file access permissions do not allow the specified action./tmp/vgdata/tmp/ejemplo/homefind: 0652-081 cannot change directory to </home/lost+found>: : The file access permissions do not allow the specified action.

...

El sexto caso de los ejemplos muestra cómo cuando un usuario usa find, el comando no puede ir donde el usuario manualmente no puede ir (usando cd). En este caso se muestra cómo usar dos directorios para iniciar una búsqueda (simplemente separándolos con espacios), y cómo buscar según el número de nombres (en este caso los que tengan más de dos nombres).


e@abe:e/> find /tmp /home -links +2 2> /dev/null/tmp/tmp/bos/tmp/vgdata/tmp/ejemplo/home/home/e/home/e/subdir1/home/j/home/ldapdb2/home/ldapdb2/sqllib/home/ldapdb2/sqllib/function/home/ldapdb2/sqllib/spmlog/home/ldapdb2/ldapdb2/home/ldapdb2/ldapdb2/NODE0000/home/ldapdb2/ldapdb2/NODE0000/SQL00001

...

El séptimo caso de los ejemplos muestra cómo cuando un usuario usa find, el comando no puede ir donde el usuario manualmente no puede ir (usando cd). Para evitar la mezcolanza de lo reportado por find con los mensajes de error se usa redirección, se mandan los mensajes de error al “archivo” /dev/null.

e@abe:e/> find /tmp /home ! -user e -ls 2> /dev/null 2 8 drwxrwxrwt 10 bin bin 8192 Sep 18 09:22 /tmp 10 1 drwxr-xr-x 2 root system 256 Aug 9 13:15 /tmp/.oslevel.datafiles 11 0 -rw-r--r-- 1 root system 0 Apr 10 13:18 /tmp/.oslevel.datafiles/.oslevel.hold 26 1 -rw-r--r-- 1 root system 62 Aug 9 12:33 /tmp/.oslevel.datafiles/.oslevel.mlinfo.cache 29 1 -rw-r--r-- 1 root system 5 Aug 9 12:33 /tmp/.oslevel.datafiles/.oslevel.cache.sum 52 3 -rw-r--r-- 1 root system 3068 Aug 17 10:37 /tmp/.ctinst.log 106 13 -rwxr--r-- 1 test02 testgrp1 12292 Aug 9 23:56 /tmp/.DS_Store 120 1 -rw-r--r-- 1 root system 406 Apr 10 08:47 /tmp/.sr_migrate.log 4 0 -rw------- 1 root system 0 Apr 10 11:05 /tmp/.strload.mutex 14 49 -rw-r--r-- 1 root system 49464 Apr 10 15:41 /tmp/.tmpfile.123028 23 1 -rw-r--r-- 1 root system 29 Aug 9 10:42 /tmp/File1.txt 17 4 -rw-r--r-- 1 root system 3584 Apr 13 00:38 /tmp/tlist159808 8 0 -rw-r----- 1 root system 0 Apr 10 20:48 /tmp/Spmi_shm_hook 18 888 -rw-r----- 1 root system 909172 Aug 9 11:55 /tmp/samba-client-2.2.7-4.aix4.3.ppc.rpm

...


En este octavo caso de los ejemplos se usa find con un operador lógico NOT (el símbolo !), donde unido con -user e indicia “seleccionar los que su dueño no es e”, como tal vez no pueda entrar a buscar en ciertos directorios, los mensajes de error se redireccionan a /dev/null (con 2>).

e@abe:e/> find /home -size +10find: 0652-081 cannot change directory to </home/lost+found>: : The file access permissions do not allow the specified action./home/e/.sh_history/home/e/MadRamon 1.png/home/e/subdir1/MadRamon 1.png/home/e/subdir1/smit.log/home/e/ibmserver2-lslpp-L.txtfind: 0652-081 cannot change directory to </home/j/.ssh>: : The file access permissions do not allow the specified action./home/ldapdb2/sqllib/db2dump/db2diag.log/home/ldapdb2/sqllib/db2dump/ldapdb2.nfy

...En este noveno caso de los ejemplos se muestra el uso de la opción de selección -size. Con ésta se dice a find que seleccione los archivos que miden más de 5KB (10 bloques de 512B). El comando reporta que no pudo entra a algunos subdirectorios del inicial /home.

e@abe:e/> find /home -mtime -1 -ls 2> /dev/null 66 9 -rw------- 1 e system 9166 Sep 18 09:29 /home/e/.sh_history

En el décimo caso se le dice a find que seleccione los archivos -o directorios- debajo de /home que han sido modificados hace menos de un día (con la opción de selección -mtime -1), que les liste los detalles (con la acción -ls), y los mensajes de error los mandamos al archivo /dev/null.

e@abe:e/>find /home -type f -a -user e -ok rm {} \; find: 0652-081 cannot change directory to </home/lost+found>: : The file access permissions do not allow the specified action.rm /home/e/.sh_history (?) n rm /home/e/dato viejo (?) yrm /home/e/LitteFile (?)

...

En el caso once de los ejemplos se le dice a el comando find que seleccione los archivos que cumplen dos criterios: que sean de tipo f (es decir que sean archivos), usando el criterio de selección -type f y (AND) que tengan como dueño al usuario e. Con cada uno de los seleccionados deberá ejecutar un rm, pero deberá preguntar antes de ejecutar, para ello usando la acción -ok rm {} \;. Se nota cómo find reemplaza el nombre de lo encontrado o seleccionado en la posición donde está el par de símbolos {} en el comando armado para la acción -ok. Se nota también cómo \; pertenece a la sintaxis pero no se usa a la hora de ejecutar el comando. Se nota finalmente cómo es la pregunta que find hace, y cómo se


puede responder usando y -para dar un sí y que find ejecute el comando que armó-, o usando otra cosa -en los ejemplos n- para que find no ejecute el comando que armó.

Ejemplo Especial:

Para buscar los archivos que cuyo nombre tiene alguna característica y que contienen cierto texto se usa:

find /directorio/inicial -name ‘*.extensión’ | xargs grep -l ‘texto a buscar’

Esta construcción ubica simplemente los archivos a los que “amerita” revisarles sus contenidos (usando el comando find, que no revisa contenidos), y luego de ubicados se los pasa a grep que los abre y sí revisa línea por línea para verificar si dentro de los contenidos se encuentra el texto a buscar (grep abre y revisa los contenidos, pero no ubica los archivos). Esta construcción reporta el nombre de cada archivo que contenga el “texto a buscar”, y la línea donde el texto se encontró.


Ejecución de comandos en cantidades de archivos: xargs

1

2

3

4

5

6

7

8

9

10

comandoarg1arg2arg3arg4arg5...

xargs

Como muchas veces un administrador usa find para ejecutar un comando en muchísimos archivos, casi siempre a través de la acción -exec del comando find, y como find ejecuta al comando una vez por cada uno de los archivos seleccionados, y si find selecciona miles de archivo el comando se ejecutará -o al menos se intentará ejecutar- miles de veces. Como muchos o muchísimos de los comandos de UNIX pueden ejecutarse dándole muchos -tal vez centenares- de argumentos, es muy ineficiente ejecutar miles de veces un comando con un argumento, en vez de una vez con miles de argumentos.

En muchos caso puede usarse la construcción comandoEjecutar -opciones $(find /directorio /criterios -print), pero si find selecciona miles de archivos la línea de comandos dentro de $( ... ) quedará muy muy larga, posiblemente generando error, ya que la línea de comandos del intérprete shell soporta secuencias muy largas, pero no infinitas.

Para sobreponerse a todas las situaciones mencionadas los UNIX incluyen un comando llamado xargs que:

Recibe nombres de archivos por entrada estándar y con los mismos “arma” líneas de comandos largas.

Conoce las limitaciones de las líneas de comandos del UNIX donde ejecuta para no sobrepasar los topes.

Permite especificar cómo deben ser las líneas de comandos que arma.

La sintaxis del comando xargs es:xargs [ -E marcaFin ] [ -I comodín ] [ -L mínimo ] [ -n máximo ] [ -p ] [ -s maxCars ] [ -t ] comando

Donde:



El comando xargs necesita una lista de nombres en la entrada estándar.

El comando xargs combina comando con cierto número de argumentos que ha leído de la entrada estándar así:

La opción I se usa para indicar a xargs un texto en el comando que deberá reemplazarse por cada uno de los nombres leídos de la entrada estándar. Si no se usa se asume el texto predeterminado {}.

La opción L se usa para indicar a xargs cuántos nombres deberá usar mínimo para cada invocación del comando.

La opción n se usa para indicar a xargs cuántos nombres deberá usar máximo de lo leído de la entrada estándar para cada invocación del comando. Si el comando no tiene el texto de reemplazo ni se usó la opción I xargs tratará de incluir el máximo de nombres posibles sin sobrecargar los límites de la línea de comandos del UNIX donde se está ejecutando. Es posible que la última ejecución se ejecute con pocos nombres debido a que xargs va consumiendo la entrada estándar.

La opción p se usa para que xargs pregunte antes de cada invocación del comando.

La opción s se usa para indicar a xargs que no se limite en el número de nombres a usar en cada invocación, si no que cada invocación no supere un número máximo de caracteres dado por el argumento de la opción s.

La opción t se usa para hacer trazado (debug) de las ejecuciones de xargs.

Ejemplos:e@abe:e/> echo file[C-H]* | xargs compress -vfileC: Compression: 55.18% This file is replaced with fileC.Z.fileD: Compression: 55.18% This file is replaced with fileD.Z.fileE: Compression: 55.18% This file is replaced with fileE.Z.fileF: Compression: 55.14% This file is replaced with fileF.Z.fileG: Compression: 55.14% This file is replaced with fileG.Z.fileH: Compression: 55.18% This file is replaced with fileH.Z.

En el primer caso de los ejemplos se usa artificialmente xargs para ejecutar un comando sobre muchos archivos, en este caso se le da compress -v a xargs y el arma una línea de comandos con posiblemente muchísimos argumentos, toda la línea comenzando con compress -v. Si la línea de comandos es demasiado grande, el tomaría muchos de los argumentos que va leyendo de la entrada estándar y armaría la línea de comandos más grande posible comenzando con compress -v. Armaría una segunda, y así, hasta consumir toda la entrada estándar.

e@abe:e/> echo file[C-H]* | xargs -t compress -vcompress -v fileC fileD fileE fileF fileG fileH fileC: Compression: 55.18% This file is replaced with fileC.Z.fileD: Compression: 55.18% This file is replaced with fileD.Z.


fileE: Compression: 55.18% This file is replaced with fileE.Z.fileF: Compression: 55.14% This file is replaced with fileF.Z.fileG: Compression: 55.14% This file is replaced with fileG.Z.fileH: Compression: 55.18% This file is replaced with fileH.Z.

En el segundo caso de los ejemplos se le da la misma entrada a xargs, pero se usa la opción t para poder observar cómo es la línea de comandos que compress usaría -que xargs arma-.

e@abe:e/> echo file[C-H]* | xargs -t -n3 compress -vcompress -v fileC fileD fileE fileC: Compression: 55.18% This file is replaced with fileC.Z.fileD: Compression: 55.18% This file is replaced with fileD.Z.fileE: Compression: 55.18% This file is replaced with fileE.Z.compress -v fileF fileG fileH fileF: Compression: 55.14% This file is replaced with fileF.Z.fileG: Compression: 55.14% This file is replaced with fileG.Z.fileH: Compression: 55.18% This file is replaced with fileH.Z.

En el tercer caso de los ejemplos se usa xargs con la misma entrada, pero esta vez además de usar t para observar los comandos que xargs arma, se usa la opción n con un 3 para que xargs arme líneas de comandos con máximo tres ítems tomados de la entrada estándar.

e@abe:e/> find . -name 'file[C-H]*' | xargs -L 1 -I _ echo mv _ _-Compr mv ./fileG.Z ./fileG.Z-Comprmv ./fileH.Z ./fileH.Z-Comprmv ./fileC.Z ./fileC.Z-Comprmv ./fileD.Z ./fileD.Z-Comprmv ./fileE.Z ./fileE.Z-Comprmv ./fileF.Z ./fileF.Z-Compr

En el cuarto caso de los ejemplos se usa el comando xargs en una situación típica: combinado con find. En este caso find busca y selecciona -y reporta- unos ciertos archivos, que pasa a xargs a través de redirección, el que armará unas líneas de comandos. Con la opción -L xargs no armará líneas de comandos imposiblemente grandes, tomará tantos ítems de la entrada estándar como le dice el argumento de L, en esta caso un item. Con la opción -I se indica a xargs que use algo como comodín para ubicar en la línea de comandos el texto del ítem que recién tomó de la entrada estándar. En este caso se usa un _. Luego se arma una línea de comandos con el ítem. Para no necesariamente ubicarlo al final de lo dado a xargs como argumento se usa el símbolo de reemplazo, en este caso un _. El símbolo de reemplazo puede usarse hasta cinco veces en una línea de reemplazo generada por xargs. Como se ve xargs deberá armar algo como echo mv Nombre1 Nombre1-Compr, y se nota que en realidad es así, porque se observan unas líneas de salida mv Nombre1 Nombre1-Compr.


Comprimir archivos 1: compress & uncompress

compress

uncompress

Hace tres décadas unos investigadores y desarrolladores inventaron un algoritmo para comprimir la información digital por medio de la codificación de las repeticiones binarias en los archivos, podo después en UNIX se desarrollaron un par de comandos: uno toma un archivo y si tiene sentido lo reemplaza por otro comprimido con el nombre ligeramente cambiado -este comando se denomina compress- y el otro toma una comprimido y lo reemplaza por la versión sin comprimir, ajustándole el nombre -este otro comando se denomina uncompress-.

El primer comando tiene la sintaxis:compress [ -c ] [ -f | -F ] [ -v ] [ archivo ... ]

El segundo comando tiene la sintaxis:uncompress [ -c ] [ -f | -F ] [ -v ] [ archivo ... ]

Donde:



Si a cualquiera de los dos comandos (compress o uncompress) no se le dan archivos como argumento, intentarán leer de la entrada estándar y escribir en la salida estándar.

La opción c se usa para que tanto compress como uncompress escriban en la salida estándar (independientemente de se dio archivo como argumento). Así no intentan escribir archivos.


La opción f (o la opción F, son exactamente equivalentes) forza la creación del archivo comprimido o descomprimido, según el caso. El comando compress no intenta crear el archivo comprimido si ve que el intento de compresión no comprime, que el archivo quedaría igual o más grande.

La opción v se usa para que compress (o uncompress) reporte en la salida estándar de errores la estadística de compresión por archivo.

Ambos comandos intentan crear un archivo con el mismo dueño, grupo, permisos y fechas que el original, pero si no corren como root no podrán crear archivos con usuario diferente del bajo el que ejecutan.

Nótese que ninguno de los comandos trabajan archivos empaquetados, así, que si se les dan cinco archivos generarán cinco archivos más pequeños, no uno sólo que contiene copias comprimidas de los cinco.

Ejemplos:e@abe:e/> find . -size +2000c -ls 64 4 drwxr-xr-x 4 e system 4096 Sep 18 10:56 . 66 11 -rw------- 1 e system 10418 Sep 18 10:56 ./.sh_history 182 3 -rw-r--r-- 1 e system 2413 Aug 18 21:40 ./procesos.txt 177 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileH 180 18 -rw-r--r-- 1 e system 17804 Aug 14 23:16 ./MadRamon 1.png12289 18 -rw-r--r-- 1 e system 17804 Aug 16 17:37 ./subdir1/MadRamon 1.png12290 10 -rw-r--r-- 1 e system 10181 Aug 16 17:37 ./subdir1/smit.log 191 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileB 194 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileC 195 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileD 196 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileE 197 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileF 198 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileG 199 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileI 217 104 -rw-r----- 1 e system 105515 Sep 15 18:14 ./ibmserver2-lslpp-L.txt

En este primer caso de los ejemplos se buscan archivos “que ameritan ser comprimidos”, únicamente, usando find con el criterio -size.

e@abe:e/> compress -v $(find . -size +2000c). is not a regular file. It is not changed../MadRamon: A file or directory in the path name does not exist.1.png: A file or directory in the path name does not exist../subdir1/MadRamon: A file or directory in the path name does not exist.1.png: A file or directory in the path name does not exist.compress: 0653-054 ./subdir1/smit.log.Z already has a .Z suffix. It is not changed../.sh_history: Compression: 50.65% This file is replaced with ./.sh_history.Z../ibmserver2-lslpp-L.txt: Compression: 77.47% This file is replaced with ./ibmserver2-lslpp-L.txt.Z.


En este segundo caso de ejemplo se combina find con compress usando substitución de comandos para que se vayan comprimiendo los archivos que find encontró. Se usa compress con la opción v para que reporte las estadísticas de compresión de cada archivo que se va comprimiendo.

e@abe:e/> find . -name '*Z' -exec uncompress -v {} \;./procesos.txt.Z: This file is replaced with ./procesos.txt../fileH.Z: This file is replaced with ./fileH../fileB.Z: This file is replaced with ./fileB../subdir1/smit.log.Z: This file is replaced with ./subdir1/smit.log../fileC.Z: This file is replaced with ./fileC../.sh_history.Z: This file is replaced with ./.sh_history../fileD.Z: This file is replaced with ./fileD../fileE.Z: This file is replaced with ./fileE../fileF.Z: This file is replaced with ./fileF../fileG.Z: This file is replaced with ./fileG../fileI.Z: This file is replaced with ./fileI../ibmserver2-lslpp-L.txt.Z: This file is replaced with ./ibmserver2-lslpp-L.txt.

En el tercer caso de ejemplo se usa la acción -exec del comando find para invocar uncompress en cada archivo comprimido -que se sabe que tiene el nombre terminado en Z. Se usa uncompress con la opción v para que reporte los archivos conforme los va descomprimiendo.


Comprimir archivos 2: gzip & gunzip

gzip

gunzip

Como tanto compress como uncompress están basados en el algoritmo patentado LZW (en este momento el algoritmo es propiedad de Unisys-, Jean-Loup Gailly y Mark Adler lanzaron el 31 de octubre de 1992 un nuevo par de programas diseñados para reemplazarlos, todo bajo el auspicio del proyecto GNU. Este nuevo par de programas usan un algoritmo ahora llamado DEFLATE, que es una combinación de LZ77 y codificación Huffman. Como este par de comandos hacen parte del proyecto GNU, ambos son de código abierto.

Igual que compress, gzip está diseñado para comprimir archivos individuales, y gunzip está diseñado para descomprimir los archivos creados por gzip. Nótese que gunzip reconoce los archivos creados con compress y puede descomprimirlos.

Igual que compress, gzip toma un archivo y lo reemplaza por otro comprimido, con el nombre ligeramente cambiado agregándole .gz, y gunzip toma un archivo .gz comprimido y lo descomprime, generando un archivo sin la extensión .gz. La sintaxis de ambos comandos es sencilla:

gzip [ -c ] [ -f ] [ -v ] [ -dígito | --fast | --best ] [ archivo ... ]

ygunzip [ -c ] [ -f ] [ -v ] [ -t ] [ -l ] [ archivo ... ]

Donde:



Si a cualquiera de los dos comandos (gzip o gunzip) no se le dan archivos como argumento, intentarán leer de la entrada estándar y escribir en la salida estándar.


La opción c se usa para que tanto gzip como gunzip escriban en la salida estándar (independientemente de se dio archivo como argumento). Así no intentan escribir archivos.

La opción f (o la opción F, son exactamente equivalentes) forza la creación del archivo comprimido o descomprimido, según el caso. El comando gzip no intenta crear el archivo comprimido si ve que el intento de compresión no comprime, que el archivo quedaría igual o más grande.

La opción dígito (que recibe de 1 a 9) se usa para seleccionar un método de compresión: el más rápido es 1, que posiblemente genera un archivo poco comprimido, es equivalente a la opción -fast; el más lento es 9, que posiblemente genera un archivo mucho más pequeño, pero consumiendo más RAM y CPU en el proceso, es equivalente a -best. Lo predeterminado es 6.

La opción v se usa para que gzip (o gunzip) reporte en la salida estándar de errores la estadística de compresión por archivo.

La opción l se usa en gunzip no para descomprimir archivos, si no para reportar estadísticas de compresión por archivo.

La opción t se usa para que gunzip haga pruebas de integridad en los archivos comprimidos y reporte lo que encuentre incongruente.

Ambos comandos intentan crear un archivo con el mismo dueño, grupo, permisos y fechas que el original, pero si no corren como root no podrán crear archivos con usuario diferente del bajo el que ejecutan.

Note que como gzip comprime individualmente los archivos, es muy común primero empacar archivos con tar y comprimir lo que este genera. Estos archivos salidos de la combinación de los dos comandos casi siempre se encuentran con extensiones .tar.gz o tgz y se denominan tarballs.

Ejemplos:e@abe:e/> find . -size +2000c -ls 64 4 drwxr-xr-x 4 e system 4096 Sep 18 11:19 . 221 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileH 182 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileB 177 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileC 180 18 -rw-r--r-- 1 e system 17804 Aug 14 23:16 ./MadRamon 1.png12289 18 -rw-r--r-- 1 e system 17804 Aug 16 17:37 ./subdir1/MadRamon 1.png12290 10 -rw-r--r-- 1 e system 10181 Aug 16 17:37 ./subdir1/smit.log 191 11 -rw------- 1 e system 10456 Sep 18 10:57 ./.sh_history 193 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileD


194 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileE 195 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileF 196 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileG 197 3 -rw-r--r-- 1 e system 2245 Sep 9 18:06 ./fileI 198 104 -rw-r----- 1 e system 105515 Sep 15 18:14 ./ibmserver2-lslpp-L.txt 217 3 -rw-r--r-- 1 e system 2413 Aug 18 21:40 ./procesos.txt

En este primer caso de los ejemplos se buscan archivos “que ameritan ser comprimidos”, únicamente, usando find con el criterio -size.

e@abe:e/> gzip -v $(find . -size +2000c)gzip: . is a directory -- ignored./fileH: 72.8% -- replaced with ./fileH.gz./fileB: 72.8% -- replaced with ./fileB.gz./fileC: 72.9% -- replaced with ./fileC.gz./MadRamon: No such file or directory1.png: No such file or directory./subdir1/MadRamon: No such file or directory1.png: No such file or directory./subdir1/smit.log: 72.3% -- replaced with ./subdir1/smit.log.gz./.sh_history: 72.5% -- replaced with ./.sh_history.gz./fileD: 72.9% -- replaced with ./fileD.gz./fileE: 72.8% -- replaced with ./fileE.gz./fileF: 72.8% -- replaced with ./fileF.gz./fileG: 72.8% -- replaced with ./fileG.gz./fileI: 72.8% -- replaced with ./fileI.gz./ibmserver2-lslpp-L.txt: 87.0% -- replaced with ./ibmserver2-lslpp-L.txt.gz./procesos.txt: 71.6% -- replaced with ./procesos.txt.gz

En este segundo caso de ejemplo se combina find con gzip usando substitución de comandos para que se vayan comprimiendo los archivos que find encontró. Se usa gzip con la opción v para que reporte las estadísticas de compresión de cada archivo que se va comprimiendo.

e@abe:e/> find . -name '*gz' -exec gunzip -l {} \;compressed uncompr. ratio uncompressed_name 633 2245 72.8% ./fileBcompressed uncompr. ratio uncompressed_name 631 2245 72.9% ./fileCcompressed uncompr. ratio uncompressed_name 2902 10456 72.5% ./.sh_historycompressed uncompr. ratio uncompressed_name 2842 10181 72.3% ./subdir1/smit.logcompressed uncompr. ratio uncompressed_name 631 2245 72.9% ./fileDcompressed uncompr. ratio uncompressed_name 633 2245 72.8% ./fileEcompressed uncompr. ratio uncompressed_name 633 2245 72.8% ./fileFcompressed uncompr. ratio uncompressed_name


633 2245 72.8% ./fileGcompressed uncompr. ratio uncompressed_name 633 2245 72.8% ./fileIcompressed uncompr. ratio uncompressed_name 13669 105515 87.0% ./ibmserver2-lslpp-L.txtcompressed uncompr. ratio uncompressed_name 716 2413 71.6% ./procesos.txtcompressed uncompr. ratio uncompressed_name 633 2245 72.8% ./fileH

En el cuarto caso se usa la opción de acción -exec del comando find para ejecutar gunzip -l en cada archivo comprimido y obtener unas estadísticas de compresión por archivo.

e@abe:e/> find . -name '*gz' -print | xargs gunzip -vlmethod crc date time compressed uncompr. ratio uncompressed_namedefla c58ff355 Sep 9 18:06 633 2245 72.8% ./fileBdefla 4ee49376 Sep 9 18:06 631 2245 72.9% ./fileCdefla db9b9031 Sep 18 10:57 2902 10456 72.5% ./.sh_historydefla 44d5bb72 Aug 16 17:37 2842 10181 72.3% ./subdir1/smit.logdefla 4401742b Sep 9 18:06 631 2245 72.9% ./fileDdefla ae144046 Sep 9 18:06 633 2245 72.8% ./fileEdefla 7cc54b0d Sep 9 18:06 633 2245 72.8% ./fileFdefla d675841c Sep 9 18:06 633 2245 72.8% ./fileGdefla 58651c7f Sep 9 18:06 633 2245 72.8% ./fileIdefla e3f19b59 Sep 15 18:14 13669 105515 87.0% ./ibmserver2-lslpp-L.txtdefla e1b6233a Aug 18 21:40 716 2413 71.6% ./procesos.txtdefla f2d5d36e Sep 9 18:06 633 2245 72.8% ./fileH 25189 146525 82.8% (totals)

En el quinto caso se usa una combinación de find con xargs con la esperanza de que haya sólo una ejecución de gunzip -vl. Así (con las opciones v y l)se obtiene un reporte más detallado por archivo, pero como es una única ejecución, el reporte es más conciso (y tiene totales).

e@abe:e/> find . -name '*gz' -print | xargs gunzip -v ./fileB.gz: 72.8% -- replaced with ./fileB./fileC.gz: 72.9% -- replaced with ./fileC./.sh_history.gz: 72.5% -- replaced with ./.sh_history./subdir1/smit.log.gz: 72.3% -- replaced with ./subdir1/smit.log./fileD.gz: 72.9% -- replaced with ./fileD./fileE.gz: 72.8% -- replaced with ./fileE./fileF.gz: 72.8% -- replaced with ./fileF./fileG.gz: 72.8% -- replaced with ./fileG./fileI.gz: 72.8% -- replaced with ./fileI./ibmserver2-lslpp-L.txt.gz: 87.0% -- replaced with ./ibmserver2-lslpp-L.txt./procesos.txt.gz: 71.6% -- replaced with ./procesos.txt./fileH.gz: 72.8% -- replaced with ./fileH

En el sexto caso se usa una combinación parecida, pero no un reporte de compresión (con gunzip -l), si no una descompresión de los archivos, aunque también reporta, porque se incluyó la opción v de gunzip.


Empacar archivos: tar

tar

A fines de la década de 1980 se notaba cómo la utilitad básica para llevar a cabo copias de respaldo a cinta de la época era inadecuada e insuficiente. Por esta razón central se dió un nuevo desarrollo que terminó tomando la forma del comando tar (tape archive). Este comando y el formato que se desarrolló para que el mismo manejara se dirigieron originalmente a ser almacenados directamente en dispositivos en burto (raw devices), no en archivos como es muy común ahora. Esta utilidad y su formato se estandarizaron en POSIX.1-1988 y luego en POSIX.1-2001. Aunque originalmente fue una herramienta y un formato para copias de respaldo en dispositivos puramente secuenciales ahora es más común como un formato para el transporte de múltiples archivos como un todo.

La mayoría de las utilidades tar de los sistemas UNIX trabajan lo que ahora se denomina “formato USTAR” (Uniform Standard Tape Archive), formato que permite almacenar múltiples -muchísimos- archivos, con sus metadatos dentro de uno solo. Como los archivos tar tienen un encabezado por archivo almacenado dentro de él, y este encabezado tiene unos limitantes, conviene saber cuáles son estos límites: básicamente porciones de nombre de máximo cien caracteres y archivos individuales de máximo 8GB.

Note que tar archiva pero no comprime, dejando esta tarea a alguna otra utilidad o al dispositivo o medio de almacenamiento.

La sintaxis de tar es bastante compleja, pero de manera resumida se tiene:tar { -c | -r | -x | -u } [ -R ] [ -D ] [ -C directiorio ] [ -L ListaInclusión ] [ -X ListaExclusión ] [ -p ] [ -v ] [ archivo ... ]

Donde:




La opción c se usa para crear un nuevo archivo de respaldo, copiando los archivos mencionados en ListaInclusión o como argumentos archivo, comenzando desde el inicio del archivo de respaldo (no agrega).

La opción r se usa para agregar archivos a un archivo de respaldo, copiando los archivos mencionados en ListaInclusión o como argumentos archivo, comenzando desde el fin del archivo de respaldo (agrega). Esta opción es válida para archivos de sistema de archivo únicamente, no es válida si el destino de copia es una cinta de respaldo.

La opción x se usa para extraer archivos de una copia de respaldo (restaurar), copiando los archivos mencionados en ListaInclusión o como argumentos archivo, al directorio actual, teniendo en cuenta la ruta de directorio almacenada en el archivo de copia de respaldo.

La opción u se usa para agregar archivos a un archivo de copia de respaldo, pero únicamente si no existen ya dentro de la copia de respaldo, o si la copia dentro de la copia de respaldo tiene fecha de modificación anterior. Los archivos que se copia se mencionan en ListaInclusión o son mencionados como argumento archivo (actualiza la copia de respaldo). Esta opción es válida para archivos de sistema de archivo únicamente, no es válida si el destino de copia es una cinta de respaldo.

La opción t se usa para que tar lea el medio o archivo de copia de respaldo, pero que no intente crear los archivos (no intente recuperar). Se usa básicamente junto con la opción v para listar los contenidos de un medio o archivo de copia.

La opción R se usa para forzar a tar para que procese recursivamente los archivos mencionados en ListaInclusión o dados como argumentos archivo.

La opción D se usa para forzar a tar para que no procese recursivamente los archivos mencionados en ListaInclusión o dados como argumentos archivo.

La opción C se usa para que tar se cambie de directorio antes de procesar (agregar o extraer) los archivos que siguen como parámetro. tar se cambia al directorio dado como argumento de la opción C.

La opción L con un nombre de archivo como argumento para dar a tar una lista de archivos y directorios a procesar. Esta lista puede usarse como archivos a copiar al medio de respaldo o como archivos a recuperar del medio de respaldo. El archivo dado como argumento a la opción L debe tener un nombre de archivo a procesar por línea.


La opción X tiene un uso parecido a la opción L: se usa con un nombre de archivo como argumento para dar a tar una lista de archivos y directorios a excluir de todo procesamiento. Esta lista puede usarse como archivos a excluir de la copia al medio de respaldo o como archivos a no recuperar del medio de respaldo. El archivo dado como argumento a la opción L debe tener un nombre de archivo a excluir por línea.

La opción p indica a tar que debe procesar los atributos completos de los archivos: si está copiando a un medio de respaldo deberá copiar dueño, grupo, permisos, fechas y demás; si está recuperando deberá intentar recuperar dueño, grupo, permisos, fechas y demás. La mayoría de sistemas UNIX impiden modificar el usuario dueño de los archivos a menos que se esté trabajando como root.

La opción v se usa para que tar vaya reportando los nombres y los detalles de los archivos conforme los copia a o desde un medio o archivo de copia de respaldo.

La opcón f es quizás la más importante: se usa para indicar a tar dónde debe almacenar la copia de respaldo con todo, o de dónde debe extraer lo que se quiere recuperar. El argumento de la opción f debe ser un dispositivo de almacenamiento secuencial como una cinta (nombre que varía enormemente entre las diferentes variantes de UNIX) o un archivo tradicional. Si al comando tar no se le da la opción f intentará leer (cuando usa las opciones t o x) o escribir (cuando se usa con c, u o r) a o desde un dispositivo de copia de respaldo predeterminado según el UNIX donde esté en ejecución -conclusión: siempre use la opción f para indicarle a tar el medio de almacenamiento de las copias de respaldo-.

Ejemplos:e@abe:e/> ls -l archivo*-rw-r--r-- 1 e system 0 Sep 09 19:21 archivo A.txt-rw-r--r-- 1 e system 0 Sep 09 19:21 archivo.part.txt-rw-r--r-- 1 e system 0 Sep 09 18:14 archivo.txt-rw-r--r-- 1 e system 0 Sep 09 19:21 archivo23.txt-rw-r--r-- 1 e system 105 Sep 09 18:05 archivoA.txt-rw-r--r-- 1 e system 919 Sep 09 18:05 archivoAB.txt-rw-r--r-- 1 e system 105 Sep 09 18:07 archivoE.txt-rw-r--r-- 1 e system 105 Sep 09 18:07 archivoZ.txt-rw-r--r-- 1 e system 220 Sep 09 18:06 archivoaB.txt-rw-r--r-- 1 e system 220 Sep 09 18:06 archivoab.txt

El primer caso de los ejemplos simplemente muestra un listado de los archivos que se tienen antes de iniciar el trabajo directamente con tar.

e@abe:e/> tar -cvpf empaque.tar archivo*a archivo A.txt 0 blocks.a archivo.part.txt 0 blocks.a archivo.txt 0 blocks.


a archivo23.txt 0 blocks.a archivoA.txt 1 blocks.a archivoAB.txt 2 blocks.a archivoE.txt 1 blocks.a archivoZ.txt 1 blocks.a archivoaB.txt 1 blocks.a archivoab.txt 1 blocks.e@abe:e/> ls -l *tar-rw-r--r-- 1 e system 10240 Sep 18 23:38 empaque.tar

El segundo caso de los ejemplos muestra cómo se usa tar para crear un archivo de respaldo: básicamente a través de las opciones c y f. En el ejemplo se agregan las opciones v y p para que además tar liste los nombres de los archivos conforme los va copiando al respaldo y para que guarde todos los detalles como el dueño y los permisos para poderlos recuperar después.

e@abe:e/> gzip -v9 *tarempaque.tar: 92.5% -- replaced with empaque.tar.gz

El tercer caso de los ejemplos simplemente usa gzip para comprimir la copia de respaldo creada con tar.

e@abe:e/> rm archivo* && ls -l archivo*ls: 0653-341 The file archivo* does not exist.

El cuarto caso de los ejemplos se deshace -borrando- de los archivos originales. Comprueba también que se perdieron.

e@abe:e/> gunzip -c empaque.tar.gz | tar -tvp tar: /dev/rmt0: There is a request to a device or address that does not exist.

El quinto caso de los ejemplos muestra cómo tar no lee la entrada estándar -así que no recibe del comando “anterior”-.

e@abe:e/> gunzip -c empaque.tar.gz | tar -tvpf --rw-r--r-- 501 0 0 Sep 09 19:21:29 2007 archivo A.txt-rw-r--r-- 501 0 0 Sep 09 19:21:29 2007 archivo.part.txt-rw-r--r-- 501 0 0 Sep 09 18:14:20 2007 archivo.txt-rw-r--r-- 501 0 0 Sep 09 19:21:29 2007 archivo23.txt-rw-r--r-- 501 0 105 Sep 09 18:05:31 2007 archivoA.txt-rw-r--r-- 501 0 919 Sep 09 18:05:39 2007 archivoAB.txt-rw-r--r-- 501 0 105 Sep 09 18:07:36 2007 archivoE.txt-rw-r--r-- 501 0 105 Sep 09 18:07:45 2007 archivoZ.txt-rw-r--r-- 501 0 220 Sep 09 18:06:16 2007 archivoaB.txt-rw-r--r-- 501 0 220 Sep 09 18:06:06 2007 archivoab.txt

El sexto caso de los ejemplos muestra cómo tar puede leer de la entrada estándar o escribir en la salida estándar si se usa la opción f con un menos (-) como argumento.

e@abe:e/> gunzip -c empaque.tar.gz | tar -xvpf -x archivo A.txt, 0 bytes, 0 media blocks.x archivo.part.txt, 0 bytes, 0 media blocks.x archivo.txt, 0 bytes, 0 media blocks.x archivo23.txt, 0 bytes, 0 media blocks.


x archivoA.txt, 105 bytes, 1 media blocks.x archivoAB.txt, 919 bytes, 2 media blocks.x archivoE.txt, 105 bytes, 1 media blocks.x archivoZ.txt, 105 bytes, 1 media blocks.x archivoaB.txt, 220 bytes, 1 media blocks.x archivoab.txt, 220 bytes, 1 media blocks.

En el séptimo caso de los ejemplos se usa la misma combinación de gunzip para descomprimir y de tar con la opción x y f- para recuperar los archivos contenidos en una copia de respaldo comprimida. Como se incluye la opción p, tar recuperará con todos los atributos de archivo -incluso con el dueño adecuado a menos que no se use el usuario root para recuperar-.


Comandos varios

Existen muchísimos comandos útiles en UNIX. Muchos son muy prácticos a la hora de hacer scripts de shell.

Comando host

El sencillo comando host se usa básicamente para hacer ejercicio del sistema de resolución de nombres de un sistema UNIX. La sintaxis básica es:

host dirección

ohost nombre

Ejemplos:

e@abe:e/> host moeMoe.lan is 192.168.1.8, Aliases: moe, ramone@abe:e/> host 192.168.1.254gateway is 192.168.1.254, Aliases: gw

Comando hostname

El sencillo comando hostname se usa para configurar o consultar el nombre de la máquina UNIX actual. La sintaxis es:

hostname

ohostname NuevoNombre

Ejemplo:

e@abe:e/> hostnameabe

Comando uptime

El comando uptime muestra la información de “vida” del sistema donde se corre. El comando muestra la hora en que se ejecuta, cuánto lleva el sistema desde que se inició, el número de usuarios conectados con sesión interactiva, y la carga promedio en el último período de 1 minuto, 5 minutos y 15 minutos. La carga promedio es el número de procesos en estado activo durante el período.

Ejemplo:

e@abe:e/> uptime 12:00AM up 1 day, 9:20, 10 users, load average: 0.24, 0.10, 0.10


Comando du

El comando du (disk usage) se usa para obtener cuánto espacio en disco ocupan unos archivos y/o directorios. Cuando se indican directorios el comando calcula cuánto ocupan en disco los archivos contenidos dentro del directorio mas lo que ocupa el directorio en sí. La sintaxis de du es:

du [ -a | -s ] [ -k | -m | -g ] [ -H ] [ archivo ... ]

Donde:

La opción a se usa para que du reporte por cada archivo contenido en los directorios dados como argumentos, o en directorio actual si no se da como argumento. El comando du reporta siempre por cada uno de los argumentos dados, aunque sean archivos.

La opción s se usa para que du reporte un resumen total del espacio ocupado por todos los argumentos dados. El comando reportará el resumen del directorio actual si no se le dan argumentos.

La opción k se usa para que el reporte generado por du esté dado en kilobytes.

La opción m se usa para que el reporte generado por du esté dado en megabytes.

La opción g se usa para que el reporte generado por du esté dado en gigabytes.

La opción H se usa para que du siga los enlaces simbólicos y tenga en cuenta el espacio ocupado por lo apuntado por el enlace simbólico.

Si no se dan ni k ni m ni g el comando du reportará en bloques de 512B sin importar el formato en que estén almacenados los archivos en disco.

Si a du no se le dan argumentos (ni archivos ni directorios) usará el directorio actual como argumento.

Ejemplos:e@abe:e/> du0 ./.ssh0 ./subdir1/Antiguo_SubDir64 ./subdir1640 .e@abe:e/> du -ms /tmp /etcdu: /tmp/lost+found: The file access permissions do not allow the specified action.du: /tmp/wsmdata.196726: The file access permissions do not allow the specified action.122.36 /tmpdu: /etc/tunables: The file access permissions do not allow the specified action.16.36 /etc


Comando sum

El comando sum muestra la suma de chequeo y cuántos bloques mide cada uno de los archivos dados como parámetros. Normalmente se usa para verificar que un archivo recién transmitido transmitió y se recibió bien. Si a sum no se le dan archivos como argumentos usará la entrada estándar. La sintaxis básica de sum es:

sum [ archivo ... ]

Ejemplos:e@abe:e/> sum Meses.txt /etc/passwd46778 1 Meses.txt41837 1 /etc/passwd

El comando sum usa un algoritmo estándar aparecido en BSD Unix 4.3.

Comando cksum

El comando cksum muestra la suma de chequeo calculada según un algoritmo más moderno de 32 bits y cuántos bytes mide cada uno de los archivos dados como parámetros. Normalmente se usa para verificar que un archivo recién transmitido transmitió y recibió bien. Si a cksum no se le dan archivos como argumentos usará la entrada estándar. La sintaxis de cksum es:

cksum [ archivo ... ]

Ejemplos:e@abe:e/> cksum Meses.txt /etc/passwd1927595220 175 Meses.txt3518703885 676 /etc/passwd

El comando cksum usa el algoritmo estándar de verificación CRC que se usa para verificar las tramas ethernet.

Comando true

El comando true devuelve un código de retorno verdadero siempre. No muestra ningún tipo de salida. Sintaxis:

true

Ejemplo:e@abe:e/> true && echo Devuelve VERDADERODevuelve VERDADERO

Existe un comando false que siempre devuelve un código de retorno falso.


Comando yes

El comando yes genera una infinita cantidad de líneas de texto yes cuando se ejecuta. La idea es usarlo redirigido a un comando que está esperando una respuesta positiva. Según el idioma en que se esté trabajando es posible que genere otro texto como respuesta. Sintaxis:

yes [ texto ]

Si se da un texto como argumento, el comando yes genera infinitas líneas repitiendo el texto dado como argumento.


Uso avanzado del intérprete de comandos:

Uso del intérprete como un lenguaje de programación

Una de las más poderosas características de UNIX no es una característica de UNIX, es una característica del intérprete de comandos estándar en UNIX. El intérprete estándar de comandos de UNIX (sea Bourne Shell, Bourne Again Shell, o sea Korn Shell, o sean los otros) siempre recibe los comandos y características que permiten la programación. Aunque existen características, sentencias y comandos que tienen sentido cuando se está en medio de un código programado, todas las sentencias y comandos del intérprete pueden ser usadas en todo momento; es decir, no hay que hacer que el shell esté en un modo especial para programar, ni hay ciertas características que funcionan es cuando el shell las encuentra en un archivo programado.

Desarrollo de shell scripts

El desarrollo de pequeñas -o grandes- rutinas programadas, o utilidades específicas a una instalación se beneficia enormemente de lo que se denominan shell scripts. Estos son archivos de texto que contienen comandos UNIX, y que muy comúnmente harán uso de comandos que se constituyen en las sentencias de control de un lenguaje de programación muy fácil y a la vez muy poderoso. Como todos los comandos -instalados originalmente o no- que haya disponibles en un sistema UNIX son usables desde el intérprete de comandos entonces dentro de un archivo de comandos del intérprete de comandos se pueden usar, así todos los comandos que hayan en un sistema son usables por el lenguaje, como si fueran originales.

Hay dos detalles básicos que hacen más fácil el uso de un shell script:

Que sea ejecutable. Si un script del shell no es ejecutable pero es legible por el usuario el mismo lo podrá usar, pero solo si lo usa con el nombre del intérprete como prefijo: ksh /nombre/archivo/script o aún sh /nombre/script; pero será más cómodo si al script sólo hay que invocarlo por su nombre, sin necesidad de el mencionado prefijo.

Que el sistema pueda encontrarlo en el PATH. Si un shell script no está encontrable en alguno de los directorios de la variable PATH del usuario al usuario le tocará invocarlo por su nombre completo: /nombre/shellscript; pero será más cómodo para el usuario si el sistema lo encuentra fácil: shellscript.

Pregunta: cómo se hace que un script de shell sea al mismo tiempo legible y ejecutable?

Pregunta: cómo se ajusta la variable PATH del usuario permanentemente?


Pruebas lógicas: test

Una de los más básicos elementos dentro de un ambiente de programación son las pruebas lógicas. El lenguaje del shell tiene la posibilidad de hacer pruebas lógicas de una manera muy sencilla: a través del comando test.

El comando test recibe una o más condiciones lógicas y devuelve un código de retorno cero (0) considerado como verdadero si la prueba lógica da verdadero, y devuelve diferente de cero si la prueba lógica da falso. La sintaxis básica es muy sencilla:

test pruebaLógica

o[ pruebaLógica ]

Donde:

El comando test es equivalente a [.

El comando test ignora el ] final.

Si se usa la sintaxis [ ] hay que recordar que es un comando con argumentos, así que los espacios son obligatorios.

El comando test devuelve verdadero a través de un código de retorno cero (0), no genera mensajes por salida.

El comando test devuelve falso a través de un código de retorno diferente de cero, no genera mensajes por salida, a menos que haya errores de sintaxis.

Existen muchas clases de pruebas lógicas, que se detallan a continuación.

Pruebas lógicas básicas

El comando test tiene una serie de operaciones lógicas básicas, que aunque tienen un “aspecto extraño” cuando se usan con test tienen mucho “mejor apariencia” cuando se usan con la sintaxis [ ]:

‣ expresión devuelve verdadero si expresión devuelve verdadero.

‣ comando devuelve verdadero si comando devuelve verdadero (0).

‣ ! expresión (~) devuelve verdadero si expresión devuelve falso.

‣ cadena1 = cadena2 (≡) devuelve verdadero si cadena1 (de texto) es igual a cadena2 (de texto).

‣ cadena1 == cadena2 (≡) devuelve verdadero si cadena1 (de texto) es igual a cadena2 (de texto).


‣ cadena1 != cadena2 (≢) devuelve verdadero si cadena1 (de texto) es diferente de cadena2 (de texto)

‣ expr1 -a expr2 (⊼) devuelve verdadero si expr1 es verdadero y expr2 es verdadero también. Si expr1 es falso expr2 nunca se ejecuta.

‣ expr1 -o expr2 (⊻) devuelve verdadero si expr1 es verdadero o si expr2 es verdadero. Si expr1 es verdadero expr2 nunca se ejecuta.

‣ expr1 -eq expr2 (=) devuelve verdadero si el valor numérico de expr1 es igual al valor numérico de expr2.

‣ expr1 -ne expr2 (≠) devuelve verdadero si el valor numérico de expr1 no es igual al valor numérico de expr2.

‣ expr1 -gt expr2 (>) devuelve verdadero si el valor numérico de expr1 es mayor que el valor numérico de expr2.

‣ expr1 -lt expr2 (<) devuelve verdadero si el valor numérico de expr1 es menor que el valor numérico de expr2.

‣ expr1 -ge expr2 (≥) devuelve verdadero si el valor numérico de expr1 es mayor o igual que el valor numérico de expr2.

• expr1 -le expr2 (≤) devuelve verdadero si el valor numérico de expr1 es menor o igual que el valor numérico de expr2.

Ejemplos:e@abe:e/> [ $(whoami) = "root" ] && echo "Estoy conectado como root!"e@abe:e/> [ $(whoami) != "root" ] && echo "No estoy conectado como root!" No estoy conectado como root!

Los dos primeros casos de los ejemplos muestran el uso de la prueba lógica “igual que” y “no igual que” en el comando test. Como el comando test no muestra salida (sólo muestra salida de errores cuando hay errores de sintaxis) se usan las construcciones lógicas del shell de ejecución condicional (&&) para generar un mensaje en caso de que se necesite.

e@abe:e/> ps PID TTY TIME CMD 73924 pts/0 0:00 -bash 233706 pts/0 0:00 ps 315406 pts/0 0:00 -ksh e@abe:e/> echo $$315406e@abe:e/> [ $$ -gt 1000 ] && echo "Mi numero de proceso es mayor que mil"Mi numero de proceso es mayor que mil


El caso tres de los ejemplos muestra el uso del operador lógico numérico “mayor que” del comando test. Igual que antes se usa ejecución condicional en el shell para generar un mensaje con echo.

e@abe:e/> groupssystem staff security audit perf shutdowne@abe:e/> groups | wc -w 6e@abe:e/> [ $(groups | wc -w) -lt 10 ] && echo "Mi usuario esta en menos de diez grupos"Mi usuario esta en menos de diez grupos

El caso cuatro de los ejemplos muestra el uso combinado de sustitución de comandos dentro de test y del uso del operador “menor que “del comando test. Como en todos los ejemplos, se usa ejecución condicional en el shell para generar un mensaje con echo.

Pruebas lógicas con cadenas de texto

Además de las básicas (como cadena1 = cadena2), el comando test implementa también:

‣ “cadena” devuelve verdadero si cadena no es nula.

‣ -n “cadena” devuelve verdadero si cadena tiene longitud mayor que cero.

‣ -z “cadena” devuelve verdadero si cadena tiene longitud exactamente igual a cero.

Ejemplos:e@abe:e/> [ $(whoami) ] && echo "Tengo usuario!"Tengo usuario!

El primer caso de los ejemplos muestra el uso de “cadena” en el comando test.e@abe:e/> [ -n "$LOGNAME" ] && echo "Estoy conectado!"Estoy conectado!

El segundo caso de los ejemplos muestra el uso del operador lógico n del comando test.

Pruebas lógicas con archivos

Mucha de la funcionalidad del lenguaje de programación del shell gira alrededor de las necesidades del administrador del sistema. Así, como la administración normalmente manipula archivos, el comando básico test tiene implementadas unas series de pruebas con archivos:

‣ -r archivo devuelve verdadero si el usuario tiene permiso de lectura sobre el archivo.

‣ -w archivo devuelve verdadero si el usuario tiene permiso de escritura sobre el archivo.


‣ -x archivo devuelve verdadero si el usuario tiene permiso de ejecución sobre el archivo.

‣ -f archivo devuelve verdadero si archivo existe y es un archivo común.

‣ -d directorio devuelve verdadero si archivo existe y es un directorio.

‣ -c archivo devuelve verdadero si archivo existe y es dispositivo de caracteres.

‣ -b archivo devuelve verdadero si archivo existe y es dispositivo de bloque.

‣ -s archivo devuelve verdadero si archivo existe y tiene tamaño mayor que cero.

‣ -t número devuelve verdadero si el descriptor de archivo número está asociado a una terminal. Si no se da número asume 1 (la salida estándar).

Ejemplos:e@abe:e/> [ -r /etc/passwd ] && echo "/etc/passwd debe ser legible."/etc/passwd debe ser legible.e@abe:e/> [ -w /etc/passwd ] || echo "/etc/passwd no debe ser escribible"e@abe:e/> ls -l /etc/passwd-rw-rw-r-- 1 root system 676 Sep 17 14:40 /etc/passwd

El primer caso de los ejemplos muestra cómo se puede probar si el usuario actual -con el que se ejecuta test- tiene permisos para leer o escribir un archivo (o directorio).

e@abe:e/> [ -d /etc/security -a -x /etc/security ] && echo "Puedo entrar a /etc/security" Puedo entrar a /etc/security

El segundo caso muestra cómo comprobar que se tiene un directorio y que se tienen permisos para entrar al mismo (usando los operadores de prueba lógica d y x), además muestra el uso del operador lógico a (AND).

e@abe:e/> [ -b /dev/hdisk3 ] && echo "El dispositivo hdisk3 existe"El dispositivo hdisk3 existe

El tercer caso muestra cómo comprobar la disponibilidad de un cierto dispositivo de bloques en el sistema (el caso se basa en un dispositivo disco en AIX).

e@abe:e/> [ -t ] && echo "Estoy trabajando en una terminal interactiva" Estoy trabajando en una terminal interactiva

El cuarto caso muestra cómo comprobar si se está trabajando interactivamente. En caso de que haya una redirección [ -t ] devuelve falso.


Operadores y Operaciones: expr

El intérprete de comandos implementa un lenguaje de programación, y como podremos imaginar hay tres cosas básicas que manejar en cualquier lenguaje de programación: valores lógicos, información textual e información numérica. El shell realmente no está hecho para alto procesamiento matemático, ya que las operaciones deben realizarse apoyadas en un comando que veremos a continuación: expr.

El comando expr recibe unos operandos y operaciones como argumentos, realiza la operación y la reporta por salida estándar, así que deberán usarse las facilidades del shell para capturar la salida si la queremos usar, en especial si la necesitamos almacenada en alguna variable. La sintaxis es muy sencilla:

expr operando operador operando ...

Donde:

El comando necesita hacer las operaciones sobre varios argumentos, así que hay que separárselos con espacios.

Las operaciones básicas son suma (+), resta (-), multiplicación (*), división entera (/), módulo o residuo (%). Como el * de la multiplicación es también un comodín del shell, hay que “escaparlo” para que el shell no lo interprete como “todos los archivos”, usando \*.

oper1 | oper2 retorna el valor de oper1 si no es nulo y no es cero, en ambos casos retornando el valor de oper2. Como el símbolo | es especial en el shell entonces habrá que usarlo “con escape” \|.

oper1 & oper2 retorna el valor de oper1 si ambos valores son diferentes de nulo y de cero, de lo contrario devuelve cero. Como el símbolo & es especial en el shell, entonces habrá que usarlo “con escape” \&.

cadena : exprReg2 retorna cuántos caracteres de cadena cumplen con la expresión regular exprReg2, asumiendo que está anclada al comienzo (como si tuviera un símbolo ^). Si no concuerda retorna un cero (0). Si se usan paréntesis para captura devuelve lo capturado. Como las expresiones comúnmente tienen símbolos con significado especial en el shell normalmente exprReg2 está encerrada en ' '. Para captura se usan paréntesis con escape .

match cadena exprReg2 exactamente equivalente a cadena : exprReg2.

length cadena retorna la longitud -en caracteres- de cadena.

index cadena1 cadena2 retorna la primera posición en cadena1 donde cualquier caracter en cadena2 existe.


substr cadena inicio cuántos retorna la subcadena tomada de cadena iniciada en la posición inicio y con longitud cuántos caracteres.

Ejemplos:e@abe:e/> i=1e@abe:e/> i=$(expr $i + 1)e@abe:e/> echo $i2

El caso uno de los ejemplos muestra cómo realizar operaciones matemáticas básicas con las variables del shell: usando variable=$(expr operaciones ...). Nótese cómo debe usarse sustitución de comandos, sustitución de variables y espacios para separar los operandos y los operadores.

e@abe:e/> CADENA="Nombre Propio"e@abe:e/> echo "Longitud =" $(expr length $CADENA)expr: 0402-050 Syntax error.Longitud =e@abe:e/> echo "Longitud =" $(expr length "$CADENA") Longitud = 13

El caso dos de los ejemplos muestra cómo es fácil cometer un error de sintaxis con expr. En nuestro ejemplo, la variable de texto contiene dos palabras, pero la operación length de expr espera un único operando -argumento- por lo que devuelve Syntax error. Se usan las comillas dobles para que el shell pase un único argumento al comando expr, pero que al mismo tiempo, la variable esté evaluada.

e@abe:e/> CADENA="Nombre Propio"e@abe:e/> set -o vie@abe:e/> echo "Longitud =" $(expr length '$CADENA')Longitud = 7

En el caso tres de los ejemplos se muestra cómo se evalúa la longitud de $CADENA no la longitud de los contenidos de la variable CADENA si se usan comillas sencillas!.

e@abe:e/> RESP=se@abe:e/> if expr "$RESP" : "[yYsS]" >/dev/nullthenecho RESP comienza con "y", "Y", "s" o "S"fiRESP comienza con y, Y, s o S

El caso cuatro de los ejemplos muestra cómo usar el operador : (match) de expr. Si la primera cadena argumento concuerda con la expresión regular del segundo argumento expr devuelve la longitud de lo que concuerda y además retorna un cero (verdadero), así que el if se cumple. Como de pronto no conviene ver el 1 que reporta expr, se hace redirección a /dev/null.

e@abe:e/> if VAL=$(expr "$RESP" : '$[yYsS]$')then


echo "RESP begins with 'y', 'Y', 's' o 'S'" echo "VAL=$VAL"fiRESP begins with 'y', 'Y', 's' o 'S'VAL=S

El quinto caso de los ejemplos muestra que se puede capturar la salida de expr para usarla después. En este caso se usa una expresión regular que contiene  para capturar el texto de la concordancia.

e@abe:e/> expr 7 / 23

El sexto caso muestra cómo expr sólo hace cálculos con enteros.e@abe:e/> expr index abcdef fd4

El séptimo caso muestra el uso de la operación index del comando expr.e@abe:e/> expr substr "Goodnight Ladies" 11 6Ladies

El octavo caso de los ejemplos muestra el uso de la operación substr el comando expr.


Comandos de control de flujo: if, then, else & fi

Todo lenguaje de programación necesita sentencias de control de flujo. Como en el shell todo se basa en comandos, lo que aquí tenemos son comandos de control de flujo, el primero que veremos de los mismos es if. Hay varios estilos de la sintaxis:

if comandoCondiciónthen Comandos si verdadero ...fi

o tambiénif comandoCondiciónthen Comandos si verdadero ...else Comandos si falso ..fi

pero tambiénif comandoCondiciónthen Comandos si verdadero ...elif comandoCondicion2 Comandos si Condición2 verdadera ...else Comandos si falso ...fi

Donde:

La sentencia de control if ejecuta comandoCondición y analiza el código de retorno. Si devuelve verdadero (es decir 0), ejecuta lo anidado (Comandos si verdadero). Si hay una parte else y el comandoCondición devuelve falso (es decir no 0) ejecuta lo anidado (Comandos si falso).

La sentencia de control if puede simular una sentencia “case ... select” de otros lenguajes de programación a través de la parte elif comandoCondición2.

La sentencia de control if termina con un fi.

Ejemplos:

if [ "$VAL" = "Y" ]More...then


More... echo VAL igual YMore...elif [ "$VAL" = "S" ]More...thenMore... echo VAL igual SMore...elseMore... echo VAL igual a otra cosaMore...fiVAL igual S

En el caso uno de los ejemplos se observa el uso más típico del comando test: combinado como comandoCondición con el comando if.

e@abe:e/> if grep -q root /etc/passwdMore...thenMore... echo root existe en /etc/passwdMore...firoot existe en /etc/passwd

En el caso dos de los ejemplos se observa cómo cualquier comando es válido para usar con if, aunque hay que verificar que el comando si devuelve códigos de retorno que tengan sentido. En el caso del ejemplo, grep devuelve verdadero si la expresión regular del primer argumento está o se encuentra entre las líneas de los archivos dados.


Comandos de control de flujo: for, do & done

Normalmente una computadora es útil para tareas repetitivas. Una tarea que no se repite no amerita programación la verdad. Existen varias maneras de llevar a cabo tareas repetitivas en el shell. La primera manera que veremos es la de repetir una tarea un número finito dado de veces, usando una ligera variación en un valor en cada una de las repeticiones. Para este estilo de repeticiones existe el comando for en el shell. La sintaxis es muy sencilla:

for variable in listado comandos ...done

Donde:

El comando for creará una nueva variable si no existe.

El comando for inicia tomando el primer valor de lista, asignándolo a variable y ejecutando todos los comandos anidados.

El comando for prosigue tomando el siguiente valor de lista, asignándolo a variable y ejecutando todos los comandos anidados.

El comando for termina con la ejecución donde variable tiene el último valor de lista.

La secuencia de comandos del shell continúa en la línea que sigue a done.

Ejemplos:

e@abe:e/> for i in 1 2 3 4More...doMore... echo $iMore...done1234

El caso del ejemplo muestra lo básico del comando for. Nótese cómo la lista se le da literal, expandida, for no recibe un rango y fabrica los elementos.

e@abe:e/> for FIL in *.tsvMore...doMore... echo "Archivo: $FIL"More...doneArchivo: Celulares.tsvArchivo: Empresas.tsv


En el segundo caso de los ejemplos se observa cómo puede aprovecharse que las sustituciones de comodines del shell generan listas de nombres de archivos, así que pueden usarse con el comando for.


Comandos de control de flujo: while, do & done

Otro estilo de estructura de ejecución repetitiva no tiene los elementos prefabricados, así que no se sabe inicialmente cuántas repeticiones habrá que hacer. Lo que sí se sabe es cuándo hay que seguir repitiendo o cuándo hay que parar. Para este estilo de repetición existe el comando de shell while. Es también muy sencillo (tal vez más que for):

while comandoCondicióndo comandos ...done

Donde:

El comando while ejecuta al comandoCondición y analiza si el código de retorno es verdadero.

Mientras el código de retorno de comandoCondición sea verdadero el comando while ejecutará todos los comandos anidados.

Cada vez que termina un ciclo de comandos anidados el comando while re-ejecuta comandoCondición, analizando nuevamente si el código de retorno es verdadero.

Cuando el comandoCondición retorne diferente de verdadero el comando while dejará de ejecutar los comandos anidados y terminará. La ejecución continúa en la línea que sigue a done.

Ejemplos:

e@abe:e/> while who | grep -q rootMore...doMore... write root << FINMore... Hola rootMore...FINMore... sleep 30More...donee@abe:e/>

El caso de los ejemplos ejecuta un comando who, y un comando grep que busca a root dentro de la lista de usuarios generada por who. El comando ejecutará los anidados write y sleep mientras se encuentre a root conectado como usuario.

Estando dentro de un ciclo for o un ciclo while puede romperse usando el comando break. Este incondicionalmente se sale del ciclo y continúa en la línea que sigue al done:

e@abe:e/> i=1e@abe:e/> while truedo printf $i


i=$(expr $i + 1) [ $i -eq 5 ] && break echo -- -done1 -2 -3 -4

En el ejemplo se muestra el uso del comando break. Nótese cómo se sale inmediatamente del ciclo while, ni siquiera pasa por el comando echo que sigue.


Manipulación de variables: let

Como la manipulación aritmética de variables usando sustitución de variables y sustitución de comandos apoyándose en expr es supremamente incómoda, los intérpretes que cumplen POSIX -como Korn Shell- incluyen el comando let. El comando let permite el trabajo aritmético con variables sin necesidad de estar usando el prefijo $ por ejemplo, además sabe reconocer las expresiones aún cuando no están separadas por espacios.

La sintaxis de let es sencilla:let expresión

olet variable=expresión

o también(( expresión ))

Donde:

El comando let y la construcción (( )) son equivalentes.

El comando let devuelve verdadero si las operaciones de las expresiones pudieron ejecutarse y no resultaron en cero (0).

El comano let soporta muchos operadores, a saber:

‣ -expr el negativo de expr

‣ !expr 0 cuando expr es diferente de cero, de lo contrario 1

‣ ~expr el complemento de expr

‣ expr1 * expr2 producto de expr1 y expr2

‣ expr1 / expr2 cociente de expr1 entre expr2

‣ expr1 % expr2 residuo de dividir expr1 entre expr2

‣ expr1 + expr2 suma de expr1 más expr2

‣ expr1 - expr2 diferencia de expr1 con expr2

‣ expr1 << expr2 desplazamiento de expr2 bits a la izquierda de expr1

‣ expr1 >> expr2 desplazamiento de expr2 bits a la derecha de expr1

‣ expr1 <= expr2 1 si expr1 es menor o igual que expr2, de lo contrario 0

‣ expr1 < expr2 1 si expr1 es menor que expr2, de lo contrario 0

‣ expr1 > expr2 1 si expr1 es mayor que expr2, de lo contrario 0

‣ expr1 >= expr2 1 si expr1 es mayor o igual que expr2, de lo contrario 0


‣ expr1 == expr2 1 si expr1 es igual que expr2, de lo contrario 0

‣ expr1 != expr2 1 si expr1 no es igual que expr2, de lo contrario 0

‣ expr1 & expr2 AND de los bits de expr1 con los bits de expr2

‣ expr1 | expr2 OR de los bits de expr1 con los bits de expr2

‣ expr1 ^ expr2 XOR de los bits de expr1 con los bits de expr2

‣ expr1 && expr2 1 si tanto expr1 como expr2 son no-cero, de lo contrario 0

‣ expr1 || expr2 1 si alguno de expr1 o expr2 es no-cero, de lo contrario 0

‣ var = expr asigna el valor de expr a la variable var

‣ var += expr agrega el valor de la expresión expr al valor actual de la variable var

‣ var -= expr resta el valor de la expresión al valor actual de la variable

‣ var *= expr multiplica el valor de la variable por el valor de la expresión

‣ var /= expr divide el valor de la variable entre el valor de la expresión

‣ var %= expr asigna a la variable el valor de dividirla por el valor de la expresión

‣ var <<= expr desplaza el valor de la variable expr bits a la izquierda

‣ var >>= expr desplaza el valor de la variable expr bits a la derecha

‣ var &= expr asigna a la variable el resultado de var & expr

‣ var |= expr asigna a la variable el resultado de var | expr

‣ var ^= expr asigna a la variable el resultado de var ^ expr

Ejemplos:e@abe:e/> let i=1e@abe:e/> let i+5*4 e@abe:e/> echo $i1e@abe:e/> let i=i+5*4e@abe:e/> echo $i21e@abe:e/> let i=5 j=4e@abe:e/> if (( i*j<25 ))More...thenMore... echo "i*j es menor que 25"More...fii*j es menor que 25

Como se observa en los ejemplos, el comando let permite definir variables. De paso las variables quedan definidas como enteras. El comando let deja hacer operaciones aunque el


valor se pierda, se nota que no reporta resultados por salida estándar; este estilo de uso sólo tiene aplicación real cuando sirve de comandoCondición para if o para while. Más adelante se muestra cómo hacer operaciones con let permite ahorrarse $ en la sustitución de variables, y permite ahorrarse $( ) para la sustitución de comandos. Además, no importan tanto los espacios entre operando y operador.

En los ejemplos también se muestra cómo se pueden definir y redefinir varias variables en una sola invocación del comando let. Posteriormente se muestra cómo usar la sintaxis alterna (( )) equivalente a let. Esta sintaxis no solo es más clara, si no que no es necesario hacer escape de los símbolos que let usa para aritmética como | o >.
