Fundamentos de Linux Ver.0.9
-
Upload
giss-cartagena -
Category
Documents
-
view
112 -
download
0
Transcript of Fundamentos de Linux Ver.0.9
Índice de contenidoCapítulo 1 Introducción...............................................................................................................7
1. Descripción del Capítulo.......................................................................................................92. Historia de Unix...................................................................................................................103. Movimiento Open Source....................................................................................................15
Definición de Open Source................................................................................................153.1 GNU..............................................................................................................................183.2 FSF (Free Software Foundation)...................................................................................193.3 GPL (GNU General Public License) ó 'copyleft'............................................................203.4 Tipos de Licencias en Linux..........................................................................................20
4. Orígenes de Linux...............................................................................................................245. Características de Linux......................................................................................................266. Distribuciones mas conocidas.............................................................................................28
Mandrake............................................................................................................................28RedHat................................................................................................................................29LGIS Linux..........................................................................................................................29Knoppix...............................................................................................................................29Gentoo................................................................................................................................29Debian.................................................................................................................................30Slackware............................................................................................................................30SuSE...................................................................................................................................30Lycoris Desktop/LX.............................................................................................................31Lindows...............................................................................................................................31Xandros...............................................................................................................................31Linux From Scratch.............................................................................................................31Fedora Core........................................................................................................................31
7. Estándares..........................................................................................................................32Linux Standard Base ( LSB )...............................................................................................32Filesystem Hierarchy Standard (FHS).................................................................................34Li18nux................................................................................................................................35
8. Ambientes...........................................................................................................................368.1 Shells............................................................................................................................378.2 Gráficos.........................................................................................................................39
Capacidades...............................................................................................................40Características más notorias......................................................................................40
9. Acceso al sistema...............................................................................................................42Evaluación Capítulo................................................................................................................43
Fundamentos de Linux 1
Capítulo 2 Manipulación de Archivos......................................................................................47
Conceptos...............................................................................................................................49Tipos de archivos................................................................................................................502.2 Estructura básica .........................................................................................................522.3 Nombres de archivos....................................................................................................55
3 Manejo de directorios...........................................................................................................573.1 Comandos básicos........................................................................................................573.2 Home directory..............................................................................................................623.3 Directorio actual............................................................................................................633.4 Ruta absoluta................................................................................................................643.5 Ruta relativa..................................................................................................................65
4. Visualización y manejo de archivos.....................................................................................674.1 Creación y organización de archivos............................................................................674.2 Visualización de archivos de texto................................................................................724.3 Visualización de archivos de datos...............................................................................754.4 Caracteres de expansión de nombres..........................................................................774.5 Búsqueda de archivos...................................................................................................794.6 Comparación de archivos .............................................................................................81
Evaluación Capítulo................................................................................................................84
Capítulo 3 Edición de Archivos................................................................................................87
1 Descripción del capítulo.......................................................................................................892 Editores de texto..................................................................................................................90
2.1 Uso................................................................................................................................902.2 Editores de texto comunes en Linux ............................................................................91
Vi & Vim..................................................................................................................................943.1 Iniciando vi....................................................................................................................943.2 Modos de operación......................................................................................................943.3 Terminación de vi y salvado de archivos .....................................................................963.4 Comandos para movimiento del cursor ........................................................................973.5 Comandos para inserción de texto................................................................................993.6 Editando texto (cambiando, borrando)........................................................................1013.7 Copiado y pegado de texto ........................................................................................1033.8 Búsqueda de texto .....................................................................................................1043.9 Opciones de configuración..........................................................................................105
Evaluación Capitulo...............................................................................................................107
2 Fundamentos de Linux
Capítulo 4 Linea de comandos...............................................................................................109
1 Descripción del capítulo.....................................................................................................1112 Interfaces linea de comando..............................................................................................112
2.1 Definición de CLI y/o SHELL.......................................................................................1122.2 Shells en Unix y Linux.................................................................................................1142.3 Bash shell....................................................................................................................118
Evaluación Capítulo..............................................................................................................141
Capítulo 5 Interfaces Gráficas................................................................................................145
1 Descripción del capítulo.....................................................................................................1472 Introducción........................................................................................................................148
2.1 Conceptos básicos......................................................................................................1482.2 Evolución GUI's...........................................................................................................150
3 X Window ..........................................................................................................................1523.1 Función.......................................................................................................................1523.2 Arquitectura.................................................................................................................1523.3 Implementaciones.......................................................................................................1593.4 Inicio de X Window......................................................................................................1603.5 Archivos y Herramientas de Configuración.................................................................164
4 KDE....................................................................................................................................1664.1 Descripción.................................................................................................................1664.2 Iniciando KDE.............................................................................................................1664.3 Componentes..............................................................................................................1664.4 Herramientas de Configuración...................................................................................170
5 GNOME..............................................................................................................................1715.1 Descripción.................................................................................................................1715.2 Iniciando GNOME.......................................................................................................1715.3 Componentes..............................................................................................................1715.4 Herramientas de Configuración...................................................................................173
Capítulo 6 Impresión de Archivos..........................................................................................175
1 Descripción del capitulo......................................................................................................1772 Sistemas de impresión ......................................................................................................178
2.1 LPD.............................................................................................................................1792.2 LPRNG........................................................................................................................180
2.3 CUPS..............................................................................................................................1803 Impresión de Archivos........................................................................................................184Evaluación Final....................................................................................................................191
Fundamentos de Linux 3
Capítulo 7 Manejo de Permisos..............................................................................................193
1 Descripción del capítulo.....................................................................................................1952 Usuarios y grupos en Linux................................................................................................196
2.1 Descripción.................................................................................................................1962.2 Atributos .....................................................................................................................1962.3 Archivo /etc/passwd....................................................................................................1992.4 Archivo /etc/shadow....................................................................................................2012.5 Archivo /etc/group.......................................................................................................203
3 Permisos sobre archivos....................................................................................................2043.1 Propietarios.................................................................................................................2043.2 Permisos.....................................................................................................................207
4 Evaluación del capítulo......................................................................................................215
Capítulo 8 Manejo de entrada/salida......................................................................................219
1 Descripción del capítulo.....................................................................................................2212 Conceptos..........................................................................................................................222
2.1 Descriptores de archivos.............................................................................................2222.2 Entrada estándar (standard input) ..............................................................................2232.3 Salida estándar (standard output)...............................................................................2242.4Error estándar (standard error)....................................................................................224
2 Redireccionamiento............................................................................................................2254 Tuberías (Pipes).................................................................................................................2315 Comando tee......................................................................................................................2326 Evaluación del capitulo.......................................................................................................234
Capítulo 9 Procesamiento de Archivos de texto con filtros................................................237
1 Descripción del capítulo.....................................................................................................2392 Definición de filtros.............................................................................................................2403 Extracción de información..................................................................................................2424 Formateo de archivos.........................................................................................................2485 Combinación de archivos...................................................................................................2526 Sustitución de texto............................................................................................................2597 Ordenamiento.....................................................................................................................2618 Otros comandos.................................................................................................................264Evaluación Capítulo..............................................................................................................268
4 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares..........................................................................271
1 Descripción del capítulo.....................................................................................................273Definición de expresión regular.............................................................................................2743 Cómo se construye una expresión regular.........................................................................276
Metacaracteres.................................................................................................................276Clases...............................................................................................................................278Literales.............................................................................................................................279Cuantificadores.................................................................................................................279Anclajes.............................................................................................................................280Alternativas.......................................................................................................................280
Expresiones regulares extendidas........................................................................................2814. Búsqueda de texto (grep)..................................................................................................2825. Procesamiento de flujo de texto........................................................................................285
Editor de lineas ed............................................................................................................285Comando sed....................................................................................................................289
6. Uso de expresiones regulares en vi..................................................................................2957. Evaluación del capítulo.....................................................................................................301
Capítulo 11 Control de Procesos...........................................................................................305
1 Descripción del capítulo.....................................................................................................3072 Definición de proceso ........................................................................................................3083 Ciclo de vida.......................................................................................................................3094 Estados de un proceso.......................................................................................................3115 Visualización de procesos..................................................................................................3136 Control de procesos...........................................................................................................316
6.1 Procesos en “Foreground” y “Background”.................................................................3166.2 Envío de señales.........................................................................................................3216.4 Manejo de prioridades.................................................................................................324
7 Programación de procesos para su ejecución posterior.....................................................3279. Programación de procesos para ejecución periódica........................................................332Evaluación Capítulo..............................................................................................................334
Fundamentos de Linux 5
Capítulo 12 Documentación...................................................................................................337
1 Descripción del capítulo.....................................................................................................3392 Ayuda del Sistema.............................................................................................................340
2.1 Comando man.............................................................................................................3402.2 Comandos apropos y whatis.......................................................................................3452.3 Configuración del man................................................................................................346
3. Acceso a documentos en el sistema.................................................................................3484. Documentación en Internet...............................................................................................350
6 Fundamentos de Linux
Capítulo 1 Introducción
Capítulo 1Introducción
Fundamentos de Linux 7
Capítulo 1 Introducción
8 Fundamentos de Linux
Introduccion
DESCRIPCIÓN
Historia de Unix¿Qué es OpenSource?
FSF, GNU y GPLTipos de LicenciasOrígenes de Linux
Características de LinuxDistribuciones
EstándaresInterfaces y acceso al Sistema
Capítulo 1 Introducción
1. Descripción del Capítulo
En el presente capítulo se introduce al alumno a los antecedentes e historia de Linux y Unix, y
se describen los términos mas importantes del Vocabulario de Linux.
Al terminar el capítulo el alumno conocerá la historia de Unix y Linux así como los términos de
OpenSource, GNU, GPL, FSF, y licenciamientos existentes en Linux, conocerá también las
interfaces del Sistema y como acceder a este.
Los tópicos a ver son:
• Historia de Unix
• ¿Que es OpenSource?
• ¿Qué signfica GNU, FSF y GPL? y su importancia en Linux.
• Tipos de Licencias en Linux.
• Orígenes e Historia de Linux.
• Características principales de Linux.
• Distribuciones de Linux mas conocidas.
• Estandares utilizados en Linux.
• Interfaces de Linux y acceso al Sistema.
Fundamentos de Linux 9
Capítulo 1 Introducción
2. Historia de Unix
En los años '60, un proyecto estaba bajo la linea del Instituto Tecnológico de Massachusetts
(MIT), para mejorar el uso de habilidades con software de tiempo compartido. El MIT, los
laboratorios Bell, y General Electric fueron colaboradores en esta aventura.
En 1966, un grupo de investigadores de los Laboratorios Bell desarrolló un sistema operativo
experimental llamado MULTICS (Información multiplexada y Sistema de Computación). Fue
diseñado como sistema operativo interactivo para una computadora General Electric GE 645,
permitiendo compartir información al mismo tiempo que daba seguridad. Sin embargo, hubieron
muchos retrasos en el desarrollo y las versiones resultaron lentas y con mucha necesidad de
memoria. Por esto y otras razones, los laboratorios Bell abandonaron el proyecto, pero sus
ideas innovadoras serían ocupadas más adelante.
En 1969, Ken Thompson, uno de los investigadores del MULTICS, diseñó un juego para la GE
llamado SPACE TRAVEL, que simulaba el sistema solar y una nave espacial, pero no le
10 Fundamentos de Linux
Introduccion
Historia de Unix
● Historia y Linea de Tiempo– Los Orígenes Multics y los Laboratorios Bell
– Unics a Unix
– Creadores: Ritchie, Thompson y Kernighan
– AT&T
– BSD
– OpenGroup y evolución de estándares
Capítulo 1 Introducción
resultó. Con la ayuda de Dennis Ritchie, Thompson volvió a escribirlo, ahora para el PDP-7 de
DEC ( Digital Equipment Corporation ), aprovechando para escribir un sistema operativo, con
un sistema de archivo diseñado por Thompson, Ritchie y Rudd Canaday. Ellos crearon un
sistema operativo multitarea, con sistema de archivos, intérprete de órdenes y algunas
utilidades para el PDP-7, y luego se revisó el juego SPACE TRAVEL para ejecutarlo sobre él.
Se le llamó al sistema con el nombre de UNICS (Información Uniplexada y Sistema de
Computación), pues podía soportar dos usuarios simultáneamente. Ese nombre, un juego de
palabras sobre MULTICS, es atribuido a Brian Kernighan. En 1970, el nombre se cambió a
Unix.
El grupo de Investigación en Informática quería trasladar el Unix a una máquina más grande.
Thompson y Ritchie adquirieron un DEC PDP-11/20 para añadir procesamiento de texto al
Unix. Este sistema, con el programa de procesamiento de texto runoff, fueron llevados al PDP-
11/20 en 1970. Este sistema de procesamiento de texto, consistente en Unix, un editor de texto
y el runoff fueron adoptados por el departamento de patentes de Bell como procesador de texto;
runoff evolucionó a troff, que además tiene capacidad de composición tipográfica, y es usado
aún en nuestros días.
Fundamentos de Linux 11
Capítulo 1 Introducción
En 1972 habían 10 computadoras con Unix y se esperaban más. En 1973, Ritchie y Thompson
escribieron el núcleo de Unix en C, un lenguaje de programación de alto nivel, a diferencia de la
mayoría de los sistemas, escritos generalmente en ensamblador. Thompson pensó en escribir
Unix en Fortran, pero encontró dificultades con ese lenguaje, debido a su falta de portabilidad.
El Unix en C se podía mantener más fácilmente, y podía trasladarse a otras máquinas casi sin
problemas. El Unix se hizo muy popular por sus innovaciones y por estar escrito en lenguaje de
alto nivel modificable de acuerdo a preferencias personales. Y sus conceptos siguieron
creciendo: Se incorporaron los redireccionamientos estándar (redirección de entrada y salida
entre dos o más programas, denotada con el símbolo | (pipe)), sugeridos por Doug Mc. Llory y
desarrollados por Thompson a principios de los '70, haciendo posible el desarrollo de la filosofía
Unix.
En 1974 empezó a usarse en Bell la cuarta edición de Unix. En 1977 salieron la quinta y sexta
ediciones con muchas más herramientas. En 1978 ya eran más de 600 las máquinas con Unix
en Bell y en las Universidades. La séptima edición de Unix salió en 1979.
12 Fundamentos de Linux
Introduccion
Historia de Unix
● Timeline:
Capítulo 1 Introducción
El sistema III de Unix se convirtió en 1982 en la primera versión comercial del sistema Unix de
AT&T. Este sistema III y las versiones experimentales se distribuyeron en universidades y otros
laboratorios de investigación, los que modificaron bastante las versiones que adquirieron, hasta
el punto de perderse compatibilidad entre versiones distintas. Para solucionar el problema,
AT&T introdujo el Unix sistema V versión 1 en 1983 (el sistema IV sólo existió en AT&T como
versión interna). Con este sistema, comenzaría a mantenerse la compatibilidad con otras
versiones de Unix. Incorporó algunas características de BSD, el Unix desarrollado en la
Universidad de California en Berkeley, como el editor vi y la biblioteca de manejo de pantalla
curses. La versión 2 salió en 1985, con protección de archivos y registros para uso exclusivo
por un programa, control de trabajos y administración ampliada del sistema.
La versión que salió de Unix a finales de los '80, es la versión 4, que fusiona las versiones más
populares del Unix y los sistemas BSD, Xenix y SunOS, ajustándose a los estándares
importantes definidos para el sistema por diversas organizaciones como el IEEE, el ANSI, el
NIST, etc. Para ello fue necesario redefinir partes de su estructura, como el sistema de
archivos, tratando de mantener compatibilidad con versiones anteriores del sistema V de Unix.
Las últimas versiones son: BSD fue 4.4BSD-Lite release 2 publicada por el CSRG, SunOS
SunOS 5.7
El conjunto de órdenes del SVR4 se construyó fusionando el conjunto de órdenes del sistema V
versión 3.2 con las órdenes populares de BSD, XENIX y SunOS, añadiendo nuevas órdenes y
actualizando algunas antiguas. Hubieron, eso sí, algunos problemas con órdenes que tenían el
mismo nombre, aunque eran de distintas versiones y hacían cosas distintas. Para solucionar
ese problema se crearon paquetes de compatibilidad para que los usuarios de estas versiones
pudieran usarlas.
La versión 4 soporta cuatro intérpretes de órdenes, o shells. Como shell por omisión, tiene una
versión ampliada del sistema V estándar.(Bourne Shell) Además, como ya dije, existen otros
tres shells:
• El Shell Korn, creado por David Korn, ofrece un superconjunto de las características del shell
del sistema V, incluyendo historia de órdenes, edición de línea de comandos y características
ampliadas de programación.
Fundamentos de Linux 13
Capítulo 1 Introducción
• El Shell C, procedente del sistema BSD y desarrollado por Bill Joy, comparte capacidad de
control de trabajos, historia de órdenes, capacidad de edición, etc.
En 1992 es lanzada la versión 4.2 del sistema V de SVR y en diciembre de 1994 Novell libera
SVR4.2MP, que es el lanzamiento final para el sistema V.
En 1995 X/Open introduce UNIX 95 programa para la implementación de “Single UNIX
Specification, Novell” vende la linea “UnixWare” a SCO. En 1997 Open Group lanza la versión 2
de “Single UNIX Specification” que incluye la ayuda en tiempo real, para procesadores de 64
bits y más grandes.
En 1998 Open Group introduce UNIX 98 en la familia de la marca incluyendo la base del
sistema, las estaciones de trabajo y los servidores, los primeros productos registrados fueron
para Sun, IBM and NCR.
En 1999 Open Gruop y la IEEE desarrollan en común la revisión de POSIX y de “Single UNIX
Specification”, lanzando en 2001 la versión 3 unido a IEEE POSIX, en ese mismo año se lanzó
el núcleo de Linux 2.4
En 2003 se aprueban la base de la versión 3 de “Single UNIX Specification” como estándar
internacional y se lanza el núcleo de Linux 2.6.
Más información al respecto de Estándares Unix se puede ver en http://www.unix.org.
14 Fundamentos de Linux
Capítulo 1 Introducción
3. Movimiento Open Source
Definición de Open Source
Código abierto (open source en inglés) es el término por el que se conoce al software
distribuido y desarrollado de tal forma que puede ser compartido abiertamente entre
desarrolladores y usuarios finales con el fin de que todos aprendan de todos. Este término
empezó a utilizarse en 1998 por algunos usuarios de la comunidad del software libre, tratando
de usarlo como reemplazo al ambiguo nombre original del software libre (free software).
En inglés, "free software" puede significar diferentes cosas. Por un lado, permite pensar en
"software por el que no hay que pagar", y se adapta al término de forma igualmente válida que
el significado que se pretende (software que posee ciertas libertades).
Open source no sólo significa acceso al código fuente. Las condiciones de distribución de un
programa open-source deben cumplir con el siguiente criterio:
Fundamentos de Linux 15
Introduccion
Movimiento OpenSource
● OpenSource y/ó Código Abierto● Características del OpenSource
– Libre Redistribución
– Acceso al código fuente
– Protección “Trabajos Derivados”
– Integridad del código fuente
– No discriminación de personas, grupos, uso
– Uso y características de licencias OpenSource
– Ejemplos de Licencias
Capítulo 1 Introducción
1. Libre Redistribución
La licencia no debe restringir a nadie vender o entregar el software como un componente de
una distribución de software que contenga programas de distintas fuentes. La licencia no debe
requerir “royalty” ni ningun tipo de cuota por su venta.
2. Código Fuente
El programa debe incluir el código fuente, y se debe permitir su distribución tanto como código
fuente como compilado. Cuando de algún modo no se distribuya el código fuente junto con el
producto, deberá proveerse un medio conocido para obtener el código fuente sin cargo, a
través de Internet. El código fuente es la forma preferida en la cual un programador modificará
el programa. No se permite el código fuente deliberadamente confundido (obfuscation).
Tampoco se permiten formatos intermedios, como la salida de un preprocesador, o de un
traductor.
3. Trabajos Derivados
La licencia debe permitir modificaciones y trabajos derivados, y debe permitir que estos se
distribuyan bajo las mismas condiciones de la licencia del software original.
4. Integridad del Código Fuente del Autor.
La licencia puede restringir la distribución de código fuente modificado sólo si se permite la
distribución de "patch files" con el código fuente con el propósito de modificar el programa en
tiempo de construcción. La licencia debe permitir explícitamente la distribución de software
construido en base a código fuente modificado. La licencia puede requerir que los trabajos
derivados lleven un nombre o número de versión distintos a los del software original.
5. No Discriminar Personas o Grupos.
La licencia no debe hacer discriminación de personas o grupos de personas.
6. No Discriminar Campos de Aplicación.
La licencia no debe restringir el uso del programa en un campo específico de aplicación. Por
ejemplo, no puede restringir su uso en negocios, o en investigación genética.
16 Fundamentos de Linux
Capítulo 1 Introducción
7. Distribución de la Licencia.
Los derechos concedidos deben ser aplicados a todas las personas a quienes se redistribuya el
programa, sin necesidad de obtener una licencia adicional.
8. La Licencia No Debe Ser Específica a un Producto.
Los derechos aplicados a un programa no deben depender de la distribución particular de
software de la que forma parte. Si el programa es extraído de esa distribución y usado o
distribuido dentro de las condiciones de la licencia del programa, todas las personas a las que
el programa se redistribuya deben tener los mismos derechos que los concedidos en
conjunción con la distribución original de software.
9. La Licencia No Debe Contaminar Otro Software.
La licencia no debe imponer restricciones sobre otro software que es distribuido junto con el.
Por ejemplo, la licencia no debe insistir en que todos los demás programas distribuidos en el
mismo medio deben ser software open-source.
10. Ejemplos de Licencias.
Las licencias GNU GPL, BSD, “X Consortium”, y “Artistic” son ejemplos de licencias que
consideramos que cumplen con la definición de Open Source. También la licencia MPL cumple
con la definición.
Fundamentos de Linux 17
Capítulo 1 Introducción
3.1 GNU
El Proyecto GNU es una campaña para difundir el Free Software. Fue iniciada por Richard
Stallman en 1984 y pretende implantar la tendencia hacia el desarrollo de software sin límites
de derechos de autor y bajo precio.
El proyecto GNU ha desarrollado un sistema completo de software libre llamado “GNU” (GNU
No es Unix) que es compatible con Unix. El documento inicial de Richard Stallman sobre el
proyecto GNU se llama Manifiesto GNU. Se escogió como nombre “GNU” porque era un
acrónimo recursivo de “GNU No es Unix”.
La palabra “libre” se refiere a libertad, no a precio. Puedes o no pagar un precio por obtener
software GNU. De cualquier manera, una vez que obtienes el software, tienes tres libertades
específicas para usarlo. Primera, la libertad de copiar el programa y darlo a tus amigos o
compañeros de trabajo; segunda, la libertad de cambiar el programa como desees, por tener
acceso completo al código fuente; tercera, la libertad de distribuir una versión mejorada
18 Fundamentos de Linux
Introduccion
Movimiento OpenSource
● Free Software Foundation y GNU– Richard Stallman: Fundador
– Proteger y distribuir Software Libre (OpenSource)
– “GNU Operating System”
● GPL– GNU Public License
– Principal y mas importante licencia de OpenSource
● Freeware, Shareware, Adware● OpenSource, Apache, FreeBSD
Capítulo 1 Introducción
ayudando así a construir la comunidad (si redistribuyes software GNU, puedes cobrar una cuota
por el acto físico de efectuar la copia, o bien puedes regalarla).
El proyecto GNU fue concebido en 1983 como una forma de devolver el espíritu cooperativo
que prevalecía en la comunidad computacional en días pasados---hacer la cooperación posible
al eliminar los obstáculos impuestos por los dueños de software privativo.
En 1971, cuando Richard Stallman comenzó su carrera en el MIT (Instituto de Tecnología de
Massachusetts), trabajó en un grupo que usaba software libre exclusivamente. Incluso
compañías informáticas frecuentemente distribuían software libre. Los programadores eran
libres de cooperar unos con otros, y frecuentemente lo hacían.
En los 80, casi todo el software era privativo, lo cual significa que tenía dueños que prohibían e
impedían la cooperación entre usuarios. Esto hizo necesario el Proyecto GNU.
Cada usuario de computadoras necesita un sistema operativo; si no existe un sistema operativo
libre, entonces no puedes ni siquiera comenzar a usar una computadora sin recurrir a un
software privativo. Así que el primer elemento en la agenda del software libre es un sistema
operativo libre.
Un sistema operativo no es sólo el núcleo; sino que también incluye compiladores, editores,
formateadores de texto, software de correo y muchas otras cosas. Por todo esto, escribir un
sistema operativo completo es un trabajo bastante grande. Se necesitaron muchos años.
El objetivo inicial de un sistema operativo libre parecido al Unix ha sido alcanzado. En los 90, ya
se había encontrado o escrito los componentes principales, excepto uno: el núcleo. Entonces
Linux, un núcleo libre, fue desarrollado por Linus Torvalds. Combinando Linux con el ya casi
completo sistema GNU se consiguió un sistema operativo completo: un sistema GNU basado
en Linux. Se estima que hay cientos de miles de personas que ahora usan sistemas GNU
basados en Linux, incluyendo Slackware, Debian, Red Hat y otros.
3.2 FSF (Free Software Foundation)
La Fundación para el Software Libre (FSF) está dedicada a eliminar las restricciones sobre el
copiado, redistribución, entendimiento, y modificación de programas de computadoras.
Fundamentos de Linux 19
Capítulo 1 Introducción
Promocionando el desarrollo y uso del software libre en todas las áreas de la computación, pero
muy particularmente, ayudando a desarrollar el sistema operativo GNU.
Muchas organizaciones distribuyen cualquier software libre que este disponible. En cambio, la
Fundación para el Software Libre se concentra en desarrollar nuevo software libre, y en hacer
de este software un sistema coherente, el cual puede eliminar la necesidad de uso del software
privativo.
Además de desarrollar GNU, FSF distribuye copias de software GNU y manuales por un costo
de distribución, y acepta donaciones deducibles de impuestos (en los Estados Unidos), para
apoyar el desarrollo de software GNU. Muchos de los fondos de la FSF provienen de los
servicios de distribución.
3.3 GPL (GNU General Public License) ó 'copyleft'
GPL es un tipo de licencia sobre la propiedad intelectual en la cual únicamente se exige que
aquellos desarrollos hechos con material licenciado bajo GPL sean a su vez GPL. Se trata de
proteger la no ocultación de código.
La licencia GPL se aplica al software de la FSF (Free Software Foundation) y el proyecto GNU
y otorga al usuario la libertad de compartir el software y realizar cambios en él. Dicho de otra
forma, el usuario tiene derecho a usar el programa, modificarlo y distribuir las versiones
modificadas pero no tiene permiso de realizar restricciones propias con respecto a la utilización
de ese programa modificado.
La licencia GPL o copyleft (contrario a copyright) fue creada para mantener la libertad del
software y evitar que alguien quisiera apropiarse de la autoría intelectual de un determinado
programa.
3.4 Tipos de Licencias en Linux
La licencia de software es una especie de contrato, en donde se especifican todas las normas y
cláusulas que rigen el uso de un determinado programa, principalmente se estipulan los
alcances de uso, instalación, reproducción y copia de estos productos.
20 Fundamentos de Linux
Capítulo 1 Introducción
En el momento en que usted decide descargar, instalar, copiar o utilizar un determinado
SOFTWARE, implica que usted acepta las condiciones que se estipulan en la LICENCIA que
trae ese programa.
Además de las licencias mencionadas en la sección anterior esta el FreeBSD y APACHE.
El propósito de FreeBSD es el de proporcionar software a cualquier para cualquier propósito sin
obligaciones.
En base al tipo de licenciamiento y restricciones / derechos que nos proporcionan éstas
tenemos las siguientes categorías de software.
Free Software
La palabra anglosajona “free” traducida al español tiene dos aceptaciones: libre y gratis.
Cuando hablamos de “free” software tenemos la tendencia a creer que se trata solamente de
programas que el usuario puede utilizar sin pagar un peso y que normalmente se encuentran
gratis en Internet. Pero “free software” es mucho mas que eso. Según Richard Stallman,
fundador del proyecto GNU, “el término software libre ha sido mal interpretado, pues no tiene
nada que ver con el precio, tiene que ver con libertad”.
Open Source
Es necesario aclarar que “Open Source” y “Free Software” son esencialmente lo mismo, la
diferencia radica en que los defensores del “Free Software” no están ciento por ciento de
acuerdo con que las empresas disfruten y distribuyan “Free Software” ya que, según ellos, el
mercado corporativo antepone la utilidad a la libertad, a la comunidad y a los principios y por
ende no va de la mano con la filosofía pura detrás del “Free Software”.
Open Source es el software que puede ser compartido abiertamente entre desarrolladores y
usuarios finales de tal forma que todos aprendan de todos. Tal es el caso de Linux, que espera
juntar a desarrolladores de todo el mundo, profesionales y aficionados a la espera del despegue
definitivo de la tecnología bajo licencia Open Source.
Fundamentos de Linux 21
Capítulo 1 Introducción
Software de Dominio Publico
El software de dominio público no está protegido por las leyes de derechos de autor y puede
ser copiado por cualquiera sin costo alguno. Algunas veces los programadores crean un
programa y lo donan para su utilización por parte del público en general. Lo anterior no quiere
decir que en algún momento un usuario lo pueda copiar, modificar y distribuir como si fuera
software propietario. Así mismo, existe software gratis protegido por leyes de derechos de autor
que permite al usuario publicar versiones modificadas como si fueran propiedad de este último.
Freeware
Es software que el usuario final puede bajar totalmente gratis de Internet. La diferencia con el
Open Source es que el autor siempre es dueño de los derechos, o sea que el usuario no puede
realizar algo que no esté expresamente autorizado por el autor del programa, como modificarlo
o venderlo. Un ejemplo de este tipo de software es el traductor Babylon, Quintessential,
BSPlayer, etc.
Shareware
Es software que se distribuye gratis y que el usuario puede utilizar durante algún tiempo. El
autor requiere que después de un tiempo de prueba el usuario pague por el software,
normalmente a un costo bastante bajo, para continuar usando el programa. Algunas veces el
programa no deja de funcionar si el usuario no paga, pero se espera que este último pague una
suma de dinero y se registre como usuario legal del software para que además del programa
reciba soporte técnico y actualizaciones. El usuario puede copiar el software y distribuirlo entre
sus amigos pero se espera que que estos últimos paguen por el programa después de
culminado su período de prueba. El 'bajo costo' del shareware se debe a que el producto llega
directamente al cliente (Internet), evitando así los costos de empaque y transporte. (Por
ejemplo. WinRar). A menudo el software shareware es denominado como software de
evaluación.
Hay también software shareware que deja de funcionar después de un periodo de prueba, los
llamados “Try Out”.
22 Fundamentos de Linux
Capítulo 1 Introducción
Adware
Como ya sabemos, existen varios tipos de programas «gratuitos»: shareware, programas de
prueba, normalmente de 30 días, freeware, programas gratuitos sin límite de uso, ahora ha
salido una nueva clase demoninada "Adware", que no son mas que programas financiados con
publicidad. Es decir, el software es gratuito en su uso a cambio de tener un banner de
publicidad visible en todo momento mientras utilizamos el programa. Se supone que éste es el
único «precio» que debemos pagar por usar este tipo de aplicaciones, al menos eso nos dicen.
Pero, en ocasiones, estos programas aprovechan que tienen que estar conectados a la Red
para descargarse la publicidad y pueden enviar algunos datos personales.
Fundamentos de Linux 23
Capítulo 1 Introducción
4. Orígenes de Linux
Linux, el núcleo o kernel de GNU/Linux, se desarrolló originalmente como un proyecto que
Linus Torvalds emprendió en su tiempo libre. Se inspiró en Minix, un sistema Unix básico
desarrollado por Andy Tannenbaum. Las primeras discusiones acerca del núcleo Linux tuvieron
lugar en el grupo de noticias de Usenet “comp.os.minix”. Estas discusiones se centraban sobre
todo en el desarrollo de un sistema pequeño y académico de Unix para usuarios de Minix que
querían algo más.
El primitivo desarrollo del núcleo Linux se centró en las características multitarea del interfaz en
modo protegido del 80386, escrito en código ensamblador.
Nunca se hizo un anuncio de la versión 0.01. Las fuentes del 0.01 ni siquiera eran ejecutables.
Contenían sólo los rudimentos básicos de las fuentes del núcleo y daban por supuesto que se
tenía acceso a una máquina con Minix para compilarlas y experimentar con ellas.
El 5 de octubre de 1991 Linus Torvalds anunció la primera versión “oficial'' del núcleo Linux”, la
24 Fundamentos de Linux
Introduccion
Origenes de Linux
● Creado por Linux Torvalds● Primera Versión Liberado:
– 0.02 el 5 de Octubre de1991
● Linux 1.0 liberado el 15 de Marzo de 1994● Versión actual (enero 2005): 2.6.10● Linux se refiere al núcleo del Sistema Operativo
(kernel)● Se complementa con Software y herramientas
varias de OpenSource
Capítulo 1 Introducción
versión 0.02. En este punto, Linus podía ejecutar bash (el GNU Bourne Again Shell) y gcc (el
compilador C GNU) pero no mucho más. De nuevo, estaba pensado como un sistema para
hackers. La orientación principal fue el desarrollo del núcleo; el soporte de usuarios, la
documentación y la distribución todavía no habían sido atendidos.
Después de la versión 0.03 Torvalds dio el salto a la versión 0.10, según empezó a trabajar
más gente en el sistema. Después de varias revisiones posteriores, Linus incrementó el número
de versión a la 0.95 en marzo de 1992 para reflejar su impresión de que el sistema estaba
preparado para un inminente lanzamiento “oficial” (Generalmente a un programa no se le
numera con la versión 1.0 hasta que no está en teoría completo, o libre de errores). Casi año y
medio después, a finales de diciembre de 1993, el núcleo de estaba todavía en la versión 0.99,
acercándose rápidamente a la versión 1.0.
Torvalds ha continuado liberando nuevas versiones del núcleo, consolidando aportes de otros
programadores y haciendo cambios por su cuenta. Todas las versiones de Linux que tienen el
número de sub-versión (el segundo número) par, pertenecen a la serie "estable", por ejemplo:
1.0.x, 1.2.x, 2.0.x, 2.2.x, 2.4.x y actualmente 2.6.x, mientras que las versiones con sub versión
impar, como la serie 2.5.x, son versiones de desarrollo, es decir que no son consideradas de
producción. Además de estas versiones "oficiales" del núcleo, es posible obtener versiones
"alternativas" en otras fuentes. Los encargados de las Distribuciones de Linux, normalmente
mantienen sus propias versiones del núcleo, que a veces incluyen por ejemplo, controladores
que no han sido incorporados a la versión oficial.
La versión mas reciente es la 2.6.10, que salió el 24 de diciembre del 2004.
Fundamentos de Linux 25
Capítulo 1 Introducción
5. Características de Linux
Es un sistema operativo multitarea y multiusuario, como lo son todas las otras versiones de
UNIX. Esto significa que muchos usuarios pueden autenticarse en el sistema y ejecutar
programas, y hacerlo de forma simultánea.
Incluyen control de tareas POSIX (que se usa en los shells csh y bash), las pseudo-terminales
(dispositivos tty), y soporte para teclados nacionales o personalizados que se cargan
dinámicamente. soporta consolas virtuales que le permiten cambiar entre sesiones de login en
una única consola del sistema.
El sistema operativo soporta varios sistemas de ficheros para almacenar los datos, como el
sistema de ficheros ext2. Hay soporte para los sistemas de ficheros de Xenix y UNIX System
V, así como los sistemas de ficheros de MS-DOS y el VFAT de Windows® entre muchos otros.
El sistema de ficheros de CD-ROM ISO 9660 también está soportado.
26 Fundamentos de Linux
Introduccion
Características de Linux
● Tipo Unix (No Unix)● Multiusuario● Multitarea● Confiable● Múltiples Arquitecturas soportadas● OpenSource
Capítulo 1 Introducción
Proporciona una implementación completa del software de redes TCP/IP. Incluidos
controladores de dispositivo para muchas tarjetas Ethernet habituales, y también SLIP (Serial
Line Internet Protocol) y PPP (Point-to-Point Protocol), que proporcionan acceso a una red
TCP/IP a través de una conexión serie, PLIP (Parallel Line Internet Protocol), y NFS (Network
File System - Sistema de Ficheros de Red). También está soportada toda la gama de clientes y
servicios TCP/IP, lo que incluye FTP, telnet, NNTP, SMTP, etc..
Algunas características técnicas importantes son: el núcleo soporta ejecutables con paginación
por demanda, compartición de las páginas de memoria de los ejecutables mediante la técnica
copy-on-write. Implementa también la paginación de disco. Puede reservarse en el disco hasta
un Gigabyte de espacio de intercambio en hasta 8 particiones de 128 megas cada una, entre
muchas otras.
Fundamentos de Linux 27
Capítulo 1 Introducción
6. Distribuciones mas conocidas
Una distribución es un conjunto de aplicaciones y herramientas de instalación y configuración,
las cuales operan en conjunto con el núcleo de Linux.
Existe una amplia variedad de distribuciones de Linux, algunas están enfocadas a propósitos
muy específicos (e.g. seguridad, servidores de alto rendimiento) y otras a propósitos generales
(e.g. una computadora de escritorio).
Listar todas las distribuciones existentes de Linux es una tarea difícil, “www.linux.org” tiene
listadas aproximadamente 340 distribuciones diferentes. Para hacerlo más sencillo, te
presentamos a continuación la lista de las distribuciones más populares.
Mandrake
MandrakeSoft fue creado en 1998 con el propósito de hacer Linux más fácil de usar para
cualquiera. Nació como una distribución basada en RedHat, añadiendo algunas características
28 Fundamentos de Linux
Introduccion
Distribuciones
● Una Distribución es el empaquetamiento y selección de Software que una compañía o individuo realiza alrededor de un kernel de Linux
● Distribuciones conocidas– RedHat
– SuSe
– Gentoo
– Mandrake
– Debian
– etc.
Capítulo 1 Introducción
que no estaban integradas, como el entorno gráfico KDE y un instalador gráfico simple y
sencillo de usar. Mandrake es ideal para usuarios nuevos que no desean involucrarse con
profundos conocimientos técnicos, debido a su facilidad de uso.
RedHat
RedHat es la distribución más conocida y usada en el mundo, la compañía fue fundada en 1994
y además de dedicarse a la producción de la distribución ofrece otros servicios como lo son:
Red Hat Network o las certificaciones como RHCE (Red Hat Certified Engineer). Es por esto
que Red Hat es ampliamente aceptada en la industria de la tecnología informática (TI).
LGIS Linux
LGIS GNU/Linux 9 es una versión modificada de RedHat 9 (Shrike). LGIS GNU/Linux 9 es una
distribución orgullosamente mexicana la cual surge de la necesidad de contar con la última
versión de la distribución más utilizada a nivel mundial, con todas sus actualizaciones, además
de la inclusión del Escritorio Ximian Desktop 2 (XD2) con todos los productos libres (Evolution,
RedCarpet, etc.) lo que permite entre otras cosas mantener el sistema actualizado al 100% y
manipular toda la información personal con la mejor herramienta para ello (Evolution), además,
la versión "Ximian" de OpenOffice la Suite de Oficina libre que está reemplazando a sus
contrapartes propietarias.
Knoppix
Knoppix es una distribución basada en Debian que tiene una característica muy especial, la
cual es que se ejecuta directamente del CD sin necesidad de instalarlo en el disco duro. Puede
ser usado como una herramienta de recuperación o bien para echarle un vistazo a Linux antes
de instalarlo.
Gentoo
Gentoo Linux es una distribución de reciente creación basada en código fuente, es decir
provee, en conjunto con su sistema de paquetes, una jerarquía de instrucciones que automatiza
la descarga, compilación, actualización y empaquetado de software en tu máquina. Esto te
permite optimizar, configurar y mantener al día tu computadora, a tu manera y sin restricciones
Fundamentos de Linux 29
Capítulo 1 Introducción
con las últimas versiones de software. Esta distribución es ideal tanto para novatos que deseen
conocer su sistema Linux a fondo como administradores de red, programadores y usuarios de
Slackware o Linux from Scratch.
Debian
El proyecto Debian nació en 1993 como una organización de individuos que tienen como causa
común crear un sistema operativo 100% libre. Debian Linux es una distribución completamente
libre alejada de todo tipo de asociación comercial y software propietario. Su desarrollo por parte
de programadores de todo el mundo es uno de los más grandes llevados a acabo por la
comunidad de software libre. Más allá del aspecto técnico Debian es acerca de libertad.
Slackware
Slackware fue la primera distribución de Linux como las conocemos hoy en día.
Su filosofía es mantener absolutamente todo sencillo (KISS) tomando muchas ideas de los
UNIX originales, tales como el sistema de arranque. Muchos usuarios prefieren Slackware
precisamente por esa sencillez, la instalación es basada en texto y es tan sencilla que un
columnista de la Linux Journal Magazine comentó que podría completar una instalación de
Slackware sin un monitor conectado a la computadora. Parte de esta sencillez es la carencia de
sistemas automatizados de configuración, sin embargo incluye un sencillo sistema de paquetes.
Excelente como puente entre Linux y sistemas BSD tanto para usuarios avanzados como para
novatos.
SuSE
SuSE se enfoca al mercado de los escritorios y servidores, y es famoso por ser muy fácil de
instalar y por su herramienta de configuración llamada YaST. El desarrollo de SuSE es un tanto
cerrado ya que no proveen versiones beta de su distribución y además no colocan imágenes
ISO para descargar la distribución desde Internet.
30 Fundamentos de Linux
Capítulo 1 Introducción
Lycoris Desktop/LX
Destkop/LX es un sistema operativo basado en Linux hecho por la compañía Lycoris la cual
proclama ser el proveedor líder de Linux específicamente orientado al mercado del escritorio.
Lindows
Lindows es una distribución dirigida al consumidor, con un look and feel al de Microsoft®
Windows XP® o Apple® MacOS X®, lo cual incluye soporte para ejecutar aplicaciones de
Microsoft® Windows® como Microsoft® Office®.
Esta distribución no es de libre acceso, pues tiene un costo por licencia.
Xandros
Xandros es una distribución canadiense basada en Corel® Linux que se enfoca en crear una
solución de escritorio que combina lo mejor de las tecnologías de código abierto con una
atención corporativa hacia el soporte y facilidad de uso, así como compatibilidad con software
de Microsoft® Windows®.
Linux From Scratch
Linux From Scratch (LFS) es un proyecto que consiste en proveer los pasos necesarios para
construir desde cero tu propia distribución. Una de las mejores maneras de conocer como
funciona un sistema Linux por dentro, así como conocer la relación entre los componentes del
sistema.
Fedora Core
Fedora Core es el nuevo proyecto creado por la empresa Red Hat, creadora de una de las
distribuciones de Linux más importantes y utilizadas que existen. Este nuevo proyecto surge
debido a que RedHat Linux pasó a llamarse RedHat Enterprise Linux y será solo distribuida con
soporte técnico y por tanto, de pago. Pero Red Hat es consciente de que no puede dejar de
ofrecer una distribución libre y es por ello que ha creado el proyecto Fedora.
Fundamentos de Linux 31
Capítulo 1 Introducción
7. Estándares
Linux Standard Base ( LSB ).
Linux Standard Base, (acrónimo LSB), es un proyecto en conjunto de varias distribuciones
Linux bajo la organización estructural de “The Free Standards Group” para diseñar y
estandarizar la estructura interna de sistemas operativos basados en Linux. LSB está basado
en la especificación POSIX, la especificación SUS y otros estándares abiertos, pero los
extiende en ciertas áreas.
Linux Standard Base (LSB) es una especificación creada para armonizar y uniformizar el
funcionamiento y compatibilidad de las diferentes distribuciones existentes en el mercado. Lo
que se pretende es evitar que vuelva a pasar lo mismo que en su día le ocurrió al Unix: debido
a la falta de concreciones en su sistema de licenciamiento, diversas empresas hicieron sus
propias versiones del sistema, llegando a la situación que tenemos hoy en día, con Unix
fragmentado y diversas versiones en el mercado totalmente incompatibles entre si a nivel de
32 Fundamentos de Linux
Introduccion
Estándares
● Linux Standard Base (LSB)● File Hierachy Standard (FHS)● Linux Internationalization Specification (Li18nux)● Posix● Otros
Capítulo 1 Introducción
binarios.
El objetivo de LSB es desarrollar y promover un grupo de estándares que incrementarán la
compatibilidad entre las distribuciones Linux y permitirá que las aplicaciones se ejecuten en
cualquier sistema que cumpla con los estándares. Adicionalmente, LSB ayudará a coordinar
esfuerzos para recluir fabricantes de software para portar y escribir productos para Linux. El
LSB ha sido criticado por no tomar en cuenta aportaciones de proyectos externos a los
miembros de la esfera de la compañía, más notablemente del proyecto Debian. por ejemplo,
LSB especifica que las paquetes de software deberían ser entregados en el formato RPM de
Red Hat, que fue inventado mucho después que el formato de paquete "deb" de Debian, y los
desarrolladores de Debian no quieren cambiar su formato, el cual naturalmente consideran
superior. Algunos dicen que esto no es un gran problema ya que el formato RPM especificado
por el LSB es bien soportado por el programa "alien" de Debian que puede ser usado para
importar paquetes almacenados en otros formatos binarios.
La lista de individuos y organizaciones que participan en el esfuerzo de la LSB o aprueban la
LSB incluye:
• Linux Hardware Solutions, Inc.
• Red Hat Software, Inc.
• S.u.S.E. GmbH
• Software in the Public Interest
• El proyecto Debian
• VA Research.
• The China Electronics Standardization Institute
• Gelato Federation
• Japan Linux Association
• Linux International
Fundamentos de Linux 33
Capítulo 1 Introducción
• Linux Professional Institute (LPI)
• OSDL
• The Open Group
• PC Open Architecture Developers' Group (OADG)
• Software in the Public Interest (SPI)
• Software Liberty Association of Taiwan (SLAT)
• USENIX Association
• University of Wisconsin
Si quiere conocer mas a fondo de este estándar visite la pagina: http://www.linuxbase.org/
Filesystem Hierarchy Standard (FHS).
El Filesystem Hierarchy Standard (Estándar de Jerarquía de Sistema de Ficheros) o FHS define
los directorios principales y sus contenidos en Linux y otros sistemas de la familia Unix. Se
diseñó originalmente en 1994 para estandarizar el sistema de archivos entre distribuciones
Linux, basándose en la tradicional organización de directorios de sistemas Unix. En 1995 se
amplió el ámbito del estándar a cualquier Unix que se adhiriese voluntariamente.
Todos los archivos y directorios aparecen bajo el directorio raíz /, aunque se encuentre en
distintos dispositivos físicos. Ejemplos de directorios definidos por FHS incluyen:
• /bin/ Comandos esenciales binarios para todos los usuarios (cat, ls, cp...)
• /dev/ dispositivos esenciales
• /home/ Directorios de programa de los usuarios
• /etc/ Archivos de configuración del sistema
• /lib/ Bibliotecas esenciales para los binarios de /bin y /sbin
34 Fundamentos de Linux
Capítulo 1 Introducción
• /var/ Archivos de variables, como logs y ficheros temporales
• /opt/ Paquetes de programas de aplicaciones estáticos
• /sbin/ Binarios de superusuario esenciales (init, route, ifup..)
• /proc/ Sistema de Archivos que documenta el estado del núcleo (kernel), principalmente
Archivos de texto (tiempo, red...)
• /mnt/ Sistemas de Archivos montados temporalmente
Las especificaciones sobre este estándar se encuentran en la página:
http://www.pathname.com/fhs/
Li18nux
El estándar li18nux establece las especificaciones globales para que el sistema Unix sea
compatible internacionalmente. En la página oficial (http://www.li18nux.org) se encuentran
dichas especificaciones.
Fundamentos de Linux 35
Capítulo 1 Introducción
8. Ambientes
Al contrario que otros sistemas operativos, por defecto el trabajo con Linux no se realiza de una
forma gráfica, sino introduciendo comandos de forma manual. Linux dispone de varios
programas que se encargan de interpretar los comandos que introduce el usuario y realiza las
acciones oportunas en respuesta. Estos programas denominados shell son el modo típico de
comunicación en todos los sistemas Unix incluido Linux. Para muchas personas el hecho de
tener que introducir los comandos de forma manual les puede parecer intimidante y difícil,
aunque como se verá más adelante los comandos de Linux son relativamente simples y muy
poderosos.
No obstante, casi todas las distribuciones más recientes incluyen el sistema X Window, el cual
es el encargado de controlar y manejar la interfaz de usuario. X Window es mucho más
poderoso que otros entornos similares como Microsoft Windows, puesto que permite que el
usuario tenga un control absoluto de la representación de los elementos gráficos.
36 Fundamentos de Linux
Introduccion
Ambientes
● Shells o Lineas de Comandos– Bash
– Zsh
– Tcsh
● GUI (Graphical User Interface)– Xfree86
– GNOME
– KDE
– etc.
Capítulo 1 Introducción
8.1 Shells
Este modo se basa en la ejecución de una serie de comandos, que son interpretados por un
programa o shell. Linux dispone de varios de estos programas pero el más habitual es conocido
como bash o Bourne Again Shell.
Bash shell se trata de una shell de Linux compatible con POSIX que implementa parte de los
comandos de C shell y toda la sintaxis de Bourne Shell. En BASH podemos utilizar variables
que, normalmente, serán todas en mayúsculas.
Existen tanto variables de lectura, como variables de lectura-escritura. Las variables de lectura
"simplemente" nos darán información sobre el estado del shell o del sistema, sin embargo, las
de lectura-escritura nos van a permitir cambiar el comportamiento de bash. El shell bash
cuando recibe una orden (por ejemplo, un comando pasado por teclado) lo primero que hace es
ver si la orden está dentro de sus órdenes internas (como return, exit...), luego mira en los alias,
y después busca el comando en el $PATH.
El shell zsh es similar al ksh, pero incluye muchas características del csh, combina la
programación y la sintaxis del shell Korn con las características útiles del shell C, fue escrito en
1990 por Paul Falstad.
El shell tcsh se basa en csh, pero también contiene la edición de linea de comandos, un
mecanismo de historiales y otras características que no se encuentran en csh.
Si Linux se ha arrancado en modo texto el sistema arranca de forma directa el shell y queda a
la espera de introducción de nuevos comandos. Si se ha arrancado en modo gráfico se puede
acceder al shell de dos formas:
· Se puede acceder al shell del sistema presionando alguna de las siguientes combinaciones de
teclas:
· <ctrl>+<alt>+<F1>
· <ctrl>+<alt>+<F2>
Fundamentos de Linux 37
Capítulo 1 Introducción
· <ctrl>+<alt>+<F3>
· <ctrl>+<alt>+<F4>
· <ctrl>+<alt>+<F5>
· <ctrl>+<alt>+<F6>
Esto hace que el sistema salga del modo gráfico y acceda a alguna de las seis consolas
virtuales de Linux, a las cuales también se puede acceder cuando se arranca en modo de texto.
Para volver al modo gráfico hay que presionar <ctrl>+<alt>+<F7> o <ctrl>+<alt>+<F8>.
· La segunda forma es más cómoda y menos radical permitiendo acceder al shell desde el
mismo entorno gráfico. Para esto hay que abrir un programa llamado terminal o consola, por
ejemplo:
kconsole (en el entorno KDE), xterm, gnome-terminal ( en GNOME), etc como se ha visto
anteriormente.
Existen una serie de nociones básicas que hay que tener en cuenta a la hora de introducir los
comandos. En primer lugar citaremos las siguientes:
• Los comandos hay que teclearlos exactamente.
• Las letras mayúsculas y minúsculas se consideran como diferentes.
En su forma más habitual (los shells de Bourne o de Korn), el sistema operativo utiliza un signo
de $ como prompt para indicar que está preparado para aceptar comandos, aunque este
carácter puede ser fácilmente sustituido por otro u otros elegidos por el usuario. En el caso de
que el usuario acceda como administrador este signo se sustituye por #.
· Cuando sea necesario introducir el nombre de un fichero o directorio como argumento a un
comando, Linux, permite escribir las primeras letras del mismo y realiza un autorrellenado al
presionar la tecla del tabulador. Si no puede distinguir entre diversos casos rellenará hasta el
punto en el que se diferencien.
38 Fundamentos de Linux
Capítulo 1 Introducción
8.2 Gráficos
X Window es el entorno gráfico habitual de los sistemas Unix. El sistema X Window se
compone de dos parte principales el servidor X y el programa para la gestión de las ventanas.
El servidor X es el programa que se encarga realmente de dibujar en la pantalla. Por el
contrario el gestor de ventanas como su nombre indica es el encargado de crear las ventanas y
gestionar su apariencia. Debido a este modelo, la apariencia de las aplicaciones varía según se
use uno u otro gestor de ventanas, entre los que destacan por su sencillez de uso los entornos
GNOME y KDE.
Al instalar Linux el sistema puede preguntar si se desea arrancar Linux en modo texto o en
modo gráfico. Si se ha seleccionado esta última opción Linux arrancará directamente X
Window, en caso contrario en la linea de comandos hay que escribir startx con lo cual se
arranca el modo gráfico.
8.2.1 GNOME
El proyecto Gnome es uno de los más grandes avances que pudieron impulsar a Linux no sólo
como el sistema operativo consentido de los usuarios expertos de PC, y una seria amenaza
para Windows 2000, predecesor de Windows NT, como sistema operativo de redes, sino
también como un serio competidor en el campo de la PC de escritorio.
La historia de Gnome se remonta hacia mediados de 1997 cuando el mexicano Miguel de Icaza
y un grupo de amigos concluyeron que en Linux hacía falta una interfaz gráfica de usuario fácil
de utilizar, además de una interfaz que permitiese al desarrollador de software trabajar con la
misma comodidad con la que se hacía en otros sistemas operativos. Fue así que junto con
Federico Mena y otros colaboradores dio inicio Gnome.
Se trata de un ambiente gráfico de ventanas que se ejecuta en X Window, o modo gráfico que
utilizan los sistemas operativos basados sobre Unix. Permite al usuario trabajar cómodamente
administrando archivos o carpetas de un modo similar al utilizado en Windows. Su aspecto
estético, por otro lado, es sumamente agradable y con la capacidad de poderse personalizar y
aplicar mejoras al gusto del usuario.
Fundamentos de Linux 39
Capítulo 1 Introducción
Capacidades.
• Recordar la configuración del escritorio.
• Soporte para varios lenguajes humanos, de modo que que si se desea, pueden agregarse
más sin necesidad de cambiar el software.
• Soporta varios protocolos de "Drag & Drop" (arrastra y suelta) para una máxima interacción
con aplicaciones no desarrolladas para Gnome.
• Posibilidad de utilizar varios escritorios virtuales, e incluso con configuraciones distintas, que
permiten una mejor organización de las aplicaciones en uso.
Características más notorias.
• Un panel, desde donde se se inician las aplicaciones.
• Un escritorio, en donde se pueden colocar las aplicaciones y los datos.
• Un conjunto de herramientas estándar para el escritorio y aplicaciones.
• Un conjunto de características que hace fácil para las aplicaciones el poder cooperar y
coexistir entre si.
El sitio web de gnome donde se puede obtener mas información y actualizaciones es:
http://www.gnome.org
8.2.2 KDE
KDE es un ambiente gráfico que posee una colección de herramientas de configuración simple,
un administrador de archivos y un ambiente de estilos que hará más fácil y agradable su vida
con Linux. Este capítulo incluye las referencias para la instalación, la descripción de la interfaz
del usuario y cómo adaptarlas a las preferencias personales de trabajo. Instalando la interfaz
KDE que viene con , usted tiene a su disposición una interfaz de usuario y otra de administrador
personalizadas de acuerdo con la función, con las aplicaciones más utilizadas diariamente.
¡Vale la pena usarlas!
40 Fundamentos de Linux
Capítulo 1 Introducción
KDE atiende a todos los niveles de usuarios: a aquéllos que no tienen interés en aprender
tecnologías nuevas, como también a los usuarios más avanzados que necesiten algunas
funciones adicionales. El ambiente KDE contiene:
• Un ambiente de ventanas agradable y fácil de usar;
• Un administrador de archivos poderoso y de uso simplificado;
• Ayuda en línea que le dará apoyo en cualquier situación.
• Una interfaz consistente con sus aplicaciones, ya presenta un modelo estándar para las
funciones
• Un emulador de terminales que no ocupa toda la memoria cuando se abren simultáneamente
muchas ventanas.
El sitio web de KDE donde se puede obtener mas información y detalles de KDE es:
http://www.kde.org
Fundamentos de Linux 41
Capítulo 1 Introducción
9. Acceso al sistema
Para acceder al sistema se debe ser un usuario válido, esto es, un usuario que se dio de alta
por el administrador del equipo anteriormente, al usuario le fue asignado un nombre de cuenta y
un password.
Si es el superusuario (root) es preferible que cree otra cuanta de usuario normal para no
realizar cambios accidentalmente en el sistema.
Se puede ingresar al sistema en modo gráfico o modo linea de comandos.
42 Fundamentos de Linux
Introduccion
Acceso al Sistema
● ShellWelcome to Linux (i586) - Kernel 2.4.19-64GB-SMP (0).
zeus login: rootPassword:#
Capítulo 1 Introducción
Evaluación Capítulo
1. ¿Qué es Open Source?
2. ¿Qué es GNU?
3. ¿Para que fue creado y qué advierte la GNU General Public Licence?
4. ¿Diferencia entre free software y Open Source?
5. ¿Qué es software de Dominio Público?
Fundamentos de Linux 43
Capítulo 1 Introducción
6. Diferencias entre freeware, shareware y adware.
7. ¿Quién es el creador de Linux?
8. ¿Qué versiones de Linux se consideran estables?
9. Mencione dos características de Linux que están presenten en las versiones de UNIX.
10.¿Qué es una Distribución?
44 Fundamentos de Linux
Capítulo 1 Introducción
11. Mencione tres distribuciones de Linux
12.¿Qué es LSB?
13.¿Qué es FHS?
14.¿El sistema que maneja el entorno gráfico de Linux se llama?
15.Mencione dos entornos gráficos para Linux
Fundamentos de Linux 45
Capítulo 1 Introducción
16.Mencione 3 condiciones de distribución de un programa Open Source
17.¿Cuáles son las tres libertades específicas cuando se obtiene software GNU?
18.¿Cuál es la función de la FSF?
46 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
Capítulo 2 Manipulación deArchivos
Fundamentos de Linux 47
Capítulo 2 Manipulación de Archivos
48 Fundamentos de Linux
Manipulación de Archivos
Descripcion
Tipos De Archivosestructura
Estructura de directoriosManejo de Directorios (navegar, listar, crear, etc)
Directorios de trabajo Visualización y Manejo de ArchivosCaracteres de expansión de Nombres
Busqueda de ArchivosComparación de archivos
Capítulo 2 Manipulación de Archivos
Conceptos
Los tres conceptos esenciales para el manejo de archivos son:
• Tipo de Archivos en Linux
• Estructura jerárquica de directorios
• Creación y nombres de archivos
Fundamentos de Linux 49
Capítulo 2 Manipulación de Archivos
Tipos de archivos
Como en Windows, se puede emplear un cierto criterio de "tipo" para marcar las distintas clases
de archivos empleando una serie de caracteres al final del nombre que indiquen el tipo de
archivos del que se trata. Así, los archivos de texto, HTML, las imágenes PNG o JPEG tienen
extensiones .txt, .htm (o .html), .png y .jpg (o .jpeg) respectivamente.
Pese a esto Linux sólo distingue tres tipos de archivos:
• Archivos o archivos ordinarios, son los mencionados anteriormente.
• Directorios (o carpetas), es un archivo especial que agrupa otros archivos de una forma
estructurada.
• Archivos especiales o de dispositivo, son la base sobre la que se asienta Linux, puesto que
representan los dispositivos conectados a un ordenador, como puede ser una impresora. De
esta forma introducir información en ese archivo equivale a enviar información a la
50 Fundamentos de Linux
Manipulación de Archivos
Tipos de Archivos
● El uso de extensiones (.jpg, .tar, .txt) para identificación de archivos, para facilidad de las personas o aplicaciones
● En Linux se manejan basicamente tres tipos de archivos– Ordinarios
– Directorios
– De dispositivo
Capítulo 2 Manipulación de Archivos
impresora. Para el usuario estos dispositivos tienen el mismo aspecto y uso que los archivos
ordinarios. Dentro de este tipo de archivos se encuentran los denominados de caracter y los
de bloque:
• Dispositivos de caracter. Es el tipo más generico de driver de dispositivos que permiten la
transferencia de entrada/salida de cualquier tamaño, dependiendo de las capacidades del
dispositivo mismo. Los dispositivos que utilizan esta interfaz son: las terminales,
impresoras y ratones.
• Dispositivo de bloque. Es un driver de dispositivo que utiliza la instalación automática del
buffer donde se realizan las transferencias de entrada-salida de tamaño de hasta 1 Kbyte.
Los dispositivos que incluye esta interfaz son: los discos duros, las unidades de disco y la
RAM.
Fundamentos de Linux 51
Capítulo 2 Manipulación de Archivos
2.2 Estructura básica
La estructura de un archivo contiene dos aspectos fundamentales, los inodos y los datos:
• Los inodos son un índice de nodo que contiene la información sobre el archivo, como son
permisos del archivo, el propietario y el tamaño del archivo.
• Los datos son el contenido actual del archivo, puede estar vacío o tener un tamaño muy
grande.
La estructura de archivos es jerárquica y depende de los directorios. En general la estructura
del sistema de archivos se asemeja a una estructura de árbol, estando compuesto cada nudo
por un directorio o carpeta, que contiene otros directorios o archivos.
El sistema de archivos de Linux sigue todas las convenciones de Unix, lo cual significa que
tiene una estructura determinada, compatible y homogénea con el resto de los sistemas Unix.
52 Fundamentos de Linux
Manipulación de Archivos
Estructura de directorios
/
etcbin dev tmpsbinmntlib optboot root varprochome usr
Capítulo 2 Manipulación de Archivos
Al contrario que en Windows o MS-DOS el sistema de archivos en cualquier sistema Unix no
está ligado de una forma directa con la estructura del hardware, esto es, no depende de si un
determinado ordenador tiene 1, 2 o 7 discos duros para crear las unidades c:\, d:\ o m:\.
En los sistemas Unix, y por lo tanto en Linux, existe una única raíz llamada / de la que cuelgan
todos los archivos y directorios, y que es independiente de que dispositivos estén conectados al
ordenador. Estos archivos se organizan en distintos directorios cuya misión y nombre son
estándar para todos los sistema Unix.
• / Raíz del sistema de archivos.
• /dev Contiene archivos del sistema representando los dispositivos que estén físicamente
instalados en el ordenador.
• /etc Este directorio esta reservado para los archivos de configuración del sistema. En este
directorio no debe aparecer ningún archivo binario (programas). Bajo este deben aparecer
otros dos subdirectorios:
• /etc/X11 Archivos de configuración de X Window
• /etc/skel Archivos de configuración básica que son copiados al directorio del usuario
cuando se crea uno nuevo.
• /lib Contiene las bibliotecas necesarias para que se ejecuten los programas que residen
en /bin (no las bibliotecas de los programas de los usuarios).
• /proc Contiene archivos especiales que o bien reciben o envían información al kernel del
sistema (Se recomienda no modificar el contenido de este directorio y sus archivos).
• /sbin Contiene programas que son únicamente accesibles al superusuario o root.
• /usr Este es uno de los directorios más importantes del sistema puesto que contiene los
programas de uso común para todos los usuarios. Su estructura suele ser similar a la
siguiente:
• /usr/X11R6 Contiene los programas para ejecutar X Window.
• /usr/bin Programas de uso general, lo que incluye el compilador de C/C++.
• /usr/doc Documentación general del sistema.
• /usr/etc Archivos de configuración generales.
• /usr/include Archivos de cabecera de C/C++ (.h).
Fundamentos de Linux 53
Capítulo 2 Manipulación de Archivos
• /usr/info Archivos de información de GNU.
• /usr/lib Bibliotecas generales de los programas.
• /usr/man Manuales accesibles con el comando man.
• /usr/sbin Programas de administración del sistema.
• /usr/src Código fuente de programas.
Existen además de los anteriores otros directorios que se suelen localizar en el directorio /usr,
como por ejemplo las carpetas de los programas que se instalen en el sistema.
• /var Este directorio contiene información temporal de los programas (lo cual no implica que
se pueda borrar su contenido).
54 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
2.3 Nombres de archivos
La base del sistema de archivos de Linux, es obviamente el archivo, que no es otra cosa que la
estructura empleada por el sistema operativo para almacenar información en un dispositivo
físico como un disco duro, un disquete, un CD-ROM o un DVD. Como es natural un archivo
pede contener cualquier tipo de información, desde una imagen en formato PNG o JPEG a un
texto o una página WEB en formato HTML, etc. El sistema de archivos es la estructura que
permite que Linux maneje los archivos que contiene.
Todos los archivos de Linux tienen un nombre, el cual debe cumplir unas ciertas reglas:
• Un nombre de archivo puede tener entre 1 y 255 caracteres.
Fundamentos de Linux 55
Manipulación de Archivos
Nombres de Archivo
● Todos los archivos cuentan con un nombre de acuerdo a lo siguiente:– De 1 a 255 caracteres
– Cualquier carácter excepto “/”
– No se recomienda el uso de los caracteres especiales para el shell: \,?,*,[ ],( ), ^,”,',`,!,&,~,<,>
– Mayúsculas y minúsculas son diferentes
Capítulo 2 Manipulación de Archivos
• Se puede utilizar cualquier carácter excepto la barra inclinada / y no es recomendable
emplear los caracteres con significado especial en Linux, que son los siguientes: = \ ^ ~ ' " `
* ; - ? [ ] ( ) ! & ~ < >. Para emplear archivos con estos caracteres o espacios hay que
introducir el nombre del archivo entre comillas.
• Se pueden utilizar números exclusivamente si así se desea. Las letras mayúsculas y
minúsculas se consideran diferentes, y por lo tanto no es lo mismo carta.txt que Carta.txt ó
carta.Txt
56 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
3 Manejo de directorios
En esta sección se verán los comandos básicos para entrar, salir, crear directorios asi como
listar los archivos contenidos en estos.
3.1 Comandos básicos
Por lo general cada orden Linux puede tomar una serie de opciones definidas en forma de
argumentos. Estos usualmente comienzan con el carácter "-".
a) Navegando
En primer lugar para saber como movernos entre los distintos directorios es importante saber
en donde estamos localizados, esto se logra con el comando pwd. El comando pwd indica el
camino absoluto del directorio en el cual nos encontramos actualmente. Su sintaxis es:
# pwd
Fundamentos de Linux 57
Manipulación de Archivos
Manejo de Directorios
● Navegando entre directorios– cd, pwd, ., ..
● Listado de directorios– Ls
● Creado y Borrado de Directorios– Mkdir, rmdir, rm
Capítulo 2 Manipulación de Archivos
y despliega información sobre la pantalla como la siguiente:
/home/alumno/pruebas
Una vez que ya se sabe donde se está localizado se puede empezar a mover por la estructura
de los directorios, para esto se utiliza el comando “cd”, abreviación de "cambio de directorio". La
sintaxis de esta comando es:
# cd <directorio>
este comando nos posiciona dentro del directorio que se especifica.
Al entrar al sistema se comienza en el directorio “home” del usuario con el que se entró al
sistema, si un usuario “alumno” quiere entrar a una subcarpeta “documentos” debe ejecutar:
alumno@curso1:~/alumno> cd documentos
alumno@curso1:~/documentos>
Ahora alumno está en el subdirectorio documentos, para volver al directorio padre de este,
usará la orden:
alumno@curso1:~/documentos> cd ..
alumno@curso1:~>
Dese cuenta del espacio entre "cd" y "..". Cada directorio tiene una entrada de nombre ".." la
cual se refiere al directorio padre. De igual forma, existe en cada directorio la entrada "." la cual
se refiere a si mismo. Así que el comando
alumno@curso1:~/documentos> cd .
alumno@curso1:~/documentos>
nos deja donde estamos.
También pueden usarse nombres con el camino absoluto en la orden cd. Para ir al directorio de
“instructor” con cd, introduciremos la siguiente orden.
alumno@curso1:~/documentos> cd /home/instructor
alumno@curso1:~/instructor>
58 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
También, usando “cd” sin argumentos nos llevará a nuestro directorio de origen.
alumno@curso1:~/instructor> cd
alumno@curso1:~/alumno>
b) Listado (ls y variantes)
Ahora que ya sabe como moverse por los directorios necesitamos el comando ls, que despliega
la lista de archivos y directorios, por defecto los del directorio activo. Su sintaxis es:
# ls [opciones] [directorios]
Por ejemplo:
alumno@curso1:~/alumno> ls
documentos
imagenes
tareas
alumno@curso1:~/alumno>
Aquí podemos ver que alumno tiene tres entradas en su directorio actual:
documentos, tareas e imágenes.
Algunas opciones que toma este comando son:
• -F clasifica los archivos desplegados en la pantalla, al final de cada archivo coloca un
caracter que identifica de que tipo es;
• “/” indica que es un directorio,
• “*” indica que es un archivo ejecutable,
• “@” indica que es una liga, si no tiene ningun caracter al final indica
que es un archivo ordinario.
• ls -a Muestra todos los archivos incluyendo algunos que ordinariamente están ocultos para
Fundamentos de Linux 59
Capítulo 2 Manipulación de Archivos
el usuario (aquellos que comienzan por un punto). Se recuerda que el archivo punto . indica
el directorio actual y el doble punto .. el directorio padre, que contiene, al actual.
• ls -l Esta es la opción de lista larga: muestra toda la información de cada archivo incluyendo:
protecciones, tamaño y fecha de creación o del último cambio introducido.
• ls --color Muestra el contenido del directorio coloreado.
• ls -t Muestra ordenando por día y hora de modificación.
• ls -r Muestra el directorio y lo ordena en orden inverso.
• ls -R Muestra directorios recursivos.
• ls -k Muestra el tamaño del archivo en kilobytes.
• ls -s Muestra el tamaño del archivo en bloques.
• ls -x Lista en columnas.
El comando ls admite los caracteres de sustitución o metacarácteres (*) y (?). El caracter *
representa cualquier conjunto o secuencia de caracteres. El caracter ? representa cualquier
caracter, pero sólo uno.
c) Creación y borrado (mkdir,rmdir y rm)
El comando que se utiliza para la creación de archivos es mkdir, su sintaxis es:
# mkdir [opciones] directorio.
Sus opciones son:
• -m modo - establece los permisos de los directorios creados.
• -p - crea los directorios padre que falten para cada argumento directorio
Pruebe lo siguiente:
alumno@curso1:~/alumno> mkdir musica
60 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
alumno@curso1:~/alumno> ls -F
documentos/
imagenes/
musica/
tareas/
alumno@curso1:~/alumno> cd musica
alumno@curso1:~/musica> ls
alumno@curso1:~/musica>
Acaba de crear un directorio nuevo y moverse a él.
Para borrar un archivo se usa el comando rm. ("rm" viene de "remove"), su sintaxis es :
# rm [opciones] <archivos | directorios>
las opciones son:
• -r - borra recursivamente un directorio.
• -f - borra forzosamente en caso de que no se tenga permiso de escritura en forma directa.
• -i - ejecuta el comando de forma interactiva.
Un ejemplo de le ejecución de este comando es:
alumno@curso1:~/tarea> rm resumenlibro
alumno@curso1:~/tarea> ls -F
investigacion
tareas_ingles/
alumno@curso1:~/tarea>
Nótese que rm por defecto no preguntará antes de borrar un archivo, sea cuidadoso.
Una orden relacionada con rm es rmdir. Esta orden borra un directorio, pero sólo si está vacio.
Su sintaxis es:
# rmdir directorio
Si el directorio contiene archivos o subdirectorios, rmdir se quejará.
Fundamentos de Linux 61
Capítulo 2 Manipulación de Archivos
3.2 Home directory
El Home Directory es el directorio personal para cada usuario dado de alta en el sistema, este
directorio de encuentra sobre /home/”usuario”, es el directorio de inicio al prender la máquina y
en donde se guarda la información de dicho usuario.
alumno@curso1:~/alumno> pwd
/home/alumno
alumno@curso1:~/alumno>
Contiene subdirectorios, datos y archivos de configuración de su entorno de trabajo.
Una vez que te encuentres en tu home directory puedes desplazarte entre otros directorios de
otros usuarios, si se tienen los permisos necesarios.
alumno@curso1:~/alumno> cd /home/instructor
bash: cd: /home/instructor/: Permission denied
Nos podemos referir al propio home directory con el metacaracter “~” de la siguiente manera:
alumno@curso1:~/alumno> cd /home/alumno/tarea
alumno@curso1:~/alumno> cd ~/tarea
62 Fundamentos de Linux
Manipulación de Archivos
Directorios predeterminados
● Home Directory– Directorio de trabajo por defecto de cada usuario
● Directorio actual– Directorio en el que se esta actualmente (.)
● Directorio Padre– Directorio superior del directorio actual (..)
Capítulo 2 Manipulación de Archivos
3.3 Directorio actual
En cualquier momento, las órdenes que teclee al intérprete de comandos son dadas en
términos de su directorio de trabajo actual. Puede pensar en su directorio actual de trabajo
como en el directorio en el que actualmente está "situado". Cuando entra en el sistema, su
directorio de trabajo se inicializa a su directorio home_/home/”usuario” . En cualquier momento
que referencie a un archivo, puede hacerlo en relación a su directorio de trabajo actual, en lugar
de especificar el camino completo del archivo.
Vemos un ejemplo. Juan tiene el directorio tareas, y tareas contiene el archivo investigación.
Si Juan quiere echar un vistazo a ese archivo, puede usar la orden
/home/Juan# more /home/Juan/tareas/investigacion
La orden “more” simplemente muestra el archivo, pantalla a pantalla. Pero, como el directorio
de trabajo actual de Juan es “/home/Juan”, podría haberse referido al archivo de forma relativa
a su directorio de trabajo actual. La orden sería
/home/Juan# more tareas/investigacion
Fundamentos de Linux 63
Capítulo 2 Manipulación de Archivos
3.4 Ruta absoluta
Todos los archivos tienen una única dirección absoluta que es hecha con la concatenación de
todos los nombres de directorios bajo la jerarquía, empezando desde el directorio root hasta el
archivo. Los nombres de los directorios están separdos por “/”.
Una ruta absoluta siempre empieza con “/”, que representa el directorio root.
Usando la ruta absoluta es fácil accesar a los archivos de arriba del directorio actual de trabajo.
Otro término para referirse a la ruta absoluta es ruta completa
El comando pwd despliega la ruta absoluta de tu directorio de trabajo actual.
64 Fundamentos de Linux
Manipulación de Archivos
Rutas Absolutas
● Ruta Absoluta– Cuando se hace referencia a un directorio desde la raiz
se habla de ruta absoluta.
– ej. $cd /usr/local/bin
– El comando pwd despliega la ruta absoluta del directorio actual
● Ruta Relativa– Cuando se hace referencia a directorios a partir del
directorio
Capítulo 2 Manipulación de Archivos
3.5 Ruta relativa
Una ruta relativa especifica un archivo con una ruta que es relativa a tu directorio actual de
trabajo.
Para acceder a archivos en el directorio de trabajo actual o cualquiera de los subdirectorio, se
puede usar la ruta relativa. Por ejemplo, si está sobre el directorio /home/Juan/# , para listar un
archivo en el directorio /home/Juan/tareas/tareas_ingles/tarea1, use:
#ls -l tareas/tareas_ingles/tarea1
Una ruta relativa no empieza con “/”
Se pueden utilizar los directorios especiales punto (.) y punto-punto (..)en rutas relativas para
acceder a archivos dentro del directorio de trabajo actual. Por ejemplo , si está en el directorio /
home/Pedro y quiere listar el directorio /home/Juan/tareas, debe teclear el comando:
Fundamentos de Linux 65
Manipulación de Archivos
Rutas Relativas
● Ruta relativa– Cuando referenciamos directorios a partir del actual
– O usando “.” y “..” ● Cd ..● ./a.out
mariog@venus:~> pwd/home/mariogmariog@venus:~> cd tempmariog@venus:~/temp> pwd/home/mariog/tempmariog@venus:~/temp>
Capítulo 2 Manipulación de Archivos
#ls ../Juan/tareas
Recuerde que el directorio punto-punto esta en todos los directorios y hace referencia al
directorio padre . En el ejemplo el directorio padre de /home/Pedro es /home.
66 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
4. Visualización y manejo de archivos
Se verán los comandos básicos para la manipulacion de archivos.
4.1 Creación y organización de archivos
Copia de archivos. Comando cp
Este comando tiene la siguiente sintaxis:
cp [opciones] <fuente> <destino>
y hace una copia de “fuente” y le llama “destino”. Si “destino” no existía, lo creá con los mismos
atributos de “fuente”. Si “destino” existía antes, su contenido queda destruido y es sustituido por
el de “fuente”. El archivo “destino” estará en el mismo directorio que “fuente”. Tanto “fuente”
como “destino” indican el nombre de un archivo, que puede incluir la ruta al mismo si alguno de
ellos no se encuentra en el directorio actual.
Fundamentos de Linux 67
Manipulación de Archivos
Creación y Organización de Archivos
● Copia de Archivos– cp
● Enlaces a archivos– ln
● Traslado y renombre de Archivos– mv
● Creacion de Archivos (vacios)– touch
Capítulo 2 Manipulación de Archivos
Algunas opciones de este comando son:
• -p - si es posible preserva los atributos (dueño, grupo y permisos) de los archivos originales
en las copias.
• -d - preserva los enlaces simbólicos en lugar de copiar los archivos a los que estos apuntan.
Actualmente es así por defecto.
• -L - no preserva los enlaces simbólicos, o sea copia los archivos a los que estos apuntan.
• -R - copia recursívamente un directorio.
• -a - es equivalente a las opciones -dpR.
• -i - utiliza una forma interactiva (pregunta antes de sobrescribir el destino).
• -l - hace enlaces fuertes a los archivos fuentes en lugar de copiarlos.
Otra posibilidad es:
cp fuente1 fuente2 destino
que hace copias de “fuente1” y “fuente2” en el directorio “destino”.
Enlaces a archivos. Comando ln
En Linux un mismo archivo puede estar repetido con más de un nombre, ya que con el
comando cp se pueden realizar cuantas copias se desee del archivo. Pero, a veces, es más
práctico tener un mismo archivo con varios nombres distintos, y lo que es más importante,
poder acceder a él desde más de un directorio. En Linux esto recibe el nombre de enlaces
múltiples a un archivo. El ahorro de espacio de disco es importante al poder compartir un
archivo con más de un usuario. Estos enlaces son muy prácticos a la hora de utilizar archivos
que pertenecen a directorios distintos. Gracias a los enlaces se puede acceder a muchos
archivos desde un mismo directorio, sin necesidad de copiar en ese directorio todos esos
archivos. La sintaxis de este comando es,
68 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
# ln [opciones] origen destino
A partir de este momento el archivo “origen” tiene dos nombres: “origen” y “destino”. A
diferencia de los comandos cp y mv, este comando toma más precauciones, ya que advierte
previamente si el nombre “destino” está ocupado, y en este caso no se ejecuta.
Las opciones más comunes de este comando son:
• -d - permite al super-usuario (root) hacer enlaces rígidos a directorios.
• -s - crear enlace simbólico (ligas suaves).
• -f - borrar los archivos de destino que ya existen.
Los archivos enlazados a otro se borran como los archivos normales. Si se borra el archivo
original permanece su contenido en los archivos enganchados.
Existen ligas fuertes y ligas sueves (opción -s) la diferencia entre estas dos tipos de ligas es
que las primeras realizan una copia del archivo al archivo original, hasta llegar a confundir cúal
es cúal, y cada archivo creado con ligas fuertes tiene un i-nodo diferente, el i-nodo es un
número que identifica al archivo, cuando se crean ligas suaves, el i-nodo se conserva, el
concepto de liga suave es muy similar a un acceso directo en Windows, ya que no ocupa
espacio en disco duro.
Traslado y cambio de nombre de archivos. Comando mv
Este comando mueve un archivo de un directorio a otro. Este comando tiene una sintaxis
similar al comando cp:
# mv [opciones] fuente destino
El comando mv realiza la misma función que el cp pero además destruye el archivo original. En
definitiva traslada el contenido de “fuente” a “destino”; a efectos del usuario lo que ha hecho es
cambiar el nombre a “fuente”, llamándole “destino”.
Algunas opciones de este comando son:
Fundamentos de Linux 69
Capítulo 2 Manipulación de Archivos
• -i - ejecuta el comando de forma interactiva, o sea, pregunta ante de sobrescribir el destino si
existiera.
• -u - actualiza (upgrade) el destino con el fuente solo si este es más reciente.
Hay que recalcar que el comando mv sirve así mismo para cambiar el nombre de los archivos.
Borrado de archivos. Comando rm
Este comando tiene la sintaxis siguiente:
# rm [opciones] archivo
Este comando elimina uno o más archivos de un directorio en el cual tengamos permiso de
escritura. Con este comando resulta facilísimo borrar archivos inútiles, y desgraciadamente,
también los útiles.Por eso es conveniente y casi imprescindible emplear lo opción -i, de la forma
siguiente:
# rm -i archivo
Con esta opción, Linux pedirá confirmación para borrar cada archivo de la lista, de si realmente
se desea su destrucción o no. Se recomienda usar siempre este comando con esta opción para
evitar el borrado de archivos útiles. Por ejemplo, si se teclea,
# rm -i superfluo
aparecerá en pantalla el aviso siguiente:
remove superfluo?
y habrá que contestar y (yes) o n (not). En este comando se pueden utilizar los caracteres de
sustitución (* y ?), como por ejemplo,
#rm fich*
que borraría todos los archivos del directorio actual que comiencen por fich. El comando rm *
borrará todos los archivos del directorio actual, mientras que
70 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
#rm -i *
realiza una labor análoga, pero con previa confirmación.
Crear archivos. Comando touch
Puede crear archivos nuevos usando el comando touch, que creará un archivo vacío que puede
usar para añadir textos o datos. Este comando tiene la sintaxis siguiente
# touch file
Fundamentos de Linux 71
Capítulo 2 Manipulación de Archivos
4.2 Visualización de archivos de texto
Comando cat
Este comando permite visualizar el contenido de uno o más archivos de forma no formateada.
También permite copiar uno o más archivos como apéndice de otro ya existente. La sintaxis de
este comando es la siguiente:
# cat [opciones] file
Las opciones que toma este comando son:
• -n - numera las líneas
• -s - elimina las líneas en blanco
Algunas formas de utilizar este comando son las siguientes,
72 Fundamentos de Linux
Manipulación de Archivos
Visualización de archivos
● Texto– cat, more y less
– tail y head
● Datos– od
– strings
Capítulo 2 Manipulación de Archivos
# cat file
Saca por pantalla el contenido del archivo filename.
# cat file1 file2...
Saca por pantalla, secuencialmente y según el orden especificado, el contenido de los archivos
indicados.
# cat file1 file2 >file3
El contenido de los archivos file1 y file2 es almacenado en file3.
# cat file1 file2 >>file3
El contenido de file1 y file2 es añadido al final de file3.
# cat >file1
Acepta lo que se introduce por el teclado y lo almacena en file1 (se crea file1). Para terminar se
emplea <ctrl>d
Comandos more y less
Estos comandos permiten visualizar un archivo pantalla a pantalla. El número de lineas por
pantalla es de 23 líneas de texto y una última linea de mensajes, donde aparecerá la palabra
“more”. Cuando se pulsa la barra espaciadora (el espacio en blanco), se visualizará la siguiente
pantalla. Para salir de este comando se pulsa “<ctrl>d” o “q”. La sintaxis es:
# more [opciones] file
Las opciones son:
• -c - edita pantalla a pantalla
• -d - número de lineas que se van a editar
• +número de líneas - número de la línea a partir de la cual se va a editar.
El comando less es muy similar al anterior pero permite el desplazamiento a lo largo del texto
Fundamentos de Linux 73
Capítulo 2 Manipulación de Archivos
empleando las teclas de cursores pudiendo desplazarse hacia arriba o abajo de un archivo. Su
sintaxis es:
# less file
Comandos head y tail
Estos dos comandos funcionan como filtros.
Puede utilizar el comando head en caso de que desee ir al inicio de un archivo. El comando es:
#head [opciones] file
Las opciones que toma este comando son:
• -c N - escribe los primeros N bytes.
• -n N - escribe las primeras N lineas en vez de las primeras 10 (que es el valor
predeterminado).
Head puede ser muy útil, pero como está limitado a las primeras líneas, no podrá ver el largo
del archivo.
El contrario de “head” es “tail”. Usando “tail”, puede volver a ver las diez últimas lineas de un
archivo. Esto puede ser muy útil para ver las últimas lineas de un archivo de registro y así ver
los mensajes importantes del sistema. También puede usar “tail” para vigilar cómo se actualizan
los archivos de registro (log). Usando la opción -f, tail imprimirá automáticamente los nuevos
mensajes desde un archivo abierto a la pantalla en tiempo real. El camando es:
# tail [opciones] file
Sus opciones son:
• -c N - escribe los últimos N bytes
• -n N - escribe las últimas N líneas.
• -f - escribir la última parte del archivo a medida que va creciendo. Esta opción es muy útil
para monitorear archivos de registro que van creciendo con el tiempo.
74 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
Por defecto, sólo puede leer las últimas diez líneas de un archivo, aunque puede cambiar este
número especificándolo, como en el comando a continuación:
#tail -20 file
4.3 Visualización de archivos de datos
Comando od
El comando od (Octal Dump), nos permite ver byte a byte el contenido de un archivo. Su
sintaxis es:
# od [opciones] file
Las opciones posibles de este comando son:
• -b - interpreta los bytes como números octales
• -c - interpreta los bytes como caracteres
• -h - interpreta los bytes como números hexadecimales
od -cb archivo nos muestra los caracteres, y debajo de cada caracter el número octal del byte.
Cuando se ejecuta este comando la primera columna es la dirección de cada línea que vemos.
od nos muestra el contenido del archivo expresado en números octales, generalmente tomados
de a dos bytes.
Comando strings
El comando strings busca secuancias de cuatro a mas caracteres imprimibles en un archivo
binario y lo imprime en la salida estándar. Su sintaxis es:
# strings [opciones] file
Las opciones que toma son:
• -a explora archivos en su totalidad
Fundamentos de Linux 75
Capítulo 2 Manipulación de Archivos
• -n num especifica el mínimo de la longitud de la cadena a reportar, el valor por default es 4.
• -t formato escribe cada cadena precedida por su compensación de byte en el archivo. El
formato a usar para la compensación son: d (decimal), o (octal) y x (hexadecimal).
76 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
4.4 Caracteres de expansión de nombres
Los símbolos * y ? son denominados metacaracteres ya que se pueden utilizar para sustituir
caracteres a la hora de ejecutar varios comandos.
EL “*” puede ser sustituido por un número indeterminado de cualquier combinación de
caracteres.
alumno@curso1:~/etc> ls pas*
passwd passwd- passwd.lock
El “?” sólo representa a un caracter cualquiera.
alumno@curso1:~/etc> ls pas?wd
passwd
Los rangos, expresados con corchetes "[ ]", son metacaracteres de posición y reemplazan todos
los caracteres que estén dentro del rango definido. Los rangos que pueden definirse son letras
Fundamentos de Linux 77
Manipulación de Archivos
Expansión de nombres
● Metacaracteres de expansion de nombres, permiten la sustitucion de nombres y caracteres cuando se hace referencia a varios archivos– *
– ?
– [ ]
– [^ ]
Capítulo 2 Manipulación de Archivos
minúsculas, letras mayúsculas y números del 0 al 9. Un rango no puede ir desde la "a"
minúscula hasta la "Z" mayúscula. Existen formas de definir estos rangos, pero hay que usar
"rangos combinados".
78 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
4.5 Búsqueda de archivos
Comando locate
El comando locate busca en una base de datos, actualizada periódicamente, todos los paths en
la jerarquía de archivos que contengan una cadena determinada. Su sintaxis es:
# locate
El programa updatedb actualiza la base de datos de locate. Explora por completo el sistema de
archivos (incluidos otros sistemas de archivos que se encuentren montados a no ser que se le
indique lo contrario) e inserta todos los directorios y archivos que encuentre en la base de datos
que usa locate para recuperar dicha información. La sintaxis de este comando es:
# updatedb
Fundamentos de Linux 79
Manipulación de Archivos
Busqueda de Archivos
● Mediante uso de base de datos indexada– Updatedb
– Locate
● Mediante una busqueda explicita y por patrones– find [camino] [opciones]
Capítulo 2 Manipulación de Archivos
Comando find
El comando find es uno de los más poderosos en un sistema Linux. Permite buscar de forma
recursiva en un directorio a todos los archivos que cumplan ciertas condiciones. Las
condiciones pueden estar relacionadas con el nombre de los archivos, el tamaño, los permisos,
el tipo, las fechas de acceso y modificación, etc. La sintaxis es:
# find [camino] [opciones]
Algunas opciones:
• -name <expresión> : permite especificar patrones para los nombres de los archivos a buscar.
• -type <tipo> : permite indicar el tipo de archivo a buscar. Este puede ser d para directorios, f
para archivos regulares, l para enlaces simbólicos, b para dispositivos de bloque, c para
dispositivos de caracter, p para tuberías y s para sockets.
• -size +/-<n> : permite indicar el tamaño máximo y/o mínimo de los archivos a buscar. Por
defecto el tamaño se expresa en bloques de 512 bytes, pero si se precede este por un
caracter “c” se referirá a bytes, “k” a kilobytes, “w” a palabras de dos bytes y “b” a bloques.
• -perm [+|-]<modo> : permite referirse a aquellos archivos cuyos permisos sean exactamente
modo, incluya todos los de modo (signo -) o incluya alguno de los de <modo> (signo +). El
valor de <modo> se expresa en forma numérica.
• -nouser/-nogroup : permite referirse a aquellos archivos o directorios que no posean dueño o
grupo asociado.
• -inum <n> : permite referirse a los archivos a través de su número de i-nodo.
• -exec <comando>: permite definir un comando a ejecutarse para cada resultado de la
búsqueda. La cadena {} se sustituye por el nombre de los archivos encontrados. El caracter ;
permite indicar la finalización del comando.
# find /etc -name '*.conf' -->busca en /etc todos los archivos con extensión
conf
80 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
4.6 Comparación de archivos
Comando diff
El comand diff fué creado para comparar el contenido de dos archivos cualesquiera y mostrar
en una lista las líneas en las que se hayan detectado diferencias. La sintaxis es:
# diff [opcion)] file1 file2
• -q - indica tan sólo si existen diferencias entre el contenido de los dos archivos
seleccionados.
• -b - hace que se ignoren los espacios en blanco tanto finales como tratados en grupo.
Fundamentos de Linux 81
Manipulación de Archivos
Comparación y verificación de Archivos
● Comparación– cmp
– diff
● Verificación mediante algoritmos de “checksum”– sum
– md5sum
Capítulo 2 Manipulación de Archivos
Comando cmp
El comando cmp compara el contenido de dos archivos, imprimiendo en pantalla por defecto la
primera diferencia encontrada (si existe). Esta orden recibe como parámetro los dos nombres
de los archivos a comparar. Su sintaxis es:
# cmp [opciones] file1 file2
Las opciones son:
• -l - muestra un listado completo de todas las diferencias.
• -s - el comando devuelve un valor de comparación que será:
• 0 si los archivos son idénticos.
• 1 si los archivos son diferentes.
• 2 si ha habido un error en la ejecución del comando.
Comando sum
El comando sum calcula e imprime en la salida estándar la suma de las palabras de un archivo,
ademas de imprimir el numero de bloques del archivo. Si no se especifica un nombre de archivo
se utiliza la salida estándar. La sintaxis es:
# sum [opciones] file
Las opciones pueden ser:
• -r – usa el algoritmo sum BSD, usa bloques de 1K
• -s – usa el algoritmo sum del sistema V, usa bloques de 512 bytes
Comando md5sum
El comando md5sum es similar al comando sum, con la diferencia de que utiliza el algoritmo de
la suma md5.
82 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
Las sumas MD5, también llamadas “digests” o “hashes”, son cadenas obtenidas mediante la
aplicación de un algoritmo de cifrado llamado MD5 a una entrada.
MD5 (Message Digest Algorithm #5), es un algoritmo de cifrado que realiza la comprobación de
la integridad de archivos binarios, mediante la generación de códigos de control llamados
"hashes", una clase de huella digital única.
Fundamentos de Linux 83
Capítulo 2 Manipulación de Archivos
Evaluación Capítulo
1. ¿Cuáles son los tipos de archivo que maneja Linux?
2. ¿Qué es un archivo de dispositivo de caracter y de dispositivo de bloque?
3. Mencione los aspectos fundamentales de la estructura de un archivo
4. Mencione las características de la estructura de archivos en Linux
84 Fundamentos de Linux
Capítulo 2 Manipulación de Archivos
5. Describa el Contenido de:
/usr
/var
/etc
/usr/lib.
6. ¿Qué es un archivo?
7. ¿Cuáles son las reglas que debe cumplir el nombre de un archivo?
8. ¿Qué es el Home Directory?
Fundamentos de Linux 85
Capítulo 2 Manipulación de Archivos
9. Mencione la diferencia entre ruta absoluta y ruta relativa.
10.Mencione la diferencia entre liga fuerte y liga suave .
86 Fundamentos de Linux
Capítulo 3 Edición de Archivos
Capítulo 3 Edición deArchivos
Fundamentos de Linux 87
Capítulo 3 Edición de Archivos
88 Fundamentos de Linux
Edición de Archivos
Descripción
Uso y Editores de texto en LinuxVI
Modos de operaciónTerminaciónNavegación
Inserción y edición de textocopiado y pegado de texto
BúsquedaConfiguración
Capítulo 3 Edición de Archivos
1 Descripción del capítulo.
En este capítulo se introduce al alumno a una de las tareas básicas del sistema operativo y de
las más importantes que es la edición de archivos de texto, los cuales pueden ser programas,
archivos de configuración u otros, enfocándose principalmente en el editor “VI”.Los puntos que
se describen son:
Uso y editores de texto en Linux
Editor VI
Modos de operación de VI
Terminación de VI
Navegando en VI
Inserción y Edición de texto en VI
Copiado y pegado de Texto
Búsqueda de Texto en VI
Configuración del Editor VI
Fundamentos de Linux 89
Capítulo 3 Edición de Archivos
2 Editores de texto.
Un editor de texto es simplemente un programa usado para la edición de archivos que
contienen texto, como una carta, un programa en C, o un archivo de configuración del sistema.
2.1 Uso
Los editores de texto se utilizan principalmente para la edición de archivos de configuración y la
creación de shell.
2.2 Editores de texto comunes en Linux
a) Vi & Vim.
VI es un editor de texto visual, de pantalla completa, basado en el editor de línea ed. Es un
editor que se puede encontrar en cualquier sistema UNIX, desde antiguas estaciones Sun
Solaris o HP-UX hasta las más recientes distribuciones de GNU/Linux o FreeBSD, OpenBSD,
90 Fundamentos de Linux
Edición de Archivos
Uso y editores comunes
● Edición y Modificación de archivos de texto– Cartas
– Programas (C, Fortran, Java, etc.)
– Archivos de configuración
● Editores comunes:– VI o Vim
– Emacs
– Pico
– Otros (Joe, etc.)
Capítulo 3 Edición de Archivos
etc.
Por otro lado existe VIM (VI Improved, VI Mejorado) es el editor de texto VI de toda la vida, pero
con una serie de mejoras y añadidos que lo hacen aún mejor:
• es bastante más amigable que VI, ya que permite un uso más intuitivo
• incorpora coloreado de sintaxis para casi todos los lenguajes de programación y ficheros de
configuración que puedas encontrar en Linux/UNIX.
• la posibilidad de utilizar un interfaz gráfico
VI es además un editor muy potente, que permite hacer complicadas operaciones en grandes
archivos con unos pocos comandos, por lo que su aprendizaje puede ahorrarnos mucho tiempo.
Otra ventaja de VI es que al ser tan común suele encontrarse incluso en disquetes de rescate.
Para ejecutar este editor se corre el comando vi para utilizar VIM se corre simplemente vim, en
algunas distribuciones de Linux “vi” y “vim” suelen ser el mismo comando. . Si quieres utilizar la
interfaz gráfica de VIM ejecuta “gvim”.
En el resto del tema conservaremos el nombre de VI aunque estemos trabajando con VIM.
Este comando admite varias opciones que se le pueden pasar como parámetros, p. ej. el
nombre del archivo que queremos editar:
# vi file
También puedes especificar la linea en la que quieres empezar con el parámetro +n. Por
ejemplo para empezar en la línea 12:
# vi file +12
en la página http://www.vim.org/ puede encontrar mas información sobre este editor
b)Emacs
Emacs, junto con VI, ha sido uno de los primeros editores de texto para UNIX. Visualmente
presenta un interfaz similar al de un editor de texto corriente, lo cierto es que tiene muchísimas
Fundamentos de Linux 91
Capítulo 3 Edición de Archivos
posibilidades que no atribuirías a un editor de texto para consola. Por ejemplo, el indentado
automático de código Pascal, Java, C, o cualquier lenguaje para el que haya escrito un módulo
para Emacs de asistencia a la programación, nos ofrece posibilidades de trabajar con CVS,
enviar correo electrónico, y un largo etcétera de posibilidades.
Existen cientos de combinaciones de teclas en Emacs que nos permiten hacer cualquier cosa
sin ver un menú. Los usuarios expertos de Emacs valoran esta posibilidad, pues a la hora de
escribir con prisas, un menú puede ser algo muy incómodo. Pero para los que están
empezando la tecla F10 nos da acceso a todos los menús de Emacs, menú, archivo, edición,
cambio entre las distintas ventanas de edición de texto, etc.
# emacs file
Si desea más información consulte la página http://www.gnu.org/software/emacs/emacs.html
c) Pico
Pico es un editor simple orientado a pantalla de texto, basado en el compositor de sistemas de
mensajes 'Pine'. Al igual que Pine, las órdenes se muestran al pie de la pantalla, y se suministra
ayuda sensible al contexto. Los caracteres se insertan de forma inmediata en el texto al
teclearlos.
Para interactuar con el editor hay que utilizar una combinación de teclas del tipo:
• control-letra (^ letra abreviado):
• ^X sale del editor
• ^O guarda los cambios
• ^W busca una cadena
• ^K corta texto
• ^U pega texto cortado previamente
• ^G obtienes ayuda
92 Fundamentos de Linux
Capítulo 3 Edición de Archivos
# pico file
Para mas información visite la página de pico http://www.nano-editor.org/
d) Joe
El primer editor que suele aprenderse en Linux es Joe, por ser muy sencillo y rápido. Puede
usarse para editar cualquier fichero. Todos estos ficheros pueden editarse con más comodidad
con editores más potentes como Emacs o VIM pero para ello es necesario aprender a usarlos
primero, lo cual puede no resultar tan sencillo como aprender Joe.
El manejo de Joe se basa en combinaciones de teclas con la tecla Control. Denotaremos por
“Ctrl-x y” a la combinación de teclas que se obtiene al pulsar la tecla Control, seguidamente (sin
soltar la primera) pulsar la tecla x y después (soltando las teclas anteriores) pulsar la tecla y.
# joe file
Fundamentos de Linux 93
Capítulo 3 Edición de Archivos
Vi & Vim
3.1 Iniciando vi
La sintaxis de vi es:
# vi file
donde file es el nombre del archivo que desea editar.
3.2 Modos de operación
Mientras se usa vi, en cualquier momento estará en uno de tres posibles modos de operación.
Estos modos son conocidos como modo comandos, modo inserción y modo última línea.
Cuando inicia vi, está en el modo comando. Este modo le permite usar ciertas órdenes para
94 Fundamentos de Linux
Edición de Archivos
VI y modos de Operación
● VI (visual editor)– Basado en de
– Editor comun en Unix
● Sus modos de Operación– Inserción
– Comandos
– Edición en linea (ed)
● Inicio:– #vi [opciones] archivo1 [archivo2 ...]
Capítulo 3 Edición de Archivos
editar archivos o cambiar a otros modos. Por ejemplo, tecleando "x" mientras está en el modo
órdenes, borra el carácter que hay debajo del cursor. Las teclas del cursor mueven el cursor por
el fichero que estamos editando.
Generalmente, las órdenes usadas en este modo son sólo de uno o dos caracteres de longitud.
Habitualmente insertará o editará texto desde el modo inserción. Usando vi, probablemente
dedicará la mayor parte del tiempo en este modo. Inicia el modo de inserción al usar una orden
como "i" (para "insertar") desde el modo de órdenes. Una vez en el modo de inserción, irá
insertando texto en el documento desde la posición actual del cursor. Para salir del modo de
inserción y volver al de órdenes, pulse | esc |.
Modo última línea es un modo especial usado para proporcionar ciertas órdenes extendidas a
vi.
Al usar esos comandos, aparecen en la última línea de la pantalla (de ahí el nombre). Por
ejemplo, cuando teclea ":" desde el modo de órdenes, entrará en el modo última línea, y podrá
usar órdenes como "q!" (para salir de vi sin guardar los cambios). El modo de última línea es
habitualmente usado por órdenes vi mayores de un carácter.
En el modo de última línea, introduce una orden de una sola línea y pulsa <enter> para
ejecutarla.
Fundamentos de Linux 95
Capítulo 3 Edición de Archivos
3.3 Terminación de vi y salvado de archivos
Al pulsar ":", el cursor se desplazará a la última linea de la pantalla; está en modo última linea.
En el modo de última línea hay disponibles una serie de órdenes extendidas.
• La orden :q!, la cual permite salir de vi sin guardar los cambios.
• La orden :wq salva el archivo y sale de vi.
• La orden ZZ (desde el modo de comandos, sin ":") es equivalente a :wq.
• Para salvar el fichero sin salir de vi, simplemente use :w.
Recuerde que debe pulsar <enter> después de introducir la orden para que esta se ejecute en
el modo última linea.
96 Fundamentos de Linux
Edición de Archivos
Terminación de Vi
● Modo Comandos– ZZ:
● Modo de– :wq
– :q
– :q!
– :w
Capítulo 3 Edición de Archivos
3.4 Comandos para movimiento del cursor
Para desplazarse por el documento, además de las teclas del cursor existen otras opciones
tales como:
• h para mover el cursor a la izquierda
• j para mover el cursor hacia abajo
• k para mover el cursor hacia arriba
• l para mover el cursor a la derecha
• w mueve el cursor al comienzo de la siguiente palabra
• b lo lleva al comienzo de la palabra anterior
• 0 (cero) mueve el cursor al comienzo de la línea actual
Fundamentos de Linux 97
Edición de Archivos
Movimiento del Cursor
● Movimientos comunes:– h(←), j(↓), k(↑), l(→)
● En la linea:– w(inicio siguiente palabra), b(inicio palabra anterior, 0
(inicio de linea),$(fin de linea)
● En pantalla:– H (inicio texto en pantall), M(mitad texto en pantalla), L
(final texto en pantalla)
● Por páginas– <CTRLf> avance, <CTRLb> retroceso
Capítulo 3 Edición de Archivos
• $ lo lleva al final de la línea.
• <ctrl-F> avanza el cursor una pantalla hacia adelante
• <ctrl-B > lo lleva una pantalla atrás.
• H Inicio pantalla actual
• M Mitad pantalla actual
• L Final Pantalla actual
• G. para llevar el cursor al final del archivo, Puede también desplazarse a una linea arbitraria;
por ejemplo, pulsando la orden 10G llevará el cursor a la linea 10 del fichero. Para
desplazarse al comienzo, use 1G.
98 Fundamentos de Linux
Edición de Archivos
Movimiento del cursos (Cont.)
● Posiciones Específicas– G al final del archivo
– NG a la linea N
● En modo de– :N a la linea N
Capítulo 3 Edición de Archivos
3.5 Comandos para inserción de texto
Al iniciar Vi se encuentra en modo comandos para poder insertar texto en el archivo, pulse | i |
(lo que le hará entrar en modo inserción).
Mientras inserta texto, puede escribir tantas lineas como desee (pulsando <return> después de
cada una, por supuesto), y puede corregir los errores con la tecla de borrado de caracter. Para
salir del modo de inserción y volver al modo de órdenes, pulse <esc>.
Hay muchas formas de insertar texto a parte de la orden i:
• a inserta texto comenzando detrás de la posición actual del cursor, en lugar de la posición
actual del cursor.
• o para comenzar a insertar texto en la línea de debajo de la actual
• s borra el carácter en la posición del cursor y comienza a insertar texto.
Fundamentos de Linux 99
Edición de Archivos
Inserción Texto
● En modo comando podemos ejecutar varios comandos para insertar texto, la inserción dura hasta teclear <ESC>– Inserción de texto a partir de la posición actual (i)
– Inserción de texto delante del carácter actual (a)
– Inserción de nueva linea delante del cursor (o)
– Inserción de Nueva linea enla posición del cursor (O)
– Inserción inicio de linea (I)
– Inserción al final de linea (A)
Capítulo 3 Edición de Archivos
• I comienza a insertar texto al principio de la línea.
• A Comienza a insertar texto al final de la línea.
• O Comienza a insertar texto en una nueva línea encima del cursor.
100 Fundamentos de Linux
Capítulo 3 Edición de Archivos
3.6 Editando texto (cambiando, borrando)
Para borrar el texto se utiliza el modo de comandos, los comandos son:
• x borra el carácter debajo del cursor.
• dd borrar lineas enteras (es decir, pulse | d | dos veces en una fila).
• dw borra la palabra sobre la que se encuentra el cursor
• R sustituye secciones de texto. El uso de R para editar texto es bastante parecido al uso de
las órdenes “i“ y “a“, pero R sobreescribe texto en lugar de insertarlo.
• r sustituye un único carácter situado debajo del cursor.
• ~ cambia de mayúsculas a minúsculas o viceversa la letra sobre la que se encuentra el
cursor.
Fundamentos de Linux 101
Edición de Archivos
Edición de texto
● Comandos que permiten cambiar, Substituir y Borrar texto– Reemplazo de texto:
● R Reemplazo hasta teclear <ESC> ● r(caracter actual, por otro)
– Cambio de texto: c, (cw, cb, c^, c$)
– Substitución● s (similar a R)● S substituye toda la linea● ~ minusculas por mayusculas y viceversa
– Borrado de texto x, d(dw,db,d^,d$ dd), D
Capítulo 3 Edición de Archivos
• s Substitución de texto
• S Substitución del texto hasta el final de la linea
• c Cambio de texto (c$ cw c^)
Es importante el hecho de que borrar no sólo borra, sino que mantiene lo último borrado en un
buffer temporal, que servirá para pegarlo en otro sitio.
102 Fundamentos de Linux
Capítulo 3 Edición de Archivos
3.7 Copiado y pegado de texto
El comando para el copiado de texto es “y”, el comando necesita una orden de desplazamiento
después de la orden, para saber hasta cuándo realizar el trabajo.
• Y copia la linea completa, es decir, es equivalente a “y$”, esto también se hace con “yy”.
• p, el cual pegará el texto después del cursor
• P que pegará antes del cursor.
Se pueden utilizar registros para guardar varias lineas por separado y poder utilizarlas después,
la sintaxis para esto es “<letra>yy” donde <letra> debe estar entre “a“ y “z“, estos mismos
registros se utilizan para pegar “<letra>p”. Es importante que cuando se utiliza buffer se debe
anteponer las comillas antes de la letra y comando de copiado, borrado o pegado.
Fundamentos de Linux 103
Edición de Archivos
Copiar y Pegar
● Copiar – Comando y (yw, yb,y$, y^)
– Comando yy (yy, Nyy donde N indica numero de lineas)
● Pegar– Delante del cursor: p,
● np donde n numero de veces a pegar texto
– Posicion del cursor: P● nP donde n numero de veces a pegar texto
● Buffers– “[az]comando
Capítulo 3 Edición de Archivos
3.8 Búsqueda de texto
Con el caracter especial "/" (slash) podemos realizar búsquedas. Se introduce la "/" y a
continuación se teclea el patrón que se desea localizar:
/patrón
El patrón podrá ser una palabra ó cualquier otra secuencia de caracteres.
• ?patrón busca la ocurrencia del patrón recorriendo el fichero hacia atrás.
• ?? o // repetirá la última búsqueda.
• n buscará la siguiente ocurrencia y
• N repetirá la última búsqueda pero cambiando el sentido de búsqueda.
104 Fundamentos de Linux
Edición de Archivos
Búsqueda de Texto
● Busqueda de un patron– /patron
● Busqueda hacia atrás del archivo– ?patron
● Repetición busqueda– // ó ??
● Ocurrencias– Siguiente (n)
– Siguiente en sentido contrario al original (N)
Capítulo 3 Edición de Archivos
3.9 Opciones de configuración
Para realizar un configuración mas amigable del editor Vi se utilizan las opciones “set”, estas
opciones se pueden fijar de dos formas distintas:
• Desde la propia sesión del editor vi con el comando :set.
• Mediante el fichero .exrc
Para especificar las opciones desde dentro del editor vi utilice el comando set directamente. Las
abreviaturas entre paréntesis podrían ser utilizadas. Sintaxis:
• :set <opción> <parámetro> (si se espera <parámetro>) Se pueden especificar múltiples
opciones en una misma línea.
• :set <opción>? visualiza el valor de <opción>
• :set all visualiza el valor de todas las opciones.
Las opciones mas comunes son:
Fundamentos de Linux 105
Edición de Archivos
Opciones de Configuración
● Comando set– set opcion [= valor]
● Set all● Set number● Set tabstop=5
● Archivo .exrc
Capítulo 3 Edición de Archivos
• all Presenta una lista de todas las opciones del editor en la pantalla.
• Autoindent (abrev. ai, valor por defecto noai) Comienza cada nueva linea de texto de la
misma columna como la linea anterior (útil para los programadores).
• Ignorecase (abrev. ic, valor por defecto moic) Hace que vi haga caso omiso de las
mayúsculas y minúsculas durante las búsquedas.
• Number ( abrev. nu, valor por defecto nonu) Numera cada línea de texto.
• Readonly (valor por defecto noreadonly) Activa la protección contra escritura en el archivo
que esté en proceso de modificación. Esto impide que se cambie o destruya
accidentalmente el contenido del archivo.
• Showmatch ( abrev. sm, valor por defecto nosm) Muestra el paréntesis o corchete de
apertura cuando se escribe el correspondiente paréntesis o corchete de cierre. Esta opción
resulta útil cuando se escriben expresiones matemáticas o se redactan programas en un
lenguaje que utilice paréntesis o corchetes.
• Showmode (valor por defecto noshowmode) Muestra un mensaje como MODO DE
ENTRADA o MODO DE SUSTITUCIÓN en la parte inferior de la pantalla siempre que se
está en alguno de los dos modos.
• Wrapmargin (abrev. wm, valor por defecto 0(cero)) Cambia el margen derecho. n es igual al
número de espacios que hay en el margen derecho. Por ejemplo, si utiliza un terminal de 80
columnas, :set wm=8 configura el margen derecho en la columna 72.
El archivo que se encarga de guardar la configuración de Vi es .exrc, localizado en el home
directory, este archivo no se crea por defecto.
Cualquier comando que pueda ser utilizado en el modo de entrada de comandos (comandos :),
puede ser utilizado en el fichero .exrc, el cual será cargado automáticamente cada vez que
inicies vi. Además, el comando fuente, abreviaciones y las macros pueden ser usadas. No
pueden existir lineas en blanco en el fichero .exrc. Los comentarios de especifican comenzando
la linea con “.
106 Fundamentos de Linux
Capítulo 3 Edición de Archivos
Evaluación Capitulo
1. Mencione los editores de texto comunes en Linux
2. ¿Cuáles son los tres modos de operación de vi ?
3. Que hacen las siguientes órdenes de vi
ESC i
EC :q!
ESC :qw!
4. Mencione 3 órdenes en vi para el borrado de texto
Fundamentos de Linux 107
Capítulo 3 Edición de Archivos
5. Mencione 3 órdenes en vi para cambiar texto
6. ¿Qué hacen las siguientes ordenes de vi ?
Y
p
P
7. Explique como se busca texto en vi
8. ¿Con cuales opciones se configura el ambiente de vi?
108 Fundamentos de Linux
Capítulo 4 Linea de comandos
Capítulo 4 Linea decomandos
Fundamentos de Linux 109
Capítulo 4 Linea de comandos
110 Fundamentos de Linux
Linea de comandos
Descripción
Definición de Shell ó linea de comandosShells en Unix/Linux
BashExpansión de linea de Ordenes
Historia de comandosVariablesAliases
Archivos de Configuración
Capítulo 4 Linea de comandos
1 Descripción del capítulo
En el presente capítulo se describirá el uso de la interfaz de comandos o shell, que es la
principal y mas poderosa forma de interactuar con el sistema. Se describirán los siguientes
puntos:
• Definición de Shell.
• Shells utilizados comúnmente en Linux y Unix
• Descripción de Bash Shell.
• Expansión de Linea comandos
• Historia de Comandos
• Manejo de Variables de Shell
• Definición de Aliases
• Archivos de Configuración de bash shell.
Fundamentos de Linux 111
Capítulo 4 Linea de comandos
2 Interfaces linea de comando
2.1 Definición de CLI y/o SHELL
Un shell o interfaz de linea de comando es un programa que interpreta y ejecuta las órdenes
conforme se proporcionan desde la terminal. No se requiere ningún privilegio especial para
ejecutar un shell; para el sistema operativo UNIX un shell es como cualquier otro programa.
Entre las características más comunes de un shell están:
• la interpretación de guiones de shell
• la expansión de comodines en nombres de archivos
• la combinación de órdenes para formar interconexiones
• la recuperación de órdenes previas
112 Fundamentos de Linux
Linea de comandos
Definición
● Shell:– Programa que interpreta y ejecuta las ordenes conforme
se proporcionan desde la terminal
● Características– Interpretación guiones del shell
– Expansión de caracteres comodines
– Manejo de entrada/salida de comandos
– Recuperación de Ordenes previas
– Programación scripting (condicionales, ciclos, variables, etc)
Capítulo 4 Linea de comandos
• las construcciones condicionales y los ciclos
• las variables para crear abreviaturas
Fundamentos de Linux 113
Capítulo 4 Linea de comandos
2.2 Shells en Unix y Linux
a) Sh (shell Bourne)
El shell Bourne, sh, escrito por Steve Bourne en 1979, es el primero de los shells principales.
Los shells más recientes son más fáciles de usar, porque ofrecen recursos de los que carece el
shell Bourne, como la edición de las líneas de órdenes, la recuperación de órdenes emitidas
previamente, y los alias para las órdenes de uso común.
Entre los recursos importantes que ofrece “sh” están los siguientes:
• Operadores para la ejecución en segundo plano, o ejecución condicional de órdenes.
• Enunciados para repetir la ejecución de órdenes, incluida la iteración a lo largo de una
secuencia de valores que pueden asignarse a una variable de iteración.
• Variables substituibles.
114 Fundamentos de Linux
Linea de comandos
Shells comúnes
● Unix– Sh
– Ksh
– Csh
● Linux– Bash
– Zsh
– tcsh
Capítulo 4 Linea de comandos
• Exportación de variables específicas a un proceso hijo.
• Tres formas de entrecomillado.
• Ejecución de órdenes en subshells.
• Notificación automática de la llegada de correo.
• Inclusión de datos de entrada para una orden en un guión de shell como parte del guión.
• Captura de señales, y ejecución de órdenes específicas cuando ocurre una señal
determinada.
• Ejecución de órdenes en archivos de iniciación antes de leer cualquier entrada. Estos
archivos de iniciación pueden servir para adecuar sh a las necesidades propias.
b) csh (shell C)
El shell C, disponible a través de la orden csh, se desarrolló como parte de BSD UNIX. A pesar
de su nombre el shell C no es mucho más parecido a C que el Bourne. Algunas de las
características del shell C que no se incluyen en el Bourne son:
• La posibilidad de recuperar órdenes previas mediante un mecanismo de “historia”.
• La capacidad de conmutar entre procesos y controlar su avance (control de trabajos).
• Formas más flexibles de sustitución de variables.
• Operadores adicionales, de sintaxis similar a la de C.
• Alias para órdenes de uso frecuente, sin tener que usar guiones.
En csh se puede interrumpir la mayoría de las órdenes si se presiona ctrl-c, con lo cual se
vuelve al indicador de csh.
c) Ksh (shell Korn)
El shell Korn, “ksh”, ofrece una síntesis de las características de los shells Bourne y C, además
de otras propias. Fue desarrollado por David Korn, de ATT Bell Laboratories, en 1982,
Fundamentos de Linux 115
Capítulo 4 Linea de comandos
presentando versiones mejoradas en 1986 y 1988.
El shell Korn sigue de cerca los convencionalismos del shell Bourne, y casi todos los guiones
escritos para el primero funcionan con el segundo. Las características principales que se
adoptaron del shell C son:
• Listas históricas para la recuperación de órdenes previas.
• Control de trabajos, con la capacidad para pasar trabajos específicos al primer o segundo
plano.
• Alias para los nombres de órdenes.
• Empleo de ‘~’ para representar el directorio base del usuario, o, al combinarse con un
nombre de usuario, el de otro usuario.
• Capacidad para calcular expresiones numéricas generales, y asignar el resultado a una
variable.
Algunas de las características nuevas de ksh son:
• Edición interactiva de la línea de órdenes, incluida la complementación de nombres de
fichero con las mismas características de csh y la posibilidad de editar la lista histórica.
• Mejores definiciones de funciones, que ofrecen variables locales y permiten escribir
funciones recursivas.
• Comparación extendida de patrones para nombres de ficheros y otras construcciones,
parecidas a la de egrep.
• Capacidad para extraer la porción de una cadena especificada por un patrón.
• Capacidad para cambiar fácilmente de un directorio a otro.
d) Bash
El Bourne Again shell (mejor conocido como Bash) fue creado con la finalidad de utilizarlos en
el proyecto GNU. La intención fue que este fuera el intérprete de comandos estándar en el
116 Fundamentos de Linux
Capítulo 4 Linea de comandos
sistema GNU. El Bourne Again shell "nació" oficialmente un domingo, 10 de enero de 1988. El
responsable de las primeras versiones de Bash fué Brian Fox y que posteriormente continuó
actualizándolo hasta 1993. En los inicios de 1989, Chet Ramey comenzó a ayudar a Brian y fué
el responsable de muchos arreglos en el código y nuevas características.
Hoy en día el mantenedor oficial de bash es Chet Ramey.
e) tcsh (shell C mejorado)
El shell tcsh es una versión mejorada del shell C, que ha adquirido mucha popularidad. Algunos
de los recursos adicionales que ofrece son:
• Capacidad para editar la línea de órdenes interactivamente.
• Llamada sencilla de órdenes ejecutadas con anterioridad, las cuales se pueden editar.
• Complementación interactiva de nombres de archivos y órdenes.
• Consulta de la documentación sobre una orden cuando es tecleada.
• Capacidad para programar la ejecución periódica de una orden.
• Marcas de la hora en la lista histórica.
Fundamentos de Linux 117
Capítulo 4 Linea de comandos
2.3 Bash shell
La Bourne Again Shell GNU (bash) es una variante de la Bourne Shell que incluye muchas
características avanzadas como el control de tareas, el historial de órdenes, conclusión de
órdenes y nombres de ficheros.
a) Características
Las características principales que ofrece el shell Bash son:
• Variables de entorno
• La variable PATH
• Archivos de configuración
• Alias
118 Fundamentos de Linux
Linea de comandos
Bash
● Bash (Bourne Again shell)– Variante de Borne Shell compatible
– GNU
– Compatible con sh, ksh y con características adicionales
Capítulo 4 Linea de comandos
• Control de la entrada y la salida
• Expansión de nombres de ficheros
Fundamentos de Linux 119
Capítulo 4 Linea de comandos
b) Expansión e historia de linea comandos
El intérprete bash puede adivinar el archivo u orden que intenta escribir y completarlo de forma
automática por usted. Sólo tiene que teclear el principio de la orden o del nombre de fichero y
pulsar Tabulador. Si bash encuentra una única coincidencia, completará la palabra y pondrá un
espacio tras ella. Si encuentra múltiples posibilidades, completará la palabra hasta la parte
común a todas las posibilidades, y emitirá una alarma. Puede seguir escribiendo lo que le falta
a la palabra para ser única, y pulsar Tabulador de nuevo. Si no encuentra ninguna coincidencia,
se limitará a pitido.
Shell Bash tiene un historial que graba todos los comandos realizados desde que se inició el
equipo. Para acceder al historial de comandos se utiliza el comando history, éste mostrará un
historial enumerado de los últimos comandos digitados.
# history
487 cd /home/
120 Fundamentos de Linux
Linea de comandos
Expansión e Historia de Comandos
● Expansión de Archivos● Comando History
– # history
– 487 cd /home/
– 484 cd Desktop/
– 485 ls
– 486 history
● Acceso a los comando de historia– !485
Capítulo 4 Linea de comandos
484 cd Desktop/
485 ls
486 history
para hacer uso de alguno de los comandos desplegados, es posible llamarlos utilizando el
signo de admiración (!) seguido del número del comando digitado en el historial, por ejemplo:
# !484
cd Desktop/
/Desktop$
Fundamentos de Linux 121
Capítulo 4 Linea de comandos
Además del signo de admiración para llamar los comandos de la lista desplegada por history
existen otras opciones como:
• !! comando previo
• !N comando número N en la lista
• !-N enésimo comando anterior al actual
• !“cadena“ comando mas reciente que empieza con “cadena“
• !?“cadena“? comando mas reciente que contenga “cadena“
• !?“cadena“?% comando mas reciente cuyo argumento contenga “cadena“
• !$ último argumento del comando anterior
• !# el comando actual arriba de este punto
122 Fundamentos de Linux
Linea de comandos
Acceso a comandos (Historia)
● !! comando previo
● !N comando número N en la lísta
● !N nsimo comando anterior al acutual
● !“cadena“ comando mas reciente que empieza con “cadena“
● !?“cadena“? comando mas reciente que contenga “cadena“
● !?“cadena“?% comando mas reciente cuyo argumento contenga “cadena“
● !$ ultimo argumento del comando anterior
● !# el comando actual arriba de este punto
● !!“cadena“ comando previo, se agrega “cadena“
● !N “cadena“ comando N, se agrega “cadena“
● !{c1}c2 el comando mas reciente que empiesa con “cadena“ c1, se le agrega la “cadena“ c2
Capítulo 4 Linea de comandos
• !!“cadena“ comando previo, se agrega “cadena“
• !N “cadena“ comando N, se agrega “cadena“
• !{c1}c2 el comando mas reciente que empieza con “cadena“ c1, se le agrega la “cadena“ c2
• ^viejo^nuevo^ sustitución rápida, cambia la cadena “viejo“ por “nuevo“ en el comando previo
Fundamentos de Linux 123
Capítulo 4 Linea de comandos
Existen variables globales que tienen valores que especifican el funcionamiento de básico de
este comando, estas variables son:
• HISTSIZE El número de órdenes a recordar en la historia de órdenes. El valor
predeterminado es 500.
• HISTFILE El nombre del fichero en el que se guarda la historia de órdenes. El valor
predeterminado es ~/.bash_history. Si no está definido, no se guarda la historia de órdenes
cuando se acaba un shell interactivo.
• HISTFILESIZE El número máximo de lineas contenidas en el archivo de historia. Cuando se
asigna un valor a esta variable, el fichero de historia se trunca, para contener no más de ese
número de líneas. El valor predeterminado es 500. El fichero de historia se trunca también a
este tamaño tras escribir en él cuando un shell interactivo termina.
• HISTCMD El número de "historia", o índice en la lista "histórica", de la orden actual. Si
124 Fundamentos de Linux
Linea de comandos
Acceso a comandos (Historia) (Cont.)
● ^viejo^nuevo^ sustitución rapida, cambia la cadena “viejo“ por “nuevo“ en el comando previo
● VARIABLES
● HISTCMD
● HISTFILE
● HISTSIZE
● HISTFILEZISE
Capítulo 4 Linea de comandos
HISTCMD no está definido, pierde sus propiedades especiales, incluso si posteriormente es
redefinido.
Fundamentos de Linux 125
Capítulo 4 Linea de comandos
Los comandos mostrados en la lista desplegado por history se pueden modificar usando:
• modo de edición de línea
• comando fc
El modo de edición de linea emula los rasgos de los editores de texto vi o emacs, el modo por
defecto es emacs, para cambiarlo a vi ejecute:
# set -o vi
# export EDITOR=vi
Para poder ejecutar el modo de edición de linea en vi se requiere que antes se presione <Esc>.
126 Fundamentos de Linux
Linea de comandos
Edición de Comandos
● Edicion en Linea– Modo vi: Uso de comandos de vi para la edicion y
ejecucción de comandos de la Historia
– Modo Emacs: Uso de comandos de vi para la edición y ejecucion de comandos de la Historia
– $ set o “modo” < Donde modo= vi ó emacs
● Comando fc– fc l
Capítulo 4 Linea de comandos
En la siguiente tabla se listan los comandos que se ejecutan en este modo:
vi Emacs Resultado
k Ctrl-P Busca el comando anterior
j Ctrl-N Busca el comando siguiente
/scadena Ctrl-R cadena Busca el comando anterior que contenga cadena
h Ctrl-B Moverse un caracter atras.
l Ctrl-F Moverse un caracter adelante.
b Esc B Moverse atrás una palabra
w Esc F Moverse adelante una palabra
X Del Eliminar el caracter anterior
x Ctrl-D Eliminar un caracter
dw Esc D Eliminar la palabra de adelante.
db Esc H Eliminar la palabra de atrás
xp Ctrl-T Transporta dos caracteres
El comando fc tiene la siguiente sintaxis:
# fc opciones
donde las opciones son:
• -l – despliega la lista de los comandos
• -e -. edita el comando anterior en un editor de texto.
Fundamentos de Linux 127
Capítulo 4 Linea de comandos
d) Variables
Comando set
Su sintaxis es:
# set nombre_variable valor
Este comando nos devuelve el valor de nombre_variable. Si valor es especificado, entonces set
da el valor de nombre_variable a valor, creando una nueva variable si esta no existe con
anterioridad, devolviendo así su valor. Si nombre_variable comienza con un paréntesis abierto
“(“ y termina con uno cerrado “)”, entonces se refiere a un elemento del arreglo: antes del primer
caracter del paréntesis abierto es el nombre del arreglo, y los caracteres entre el paréntesis son
el índice dentro del arreglo. Si no, nombre_variable se referirá a una variable escalar.
El comando set por defecto nos muestra todas las variables de entorno actualmente definidas y
128 Fundamentos de Linux
Linea de comandos
Variables
● Comando set– set variable valor
– set
– set o opcion
● Comando unset● ej.
$setPATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/local/sbin:/usr/sbin
PIPESTATUS=([0]="0")PPID=4978PS1='\h:\w\$ '
Capítulo 4 Linea de comandos
sus respectivos valores. Un extracto de una configuración de comandos set sería mas o menos
así:
# set
PATH=/usr/local/lib/qt/bin:/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:
/usr/openwin/bin:/usr/games:.:/usr/local/ssh2/bin:/usr/local/ssh1/bin:
/usr/share/texmf/bin:/usr/local/sbin:/usr/sbin:/home/logan/bin
PIPESTATUS=([0]="0")
PPID=4978
PS1='\h:\w\$ '
PS2='> '
PS4='+ '
PWD=/home/logan
QTDIR=/usr/local/lib/qt
REMOTEHOST=ninja.tdn
SHELL=/bin/bash
El comando set puede tomar algunas opciones, tales como:
• -a – marcar variables creadas o modificadas para exportar
• -b – notifica la terminación del trabajo inmediatamente
• -h – recuerda la localización de comandos mientras se mira arriba
• -n – lee comandos pero no los ejecuta
• -m – permite el control de trabajos
Comando unset
Su sintaxis es:
# unset nombre_variable nombre_variable ...
Este comando remueve una o varias variables. Cada nombre_variable es el nombre de la
variable, especificado en cualquiera forma aceptable por el comando set. Si un
nombre_variable se refiere a un elemento de un arreglo entonces este elemento es removido
sin afectar el resto de los demás arreglos. Si un nombre_variable consiste en un nombre de
Fundamentos de Linux 129
Capítulo 4 Linea de comandos
arreglo sin un índice como paréntesis, entonces el arreglo entero es borrado. El comando unset
devuelve como resultado un comienzo de cadena. Generalmente se utilizara unset así:
# unset nombre_variable
130 Fundamentos de Linux
Capítulo 4 Linea de comandos
e) Variables de ambiente comunes
Las variables de entorno o ambiente contienen ciertos parámetros del sistema, como puede ser
el intérprete de comandos que se esté usando, u otros.
Para acceder a las variables de entorno hay que escribir un símbolo dólar ($), seguido del
nombre de la variable. Los nombres de las variables de entorno en Linux se suelen escribir en
todo mayúsculas por convenio, pero no tiene por qué ser así. Incluso se pueden poner variables
de entorno con mezclas de mayúsculas y minúsculas.
Hay algunas variables que el usuario no puede establecer, y otras que sí. Las variables de
entorno se establecen de la siguiente manera: se escribe el nombre de la variable, seguido por
un signo igual (=), seguido de un texto, que va entrecomillado si es más de una palabra.
Fundamentos de Linux 131
Linea de comandos
Variables de Ambiente
● Creación y acceso a variables:● VAR=hola● Echo $VAR
● Variables de ambiente comunes:● PS1● $EDITOR● $$● $HOME ● $PATH● $MAIL● $HISTORY
● Visualizacion (env, set) y exportar variables
Capítulo 4 Linea de comandos
Aquí hay una lista de las variables más interesantes:
• $PS1: contiene la forma del símbolo del sistema
• $EDITOR: contiene el editor de texto que se usará por omisión. Suele ser vi
• $: valor devuelto por el comando anterior
• $HOME: la ruta absoluta hasta el directorio inicial del usuario actual
• $PATH: las rutas a los programas que hay establecido para el usuario actual. Cuando se
ejecuta un comando, se buscará en estos directorios
• $MAIL: contiene la ruta hacia el directorio que se usará para guardar el correo del usuario
• $HISTORY: la ruta hacia el fichero que contiene el histórico de comandos (un fichero que
contiene los últimos comandos que has escrito en la consola
Comando env
El comando env permite visualizar la lista de variables creadas en nuestro sistema. La sintaxis
es:
# env
Comando export
El comando export se utiliza para que el valor asignado a una variable sea conocido por todos
los procesos hijos del proceso padre.
# APF=/opt/apf/bin
Si a continuación ejecutamos un guión shell que use la variable APF, fallará ya que no la
conoce.
# APF=/opt/apf/bin
# export APF
132 Fundamentos de Linux
Capítulo 4 Linea de comandos
Todos los procesos hijos heredan las variables exportadas del proceso padre.
Si el comando export se ejecuta sin ningún parámetro despliega las variables de entorno que se
exportan, la salida de este comando se muestra a continuación:
# export
declare -x COLORTERM=""
declare -x DISPLAY=":0.0"
declare -x GDMSESSION="Default"
declare -x G_BROKEN_FILENAMES="1"
declare -x HISTSIZE="1000"
declare -x INPUTRC="/etc/inputrc"
declare -x KDE_MULTIHEAD="false"
declare -x KONSOLE_DCOP="DCOPRef(konsole-12272,konsole)"
declare -x KONSOLE_DCOP_SESSION="DCOPRef(konsole-12272,session-1)"
declare -x LANG="en_US.UTF-8"
declare -x LESSOPEN="|/usr/bin/lesspipe.sh %s"
Fundamentos de Linux 133
Capítulo 4 Linea de comandos
f) Aliases
Las funciones permiten definir subrutinas programadas usando el lenguaje de Bash y los alias,
asociar nombres a comandos con ciertas opciones y argumentos de forma más nemotécnica o
abreviada.
El comando alias permite asignarle otros nombres a los comandos. De esta forma se pueden
abreviar o llamarlos de forma más nemotécnica.
Sintaxis:
# alias [nombre[=valor]...]
Sin argumentos muestra todos los alias definidos por el usuario actual. Para deshabilitar un
alias se emplea el comando unalias.
Ejemplos:
134 Fundamentos de Linux
Linea de comandos
Aliases
● Asociacion de un nombre alterno a un comando(s) y sus argumentos, para facilitar su ejecución continua.– alias [nombre[=valor]...]
– $alias cls='clear'
– unalias cls
Capítulo 4 Linea de comandos
# alias
alias c='clear'
Fundamentos de Linux 135
Capítulo 4 Linea de comandos
g) Archivos de configuración
Para cada usuario existen tres ficheros muy importantes que permiten definir en gran medida
las características del shell durante la interacción con este. Estos constituyen shells scripts y se
conocen como ficheros perfiles o profiles:
• .bash_profile: se ejecuta siempre que se abra una nueva sesión en el sistema. Cada vez que
un usuario se conecte al sistema se ejecutará el script .bash_profile, en el caso de que se
utilice a bash como shell. Para ser compatible con sus versiones anteriores, bash en caso de
que no existiera .bash_profile, ejecuta .bash_login, o sino, .profile. En este fichero se pueden
colocar las asignaciones a las variables del entorno siendo debidamente exportadas a través
de export. Existe además un profile general ubicado en /etc/profile que se ejecuta también
siempre que un usuario inicia una sesión en el sistema antes de su profile particular.
• .bash_logout: se ejecuta al terminar una sesión de trabajo. Puede contener comandos para
salvar lo hecho durante la sesión.
136 Fundamentos de Linux
Linea de comandos
Ambiente y Configuración Bash
● Controlado por los siguientes archivos:– A Nivel Global
● /etc/profile● /etc/bashrc
– A nivel Usuario● .bash_profile● .bashrc● .bash_logout
● El ambiente se define mediante variables y comandos dentro de los archivos mencionados
Capítulo 4 Linea de comandos
• .bashrc: se ejecuta siempre que se invoque un nuevo shell. Por lo general en él se colocan
las definiciones de funciones y los alias de comandos. El fichero .bashrc que posee cada
usuario por defecto ejecuta primero a /etc/bashrc.
Cuando se crea un nuevo usuario se le colocan en su directorio base estos tres ficheros cuyos
patrones están el directorio /etc/skel.
Fundamentos de Linux 137
Capítulo 4 Linea de comandos
Comandos Internos
Cada shell tiene ciertos comandos que solo pueden ser identificados por él y que en algunos
casos se anteponen a los comandos del sistema, estos comandos se conocen como comandos
interno, algunos de estos comandos que reconoce bash son:
• alias [-p] [nombre[=valor] ...] Alias sin argumentos o con la opción -p muestra la lista de alias
en la forma alias nombre=valor en la salida estándar. Cuando se dan argumentos, se define
un alias para cada nombre cuyo valor se da.
• cd [-LP] [dir] Cambia el directorio de trabajo en curso a dir.
• echo [-neE] [arg ...] Repite los args, separados por espacios, seguidos por un salto de línea.
El estado de retorno es siempre 0. Si se especifica -n, se suprime el salto de línea final. Si
se da la opción -e, se activa la interpretación de los caracteres de escape (con barra
inversa). La opción -E desactiva la interpretación de estos caracteres de escape.
138 Fundamentos de Linux
Linea de comandos
Comandos Internos
● Comandos proporcionados por el propio shell, que solo son reconocidos por el shell,y llegan a anteponerse a comandos del sistema
bash, :, ., [, alias, bg, bind, break, builtin, cd, command, compgen,
complete, continue, declare, dirs, disown, echo, enable, eval, exec, exit,
export, fc, fg, getopts, hash, help, history, jobs, kill, let, local, logout, popd,
printf, pushd, pwd, read, readonly, return, set, shift, shopt, source, suspend,
test, times, trap, type, typeset, ulimit, umask, unalias, unset, wait
Capítulo 4 Linea de comandos
• export [-fnp] [nombre[=palabra]] ... Los nombres suministrados se marcan para exportación
automática al entorno de órdenes que se ejecuten de ahí en adelante. Si la opción -f se da,
los nombres se referirán a funciones. Si no se dan nombres, o si se da la opción -p, se
muestra una lista de todos los nombres que están exportados en este shell. La opción -n
hace que la propiedad de exportación se quite de las variables nombradas; o sea, que se
quiten del entorno. export devuelve un estado de salida de 0 a menos que se encuentre una
opción inválida, uno de los nombres no sea un nombre válido de variable del shell, o que se
dé -f no siendo nombre una función.
• kill [-s nombre-señal | -n numseñal | -nombre-señal] [pid | espectrab] ... kill -l [nombre-señal
| status_salida] Envía la señal especificada por nombre-señal o numseñal a los procesos
nombrados por pid o espectrab. nombre-señal es o bien un nombre de señal como SIGKILL
o un número de señal; numseñal es un número de señal. Si nombre-señal es un nombre de
señal, éste puede darse con o sin el prefijo SIG. Si nombre-señal no está presente, entonces
se supone SIGTERM. Un argumento de -l lista los nombres de señales. Si se suministran
más argumentos cuando se da -l, se listan los nombres de las señales correspondientes a
los argumentos, y el estado de retorno es 0.
• pwd Muestra el nombre de fichero absoluto del directorio de trabajo en curso.
• set Sin opciones, se muestra el nombre y valor de cada variable del shell en un formato que
puede ser reutilizado como entrada. La salida se clasifica según la localización en curso.
Cuando se dan opciones, se establecen o quitan atributos del shell.
• umask La máscara de creación de ficheros del usuario se establece a modo.
Existen otros comandos los cuales pueden ser consultados con e manual del sistema.
Fundamentos de Linux 139
Capítulo 4 Linea de comandos
#man bashbuiltins
BASH_BUILTINS(1) BASH_BUILTINS(1)
NAME
bash, :, ., [, alias, bg, bind, break, builtin, cd, com
mand, compgen, complete, continue, declare, dirs, disown,
echo, enable, eval, exec, exit, export, fc, fg, getopts,
hash, help, history, jobs, kill, let, local, logout, popd,
printf, pushd, pwd, read, readonly, return, set, shift,
shopt, source, suspend, test, times, trap, type, typeset,
ulimit, umask, unalias, unset, wait - bash built-in com
mands, see bash(1)
BASH BUILTIN COMMANDS
Unless otherwise noted, each builtin command documented in
this section as accepting options preceded by - accepts --
to signify the end of the options.
.
.
.
140 Fundamentos de Linux
Capítulo 4 Linea de comandos
Evaluación Capítulo
1. ¿Cuál es la definición de Shell?
2. Liste tres shells comunes en Linux
3. ¿Cuáles son las características principales de Bash?
4. ¿Qué realiza el comando “history”?
5. Describa tres secuencias de instrucciones para acceder algún comando de la “historia de
Fundamentos de Linux 141
Capítulo 4 Linea de comandos
comandos”
6. ¿Cómo redefiniría el archivo en el que se guarda la historia de comandos a:
$HOME/.mis_comandos y que el número comandos guardados sea de 1000?
7. ¿Cómo podemos modificar los comandos guardados en la “historia de comandos”?
8. ¿Cuáles son las funciones del comando “set”?
9. Explique que definen las siguientes variables de ambiente:
142 Fundamentos de Linux
Capítulo 4 Linea de comandos
1. HOME
2. PATH
3. MAIL
4. PS1
5. EDITOR
10.¿Qué realiza el comando “export”?
11.¿Cuáles son los tres principales archivos de configuración de bash y en que momento se
ejecutan estos?
12.¿Qué es un comando, y como podemos determinar si un comando a ejecutar es interno o
Fundamentos de Linux 143
Capítulo 4 Linea de comandos
ejecutable del sistema?
144 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
Capítulo 5 InterfacesGráficas
Fundamentos de Linux 145
Capítulo 5 Interfaces Gráficas
146 Fundamentos de Linux
Interfaces Gráficas
Descripción
Conceptos BásicosEvolución Gui's
X WindowsInicio de X Windows
Configuración de X WindowsKDE
GNOME
Capítulo 5 Interfaces Gráficas
1 Descripción del capítulo
En el presente capítulo se describirán los componentes principales de un ambiente gráfico en
Linux, la base de estos su evolución y conceptos mas importantes, así como el procedimiento
de inicio de los ambientes gráficos, ya que a diferencia de Windows los ambientes gráficos se
ven como una aplicación mas en el sistema. Los tópicos a cubrir son:
Conceptos Basicos
Evolución GUI's
X Windows
Inicio de X Windows
Archivos configuración a nivel de usuario de X Windows
KDE
GNOME
Fundamentos de Linux 147
Capítulo 5 Interfaces Gráficas
2 Introducción
2.1 Conceptos básicos
Interfaz gráfica de usuario (GUI, acrónimo del vocablo inglés Graphical User Interface) es un
método para facilitar la interacción del usuario con la computadora a través de la utilización de
un conjunto de imágenes y objetos pictóricos (iconos, ventanas..) además de texto.
Surge como evolución de la línea de comandos de los primeros sistemas operativos y es pieza
fundamental en un entorno gráfico.
Mediante el uso de diferentes metáforas (escritorio, cesto de basura, etc.) se establecieron las
convenciones que permiten a un usuario reconocer rápidamente muchos de los elementos y
funciones de un sistema operativo. Hoy en día, las GUI poseen su propio metalenguaje y este
forma parte del imaginario simbólico de quienes usan computadoras.
Cuando se nos pregunta acerca de un programa determinado, inmediatamente asociamos su
148 Fundamentos de Linux
Interfaces Gráficas
Conceptos Básicos
● GUI's● X Windows● Manejador de Ventanas● Escritorio
Capítulo 5 Interfaces Gráficas
nombre al aspecto de su interfaz gráfica. Para el usuario, la interfaz es la aplicación.
El desarrollo de GUI efectivas y amigables fue el factor determinante para la popularización de
los ordenadores y de la informática en general. Gracias a ellas estas máquinas dejaron de ser
un lejano instrumento científico y se convirtieron en algo similar a un electrodoméstico.
El Sistema X Window, conocido también como X, es una colección de programas que forman
una interfaz para el usuario, orientada al uso de teclado, ratón (mouse) y una pantalla gráfica.
La mayoría de los sistemas de ventanas utilizan una abstracción llamada “metáfora de
escritorio“ (desktop). Esto es, la pantalla es tratada como si fuera la parte superior de un
escritorio, y cada ventana de programa como si fuera un pedazo de papel. En un escritorio real,
usted puede poner piezas de papel una al lado de otra, apilarlas unas sobre otras, moverlas
alrededor, doblarlas , y así sucesivamente. Similarmente, un sistema de ventanas como X le
permite colocar ventanas en la pantalla, apilarlas, colocarlas contiguas, moverlas, etc.
Los manejadores de ventanas son programas clientes de X que son o parte del entorno de
escritorio o, en otros casos, standalone. Su propósito principal es controlar la forma en que las
ventanas gráficas son posicionadas, redimensionadas o movidas. Los manejadores de
ventanas controlan las barras de títulos, el comportamiento del foco, los vínculos del botón del
ratón y teclas especificadas por el usuario.
Fundamentos de Linux 149
Capítulo 5 Interfaces Gráficas
2.2 Evolución GUI's
El primer sistema interactivo informático que utilizó un monitor y metáforas gráficas fue un
juego. William A. Higinbotham, un miembro del Brookhaven National Laboratory (un centro de
investigación nuclear de New York) diseño y ensambló el primer "video game" del que se ha
tenido noticia, en 1958. Usando un osciloscopio estándar como pantalla.
En el año 1963, en el MIT (Massachuset Institute of Technology) Ivan Sutherland desarrolla
Sketchpad para su tesis de doctorado ("Sketchpad: a man - machine graphical communications
system"). Este fue el primer sistema que mediante manipulación directa de gráficos en una
pantalla podía dar instrucciones al ordenador, en este caso un TX-2 de la compañía Digital
Equipment.
El desarrollo del "mouse" fue producto las investigaciones de Douglas C. Engelbart para el
Stanford Research Laboratory como parte del proyecto NLS (ARPA, NASA) hacia 1965.
Engelbart se inspiró en ideas de Vannevar Bush, quien en 1945 se permitió soñar un tiempo en
el cual los humanos operarán computadoras mediante una interfaz gráfica.
Otras investigaciones fueron hechas en el Imperial College de Londres, en 1967, donde se
diseñaron "light handles" un tipo de potenciómetro gráfico y probablemente el primer "widget"
(controlador gráfico).
De el centro de investigación Palo Alto Research Center (PARC) de Xerox hacia 1970,
emergieron todos los elementos de la interfaz gráfica contemporánea. La selección de objetos,
las ventanas, la utilización del mouse, el concepto de "WYSIWYG" (What You See Is What You
Get), la selección de texto; todos esos recursos, tan comunes hoy en día, fueron desarrollados
en el PARC.
En 1973 construyen el prototipo “Alto Computer”, la primera computadora que contaba con una
GUI. Poseía un mouse con 3 botones, ventanas y una conexión para red Ethernet.
En Junio de 1984 en el MIT presentaron la primera interfaz gráfica para el sistema operativo
UNIX: el “X-Windows System”. En adelante este sistema, a pesar de sus múltiples carencias,
sobrevivirá y se encarnará infinidad de veces debido a la popularidad y robustez del UNIX.
150 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
En 1990, Microsoft colocó en el mercado Windows 3.0 y, poco tiempo después, la versión 3.1.
En los años siguientes, cientos de aplicaciones se desarrollaron para este entorno. De la mano
de la enorme popularidad de las PC, este sistema operativo se convertirá en un estándar.
Fundamentos de Linux 151
Capítulo 5 Interfaces Gráficas
3 X Window
Todos los sistemas operativos modernos cuentan con una interfaz gráfica y Linux no es la
excepción. Las interfaces gráficas para Linux y para todos los sistemas tipo Unix en general son
conocidas como ambientes X Window. Para el caso de Linux se utiliza una implementación de
X Window con código abierto (open source) denominada XFree86 que también está disponible
para otros sistemas tipo Unix como los BSD (FreeBSD, OpenBSD y NetBSD), Solaris, etc.
3.1 Función
Un sistema de ventanas, como X, es una colección de programas que le permiten utilizar y
mostrar muchas aplicaciones en una única pantalla. Para esto divide la pantalla en varias más
pequeñas, posiblemente superponiendo secciones, llamadas ventanas, con lo que usted puede
tener varias sesiones simultaneamente en diferentes nodos o hosts, programas que muestren
gráficos, lectura de correspondencia, despliegue de texto, etc, todo corriendo al mismo tiempo.
X es el encargado de visualizar la información gráfica y es totalmente independiente del sistema
operativo. El sistema X Window distribuye el procesamiento de aplicaciones especificando
enlaces cliente-servidor. El servidor provee servicios para acceder a la pantalla, teclado y ratón,
mientras que los clientes son la aplicaciones que utilizan estos recursos para interacción con el
usuario.
3.2 Arquitectura
X está construido alrededor de una arquitectura Cliente/Servidor. Esto significa que ciertos
programas X juegan los papeles de Cliente y otros programas, diferentes, juegan el papel de
Servidor. El trabajo se logra por la comunicación entre el anterior y el último. El Cliente y el
Servidor pueden estar en el mismo computador, o en diferentes computadores.
Varios tipos de mensajes pueden ser enviados entre el Servidor y el Cliente. Estos mensajes
están agrupados en un protocolo conocido como The X Window System Protocol (Protocolo del
Sistema de Ventanas X).
152 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
El servidor de X11 es el programa responsable de dibujar en la pantalla de la estación de
trabajo. Cada aplicación envía comandos al servidor de X11 tales como : Coloca una ventana
aquí, dibuja una linea de aquí para allá, colorea esta sección azul, etc. Cuando recibe estos
comandos, el servidor de X11 desempeña las operaciones apropiadas para que la estación de
trabajo o el terminal realice la acción o muestre la información adecuada.
La razón de que el Sistema X ponga toda la responsabilidad del despliegue en pantalla en el
servidor X11, es para hacer más fácil la escritura de programas de aplicación. Diferentes
fabricantes usan diferentes métodos para controlar el despliegue en pantalla. Los programas
pueden enviar comandos simples como dibujar una línea al servidor y no preocuparse acerca
de cómo se dibuja una línea en cada tipo de Estación de Trabajo.
En otras palabras, el servidor se encarga de tomar la entrada de los usuarios y hacerla llegar a
las aplicaciones clientes, además de recibir y redireccionar las salidas de estas aplicaciones.
Fundamentos de Linux 153
Capítulo 5 Interfaces Gráficas
Los programas , llamados clientes de X11, son el corazón del sistema X Window, y la parte con
que se tendrá la mayor interacción. Cada programa es llamado cliente porque requiere que esa
acción sea procesada por el servidor X11.
Existe una gran cantidad de aplicaciones clientes para servidores X Window con las más
variadas funcionalidades. Muchas de ellas permiten acercar un poco más a los usuarios menos
expertos la posibilidad de emplear comandos de difícil comprensión o sintaxis. No obstante se
debe tener claro que en Linux todo se puede lograr con comandos, no así con las aplicaciones
gráficas que pueden no ofrecer todas las opciones posibles en aras de ser más simples o
porque no siempre se desarrollan a la par de los comandos y programas con interfaz texto.
154 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
La interfaz principal entre el usuario y un servidor X la define el gestor o manejador de ventanas
(Window Manager). Este se encarga de definir y manipular la apariencia de las ventanas:
bordes, menús, botones, barras de desplazamiento, de herramientas y de estado, entre otras
múltiples funciones. Existen muchos de estos gestores con diferentes posibilidades y
características. Entre ellos podemos citar:
• XFce: es un entorno de escritorio que consume pocos recursos. Como administrador de
ventanas utiliza una modificación de fvwm y fvwm2 llamado xfwm y utiliza la biblioteca
gráfica GTK+ para el panel y sus programas.
• Enlightenment: tal como su nombre lo indica Enlightenment (ilustración), es uno de los
administradores de ventanas más atractivos que existen y es totalmente personalizable por
medio de temas de escritorio. Si bien hace mucho tiempo que existe todavía está en
desarrollo y se lo está mejorando para hacer de él un entorno de escritorio.
• Sawfish: es uno de los últimos administradores de ventanas que aparecieron. Las primeras
Fundamentos de Linux 155
Interfaces Gráficas
Manejadores de Ventanas
Capítulo 5 Interfaces Gráficas
versiones tenían como nombre Sawmill. Es muy configurable y gráficamente agradable (al
mejor estilo Enlightenment). Está escrito en Lisp y utiliza la biblioteca gráfica GTK+.
• Window Maker: es un administrador muy estable y robusto. Imita a la interfaz de las
desaparecidas computadoras NextSTEP. Posee una herramienta de configuración que
facilita las cosas a la hora de "sintonizar" Window Maker.
• AfterStep: como Window Maker este administrador imita a las NextSTEP. Igual que el
administrador anterior AfterStep posee una herramienta de configuración propia.
• BlackBox: es uno de los administradores más rápidos que hay gracias a su pequeño
consumo de recursos. Posee renderizado en tiempo real de los decorados de las ventanas y
del fondo del escritorio. Está escrito en el lenguaje C++ y el código fuente, la documentación
y algunos temas para éste no ocupan más de 200 Kb comprimidos.
• FluxBox: es una bifurcación de BlackBox con nuevas características.
• IceWM: tiene un consumo pequeño de memoria y es muy rápido. Imita el aspecto de
Windows, Motif y OS/2. Posee un soporte básico para temas de escritorio.
• Metacity: utiliza la biblioteca gráfica GTK+ versión 2 y consume muy pocos recursos lo cual
hizo que se convirtiese en el administrador de ventanas por defecto de las últimas versiones
de GNOME. También posee soporte para temas como así también teclas de acceso directo.
• fvwm: es uno de los primeros administradores de ventanas de Linux que aparecieron. El
decorado de las ventanas es parecido a Motif. No es muy configurable pero sí es muy rápido
y consume muy poca memoria.
• pwm: este es un administrador de ventanas que tiene la particularidad de soportar varios
programas corriendo dentro de una misma ventana.
• twm: es el administrador de ventanas que trae por defecto el servidor XFree86.
Prácticamente no consume recursos, se modifica por medio de archivos de texto y es muy
simple.
156 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
La forma más acabada de una interfaz gráfica para Linux es lo que se conoce como Entorno
Gráfico de Escritorio o GDE (Graphical Desktop Environments). Estos se caracterizan
fundamentalmente por la cantidad y variedad de las aplicaciones que ofrecen, la interrelación
entre las mismas, las facilidades para la interacción con el usuario, y las posibilidades de
configuración visual que poseen de acuerdo al gestor de ventanas empleado. Los dos ejemplos
clásicos de entornos de escritorio son:
• KDE (K Desktop Environment)- es uno de los entornos de escritorio gráfico más populares de
los desarrollados hasta el momento, que ha mantenido un acelerado crecimiento desde que
apareció su primera versión oficial en 1998. Ofrece aplicaciones para la administración del
sistema y de los servicios, numerosas y diversas aplicaciones de oficina incluyendo una suite
nombrada koffice, un browser-explorador llamado konqueror muy potente, un entorno para
desarrollar aplicaciones KDE nombrado KDevelop que incluye una biblioteca de clases muy
completa, así como numerosas utilidades y aplicaciones que sirven de interfaz gráfica para
diversas funcionalidades en el sistema. En cuanto a facilidades visuales, KDE también se
Fundamentos de Linux 157
Interfaces Gráficas
Escritorios
Capítulo 5 Interfaces Gráficas
destaca bastante respecto a otros entornos gráficos, brindando herramientas para modificar
y adecuar a los gustos personales más exquisitos el entorno de trabajo. También posee
soporte para varios idiomas. Contínuamente se desarrollan y promueven nuevas
aplicaciones para el KDE incluyendo juegos, aplicaciones multimedia, etc.
• GNOME (GNU Network Object Environment) - al igual que el KDE es un entorno gráfico
completo y funcional. Ofrece un ambiente de trabajo integral, comprensible por usuarios poco
diestros y fácilmente adaptable a los más exigentes. Fue el primer entorno de escritorio
gráfico distribuido libremente para sistemas basados en Unix amparado siempre por el
proyecto GNU. Se orienta al desarrollo de aplicaciones para redes basadas en tecnologías
tan poderosas como CORBA. Ofrece soporte y documentación para múltiples lenguas. En
cuanto a las aplicaciones, ofrece, al igual que KDE, un conjunto amplio y diverso.
Para encontrar información completa acerca de gran cantidad de gestores de ventanas y
entornos de escritorio puede consultarse el sitio http://xwinman.org.
Tanto los entornos de escritorio gráficos como los gestores de ventanas siempre van a ser
clientes de un servidor X por lo que realmente cada aplicación que se ejecute en ellos deberá
conectarse a algún servidor aunque sea de forma local. Las aplicaciones propias de un tipo de
escritorio determinado pueden ejecutarse perfectamente en otro cualquiera. Podemos disponer
en un mismo sistema de varios entornos de escritorio e incluso ejecutarlos a la vez. También se
pueden tener uno o varios entornos de escritorio remotos.
158 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
3.3 Implementaciones
a) Xfree86
XFree86 es un producto derivado de The XFree86 Project, Inc. el cual es una implementación
de X Window System, XFree86 corre principalmente en sistemas UNIX y derivados, como
Linux, o cualquier otra variante de sistemas BSD, como el MacOS X (mediante Darwin) así
como OS/2 y Cygwin.
XFree86 provee una interfaz gráfica cliente/servidor entre el Hardware (mouse, teclado y
sistemas gráficos) y un entorno de escritorio que provee de un sistema de ventanas así como
de una interfaz estandarizada de aplicación (API por sus siglas en ingles).
XFree86 es independiente de la plataforma, extensible y puede utilizarse en red.
La versión actual de Xfree86 es la Xfree86-4.4.0, para mas información visite la pagina:
http://www.xfree86.org/
b) X.org
"X.Org" o “X“es una implementación de código abierto del sistema X Window desarrollada por
la "X.Org Foundation". Esta organización también se encarga de desarrollar nuevas tecnologías
y estándares para el sistema X Window.
La versión actual es X11R6.8.2, para mas información sobre esta distribución visite la pagina:
http://www.x.org/
Fundamentos de Linux 159
Capítulo 5 Interfaces Gráficas
3.4 Inicio de X Window
Para iniciar una sesión de trabajo en un entorno de escritorio determinado o simplemente en un
gestor de ventanas, se puede invocar este directamente desde el shell utilizando algún
comando. Estos scripts se ejecutan sólo si existe previamente un servidor X activo por el
display correspondiente. Para hacer ambas cosas, iniciar el servidor X y un conjunto de
aplicaciones clientes, se puede emplear el script startx. Este lee las aplicaciones clientes a
ejecutar desde el fichero .xinitrc en el directorio base del usuario actual. Existe además un tipo
de aplicación gráfica conocida como gestor de “displays“ (Display Manager) que permiten
conectarse al sistema Linux directamente a través de un diálogo gráfico. El proceso que se
desencadena de esta forma es equivalente al proceso de login en una terminal basada en
caracteres pues permite a un usuario introducir un login y un password, autenticarse e iniciar
una sesión de trabajo en un entorno gráfico determinado.
Entre los gestores de “displays“ más conocidos se encuentran: xdm, kdm y gdm. El primero es
la base de todos los demás. Visualmente es muy simple pues sólo ofrece la posibilidad de
autenticarse en el sistema introduciendo login y password, mientras que los otros provistos por
KDE y GNOME respectivamente además de esto, permiten seleccionar un escritorio
determinado u otra acción a ejecutar, posibilitan el apagado y reinicialización del sistema y dan
algunas facilidades para modificar su apariencia.
Toda aplicación cliente X se basa en un nombre de display para identificar al servidor X con el
cual se conecta. Este nombre tienen la siguiente forma:
máquina:display.pantalla
Donde:
• máquina: especifica el nombre o número IP de la máquina donde se ejecuta el servidor X
que se quiere utilizar para mostrar la aplicación. De no ponerse se asume el nombre
localhost, o sea la estación donde se trabaja.
• display: indica a través de que display se mostrará la aplicación cliente. Estos se numeran a
partir del cero. Los displays son a las interfaces gráficas como las consolas virtuales son a
160 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
las interfaces texto. Normalmente en un sistema Red Hat Linux se dispone de seis consolas
virtuales y a partir de la siete y hasta la 12 se cuenta con 6 posibles displays a través de los
cuales se pueden mostrar al menos seis sesiones gráficas ya sean locales o remotas, cada
una con su correspondiente servidor X.
• pantalla: este aspecto se utiliza cuando se dispone de varias tarjetas de video y los
monitores correspondientes. Se numeran a partir de cero, y este valor es el que también se
asume por defecto.
Para especificar el valor del display usualmente las aplicaciones con interfaz X poseen la
opción display, pero la forma más general de determinar esta propiedad es utilizando la variable
del entorno DISPLAY.
3.4.1 Nivel de Ejecución 3
Cuando startx comienza, busca un archivo .xinitrc en el directorio principal del usuario para
definir el entorno de escritorio y posiblemente otras aplicaciones clientes X a ejecutar. Si este
archivo .xinitrc no se encuentra, se utilizará el archivo por defecto /etc/X11/xinit/xinitrc.
El script por defecto xinitrc luego buscará por los archivos definidos por el usuario y archivos de
sistema por defecto, incluyendo .Xresources, .Xmodmap y .Xkbmap en el directorio principal del
usuario y Xresources, Xmodmap y Xkbmap en el directorio /etc/X11/. Los archivos Xmodmap y
Xkbmap, si existen, son usados por la utilidad xmodmap para configurar el teclado. Los
archivos Xresources son leídos para asignar valores de preferencia específicos a aplicaciones.
Después de configurar estas opciones, el script xinitrc ejecuta todos los scripts localizados en el
directorio /etc/X11/xinit/xinitrc.d/. Un script muy importante en este directorio es xinput, el cual
configura los parámetros tales como el idioma por defecto.
Luego, el script xinitrc intenta ejecutar .Xclients en el directorio principal del usuario y cambia a /
etc/X11/xinit/Xclients si no lo puede encontrar. El propósito del archivo Xclients es arrancar el
entorno de escritorio o posiblemente, sólo un gestor de ventanas básico. El script .Xclients en el
directorio principal del usuario inicia el entorno de escritorio especificado por el usuario en el
archivo .Xclients-default. Si .Xclients no existe en el directorio principal del usuario, el script
estándar /etc/X11/init/Xclients intenta iniciar otro entorno de escritorio, intentando primero con
Fundamentos de Linux 161
Capítulo 5 Interfaces Gráficas
GNOME y luego con KDE seguido por twm.
3.4.2 Nivel de Ejecución 5
Cuando el sistema arranca en el nivel de ejecución 5, se lanza una aplicación cliente de X
especial, llamada un gestor de visualización. Un usuario debe autenticarse usando el gestor de
visualización antes de que se inicien cualquier entorno de escritorio o gestores de ventanas.
Dependiendo de los entornos de escritorio instalados en su máquina, están disponibles tres
gestores de visualización diferentes para manejar la autenticación de los usuarios.
• gdm — Es el gestor de visualización por defecto para GNOME y permite que los usuarios
puedan configurar los parámetros de idioma, cierre del sistema, reinicio o conexión al
sistema.
• kdm — es el gestor de visualización de KDE que permite a los usuarios apagar, reiniciar
o conectarse al sistema.
• xdm — Este es un gestor de visualización muy básico que sólo permite que el usuario se
conecte al sistema.
Cuando arranque en el nivel de ejecución 5, el script prefdm determina el gestor de
visualización preferido haciendo referencia al archivo /etc/sysconfig/desktop. Vea el archivo:
/usr/share/doc/initscripts-<version-number>/sysconfig.txt
donde <version-number> es el número de la versión del paquete initscripts, para ver un listado
de las opciones disponibles para este archivo.
Cada uno de los gestores de visualización hace referencia al archivo /etc/X11/xdm/Xsetup_0
para configurar la pantalla de conexión. Una vez que el usuario se conecte al sistema, el script /
etc/X11/xdm/GiveConsole corre para asignar la propiedad de la consola para el usuario. Luego,
el script /etc/X11/xdm/Xsession se ejecuta para llevar a cabo muchas de las tareas que son
normalmente realizadas por el script xinitrc cuando arranca X desde el nivel de ejecución 3,
incluyendo la configuración del sistema y los recursos del usuario, así como también ejecutar
los scripts en el directorio /etc/X11/xinit/xinitrc.d/.
162 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
El usuario puede especificar cuál entorno de escritorio desea utilizar cuando se autentican
usando los gestores de visualización gdm o kdm seleccionándolo desde el menú Session
(accesado al seleccionar Botón de menú principal [en el Panel] => Preferencias => Más
Preferencias => Sesiones). Si el entorno de escritorio no es especificado en el gestor de
visualización, el script /etc/X11/xdm/Xsession verificará los archivos .xsession y .Xclients en el
directorio principal del usuario para decidir cuál entorno de escritorio cargar. Como último
recurso el archivo /etc/X11/xinit/Xclients es usado para seleccionar un entorno de escritorio o
gestor de ventanas para usarse de la misma forma que en el nivel de ejecución 3.
Cuando el usuario termina una sesión X en la visualización por defecto (:0) y se desconecta, el
script /etc/X11/xdm/TakeConsole se ejecuta y vuelve a asignar la propiedad de la consola al
usuario root. El gestor de visualización original, que continúa ejecutándose después que el
usuario se conecta, toma el control liberando un nuevo gestor de visualización. Esto reinicia el
servidor XFree86, despliega una nueva ventana de conexión y reinicia el proceso completo otra
vez.
Fundamentos de Linux 163
Capítulo 5 Interfaces Gráficas
3.5 Archivos y Herramientas de Configuración
Su entorno X11 está controlado por ciertos archivos localizados en su directorio HOME:
• .xinitrc Este archivo controla que una vez iniciada su sesión X se ejecuten las aplicaciones
que se deseen. Para añadir o borrar aplicaciones edite y modifique este archivo.
• .Xdefaults Este archivo es cargado en la base de datos de recurso de X11 cuando se
conecte por primera vez. Se utiliza para almacenar varios modos de configuración, o
recursos, los que se requieran para variadas aplicaciones.
• .twmrc Este es el archivo de configuración del administrador de ventana que será tratado a
fondo más adelante. Controlan las diversas opciones como los contenidos de los menú para
su administrador de ventana twm.
El archivo de .xinitrc determina que programa se ejecuta (incluyendo sobre todo el gestor de
ventana) cuando inicia X.xinit chequea primero su directorio home en busca del archivo .xinitrc
Si el archivo se encuentra, se ejecuta, si no utiliza el archivo predeterminado ubicado en /
etc/X11/xinit/xinitrc Este es un ejemplo simple de un archivo .xinit:
#!/bin/sh
userresources=$HOME/.Xresources
sysresources=/usr/X11R6/lib/X11/xinit/.Xresources
exec gnome-session&
xclock -geometry 50x50-1+1 &
xterm -geometry 80x50+494+51 &
xterm -geometry 80x20+494-0 &
exec xterm -geometry 80x66+0+0 -name login
Esta sesión de X empezará con el gestor de ventanas Gnome, un reloj, y tres terminales. Fíjese
en exec antes del ultimo xterm, lo que esto hace es reemplazar el shell que esta corriendo
actualmente(la que esta ejecutando el script xinitrc con el comando xterm) Cuando el usuario
cierre ese xterm, la sesión X terminará.
Muchos programas en X utilizan un sistema llamado X Resource Database (Recursos de Base
de Datos) para encontrar las preferencias del usuario (fuentes , colores ,etc.) Esta base de
datos se mantiene a través del programa xrdb. El Archivo xinitrc le dice a xrdb que también
164 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
cargara a ~/.Xresources. xrdb y ~/.Xdefaults, por lo tanto cualquiera de los nombres funcionara.
Aunque esos archivos son optativos, puede que estén ó no. Por ejemplo el archivo ~/.profile si
lo tienes tiene mas importancia que el /etc/profile, pero si no esta, actuará el archivo /etc/profile.
Un archivo .Xresources pequeño se parece a esto:
xterm*background: black
xterm*foreground: gray
xterm*scrollBar: true
xterm*font: -*-lucidatypewriter-*-r-*-*-15-*-*-*-*-*-*-*
Estas cuatro líneas especifican la información de configuración para el programa xterm Un
recurso de X se lista de esta forma:
program*option: setting/value
Cuando su administrador de ventana ( twm, por ejemplo) se ejecuta, lee su archivo de
inicialización .twmrc en su escritorio HOME. Este archivo se usa para configurar el
comportamiento de su administrador de ventanas, incluyendo:
• Cuales ventanas tendrán barras de título.
• Cuales ventanas se levantarán automáticamente cuando el cursor del ratón entre a ellas.
• Que íconos serán usados para las diferentes aplicaciones.
• Que funciones harán los botones del ratón.
• Que menús contienen.
Fundamentos de Linux 165
Capítulo 5 Interfaces Gráficas
4 KDE
4.1 Descripción
El escritorio KDE funciona de modo similar a otros entornos de escritorio gráficos. Puede
arrastrar y soltar archivos e iconos de aplicación en cualquier ubicación del escritorio. También
puede añadir nuevos iconos para todos los tipos de aplicaciones y recursos al escritorio, panel
o gestor de archivos. El escritorio es en sí mismo muy personalizable. Puede cambiar
fácilmente el aspecto de botones, decoraciones de ventanas y marcos, y fondos. También hay
disponibles herramientas de configuración que le permiten personalizar el modo en el que se
comporta el escritorio ante eventos, como hacer clic o doble clic con el ratón y pulsar
combinaciones de teclas para crear accesos directos con los que ahorrar tiempo.
4.2 Iniciando KDE
Durante la instalación, si seleccionó gráfica como tipo de conexión y KDE como escritorio
predeterminado, verá a la pantalla gráfica de conexión de KDE
Para entrar al sistema se debe ser un usuario valido para él, teclee el usuario en el indicador de
comandos de login y pulse [enter]. A continuación pulse la contraseña de dicho usuario en el
indicador de comandos de la contraseña y pulse [enter].
4.3 Componentes
El escritorio KDE contiene lanzadores de aplicación, ventanas de documentos, carpetas de
archivos, etc. También puede tener acceso al menú principal y configurar el escritorio según
sus necesidades.
Por defecto la pantalla de KDE se divide en tres partes fundamentales:
• Panel de KDE
• Escritorios
• Panel de ventanas
El panel de KDE contiene accesos directos a las aplicaciones más empleadas así como dos
166 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
menús.
El equivalente al menú Start de Windows, esto es el menú a través del cual se pueden ejecutar
las aplicaciones. Al seleccionar este elemento se despliega un menú subdivido en distintas
categorías. KDE incluye una gran cantidad de utilidades que se integran con el entorno.
Al contrario de otros entornos gráficos X Window permite organizar las ventanas en distintos
escritorios virtuales. Para cambiar de escritorio virtual se puede escoger uno de los cuatro
botones que aparecen en el panel. Justo encima del panel de KDE, aparece el escritorio, al
igual que en Windows este elemento contiene iconos que permiten acceder a los elementos
más comunes como las unidades de disco o la papelera.
Por último en la parte superior del escritorio aparece otra barra, en la que aparecerán botones
por cada ventana que se cree.
Fundamentos de Linux 167
Capítulo 5 Interfaces Gráficas
Justo encima del panel de KDE, aparece el escritorio, al igual que en Windows este elemento
contiene iconos que permiten acceder a los elementos más comunes como las unidades de
disco o la papelera. Por último en la parte superior del escritorio aparece otra barra, en la que
aparecerán botones por cada ventana que se cree.
Las ventanas en el KDE tienen un aspecto similar al de las ventanas de Windows (al menos
con el aspecto básico), pudiendo distinguir en ellas diversas partes:
168 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
En la parte superior izquierda, aparece el icono de la aplicación, seleccionando el cual aparece
un menú con las opciones básicas de manipulación de ventanas: minimizar, maximizar, cerrar;
así como otras no tan habituales como enviar la ventana a otros escritorios.
Junto a él y en la parte superior central de la ventana se encuentra la barra de títulos de la
ventana. Finalmente en la parte superior derecha aparecen tres botones con las opciones de
minimizar, maximizar y cerrar.
Esta es la disposición por defecto pero como se verá más adelante esta disposición puede ser
adaptada a los gustos del usuario de una forma muy sencilla. Por debajo de este elemento se
extiende la barra de menús y de herramientas y el área de trabajo de la aplicación.
Fundamentos de Linux 169
Capítulo 5 Interfaces Gráficas
Al igual que en Windows, KDE permite cambiar el tamaño de una ventana sin más que acercar
el ratón a un borde de la misma. En esta posición cambia el cursor, indicando en que dirección
podemos modificar el tamaño de la ventana en esa posición. Si se hace clic sobre el borde y se
arrastra cambiará el tamaño de la ventana.
Si desea documentación adicional visite la página oficial de KDE http://www.kde.org/, otra
página de interés es http://es.kde.org/ que esta en español y contiene varias ligas.
4.4 Herramientas de Configuración
La principal herramienta de configuración en KDE es el “Control Center“, esta herramienta te
permite personalizar tu escritorio, así como la configuración de los periféricos como el ratón y el
teclado, la configuración de los usuarios entre otras cosas.
Puede activar el KDE Control Center desde el icono Main Menu K o desde el Panel, haciendo
click en el icono KDE Control Center, que será como:
El KDE Control Center se divide en dos paneles principales: A la izquierda, encontrará las
elementos del menú en árbol y a la derecha, las características susceptibles de modificación.
Las distintas categorías o elementos del menú en árbol pueden estar concentradas cuando
abre el control center por primera vez
Haga click en + para desplegar la lista de opciones.
170 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
5 GNOME
5.1 Descripción
El proyecto GNOME (GNU Network Object Model Environment) surge en agosto de 1997 como
proyecto liderado por Miguel de Icaza para crear un entorno de escritorio completamente libre
para sistemas operativos libres, en especial para GNU/Linux. Desde el principio, el objetivo
principal de GNOME ha sido proporcionar un conjunto de aplicaciones amigables y un escritorio
fácil de utilizar.
Como con la mayoría de los programas GNU, GNOME ha sido diseñado para ejecutarse en
toda la gama de sistemas operativos de tipo Unix con X Window, y especialmente pensado
para GNU/Linux. Desde sus inicios se ha utilizado la biblioteca de controles gráficos GTK,
originalmente desarrollada para el programa The GIMP.
A medida que el proyecto ha ido progresando en los últimos años, los objetivos del mismo se
han extendido para tratar una serie de problemas en la infraestructura Unix existente.
Actualmente el proyecto evoluciona bajo amparo de la Fundación GNOME.
5.2 Iniciando GNOME
Se puede especificar que GNOME sea nuestro entorno gráfico a la hora de instalar el sistema.
GNOME inica muy parecido a KDE, al prender el equipo aparece una pantalla que pide insertar
el nombre de usuario valido y la contraseña de dicho usuario.
5.3 Componentes
El uso de GNOME es muy parecido al de otros entornos gráficos. La pantalla inicial de GNOME
se encuentra dividida en dos zonas principales. La parte superior en la que aparecen las
ventanas de las aplicaciones y documentos del usuario recibe el nombre de escritorio, mientras
que la parte inferior de la pantalla recibe el nombre de panel de GNOME:
Fundamentos de Linux 171
Capítulo 5 Interfaces Gráficas
Este elemento está diseñado para contener la siguiente información:
• Contiene la huella de pie o footprint, al seleccionar este elementos aparece un menú similar
al menú Start de Windows 9x con las aplicaciones más importantes instaladas.
• Las applets son enlaces a las aplicaciones de uso más frecuente como la consola, Netscape,
la ayuda, etc.
172 Fundamentos de Linux
Capítulo 5 Interfaces Gráficas
• El acceso a los escritorios virtuales. Al contrario que en Windows, X Window permite
organizar las ventanas en varios escritorios virtuales.
• Al igual que Windows el panel de GNOME dispone de un área específica en la que aparecen
los botones representativos de las ventanas.
Para obtener más documentación acerca de GNOME puede visitar la página del proyecto:
http://foundation.gnome.org/
O puede visitar la página http://www.es.gnome.org/ que se encuentra en español y tiene varias
ligas a otros istios relacionados con GNOME.
5.4 Herramientas de Configuración
La configuración del escritorio se centra en el Centro de Control de GNOME, podemos acceder
desde el menú de Aplicaciones de nuestro panel, en la sección Preferencias del Escritorio se
nos muestran todas las aplicaciones de configuración del escritorio que se encuentran
disponibles en el Centro de Control.
Entre las aplicaciones de configuración tenemos la de selección de Temas, también tenemos la
de configuración del Ratón, con el que podremos seleccionar su velocidad, la velocidad del
Doble-Click, si somos zurdos, etc. Otra herramienta importante es la de configuración del
Salvapantallas, en el que elegiremos un tipo u otro, el tiempo de espera antes de cargarlo y
mas cosas.
La herramienta de selección de la tipografía nos permite seleccionar la fuente que deseamos
para nuestro escritorio, para las aplicaciones y para el título de la ventana, así como seleccionar
el tipo de suavizado que deseamos, o si no deseamos ninguno.
Fundamentos de Linux 173
Capítulo 5 Interfaces Gráficas
pagina vacia
174 Fundamentos de Linux
Capítulo 6 Impresión de Archivos
Capítulo 6 Impresiónde Archivos
Fundamentos de Linux 175
Capítulo 6 Impresión de Archivos
176 Fundamentos de Linux
Impresión de archivos
Descripción
Sistemas de Impresión(LPD, LPRNG, CUPS)Impresión de Archivos
Visualización Cola de ImpresiónCancelado de Trabajos de impresión
Capítulo 6 Impresión de Archivos
1 Descripción del capitulo
En esta sección se verá los sistemas de impresión comunes en Linux, la impresión de archivos,
como examinar la cola de impresión y eliminar trabajos de impresión. Nos orientaremos
principalmente a las tareas realizadas comúnmente por un usuario del sistema y no como
administrador de este.
Fundamentos de Linux 177
Capítulo 6 Impresión de Archivos
2 Sistemas de impresión
El sistema de impresión de Linux (el sistema lp) es una adaptación del código escrito por los
Regents de la Universidad de California para la versión Berkeley Software Distribution (BSD)
del sistema operativo UNIX.
En los sistemas operativos multitarea la forma que tiene de administrar los trabajos de
impresión es ir guardándolos en archivos temporales, hasta que vayan saliendo por la
impresora, el último archivo en entrar es el último en salir. Cuando uno manda un trabajo de
impresión este pasa por una serie de filtros hasta que al fin llegan a un formato enténdible por
la impresora. Todo este trabajo lo realiza Linux sin que el usuario tenga que hacer nada. Este
sistema de impresión suele llamarse cola de impresión o “spooling”.
178 Fundamentos de Linux
Impresión de archivos
Sistemas de Impresión
● Los tres sistemas de impresión mas utilizados– LPD (basado en implementacion de BSD)
– LPRNG (reimplementación mejorada de LPD/LPR, utilizada en linux como sistema LPR)
● http://www.lprng.org
– CUPS (Common UNIX Printing System,)● http://www.cups.org
Capítulo 6 Impresión de Archivos
2.1 LPD
LPD (también llamado Berkeley line printer spooling system) es un sistema que maneja una
cola de impresión por cada impresora configurada, filtros para convertir información de diversos
tipos al lenguaje particular de cada impresora así como filtros de cuentas que permiten
monitorear y controlar el uso de cada impresora por parte de cada usuario. LPD recibe y
procesa solicitudes de impresión realizadas por programas cliente e imprime la información de
las colas en los dispositivos configurados para cada cola
La aplicación LPD es responsable de controlar todo lo que se refiere a impresión. Es
responsable de un gran número de cosas, tales como:
• Controlar el acceso a las impresoras conectadas directamente al ordenador y las impresoras
conectadas a otras máquinas de la red.
• Habilita a usuarios, para efecto de que puedan enviar archivos a imprimir; estos envíos se
conocen como trabajos (“jobs“).
• Previene el hecho de que varios usuarios usen la impresora al mismo tiempo, al mantener un
orden en la cola de impresión (“queue“) para cada impresora.
• Puede imprimir encabezados (“header“), también conocidos como titulares o páginas de
aviso, de tal forma que los usuarios identifiquen fácilmente sus impresiones, de una pila de
impresiones.
• Se ocupa de los parámetros para impresoras conectadas a puertos seriales.
• Puede enviar trabajos de impresión por medio de una red, a una cola LPD de una máquina
remota.
• Puede ejecutar filtros especiales para dar formato a trabajos que requieren de un manejo de
lenguaje de impresión diferente o impresoras de diferentes capacidades.
• Puede mantener un registro por uso de la impresora.
Por medio del fichero de configuración /etc/printcap,el cual es leído cada vez que lpd inicia y
Fundamentos de Linux 179
Capítulo 6 Impresión de Archivos
donde se configura cada cola de impresión, el dispositivo asociado a cada una y sus
parámetros, los filtros para los diversos tipos de información que puede imprimir y filtros de
cuentas.
En esta página http://www.linuxprinting.org/ se encuentra documentación sobre LPD
2.2 LPRNG
LPRng, que significa “LPR: the Next Generation“ (“LPR: la Siguiente Generación“)
Es una re-implementación del sistema BSD de impresión, con una gran cantidad de mejoras y
sofisticaciones, especialmente para trabajo en redes y con múltiples usuarios e impresoras.
LprNg en sus versiones recientes también provee herramientas gráficas para su configuración,
que en su apariencia es parecido al Printtol de la distribución RedHat.
El paquete LPRng contiene:
• lp es un enlace simbólico a lpr.
• lpq es el programa de monitorización de estado.
• lpr es el programa de encolado de trabajos.
• lprm es el programa de eliminación de trabajos.
• lpstat es el programa de estado de trabajos.
• lpc es el programa de control para el demonio.
• lpd es el demonio.
En http://www.lprng.org/ encontrarás información acerca de LprNg
2.3 CUPS
CUPS (Common UNIX Printing System, Sistema de impresión común para UNIX) se puede
utilizar en vez del sistema de impresión por defecto LPRng. Es un sistema de impresión
180 Fundamentos de Linux
Capítulo 6 Impresión de Archivos
portable y extensible para Unix. CUPS está siendo desarrollado por Easy Software Products,
una empresa de software emplazada en Hollywood, Maryland, que ha estado vendiendo
software comercial para Unix desde 1993. La primera versión de producción de CUPS (basada
en IPP/1.0) fue liberada en octubre de 1999. Desde entonces, se han publicado bastantes
actualizaciones para la versión 1.0, destinadas a corregir los errores encontrados, así como
añadir seguridad y portabilidad a la versión existente; se ha de notar que no se han añadido
nuevas funcionalidades para mejorar la estabilidad del código de CUPS.
CUPS 1.1 está basado en IPP/1.1 y se han añadido las funcionalidades pedidas por sus
usuarios. Al igual que con la versión 1.0, CUPS 1.1 disfrutará de las actualizaciones necesarias
para corregir cualquier problema encontrado en el software, pero no se añadirán nuevas
características.
Algunas de las ventajas de CUPS son:
• Compatibilidad para IPP (protocolo de impresión en red de siguiente generación)
• Detección automática de las impresoras de la red
• Herramienta de configuración con interfaz Web
• Compatibilidad para los ficheros de descripción de impresoras PPD
• Compatibilidad para un amplio número de impresoras
CUPS proporciona los siguientes comandos:
• lpc facilita un control limitado sobre las impresoras y clases de colas suministradas por CUPS
.
• cupsd es el planificador para el Sistema de Impresión Común de Unix.
• accept le indica al sistema de impresión que acepte trabajos de impresión para el destino
indicado.
• reject le indica al sistema de impresión que rechace trabajos de impresión para el destino
indicado.
Fundamentos de Linux 181
Capítulo 6 Impresión de Archivos
• cupsaddsmb exporta impresoras al software SAMBA para usarlas con clientes Windows.
• lpadmin configura las impresoras y clases de colas suministradas por CUPS.
• lpinfo lista los dispositivos disponibles o los controladores conocidos por el servidor CUPS.
• lpmove mueve el trabajo especificado a un nuevo destino.
• cupstestppd comprueba la validez de ficheros PPD.
• lpq muestra el actual estado de la cola de impresión para la impresora nombrada.
• lpr suministra archivos para su impresión.
• lprm cancela trabajos de impresión que ya han sido encolados.
• cancel cancela los trabajos de impresión existentes.
• disable para las impresoras o clases señaladas.
• enable inicia las impresoras o clases señaladas.
• lp suministra ficheros para su impresión o altera trabajos pendientes.
• lpoptions muestra o establece las opciones de las impresoras.
• lpstat muestra la información del estado de las clases, trabajos e impresoras actuales.
• lppasswd añade, cambia o borra contraseñas en el fichero de resumen de contraseñas de
CUPS, passwd.md5.
• cups-config es la utilidad de configuración del programa CUPS.
En http://www.cups.org/ se encontrará mas información sobre CUPS.
IPP
IPP (Internet Printing Protocol). es un diseño completamente nuevo para la impresión en red,
pero utiliza un método bien conocido y probado para la transmisión de datos actual: HTTP 1.1.
182 Fundamentos de Linux
Capítulo 6 Impresión de Archivos
Para no reinventar la rueda, y basado en un estándar de Internet existente y robusto, IPP es
capaz de manejar fácilmente otros estándares HTTP como: autenticación básica, en modo
digest o utilizando certificados; SSL o TLS, para la transmisión de datos encriptados; LDAP
para servicios de directorio (publicar datos en una impresora, opciones del dispositivo,
controladores, coste de la red; o comprobar una clave mientras se está tratando una
autenticación).
Fundamentos de Linux 183
Capítulo 6 Impresión de Archivos
3 Impresión de Archivos
El sistema Linux incluye una colección de programas, denominados sistema lp, que permiten
imprimir archivos. Se manipula con tres instrucciones básicas (lp, lpstat y cancel), y permite
imprimir desde archivos de texto hasta archivos con formatos complejos.
Comando de impresión
El comando lp se utiliza en los sistemas que utilizan el sistema de impresión CUPS, su sintaxis
es:
# lp [opciones] archivo...
Este comando permite mandar a imprimir archivos.
Las opciones que toma este comando son:
• -m hace que lp le envíe un mensaje por correo electrónico cuando se termine su trabajo de
184 Fundamentos de Linux
Impresión de archivos
Impresión
● Practicamente mismo comando en ambos sistemas● En LPRNG
– lpr [opciones] archivo ....
● En CUPS– lp [opciones] archivo ....
Capítulo 6 Impresión de Archivos
impresión
• -w hace que se escriba un mensaje en pantalla cuando la impresión se ha efectuado
• -c dice a lp que haga una copia de seguridad de su archivo (o archivos)
• -d “Destino“ especifica la impresora a la que se va a imprimir
• -n Numero de copias
• -qn se fija la prioridad del requerimiento en n (de 0 a 39)
Un ejemplo del uso de este comando es:
# lp /etc/passwd
request id is hplj-14 (1 file(s))
El comando lpr es el que se utiliza en los sistemas de impresión LPRNG su sintaxis es:
# lpr [opciones] archivo
Las opciones que maneja son:
• -E encripta cuando se conecta el servidor
• -P impresora especifica el nombre de la impresora a la que se manda la impresión
• -# indica el número de copias que se imprimirán
Por ejemplo:
# lp /etc/passwd
request id is hplj-15 (1 file(s))
Fundamentos de Linux 185
Capítulo 6 Impresión de Archivos
Visualización de colas de impresión
Comando lpstat
Para sistemas CUPS el comando lpstat nos permite obtener información acerca de los
requerimientos de impresión que hayamos realizado y del estado de las diferentes impresoras
del sistema. La sintaxis es:
# lpstat [opciones] impresora
Introduciendo lpstat sin opciones nos desplegará información acerca de los requerimientos de
impresión realizados por nosotros. Nos mostrará la identificación de los requerimientos, el
tamaño en bytes y la fecha y hora en que se realizó el requerimiento.
Las opciones que maneja el comando son:
186 Fundamentos de Linux
Impresión de archivos
Visualización Cola de Impresión
● En LPRNG se utiliza– lpq
– lpc
● En Cups se tiene– lpstat
Capítulo 6 Impresión de Archivos
• -a muestra si la impresora esta aceptando trabajos de impresión
• -c muestra las clases y miembros de impresoras
• -d muestra la impresora por defecto
• -f muestra formularios
• -o muestra el estado de salida
• -p [list] [-D] [-l] Impresora/Descripción/Formato_largo
• -r Estado del "scheduler" (gestor de impresión)
• -R posición de los trabajos en cola
• -s estado
• -u [usuario] muestra las peticiones por usuarios
• -v muestra dispositivos
Un ejemplo de este comando es:
# lpstat
hplj-14 root 2048 Thu 03 Mar 2005 10:55:22 AM CST
hplj-15 root 2048 Thu 03 Mar 2005 10:59:57 AM CST
Comando lpq
En los sistemas LPRNG se utiliza este comando para el manejo de las colas de impresión, esta
cola de impresión por defecto se encuentra en:
/var/spool/lpd/impresora
La sintaxis de lpq es:
# lpq [opciones]
En donde las posibles opciones que toma son:
Fundamentos de Linux 187
Capítulo 6 Impresión de Archivos
• -a reporta los trabajos de todas las impresoras
• -l despliega un informe más detallado de las colas de impresión
• -P especifica que cola de impresión queremos ver
Este comando desplegaría:
# lpq
Rank Owner Job File(s) Total Size
1st root 14 passwd 2048 bytes
2nd root 15 passwd 2048 bytes
188 Fundamentos de Linux
Capítulo 6 Impresión de Archivos
Comando cancel
Se utiliza el comando cancel en el sistema CUPS para cancelar las impresiones que se
encuentran en cola o que se están imprimiendo. Para cancelar una impresión es necesario
conocer la identificación del trabajo que se ha mandado a cola. La identificación se consigue
con el comando lpstat. La sintaxis de este comando es:
# cancel [opciones] num. solicitud impresora
Las opciones que puede tomar son:
-a remueve todos los trabajos de impresión
-u usuario trabajo de un usuario particular
Este comando se utilizaría de la siguiente manera:
# cancel 14
Fundamentos de Linux 189
Impresión de archivos
Cancelación de Trabajos de Impresión
● LPRNG– Lprm
● CUPS– cancel
Capítulo 6 Impresión de Archivos
Comando lprm
Se utiliza para cancelar el trabajo de impresión que se encuentra en la cola. Para especificar
que trabajo se ha de cancelar, especificamos el número de trabajo o el nombre del propietario,
en cuyo caso puede borrar más de un trabajo. Su sintaxis es:
# lprm [opciones] num.solicitud impresora
Las opciones son:
• -P impresora especifica en que impresora se cancelaran.
• # se especifique el número de trabajo que se desea cancelar, también se puede especificar
el nombre de usuario con lo que se eliminan todos los trabajos de impresión de dicho
usuario.
Un ejemplo del uso de este comando es:
# lprm 15
190 Fundamentos de Linux
Capítulo 6 Impresión de Archivos
Evaluación Final
1. ¿Cuáles son los sistemas de impresión que podemos encontrar en Linux?
2. Describa 5 ventajas de CUPS?
3. ¿Qué realiza el comando: “lp -c -n2 -q5 -d impresora /etc/passwd”?
4. El comando equivalente a “lp” en LPRNG es?
5. Los comandos “lprm” y “lpq” son equivalentes a:
Fundamentos de Linux 191
Capítulo 6 Impresión de Archivos
página vacia
192 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
Capítulo 7 Manejo dePermisos
Fundamentos de Linux 193
Capítulo 7 Manejo de Permisos
194 Fundamentos de Linux
Manejo de Permisos
Descripción
Introducción a Usuario y grupos/etc/passwd/etc/shadow/etc/group
PropietariosPermisos
Máscara de Creación de Permisos
Capítulo 7 Manejo de Permisos
1 Descripción del capítulo
Todo archivo y directorio en Linux tiene permisos establecidos que determinan que y quien
puede o no hacer alguna acción con el archivo o directorio. Estas acciones son: leer, escribir y
ejecutar.
Los permisos son la base principal en la seguridad en Linux y es una de las características que
ayudan a que Linux sea casi inmune a los Virus de computadora. Un virus debe escribir sobre
un archivo para poder infectarlo y ejecutarse de alguna manera para poder infectar mas
archivos. Con el sistema de permisos, los virus no pueden infectar cualquier archivo como lo
hacen en Windows, si el usuario no tiene permisos, el virus simplemente no puede infectar los
archivos y por tanto no puede reproducirse. Los principales tópicos a ver son:
Introducción a los conceptos básicos de Usuarios y grupos
Descripción de los archivos:
/etc/passwd
/etc/shadow
/etc/group
Propietarios de Archivos
Modificación de Permisos de Archivos
Permisos por Defecto y máscara de creación de archivos.
Fundamentos de Linux 195
Capítulo 7 Manejo de Permisos
2 Usuarios y grupos en Linux
2.1 Descripción
Independientemente de que haya muchos usuarios o no en el sistema, es importante
comprender los aspectos de la gestión de usuarios bajo Linux. Incluso si se es el único usuario,
se debe tener, presumiblemente, una cuenta distinta a la del administrador del sistema (root)
para hacer la mayor parte del trabajo.
Cada persona que utilice el sistema debe tener su propia cuenta. Raramente es una buena idea
el que varias personas compartan la misma cuenta. No sólo es un problema de seguridad, sino
que las cuentas se utilizan para identificar unívocamente a los usuarios al sistema. Es
necesario saber quién está haciendo que en cada momento.
Cada usuario pertenece a uno o más grupos. La única importancia real de las relaciones de
grupo es la perteneciente a los permisos de archivos, cada archivo tiene un ``grupo propietario''
y un conjunto de permisos de grupo que define de qué forma pueden acceder al archivo los
usuarios del grupo.
Para usar un sistema Linux es necesario estar registrado como uno de sus usuarios. Cada
usuario tiene un nombre de ingreso al sistema, una contraseña y un área del sistema de
archivos reservada para almacenar sus archivos. Así mismo, cada usuario pertenece a un
grupo. Linux permite que un usuario pertenezca a más de un grupo, y no es necesario que un
grupo tenga más de un usuario. El grupo se establece al crear la cuenta de un usuario, y el
administrador del sistema lo puede cambiar en cualquier momento. El usuario puede especificar
permiso de grupos para un archivo que le pertenece, para controlar así el tipo de acceso
permitido a los miembros del grupo.
2.2 Atributos
Usuarios
Linux es un sistema multiusuario por lo que es necesario la administración (segura) de los
distintos usuarios que van a hacer uso de los recursos del sistema. En seguida se listan los
tipos de usuarios y los privilegios deben tener. Existen al menos 3 tipos de usuarios.
196 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
• Usuarios normales con más o menos privilegios que harán uso de los recursos del sistema.
Simplemente deben poder usar algunos programas y disponer de un directorio de trabajo.
• Usuarios de Sistema son aquellos encargados de los demonios del sistema, recordemos que
para Linux todo es un fichero, el cual tiene un dueño y ese dueño tiene privilegios sobre él.
Así, es necesario que algún usuario del sistema posea los procesos de los demonios. Es
necesario que para algunos servicios del sistema se creen usuarios (generalmente para
demonios). Como puede ser el caso de Mail, irc... Estos usuarios tendrán los privilegios
necesarios para poder hacer su tarea, gestionar estos usuarios es de gran importancia. No
obstante, este tipo de usuarios no necesita que se le asigne un shell, puesto que
simplemente poseerán los demonios, pero no será necesario que hagan login en el
sistema.
• ROOT o SuperUsuario este usuario lo puede todo, en principio no hay restricciones para él.
Para poder trabajar correctamente en el sistema cualquier usuario debe de contar con
requerimientos básicos tales como, login, y password que le permitan entrar al sistema, los
números que lo identifican ante el sistema y en el grupo que pertenece, su directorio de trabajo
o “Home Directory“, del cual ya se hablo en el capitulo 2 y el tipo de shell que utilizará, las
características de estos se vieron en el capitulo 4.
Grupos
Los grupos es una manera en los sistemas multiusuario como Linux de otorgar una serie de
privilegios a un conjunto de usuarios sin tener que dárselo de forma individual a cada uno.
Todo usuario tiene siempre un grupo principal al que pertenece. Hay dos posibilidades para los
usuarios normales: que todos tengan el mismo grupo principal (generalmente users) o que
cada usuario tenga un grupo principal específico (casi siempre del mismo nombre que el
usuario). Esto responde a las necesidades de cada sistema. En el primer caso, los directorios
de trabajo de los usuarios suelen ser accesibles por el resto de usuarios (no es lo más común);
mientras que en el caso de que cada usuario tenga un grupo principal, lo normal es que los
directorios de trabajo de cada usuario sean sólo accesibles por ese usuario (que sí es lo más
común).
Fundamentos de Linux 197
Capítulo 7 Manejo de Permisos
Además, en el sistema hay más grupos que los principales de cada usuario. La misión de estos
otros grupos es la de otorgar unos permisos similares al conjunto de usuarios que forman parte
de él ante un directorio, un archivo, un dispositivo, etc.
Además de que para compartir archivos o directorios entre varios usuarios, existen grupos
como audio, cdrom y similares. Dispositivos como la tarjeta de sonido, el grabador de CDs, etc.
tienen como usuario "dueño" a root, y como grupo "dueño" a uno de estos grupos. Así, para
cada usuario que queramos que pueda usar la tarjeta de sonido, debemos añadirlo al grupo
audio.
Cada grupo del sistema tiene un número que lo identifica, así como el nombre y una lista de los
usuarios que pertenecen a él.
198 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
2.3 Archivo /etc/passwd
El sistema mantiene la información acerca de cada usuario en el archivo /etc/passwd. Cada
linea del archivo contiene información acerca de un único usuario; el formato de cada linea es:
nombre_de_usuario:password(si_es_shadow_será_x):
uid:gid:comentario:home_del_usuario:shell“
Estos campos son:
• Nombre de Usuario - Es el nombre con el que entrará en el sistema.
• Password - La palabra de paso necesaria para entrar (cifrada). Si nuestro sistema usa
shadow este campo será una x.
• UID - (User ID) Número que lo identifica en el sistema.
Fundamentos de Linux 199
Manejo de Permisos
/etc/passwd
● Archivo principal donde se definen los atributos principales de los usuarios del sistema– Formato:
– login:passwd:uid:gid:comentario:directorio_casa:shell
Capítulo 7 Manejo de Permisos
• GID - (Group ID) Número que identifica al grupo principal al que pertenece el usuario.
• Comentario - Opcional, si es necesario aclarar algo, esto solo es para el administrador, pues
el sistema no lo usa.
• home_del_usuario - Ruta absoluta del directorio de trabajo del usuario.
• Shell - Intérprete de comandos del usuario, que será el que use inmediatamente después
de entrar en el sistema, por defecto es /bin/bash.
200 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
2.4 Archivo /etc/shadow
En algunos sistemas Linux, la contraseña de cada usuario esta localizada en el archivo /
etc/passwd, en cuestiones de seguridad no es lo mejor, ya que a este archivo archivo puede
entrar cualquier persona, y aunque resulta difícil, aunque no imposible, descifrar una
contraseña codificada, una persona con malicia puede llegar a obtener las contraseñas.
La codificación en sombra ubica la contraseña en otro archivo, normalmente /etc/shadow,
configurado de forma que solo ser leído por el usuario root, el formato de cada línea de esta
archivo es la siguiente:
usuario:password:días_del_último_cambio:dias_antes_del_cambio:Dias_despues_del_c
ambio:tiempo_de_aviso:dias_antes_de_la_inhabilitacion:perido_que_lleva_caducado:
• Usuario - Nombre del usuario
• password - Es el password cifrado.
Fundamentos de Linux 201
Manejo de Permisos
/etc/shadow
● En este archivo se guardan los passwords y características de estos de cada usuario del sistema– Formato similar a /etc/passwd
● Usuario● Password● Fecha del ultimo cambio de password● Días antes de poder cambiar password● Días después en lo que se debe cambiar password● Días de advertencia antes de que expire password● Días después de expiración de password en que se deshabilita
cuenta● Fecha deshabilitación cuenta
Capítulo 7 Manejo de Permisos
• Tiempo_del_último_cambio_de_password - Pero el tiempo cuenta desde el 1 de
enero de 1970, comienzo de la era UNIX.
• Días_antes_del_cambio - Periodo (en días) donde el password debe ser cambiado.
• Días_después_del_cambio - En los días después donde debe ser cambiado.
• Tiempo_del_aviso - Periodo en el que el sistema tiene que avisar de la necesidad del
cambio.
• Inhabilitación - Días antes de la inhabilitación de la cuenta.
• Perido_caducado - Días desde el 1 de enero de 1970 en el que la cuenta está
deshabilitada.
202 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
2.5 Archivo /etc/group
Es un archivo donde se definen los grupos del sistema a los que pertenecen los usuarios. El
archivo tiene la siguiente estructura:
“nombre_grupo:password:GID:lista_usuarios “
• nombre_grupo - Por defecto con los comandos habituales se crea un grupo con el mismo
nombre que el usuario creado, aunque pueden existir otros grupos con nombres específicos.
• password - Se usa para dar a una serie de individuos un mismo directorio con una cuenta
común.
• GID - (Group ID) Número de Identificación en el Sistema del grupo.
• lista_usuarios - usuarios que pertenecen al grupo, separados por comas.
Fundamentos de Linux 203
Manejo de Permisos
/etc/group
● Archivo en el que se define los grupos de usuarios del sistema– Formato:
– grupo:password:gid:lista de usuarios
Capítulo 7 Manejo de Permisos
3 Permisos sobre archivos
3.1 Propietarios
Todos y cada uno de los elementos del sistema Linux tienen dueño, ya sean archivos,
directorios, o enlaces a dispositivos. Por un lado, tienen un usuario dueño, y por otro, un grupo
dueño. El usuario y el grupo que son dueños de un elemento no tienen por qué guardar una
relación del tipo que el usuario debería estar dentro del grupo o cosas por el estilo. Son
totalmente independientes. Así, puede existir un fichero que tenga como usuario propietario a
username, un usuario normal, y tener como grupo propietario al grupo root.
# ls -la
total 30
drwxr-xr-x 5 root root 1024 Mar 1 11:34 .
drwxr-xr-x 20 root root 4096 Mar 1 12:16 ..
-rw------- 1 root root 9216 Mar 1 12:51 aquota.user
drwxr-xr-x 2 instructor root 1024 Mar 1 11:34 instructor
204 Fundamentos de Linux
Manejo de Permisos
Manejo de Propietarios de archivos
● Cambio de propietario– Chown [opciones] usuario[:grupo] archivo1[, ....]
● Cambio de grupo– Chgrp [opciones] grupo archivo1[, ....]
Capítulo 7 Manejo de Permisos
drwx------ 2 root root 12288 Nov 24 03:45 lost+found
drwxr-xr-x 24 alumno alumno 3072 Mar 1 14:58 alumno
Cuando se trabaja en el sistema, los programas "hacen dueños" de los archivos creados
durante la sesión al usuario de esta sesión y a su grupo principal por defecto; aunque esto
puede cambiarse. Es lógico, que los archivos que estén bajo el directorio de trabajo de un
usuario le pertenezcan.
Siempre que tratemos con permisos y con dueños de elementos, debemos tener siempre
presente el hecho de que el sistema de archivos de Linux es jerárquico; esto implica que los
cambios que hagamos en un directorio, pueden influir en el resto de elementos que están
contenidos en un nivel inferior a éste (los archivos que contiene, los directorios que contiene, lo
que contienen esos otros directorios, y así sucesivamente).
a) comando chown
El comando chown (CHange OWNer) permite cambiar el propietario de los elementos del
sistema de archivos. Pero es lógico que si somos un usuario normal no podremos cambiar de
propietario los elementos que pertenecen a root o a otros usuarios. En cambio, como root
podremos cambiar el propietario de cualquier cosa. Aquí describimos las opciones más usadas
de este comando.
La sintaxis del comando chown es la siguiente:
# chown [opciones] <usuario[:grupo]> <archivo|directorio> [archivo|
directorio ...]
Las opciones incluyen:
• -R: recursivo; para cambiar el dueño de todos los archivos y subdirectorios en un directorio
dado.
• -v: modo verboso; muestra todas las acciones efectuadas por chown; reporta cuales archivos
cambiaron de dueño como resultado del comando y cuales no han cambiado.
• -c: como -v, pero sólo reporta cuales archivos cambiaron.
Fundamentos de Linux 205
Capítulo 7 Manejo de Permisos
Algunos ejemplos se muestran a continuación:
# chown usuario elemento(s)
# chown usuario.grupo elemento(s)
En el primero de los dos comandos anteriores, el usuario dueño de elementos(s) será cambiado
a usuario. El grupo dueño de elemento(s) se conservará al que estuviera antes de introducir
este comando.
Con respecto al segundo comando, actúa exactamente igual que el anterior, con la pequeña
diferencia que también cambiará el grupo dueño de elemento(s) pasando a ser grupo.
b) Comando chgrp
El comando chgrp (CHange GRouP) le permite cambiar el grupo propietario de un archivo o un
grupo de archivos; su sintaxis es muy similar a la del comando chown:
# chgrp [opciones] <grupo> <archivo|directorio> [archivo|directorio ...]
Las opciones de este comando son las mismas que las de chown, y se usa de manera muy
similar.
Un ejemplo de este comando es:
# chgrp grupo elemento(s)
elemento(s) puede ser una lista de archivos y directorios, o simplemente uno de ellos. Podemos
usar los metacaracteres conocidos (como por ejemplo el asterisco (*) para indicar varios
archivos con una sola expresión.
206 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
3.2 Permisos
Los permisos se registran en el sistema de archivos, es decir cada archivo tiene su tabla de
permisos y los puedes ver con el comando ls -l
# ls -l
-rwxr--r-- 1 alumno usuario 587 may 23 17:17 README
-rwxr-x--- 1 alumno usuario 1508 jun 18 14:07 Xvnc*
drwxr-xr-x 2 instructor usuario 8192 abr 30 08:43 install/
Los permisos son las letras y guiones que están a la izquierda, el ejemplo muestra los permisos
de dos archivos y un directorio (install) este se identifica porque la primera letra es una "d",
cuando es un archivo es un guión "-".
a) Usuarios, grupos, otros
Para entender los permisos debes conocer como se establecen, esto se puede hacer de tres
Fundamentos de Linux 207
Manejo de Permisos
Permisos
user@instructor:~> ls l archivo rwx rwx rwx 1 user users 0 20050309 19:03 archivo
Usuario
Grupo
Otros
Donde:r > lectura (4)w> escritura (2)x > ejecucion (1)
Capítulo 7 Manejo de Permisos
maneras: para el Propietario (owner), Para el Grupo (group) y para los Otros usuarios (Others),
Así, tomando como ejemplo la primera linea desplegada por el comando “ls -l“ arriba, los tres
caracteres después del “-“, que indica que es un archivo, son los permisos del propietario, los
siguientes tres especifican los permisos para el grupo y por último a los de otros usuarios:
• propietario r w x
• grupo r - -
• otros r - -
Los permisos son lectura(r), escritura(w) y ejecución(x).
b) Acceso a archivos (rwx)
En el acceso a los archivos los tres tipos de permisos se aplican de la siguiente manera:
• El permiso de lectura indica que el usuario tiene permitido ver solamente el contenido de
archivo.
• El permiso de escritura le permite realizar cambios en el archivo.
• El permiso de ejecución es necesario para los programas compilados y para cualquier guión
del shell que se desee usar como un mandato.
c) Acceso a Directorios (rwx)
Los permisos se aplican de modo diferente entre archivos y directorios.
• El permiso de lectura en un directorio permite averiguar qué hay en el directorio, pero no es
suficiente para tener acceso a los archivos cuyos nombres aparecen en él
• El permiso de escritura es necesario para añadir archivos o eliminarlos del directorio, pero no
para modificar un archivo que aparece en el directorio.
• El permiso de ejecución permite al usuario operar sobre los nombres del directorio, si los
208 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
conoce, pero no le permite averiguarlos. Normalmente se asigna el permiso “r“ cuando se
asigna el permiso “x“.
Fundamentos de Linux 209
Capítulo 7 Manejo de Permisos
d) Comando chmod
Para determinar los permisos de un archivo o directorio se utiliza el comando chmod, este
comando puede utilizar dos métodos para establecerlos, se pueden cambiar teniendo en cuenta
los permisos existentes (modo simbólico), o se pueden asignar permisos independientemente
de los ya existentes (modo absoluto).
Modo Simbólico
Cuando se utiliza el modo simbólico se pueden añadir o quitar permisos a los archivos y
directorios. El formato del comando chmod simbólico es:
# chmod [quien] código-operador permisos fichero
Donde:
• quien es el tipo de usuario, puede tener los siguientes valores:
210 Fundamentos de Linux
Manejo de Permisos
Chmod
● Sintaxis:– Chmod [opciones] modo archivo(s) ...
● Modo Simbolico– [ugoa...] [ [+=][rwxXstugo...]...][, ...]
● Modo abosuluto– ### donde # es un numero entre 0 y 7 (octal) suma de la
especificacion númerica de permisos:● r = 4● w = 2● x = 1
Capítulo 7 Manejo de Permisos
• u : propietario del archivo
• g : grupo del que el propietario es miembro
• o : usuarios clasificados como otros
• a : todos los usuarios del sistema (propietario, grupo y otros)
• código_operador Indica la operación que se va a realizar:
• + : añadir permisos
• - : quitar permisos
• permisos es el tipo de permiso:
• r : permiso de lectura
• w : permiso de escritura
• x : permiso de ejecución
• archivo es el nombre de archivo o directorio.
MODO ABSOLUTO
El modo absoluto se especifica con 3 dígitos numéricos; cada número representa los permisos
de cada tipo de usuario. Estos dígitos se obtienen, para cada clase de usuario, a partir de los
valores siguientes:
• 4 : permiso de lectura
• 2 : permiso de escritura
• 1 : permiso de ejecución.
Así tendremos:
• 0 : ningún permiso
Fundamentos de Linux 211
Capítulo 7 Manejo de Permisos
• 1 : permiso de ejecución
• 2 : permiso de escritura
• 3 : permiso de ejecución y escritura (1+2)
• 4 : permiso de lectura
• 5 : permiso de lectura y ejecución (4+1)
• 6 : permiso de lectura y escritura (4+2)
• 7 : permiso de lectura, escritura y ejecución (4+2+1)
La sintaxis para el comando chmod absoluto es:
# chmod modo fichero
Donde:
• modo son 3 dígitos numéricos, cada uno de ellos corresponde a los permisos de cada tipo de
usuario.
• fichero es el nombre del fichero o directorio.
212 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
e) Máscara de permisos por default (umask)
Para determinar cuales permisos se asocian por defecto a los archivos o directorios creados,
cada usuario posee una máscara de permisos. Esta se expresa por tres dígitos entre cero y
siete. La máscara indica que permisos no se desea que tenga el recurso creado. Por defecto
esta máscara es 002 para los usuarios comunes y 022 para root. La máscara realmente se
asocia al shell y se hereda por los subshells.
Para calcular los permisos finales dado que se tiene la máscara 022, se hace la siguiente
operación por parte del sistema:
Ficheros = totales_para_archivos – máscara - permiso_ejecución= 777 – 022
- 111 = 644 = -rw-r--r--
Directorios = totales_para_directorios - máscara = 777 - 022 = 755 = drwxr-
xr-x
Fundamentos de Linux 213
Manejo de Permisos
Umask
● Especificación de la mascara de creación de archivos:– umask S mascara
● Los permisos de los archivos creados serán:– Permisos_totales – mascara – permiso_ejecución
● Los permisos de los directorios creados serán:– Permisos_totales mascara
Capítulo 7 Manejo de Permisos
Para colocar u observar la máscara se puede emplear el comando umask. Su sintaxis es:
# umask [-S] [máscara]
Si se ejecuta el comando umask sin opciones despliega la máscara por defecto.
La opción -S despliega el complemento de la máscara por defecto en forma de caracteres
( u=rwx,g=r,o=r)
Para ser bien restrictivos se recomienda hacer: # umask 077
Los nuevos directorios tendrán el permiso: 700 = drwx------
Los nuevos archivos tendrán el permiso: 600 = -rw-------
214 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
4 Evaluación del capítulo
1. ¿Qué entendemos por “Usuarios del Sistema” y “Superusuario”?
2. ¿Qué atributos o requerimientos tiene un usuario para que sea reconocido en el sistema?
3. Describa la estructura del archivo “/etc/passwd”
4. ¿Qué función tiene el archivo “/etc/shadow”?
Fundamentos de Linux 215
Capítulo 7 Manejo de Permisos
5. Describa la función y estructura del archivo “/etc/group”
6. Describa la siguiente salida:
$ ls -la
total 30
drwxr-xr-x 5 root root 1024 Mar 1 11:34 .
drwxr-xr-x 20 root root 4096 Mar 1 12:16 ..
-rw------- 1 root root 9216 Mar 1 12:51 aquota.user
drwxr-xr-x 2 instructor root 1024 Mar 1 11:34 instructor
drwx------ 2 root root 12288 Nov 24 03:45 lost+found
drwxr-xr-x 24 alumno alumno 3072 Mar 1 14:58 alumno
7. ¿Qué realizan los comandos “chown” y “chmod”?
216 Fundamentos de Linux
Capítulo 7 Manejo de Permisos
8. Si tengo el siguiente listado
$ id
uid=500(mariog) gid=100(users) grupos=16(dialout),33(video),100(users)
$ls -ld .
drwxr-xr-x 5 instructor users 1024 Mar 1 11:34 .
$ls -l datos
-rw-rw---- 1 instructor root 9216 Mar 1 12:51 datos
¿Es posible que el usuario mariog pueda modificar el archivo datos?
¿Es posible que el usuario mariog pueda borrar el archivo “datos”?
9. ¿Que realizan los siguientes comandos:
1. $ chmod 745 /home/instructor
2. chmod u+r,g=wx,o-x /home/instructor
Fundamentos de Linux 217
Capítulo 7 Manejo de Permisos
10. Si se ejecuta el comando umask 532 ¿Cuáles serian los permisos con los que se crean
archivos y directorios en la sesión actual?
218 Fundamentos de Linux
Capítulo 8 Manejo de entrada/salida
Capítulo 8 Manejo deentrada/salida
Fundamentos de Linux 219
Capítulo 8 Manejo de entrada/salida
220 Fundamentos de Linux
Manejo de Entrada/salida
Descripción
Descriptores de ArchivosEntrada EstandarSalida EstandarError Estandar
RedireccionamientoTuberias
Comando Tee
Capítulo 8 Manejo de entrada/salida
1 Descripción del capítulo
En este capítulo se estudiará como redireccionar la entrada y la salida de algunos comandos
para hacer varios pasos en una sola linea de comandos, como sería desplegar información en
pantalla y además guardarla en un archivo.
Se describirán los siguientes tópicos:
Descriptores de Archivos
Entrada Estándar
Salida Estándar
Error Estándar
Redireccionamiento
Creación de Tuberías
Comando Tee
Fundamentos de Linux 221
Capítulo 8 Manejo de entrada/salida
2 Conceptos
2.1 Descriptores de archivos
Toda la E/S se efectúa leyendo ó escribiendo archivos, ya que todos los periféricos, incluyendo
la terminal, son archivos en el sistema de archivos. Esto significa que una sola interfaz maneja
todas las comunicaciones entre el programa y los dispositivos periféricos.
En el caso más general, antes de leer o escribir un archivo, es necesario comunicar al sistema
del intento; este proceso se conoce como abrir un archivo. Si se va a escribir en un archivo,
puede ser necesario crearlo. El sistema revisa el permiso para hacerlo (existe el archivo) Tiene
permiso de acceso?) , y si todo va bien regresa un entero no negativo llamado descriptor de
archivo. Siempre que se haga E/S en el archivo, se utiliza el descriptor de archivo para
identificarlo y, no el nombre.
222 Fundamentos de Linux
Manejo de Entrada/salida
Descriptores de Archivo
System Space
stdinstdoutstderr
...
0123 Estructura
archivo
...
...Archivo
Fisico
Atributos archivo(Inodos)
IndiceDescriptores
Descriptor de Archivo: {indice númerico que utilizan el proceso paraacceder a un archivo, este índice es creado al abrir el archivo.
Capítulo 8 Manejo de entrada/salida
Hay unos descriptores de archivo por defecto:
• 0: Entrada estándar (normalmente el teclado).
• 1: Salida estándar (normalmente la consola).
• 2: Salida de error.
2.2 Entrada estándar (standard input)
La entrada estándar (stdin) es el nombre del descriptor del archivo que un programa utiliza para
la entrada.
• Por defecto, la entrada estándar se refiere al teclado relacionado con la terminal.
• Un programa lee bytes del teclado como lo haría para cualquier archivo
• La entrada estándar se identifica por el descriptor de archivo 0
Fundamentos de Linux 223
Manejo de Entrada/salida
Entrada, salida y error estandar
● Tres archivos/descriptores ya creados por defecto– 0 > Entrada Estandar (stdin)
– 1 > Salida Estandar (stdout)
– 2 > Error Estandar (stderr)
● Stdin asociada por default al teclado de la terminal● Stdout asociado a la pantalla de la terminal● Stderr asociado a la pantalla de la terminal
Capítulo 8 Manejo de entrada/salida
2.3 Salida estándar (standard output)
Salida estándar (stdout) es el nombre que se le da al descriptor del fichero que un programa
utiliza para la salida normal.
• La salida estándar por defecto se refiere a la pantalla relacionada con la terminal.
• Un programa escribe se salida normal a la pantalla de la terminal como lo hace para
cualquier archivo.
• La salida estándar es identificada por el descriptor de archivo 1.
2.4Error estándar (standard error)
El error estándar (stderr) es el nombre del descriptor del fichero que utiliza un programa para el
error o los mensajes de diagnóstico.
• Por defecto, el error estándar se refiere a la pantalla de la terminal
• Un programa escribe sus mensajes de error en la pantalla de la terminal como lo hace para
cualquier archivo
• El error estándar es identificado por el descriptor de archivo 2.
224 Fundamentos de Linux
Capítulo 8 Manejo de entrada/salida
2 Redireccionamiento
Cualquier comando de UNIX necesita recibir información de algún "lugar" y enviar los
resultados del procesamiento a algún "lugar", así como los mensajes de error. Estos "lugares"
se llaman, respectivamente, STANDARD INPUT, STANDARD OUTPUT y STANDARD
ERROR.
Como ya se mencionó, El estándar input se refiere al medio desde el cual el comando recibe la
información. De forma similar, el estándar output se refiere al lugar que el comando envía la
salida. Cuando se redireccionan los datos el comando recibe o envía la información desde otra
fuente.
El estándar error se refiere al medio al que se mandan los mensajes de los errores que se
cometen al ejecutar un comando.
Fundamentos de Linux 225
Manejo de Entrada/salida
Redireccionamiento
● Modificación de los destinos o fuentes predeterminadas de stdin, stdout y stderr
● Redireccionamiento de entrada estándar– $comando < archivo
● Redireccionamiento de salida estándar– $comando > archivo ó $comando >> archivo
● Redireccionamiento error estándar– $comando 2>archivo ó $comando 2>> archivo
Capítulo 8 Manejo de entrada/salida
Redireccionamiento de la entrada estándar
El símbolo para redireccionar la entrada es < y se utiliza de la siguiente manera:
comando < nombre_fichero
Un ejemplo es:
# more < /etc/passwd
Redireccionamiento de la salida
El símbolo para redireccionar la salida es “>“ y se utiliza de la siguiente forma:
comando > archivo
Algunas de la precauciones que se deben tomar a la hora de redireccionar la salida son:
• Redireccionar la salida a un archivo ya existente. Cuando se redirecciona una salida, el
sistema crea un archivo con el nombre especificado. Cuando el archivo no existe, al
redireccionar la salida a él crea uno nuevo; pero si el archivo existe borra su contenido y
reescribe encima.
• Redireccionar la salida a un fichero utilizado como entrada. Cuando se ejecuta un comando
que toma un archivo y se redirecciona la salida a ese mismo archivo, se borra el archivo y
crea un nuevo archivo con el mismo nombre, por lo que cuando se opera sobre ese archivo
ya esta vacío.
# cd /
# ls > prueba
#
Este ejemplo no despliega nada en pantalla pero si se revisa el archivo prueba
# more prueba
bin
boot
dev
etc
226 Fundamentos de Linux
Capítulo 8 Manejo de entrada/salida
home
initrd
lib
lost+found
misc
mnt
opt
proc
prueba
root
sbin
tftpboot
tmp
usr
var
Añadir la salida de un comando a un archivo
Se puede añadir la salida de un comando al final de un archivo ya existente sin borrar su
contenido. El símbolo que se utiliza para ello es >> ; se hará de la siguiente forma:
comando>>nombre_fichero
Ejemplo
# ls /var >> prueba
#
En la pantalla no se verá la información, pero al ver el archivo prueba:
# more prueba
bin
boot
dev
etc
home
initrd
lib
lost+found
misc
mnt
Fundamentos de Linux 227
Capítulo 8 Manejo de entrada/salida
opt
proc
prueba
root
sbin
tftpboot
tmp
usr
var
cache
db
empty
gdm
lib
local
lock
log
nis
opt
preserve
run
spool
tmp
yp
Redireccionamiento del error estándar
Para redireccionar el error estándar a un archivo, se utilizan los símbolos 2> de la forma
siguiente:
comando 2> nombre_fichero
Para añadir la salida de error a un archivo, se utilizan los símbolos >>& de la siguiente manera:
comando 2>> nombre_fichero
228 Fundamentos de Linux
Capítulo 8 Manejo de entrada/salida
Un ejemplo de esto es:
# ls /home/hola 2> error
# more error
ls: /home/hola: No such file or directory
Fundamentos de Linux 229
Capítulo 8 Manejo de entrada/salida
Combinación de salidas
La salida y el error estándar se pueden redireccionar en una sola linea de comando:
comando 1> archivo_salida 2> archivo_error
Lo que hace este comando es mandar la salida a archivo_salida y el error a archivo_error.
Esta linea también se puede escribir:
comando > archivo_2>&1
Esta linea almacena tanto la salida estándar como el error estándar en archivo_salerr
Se puede simplificar esta línea de la siguiente manera
comando >& archivo
230 Fundamentos de Linux
Manejo de Entrada/salida
Combinacion de Salidas
● $ comando > salida 2> error● $ comando > salida 2>&1● $ comando &> archivo● $ comando > salida 2>error <entrada
Capítulo 8 Manejo de entrada/salida
4 Tuberías (Pipes)
El sistema Linux permite transferir datos entre diferentes procesos (comandos). Este proceso
se llama " piping", pues "pipe" es el nombre que se le da al símbolo utilizado para transferir
datos.
El símbolo para "piping" es “|” y se utiliza de la siguiente manera:
comando_1 | comando_2 | comando_3 | ......
Para ejemplificar esto teclee:
# ls | grep home
home
Fundamentos de Linux 231
Manejo de Entrada/salida
Tuberias
● Transferencia de datos entre diferentes procesos (salida estandar de un proceso a entrada estanda de otro proceso– comando1 | comando2 | comando3| ....
Proceso1 Proceso2stdin stdout stdinstdout
Capítulo 8 Manejo de entrada/salida
5 Comando tee
En caso de querer obtener resultados parciales en una sucesión de comandos con tuberías
nunca podríamos emplear redirección de entrada o salida en comandos intermedios de una
tubería, únicamente se admiten al principio o final de la tubería. Para resolver esto, se emplea
el comando “tee“. Este comando copia la entrada estándar a la salida estándar y a los archivos
especificados, mostrando también la salida en el terminal. La sintaxis es:
tee [opciones] [archivo...]
Opciones:
-i ignora interrupciones.
-a la información es añadida a los ficheros especificados en lugar de reescribirlos.
Su empleo en tuberías sería como el siguiente:
232 Fundamentos de Linux
Manejo de Entrada/salida
Comando Tee
● Permite enviar la salida de un comando tanto a la salida estandar como a un archivo al mismo tiempo– tee [opciones] archivo
– Uso comun en tuberias para capturar flujos de información intermedios. Ej
● comando1 | comando2| tee opciones archivo | comando3
Capítulo 8 Manejo de entrada/salida
comando | comando | tee nombre_fichero | comando | ......
Un ejemplo del funcionamiento de este comando es:
# ls | tee prueba | grep home
Fundamentos de Linux 233
Capítulo 8 Manejo de entrada/salida
6 Evaluación del capitulo
1. ¿Qué entendemos por descriptor de Archivo?
2. ¿Cuáles son los tres descriptores de archivo por defecto de un proceso?
3. ¿Cuáles son los caracteres de redireccionamiento y como funciona cada uno?
234 Fundamentos de Linux
Capítulo 8 Manejo de entrada/salida
4. ¿A que comando/secuencia es equivalente la siguiente:
comando >& archivo1
5. Explique como funciona una tubería
6. ¿Que realiza el comando “tee”?
Fundamentos de Linux 235
Capítulo 8 Manejo de entrada/salida
página vacia
236 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
Capítulo 9Procesamiento de
Archivos de texto confiltros
Fundamentos de Linux 237
Capítulo 9 Procesamiento de Archivos de texto confiltros
238 Fundamentos de Linux
Procesamiento de Archivos con filtros
Descripción
Definición de filtrosExtracción de Información
Formateado de archivosCombinación de archivos
Substitución de textoOrdenamiento de Archivos
Otros ComandosEjemplos con tuberías
Capítulo 9 Procesamiento de Archivos de texto confiltros
1 Descripción del capítulo
En este capítulo se verá el uso de los filtros para obtener solo la información de interés de
algunos archivos de texto como “/etc/passwd“ y algunos otros. Describiendo los siguientes
puntos:
Definición de filtros
Filtros para extracción de Información
Formateado de Archivos
Combinación de Archivos
Substitución de Texto
Ordenamiento de Archivos
Filtros Varios
Ejemplos con tuberías
Fundamentos de Linux 239
Capítulo 9 Procesamiento de Archivos de texto confiltros
2 Definición de filtros
Existen una gran variedad de comandos que reciben una entrada, (stdin) la procesan y emiten
una salida, (stdout) a este tipo de comandos se les llama filtros. Estos son una parte
fundamental del sistema ya que relacionando filtros se puede conseguir prácticamente
cualquier cosa, a nivel de administración de archivos.
Estos filtros son:
• cat para mostrar la entrada
• grep, tail, head y cut para seleccionar una parte de la entrada
• less y more para páginar la entrada
• sort para ordenar la entrada
240 Fundamentos de Linux
Procesamiento de Archivos con filtros
Definición Filtros
● Comandos que reciben una entrada de datos (stdin), la procesan y emiten una salida (stdout)
● Uso mas poderoso en tuberías● Filtros mas comúnes
– cut, tail, head, uniq,grep
– pr, nl
– paste, cat, join
– tr, sort
Capítulo 9 Procesamiento de Archivos de texto confiltros
• tr para alterar la entrada en forma ordenada
• comm y diff para comparar dos entradas
• wc para cortar la entrada
Fundamentos de Linux 241
Capítulo 9 Procesamiento de Archivos de texto confiltros
3 Extracción de información
Para visualizar la información necesaria que se encuentra dentro de un archivo se pueden
utilizar alguno de estos comandos, o para una visualización detallada la combinación de dos a
más.
Comando cut
Este comando se utiliza para mostrar una columna de una salida determinada. Si uno considera
al archivo como una tabla de campos, “cut” permite seleccionar campos de la tabla. Los
campos a mostrar se pueden especificar. La sintaxis de este comando es:
# cut [opciones] archivos
Las opciones que toma cut son:
242 Fundamentos de Linux
Procesamiento de Archivos con filtros
Extracción de Información
● Para visualización/extracción de información se tienen lo siguientes filtros:– Cut
– Head
– Tail
– Uniq
– grep
Capítulo 9 Procesamiento de Archivos de texto confiltros
• -c N lista los caracteres en la columna N, se puede especificar un rango de caracteres (N-M)
• -d “c“ fija el delimitador de campo (por omisión tab), donde “c“ es el caracter delimitador
• -f N lista los campos en la posición N, se pueden utilizar comas “,“ para indicar varias
columnas, así como también darle un rango con el caracter “-“
Para ver el funcionamiento de este comando teclee;
# cut -d: -f1,5 passwd
root:root
bin:bin
daemon:daemon
adm:adm
lp:lp
sync:sync
shutdown:shutdown
halt:halt
mail:mail
news:news
uucp:uucp
operator:operator
games:games
gopher:gopher
ftp:FTP User
nobody:Nobody
rpm:
vcsa:virtual console memory owner
nscd:NSCD Daemon
sshd:Privilege-separated SSH
rpc:Portmapper RPC user
rpcuser:RPC Service User
nfsnobody:Anonymous NFS User
mailnull:
smmsp:
pcap:
xfs:X Font Server
ntp:
gdm:
Fundamentos de Linux 243
Capítulo 9 Procesamiento de Archivos de texto confiltros
desktop:desktop
Este ejemplo despliega el nombre del usuario y el nombre completo del mismo tomándolo del
archivo passwd.
Comando tail
El comando tail nos permite ver las ultimas líneas de un archivo, por defecto muestra las
últimas 10, desplegando la información en la salida estándar. Su sintaxis es:
# tail [opciones] [archivo...]
Si no se le proporciona archivo tomará su entrada desde la entrada estándar, las opciones que
puede tomar este comando son:
• -c N Escribe los últimos N caracteres.
• -n N Escribe las últimas N lineas.
• -f Escribir la última parte del archivo a medida que va creciendo. Esta opción es muy útil para
monitorear archivos de registro que van creciendo con el tiempo.
En las primeras dos opciones se puede eliminar la letra “c“ o “n“ según el caso y dejar el puro
número precedido por un signo “-“, y si se precede el numero con un signo “+“ despliega
información a partir de la posición indicada.
El siguiente ejemplo explica el funcionamiento de este comando:
# tail /etc/passwd
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
244 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
Comando head
El comando head despliega por la salida estándar la primera parte de un archivo, por defecto
las primeras 10 lineas. Su sintaxis es :
# head [opciones] [archivo...]
Si no se especifica un nombre de archivo, head tomará su entrada de la entrada estándar, las
opciones que puede tomar este comando son
• -c N Escribe los primeros N bytes.
• -n N Escribe las primeras N lineas en vez de las primeras 10
El comando head despliega la información como sigue:
# head /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
Fundamentos de Linux 245
Capítulo 9 Procesamiento de Archivos de texto confiltros
Comando uniq
El comando uniq elimina las líneas repetidas de un fichero ordenado, imprimiéndolo por la
salida estándar o en otro archivo, de no especificarse un fichero toma la entrada estándar. Su
sintaxis es:
# uniq [opciones][archivo][salida]
Algunas opciones son:
• -c prefija a cada línea su número de ocurrencias.
• -d solo imprime las líneas duplicadas.
ej.
# uniq -c passwd1
1 root:x:0:0:root:/root:/bin/bash
1 bin:x:1:1:bin:/bin:/sbin/nologin
1 daemon:x:2:2:daemon:/sbin:/sbin/nologin
1 adm:x:3:4:adm:/var/adm:/sbin/nologin
1 lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
1 sync:x:5:0:sync:/sbin:/bin/sync
1 shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
1 halt:x:7:0:halt:/sbin:/sbin/halt
1 news:x:9:13:news:/etc/news:
1 operator:x:11:0:operator:/root:/sbin/nologin
1 games:x:12:100:games:/usr/games:/sbin/nologin
1 gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
1 nobody:x:99:99:Nobody:/:/sbin/nologin
1 rpm:x:37:37::/var/lib/rpm:/bin/bash
1 vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
1 nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
1 sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
1 rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
2 uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
1 nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
1 mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
1 smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
246 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
1 xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
1 ntp:x:38:38::/etc/ntp:/sbin/nologin
1 gdm:x:42:42::/var/gdm:/sbin/nologin
2 pcap:x:77:77::/var/arpwatch:/sbin/nologin
1 desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
Comando grep
La función principal del comando grep (Globally Regular Expressions Pattern) es imprimir por
pantalla las lineas que concuerden con un patrón que se le indique, si no se le pasa ningún
archivo como argumento hace la búsqueda en la entrada estándar. Su sintaxis es:
# grep [opciones] <patrón> [archivo...]
Algunas opciones son:
• -c devuelve sólo la cantidad de lineas que contienen el patrón.
• -i ignora las diferencias entre mayúsculas y minúsculas.
• -H imprime además de las líneas, el nombre del archivo donde se encontró el patrón. Es así
por defecto cuando se hace la búsqueda en más de un archivo.
• -l cuando son múltiples archivo sólo muestra los nombres de aquellos donde se encontró al
patrón y no las lineas correspondientes.
• -v devuelve las lineas que no contienen el patrón.
• -r busca en un directorio de forma recursiva.
• -n imprime el número de cada línea que contiene al patrón.
Un ejemplo es:
# grep -n root /etc/passwd
1:root:x:0:0:root:/root:/bin/bash
12:operator:x:11:0:operator:/root:/sbin/nologin
Fundamentos de Linux 247
Capítulo 9 Procesamiento de Archivos de texto confiltros
4 Formateo de archivos
Comando pr
El comando “pr” imprime el contenido de un archivo con el formato apropiado para una
impresora de lineas, es decir, que cada hoja tiene 66 lineas, incluye la fecha y la hora en que el
archivo tuvo su ultima modificación, así como el nombre del archivo, el numero de página,
además de las lineas en blanco adicionales (hasta completar 66 líneas si el archivo es menor
de ese número de lineas). Su sintaxis es:
# pr [opcion] archivo
248 Fundamentos de Linux
Procesamiento de Archivos con filtros
Formateo de archivos
● Comandos para formatear la salida de un comando o despligue de un archivo– Pr
● Utilizado principalmente para formateo de texto para impresion
Capítulo 9 Procesamiento de Archivos de texto confiltros
Las opciones que maneja este comando son:
• -K: produce la salida de un fichero en “K” número de columnas.
• -m: intercala dos ficheros.
• -h “encabezado”: define un encabezado.
• -d: muestra la salida a doble espacio.
• -p: indica pausa entre páginas.
# pr -d /etc/passwd
2004-12-15 13:27 /etc/passwd Page 1
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
Fundamentos de Linux 249
Capítulo 9 Procesamiento de Archivos de texto confiltros
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
250 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
2004-12-15 13:27 /etc/passwd Page 2
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
Fundamentos de Linux 251
Capítulo 9 Procesamiento de Archivos de texto confiltros
5 Combinación de archivos
En esta sección se verán los comandos con los que se pueden desplegar en la salida estándar
dos o mas archivos:
Comando paste
Este comando enlaza un fichero con otro, de tal manera que inserta uno al lado del otro,por
defecto el carácter de separación entre los archivos es el tabulador. Su sintaxis es:
# paste [opciones] archivos
252 Fundamentos de Linux
Procesamiento de Archivos con filtros
Combinación de Archivos
● Comandos que permiten combinar dos o mas archivos horizontal o verticalmente– Paste
– Cat
– join
Capítulo 9 Procesamiento de Archivos de texto confiltros
Las opciones que maneja paste son:
• -d“C“: especifica el carácter de separación entre ficheros, donde “C“ es el carácter de
separación
• -s: mezcla las líneas de un solo archivo en una solo línea
Para ejemplificar este comando teclee:
# paste -d'\t' passwd shadow
root:x:0:0:root:/root:/bin/bash
root:$1$CrxnMte6$P9WQXHgri7LG5pVBCEgMa1:12746:0:99999:7:::
bin:x:1:1:bin:/bin:/sbin/nologin bin:*:12746:0:99999:7:::
daemon:x:2:2:daemon:/sbin:/sbin/nologin daemon:*:12746:0:99999:7:::
adm:x:3:4:adm:/var/adm:/sbin/nologin adm:*:12746:0:99999:7:::
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin lp:*:12746:0:99999:7:::
sync:x:5:0:sync:/sbin:/bin/sync sync:*:12746:0:99999:7:::
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown shutdown:*:12746:0:99999:7:::
halt:x:7:0:halt:/sbin:/sbin/halt halt:*:12746:0:99999:7:::
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin mail:*:12746:0:99999:7:::
news:x:9:13:news:/etc/news: news:*:12746:0:99999:7:::
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin uucp:*:12746:0:99999:7:::
operator:x:11:0:operator:/root:/sbin/nologin operator:*:12746:0:99999:7:::
games:x:12:100:games:/usr/games:/sbin/nologin games:*:12746:0:99999:7:::
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin gopher:*:12746:0:99999:7:::
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin ftp:*:12746:0:99999:7:::
nobody:x:99:99:Nobody:/:/sbin/nologin nobody:*:12746:0:99999:7:::
rpm:x:37:37::/var/lib/rpm:/bin/bash rpm:!!:12746:0:99999:7:::
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
vcsa:!!:12746:0:99999:7:::
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin nscd:!!:12746:0:99999:7:::
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
sshd:!!:12746:0:99999:7:::
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin rpc:!!:12746:0:99999:7:::
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
rpcuser:!!:12746:0:99999:7:::
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
nfsnobody:!!:12746:0:99999:7:::
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
mailnull:!!:12746:0:99999:7:::
Fundamentos de Linux 253
Capítulo 9 Procesamiento de Archivos de texto confiltros
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin smmsp:!!:12746:0:99999:7:::
pcap:x:77:77::/var/arpwatch:/sbin/nologin pcap:!!:12746:0:99999:7:::
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
xfs:!!:12746:0:99999:7:::
ntp:x:38:38::/etc/ntp:/sbin/nologin ntp:!!:12746:0:99999:7:::
gdm:x:42:42::/var/gdm:/sbin/nologin gdm:!!:12746:0:99999:7:::
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
desktop:!!:12746:0:99999:7:::
Comando cat
El comando “cat” (concatenate) se utiliza para visualizar por pantalla el contenido de uno o más
archivos. Cuando se especifica más de un archivo, “cat” los edita uno detrás de otro. La sintaxis
del comando es:
# cat [opciones] archivos
Donde las opciones son:
• -b muestra los números de líneas sin numerar aquellas que se encuentran vacías y que son
de espacios
• -e muestra el archivo, marcando su fin de linea con el signo $
• -n muestra el archivo, con todas sus lineas numeradas secuencialmente de 1 en 1, comienza
desde el número 1.
• -r reemplaza varias lineas vacías consecutivas por una sola línea.
• -s con esta opción suprimimos todos los mensajes de error, sobre archivos no existentes,
nombre idénticos tanto de entrada como salida.
• -t muestra un archivo, indicando el uso de los tabuladores mostrándolos con los signos ^I
Este comando despliega algo como lo que sigue:
# cat passwd shadow
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
254 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
root:$1$CrxnMte6$P9WQXHgri7LG5pVBCEgMa1:12746:0:99999:7:::
bin:*:12746:0:99999:7:::
daemon:*:12746:0:99999:7:::
adm:*:12746:0:99999:7:::
lp:*:12746:0:99999:7:::
sync:*:12746:0:99999:7:::
shutdown:*:12746:0:99999:7:::
halt:*:12746:0:99999:7:::
mail:*:12746:0:99999:7:::
news:*:12746:0:99999:7:::
uucp:*:12746:0:99999:7:::
Fundamentos de Linux 255
Capítulo 9 Procesamiento de Archivos de texto confiltros
operator:*:12746:0:99999:7:::
games:*:12746:0:99999:7:::
gopher:*:12746:0:99999:7:::
ftp:*:12746:0:99999:7:::
nobody:*:12746:0:99999:7:::
rpm:!!:12746:0:99999:7:::
vcsa:!!:12746:0:99999:7:::
nscd:!!:12746:0:99999:7:::
sshd:!!:12746:0:99999:7:::
rpc:!!:12746:0:99999:7:::
rpcuser:!!:12746:0:99999:7:::
nfsnobody:!!:12746:0:99999:7:::
mailnull:!!:12746:0:99999:7:::
smmsp:!!:12746:0:99999:7:::
pcap:!!:12746:0:99999:7:::
xfs:!!:12746:0:99999:7:::
ntp:!!:12746:0:99999:7:::
gdm:!!:12746:0:99999:7:::
desktop:!!:12746:0:99999:7:::
Comando join
El comando “join” nos permite juntar dos lineas de archivos diferentes en una sola,tomando
como referencia una campo común en ambas lineas; esto es, si consideramos cada archivo
como una tabla de campos, donde un campo es común a ambos archivos, podemos generar
una salida donde se junta la información de ambas tablas (archivos) en una sola en base al
campo común, esto puede verse como una manera muy básica de crear relaciones entre
archivos (tablas) .
La sintaxis del comando es:
join [opciones]... archivo1 archivo2
donde las opciones pueden ser:
• -1 CAMPO Especifica que campo del archivo 1 se va tomar como común donde CAMPO es
un número indicando el campo que se va a tomar.
256 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
• -2 CAMPO Especifica que campo del archivo 2 se va a tomar como común donde CAMPO
es un número indicando en campo que se va a tomar.
• -t C: indica el caracter separador de campo, “C” es el caracter separador.
• -i ignorar diferencias entre mayúsculas y minúsculas
• -o FORMATO especifica el formato de salida, donde FORMATO esta compuesto por una
lista de campos de la forma ARCHIVON.CAMPON
• -e EMPTY indica que se ponga la palabra EMPTY cuando se trate de un campo vacío.
Por ejemplo si tenemos un archivo1
a c1
b c2
c c3
y un archivo2
a d1
b d2
c d3
y ejecutamos el comando join
instructor@instructor:~>join archivo1 archivo2
a c1 d1
b c1 d1
c c1 d1
Nótese que los archivos están ordenados alfabéticamente por el campo común
Otro ejemplo es el siguiente:
Supongamos que se tienen los archivos /tmp/passwd y /tmp/group y se requiere obtener una
lista de los usuarios con su grupo correspondiente, digamos mandar a pantalla una salida con
el siguiente formato:
Fundamentos de Linux 257
Capítulo 9 Procesamiento de Archivos de texto confiltros
login:nombre_grupo:home_directory
Para obtener dicha salida se requiere que obtengamos el login y home directory del archivo
“/tmp/passwd” y el nombre del grupo del archivo “/etc/group” el campo común en ambos
archivos es el gid (campo 4 y 3 respectivamente)
Lo anterior se puede realizar con el comando join utilizando los archivo mencionados,
previamente ordenados por el campo común:
instructor@instructor~>join -t: -1 4 -2 4 -o 1.1,2.2,1.6 /tmp/passwd /tmp/group|
more
dando la siguiente salida:
root:root:/root
games:users:/var/games
mariog:users:/home/mariog
pop:users:/var/lib/pop
radiusd:radiusd:/var/lib/radiusd
privoxy:privoxy:/var/lib/privoxy
mail:mail:/var/spool/clientmqueue
news:news:/etc/news
uucp:uucp:/etc/uucp
at:at:/var/spool/atjobs
vdr:video:/var/spool/video
named:named:/var/lib/named
ftp:ftp:/srv/ftp
.
.
.
258 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
6 Sustitución de texto
Comando tr
Este comando nos permite sustituir o eliminar caracteres seleccionados. Por defecto toma la
entrada estándar y la salida estándar. La sintaxis de este comando es:
# tr [opciones] argumento1 argumento2
Las opciones son:
• -d para borrar caracteres
• -c para sustituir complemento de los caracteres indicados, es decir, que no sean ésos
• -s para comprimir caracteres repetidos en uno solo.
Un ejemplo de este comando es:
Fundamentos de Linux 259
Procesamiento de Archivos con filtros
Substitución de texto
● Realmente sustitución de ocurrencias de texto en un archivo, se puede hace con editores adicionalmente– Tr
● Comando para substituir texto (translate)
Capítulo 9 Procesamiento de Archivos de texto confiltros
# more /etc/passwd | tr [a-z] [A-Z]
ROOT:X:0:0:ROOT:/ROOT:/BIN/BASH
BIN:X:1:1:BIN:/BIN:/SBIN/NOLOGIN
DAEMON:X:2:2:DAEMON:/SBIN:/SBIN/NOLOGIN
ADM:X:3:4:ADM:/VAR/ADM:/SBIN/NOLOGIN
LP:X:4:7:LP:/VAR/SPOOL/LPD:/SBIN/NOLOGIN
SYNC:X:5:0:SYNC:/SBIN:/BIN/SYNC
SHUTDOWN:X:6:0:SHUTDOWN:/SBIN:/SBIN/SHUTDOWN
HALT:X:7:0:HALT:/SBIN:/SBIN/HALT
MAIL:X:8:12:MAIL:/VAR/SPOOL/MAIL:/SBIN/NOLOGIN
NEWS:X:9:13:NEWS:/ETC/NEWS:
UUCP:X:10:14:UUCP:/VAR/SPOOL/UUCP:/SBIN/NOLOGIN
OPERATOR:X:11:0:OPERATOR:/ROOT:/SBIN/NOLOGIN
GAMES:X:12:100:GAMES:/USR/GAMES:/SBIN/NOLOGIN
GOPHER:X:13:30:GOPHER:/VAR/GOPHER:/SBIN/NOLOGIN
FTP:X:14:50:FTP USER:/VAR/FTP:/SBIN/NOLOGIN
NOBODY:X:99:99:NOBODY:/:/SBIN/NOLOGIN
RPM:X:37:37::/VAR/LIB/RPM:/BIN/BASH
VCSA:X:69:69:VIRTUAL CONSOLE MEMORY OWNER:/DEV:/SBIN/NOLOGIN
NSCD:X:28:28:NSCD DAEMON:/:/SBIN/NOLOGIN
SSHD:X:74:74:PRIVILEGE-SEPARATED SSH:/VAR/EMPTY/SSHD:/SBIN/NOLOGIN
RPC:X:32:32:PORTMAPPER RPC USER:/:/SBIN/NOLOGIN
RPCUSER:X:29:29:RPC SERVICE USER:/VAR/LIB/NFS:/SBIN/NOLOGIN
NFSNOBODY:X:65534:65534:ANONYMOUS NFS USER:/VAR/LIB/NFS:/SBIN/NOLOGIN
MAILNULL:X:47:47::/VAR/SPOOL/MQUEUE:/SBIN/NOLOGIN
SMMSP:X:51:51::/VAR/SPOOL/MQUEUE:/SBIN/NOLOGIN
PCAP:X:77:77::/VAR/ARPWATCH:/SBIN/NOLOGIN
XFS:X:43:43:X FONT SERVER:/ETC/X11/FS:/SBIN/NOLOGIN
NTP:X:38:38::/ETC/NTP:/SBIN/NOLOGIN
GDM:X:42:42::/VAR/GDM:/SBIN/NOLOGIN
DESKTOP:X:80:80:DESKTOP:/VAR/LIB/MENU/KDE:/SBIN/NOLOGIN
260 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
7 Ordenamiento
Comando sort
Este comando nos permite obtener una salida ordenada, la sintaxis de sort es:
# sort [opciones] archivos...
Las opciones que toma son:
• -b ignora espacios en blanco iniciales
• -d ordena como diccionario, considera solo blancos y caracteres alfanuméricos
• -n ordenamiento numérico
• -M Ordenamiento de meses
Fundamentos de Linux 261
Procesamiento de Archivos con filtros
Ordenamiento
● Basado principalmente en un comando– Sort [opciones] archivo ...
– Donde opciones mas comunes son:● n● t● d● u● + N donde es un número indicando campo a ordenar
Capítulo 9 Procesamiento de Archivos de texto confiltros
• -r orden inverso
• +n ordena a partir de la columna especificada
• -t indica el separador de campo
• -u elimina lineas iguales adyacentes
Un ejemplo de este comando es:
# sort -r /etc/passwd
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
rpm:x:37:37::/var/lib/rpm:/bin/bash
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
root:x:0:0:root:/root:/bin/bash
pcap:x:77:77::/var/arpwatch:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
news:x:9:13:news:/etc/news:
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
halt:x:7:0:halt:/sbin:/sbin/halt
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
262 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
bin:x:1:1:bin:/bin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
Fundamentos de Linux 263
Capítulo 9 Procesamiento de Archivos de texto confiltros
8 Otros comandos
Comando comm
Este comando nos sirve para comparar el contenido de dos archivos, linea por linea. La sintaxis
es:
# comm [opciones] archivo1 archivo2
La salida está separada en tres columnas, en la primera estarán las lineas que están en el
primer archivo y no en el segundo, en la segunda columna se verán las líneas del segundo
archivo que no estén en el primero y en la tercer columna las que están en ambos archivos.
Las opciones que puede tomar “comm” sirven para decir cual de estas tres columnas se quiere
desplegar:
264 Fundamentos de Linux
Procesamiento de Archivos con filtros
Otros Comandos
● En Linux existen cientos de comandos, por lo que las posibilidades son muchas, algunos otros comandos comunes para procesamiento de texto– comm
– diff
– wc
– nl
Capítulo 9 Procesamiento de Archivos de texto confiltros
• -1 indica que solo muestre la primera columna.
• -2 solo muestra la segunda columna
• -3 muestra la tercer columna solamente
# comm passwd passwd1
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated
SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
Fundamentos de Linux 265
Capítulo 9 Procesamiento de Archivos de texto confiltros
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
Esta line es de prueba para el ejemplo con comm
Comando diff
Compara dos archivos, indicando las lineas que difieren el uno del otro, la sintaxis de este
comando es:
# diff [opciones] archivo1 archivo2
Las opciones son:
• -b ignora la cantidad de espacios en blanco en los archivos.
• -i ignora mayúsculas y minúsculas
• -q muestra si son diferentes sin mayores detalles
# diff passwd passwd1
9d8
< mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
15d13
< ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
22d19
< rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
39d36
> Esta line es de prueba para el ejemplo con diff
Comando wc
El nombre del comando “wc” proviene de “word count”, y sirve para contar palabras, su sintaxis
es:
# wc [opciones] [archivo...]
Si se omite el nombre del archivo, wc tomará los datos de la entrada estándar.
Las opciones que toma este comando son:
• -c Contar bytes (donde los bytes son elementos alfanuméricos y espacios en blanco y saltos
266 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
de linea)
• -l Contar lineas
• -w Contar palabras
Un ejemplo es:
# wc passwd
39 53 1711 passwd
Fundamentos de Linux 267
Capítulo 9 Procesamiento de Archivos de texto confiltros
Evaluación Capítulo
1. Explique que es un filtro.
2. ¿Qué comandos utilizamos para extraer información?
3. ¿Qué ventajas me da combinar tuberías y filtros?
4. ¿Qué secuencia de comandos ejecutaría en una tubería para desplegar las lineas 5 a la 10
del archivo “/etc/passwd” mostrando únicamente la información de “login”, “home directory” y
“shell”?.
268 Fundamentos de Linux
Capítulo 9 Procesamiento de Archivos de texto confiltros
5. ¿Cuál seriá la diferencia conceptual entre el comando “paste” y “cat”?
6. Se requiere mostrar la columna referente a la terminal del comando who ¿Qué linea de
comandos se utilizaría para este fin?
7. ¿Con qué comando se ordenaría el archivo /etc/passwd por el uid del usuario?
8. ¿Qué realizan los comandos “comm” y “diff”?
Fundamentos de Linux 269
Capítulo 9 Procesamiento de Archivos de texto confiltros
9. Explique si la siguiente linea de comandos funciona o no, y ¿Qué es lo que sucedería?
who | ls -l | cut -d” “
10.¿Que requisito necesitan los campos comunes de los archivos que pasemos como
parámetros al comando “join”?
270 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
Capítulo 10 Uso deExpresiones
regulares
Fundamentos de Linux 271
Capítulo 10 Uso de Expresiones regulares
272 Fundamentos de Linux
Uso de Expresiones Regulares
Descripción
Definición de ExpresiónConstrucción
Expresiones regulares extendidasBúsqueda de texto
Procesamiento de textoUso de Expresiones regulares en Vi
Capítulo 10 Uso de Expresiones regulares
1 Descripción del capítulo
En el presente capítulo se describirá en uso de expresiones regulares para el procesamiento y
búsqueda de texto. Las expresiones regulares, son una de las características mas importantes
y poderosas de Linux. Los puntos a ver son:
Definición de Expresión Regular.
Construcción de una Expresión Regular.
Definición de Expresiones Regulares Extendidas.
Búsqueda de Texto
Procesamiento de texto (ed y sed)
Uso de Expresiones Regulares en Vi.
Fundamentos de Linux 273
Capítulo 10 Uso de Expresiones regulares
Definición de expresión regular
Una expresión regular es una plantilla formada por unos metacaracteres con significado propio
que se utiliza para especificar patrones regulares sobre cadenas de texto. Un ejemplo de algo
parecido a una expresión regular serían las plantillas para nombres de archivos usando “*” y
“?”; en este caso, “*.txt” expresaría todos los archivos cuyo nombre termina en .txt, pero una
expresión regular va mucho más allá. Una expresión regular se puede construir, para concordar
con, por ejemplo, una dirección de correo electrónico, un número, una fecha, una URL, una
etiqueta HTML, etc., es decir, cualquier cadena que cumpla unas determinadas características
de regularidad.
274 Fundamentos de Linux
Uso de Expresiones Regulares
Definición
● Expresión regular– Plantilla formada por metacaracteres con significado
propio que se utiliza para concordancia con patrones regulares de cadenas de texto
– Los caracteres con un significado especial dentro de la expresión regular se conocen como metacaracteres
Capítulo 10 Uso de Expresiones regulares
Las expresiones regulares nos van a resultar de suma utilidad para realizar operaciones sobre
cadenas de caracteres, tanto de comprobación como de edición.
Existen ciertos caracteres que tienen un significado específico dentro de una expresión regular.
Estos caracteres especiales, o metacaracteres, se pueden aplicar a definiciones para
especificar con qué caracteres se concuerda, cuantificadores para especificar el modelo de
repetición de los caracteres y también anclajes para especificar una posición dentro de un texto.
Estos caracteres, como hemos visto, se denominan metacaracteres porque tienen un
significado que va más allá del símbolo que representa y tiene un comportamiento especial en
una expresión regular.
Fundamentos de Linux 275
Capítulo 10 Uso de Expresiones regulares
3 Cómo se construye una expresión regular.
Para la construcción de una expresión regular es necesario tener otros conceptos claros antes,
como son los metacaracteres, clases, literales, cuantificadores, anclajes, y alternativas.
Metacaracteres
Primeramente pasamos a la definición de caracteres en una expresión regular. Vamos a
detallar los metacaracteres que permiten especificar una plantilla que concuerde con un texto
de unas características concretas.
276 Fundamentos de Linux
Uso de Expresiones Regulares
Construcción
● La construcción de expresiones regulares se basa en– Metacaracteres
– Clases
– Literales
– Cuantificadores
– Anclajes
– Alternativas
Capítulo 10 Uso de Expresiones regulares
Metacaracter Significado
. Concuerda con cualquier carácter (salvo fin de línea en modo multilinea)
() Subexpresión o grupo
[ ] Conjunto de caracteres
[ - ] Rango de caracteres
[^ ] Excepto ese conjunto de caracteres
| Permite una alternativa para elegir entre dos expresiones
/ / Delimita una expresión regular
\ Protege el siguiente metacaracter
Las expresiones permiten también especificar caracteres especiales no imprimibles:
Metacaracter Significado
\a pitido, el carácter BEL (07 en hexadecimal)
\e escape (1B en hexadecimal)
\cx "control-x", donde x es el carácter correspondiente
\f nueva página (0C hexadecimal)
\n nueva linea (0A hexadecimal)
\r retorno de carro (0D hexadecimal)
\t tabulador (09 hexadecimal)
\xhh caracter con código hh hexadecimal
\ddd caracter con código ddd en octal
Fundamentos de Linux 277
Capítulo 10 Uso de Expresiones regulares
Clases
Podemos especificar clases de caracteres según varias sintaxis: POSIX, tradicional o Unicode.
Según la sintaxis de clases POSIX, podemos indicar [:clase:] donde clase puede ser alguna de
las siguientes expresiones:
Clase Significado
[:alpha:] caracter alfabético
[:alnum:] caracter alfanumérico
[:ascii:] caracter ascii
[:blank:] espacio, incluye tabulador (también \s según la sintaxis tradicional)
[:cntrl:] caracter de control
[:digit:] un dígito (también \d según la sintaxis tradicional)
[:graph:] carácter gráfico
[:lower:] letra minúscula
[:print:] caracter imprimible
[:punct:] caracter de puntuación
[:space:] espacio (también \s según la sintaxis tradicional)
[:upper:] letra mayúscula
[:word:] palabra (también \w según la sintaxis tradicional)
[:xdigit:] dígito hexadecimal
En la sintaxis tradicional, además tenemos:
Metacaracter Significado
\D cualquier caracter que no sea un dígito decimal (equivalente a [^:digit:])
\S cualquier caracter que no sea un espacio en blanco (equivalente a [^:blank:]
\w cualquier caracter de de una palabra
\W cualquier caracter que no sea de una "palabra"
278 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
Literales
Cuando queramos utilizar un metacaracter como literal tendremos que protegerlo con una
contrabarra ("\"). Un ejemplo es el caso de /midominio\.dom/. En este caso el carácter "." no
tiene su valor propio de una expresión regular de ser cualquier carácter, sino que al ir protegido
representa el .
Un caso particular lo podemos encontrar si usamos expresiones regulares dentro de una shell,
por ejemplo un script de shell. En este caso deberíamos realizar en algunos casos una doble
protección con la contrabarra, una para protegerlo en shell y otra para protegerlo en la
expresión regular.
Cuantificadores
Los cuantificadores son metacaracteres de la expresiones regulares que indican las
características de repetición de caracteres o grupos.
Metacaracter Concuerda con
* repetición de 0 o más veces el carácter o subexpresión previos
+ repetición de 1 o más veces el carácter o subexpresión previos
? repetición de 0 o una vez el carácter o subexpresión previos
{n} repetición de n veces el carácter o subexpresión previos
{n,} repetición de n veces el carácter o subexpresión previos
{n,m} repetición entre n y m veces el carácter o subexpresión previos
"*" equivale a "{0,}"
"+" equivale a "{1,}"
"?" equivale a "{0,1}"
Un cuantificador hace que la concordancia sea siempre con el mayor numero de veces
posibles. Si queremos que sea con el menor posible le añadimos un "?".
Fundamentos de Linux 279
Capítulo 10 Uso de Expresiones regulares
Anclajes
Los puntos de anclaje, especifican una condición que se verifica en un punto particular del
texto, sin corresponder a ningún carácter de la cadena de entrada concreta, esto es, una
posición en el texto:
Metacaracter Significado
^ Concuerda con el principio de linea
$ Concuerda con el final de linea
< > Concuerda con una palabra
\b límites de palabra
\B no sean límites de palabra
\A inicio de la cadena de entrada (independiente del modo multilinea)
\Z fin de la cadena de entrada o nueva linea delante del final
\z fin de la cadena de entrada (independiente de modo multilinea)
Alternativas
Una alternativa es el equivalente a un O lógico. El símbolo de la alternativa es “ | ”.
280 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
Expresiones regulares extendidas
En las primeras versiones no se contaban con todos los metacaracteres mencionados, después
se implementaron en las expresiones regulares extendidas, estos caracteres son ?, +, {, |, (,
y ).
En la actualidad la mayoría de los comandos que trabajan con expresiones regulares
reconocen estos caracteres, con excepción de “ed“ que solo trabaja con expresiones regulares
básicas y el comando grep, que necesita el carácter de escape “\“ para que reconozca estos
caracteres ( con la opción -e reconoce expresiones extendidas lo que es equivalente al
comando egrep)
Fundamentos de Linux 281
Uso de Expresiones Regulares
Expresiones extendidas
● Las primeras implementaciones de expresiones regulares no contaban con todos los metacaracteres, por lo que a las expresiones con los siguientes metacaracteres se conocían como extendidas– ? + { } | ( )
● ed, no reconoce expresiones extendidas● grep requiere el carácter \ antepuesto a los
metacarateres para reconocerlos ( o utilizar egrep )
Capítulo 10 Uso de Expresiones regulares
4. Búsqueda de texto (grep)
Como ya se vió en el capítulo de filtros (capítulo 9) con el comando grep se pueden realizar
búsquedas de palabras dentro de un texto, sin embargo la funcionalidad de este comando va
mas allá, ya que permite el uso de expresiones regulares en vez de la palabra a buscar,
permitiendo realizar una búsqueda mucho más avanzada, se tiene la posibilidad de indicar si se
quiere que algo esté al principio o al final de una archivo, que esté repetido una determinada
cantidad de veces, etc. La sintaxis en esté caso para el comando es:
# grep [opciones] expr-reg [archivos]
Las opciones que maneja son las ya mencionadas anteriormente
Pare entender el uso del comando grep con expresiones regulares se mostrarán algunos
ejemplos:
282 Fundamentos de Linux
Uso de Expresiones Regulares
Búsqueda
● La busqueda se realiza con el comando grep – grep [opciones] expresion [archivos]
● ej.– grep “^r” /etc/passwd
– grep “^r|g.*x:[09]\{1,2\}:” /etc/passwd
Capítulo 10 Uso de Expresiones regulares
# grep '^r'/etc/passwd
root:x:0:0:root:/root:/bin/bash
rpm:x:37:37::/var/lib/rpm:/bin/bash
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
En este ejemplo se despliega todas las lineas del archivo passwd que comiencen con la letra
“r“.
# grep '^r.*h$' /etc/passwd
root:x:0:0:root:/root:/bin/bash
rpm:x:37:37::/var/lib/rpm:/bin/bash
Se puede ver en este ejemplo que lo desplegado disminuye al poner una condición mas en la
expresión regular, en este caso se puede entender '^r.*h$' como las lineas que comiencen con
la letra “r“ el “.“ sustituye a cualquier carácter y con “*“ se le dice que sustituya cualquier
carácter cualquier número de veces terminando la línea con una “h“.
# grep '^r.*oo.*h$' /etc/passwd
root:x:0:0:root:/root:/bin/bash
Con esta opción se simplifica mas lo desplegado en pantalla, aquí se agregó que en cualquier
parte de la linea se debe de encontrar dos “o“ juntas.
# grep 'x:[0-9]\{2\}:' /etc/passwd
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
Fundamentos de Linux 283
Capítulo 10 Uso de Expresiones regulares
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
En este ejemplo se busca que encuentre dos dígitos cualesquiera juntos en la parte del número
de usuario (UID), para este fin se antepuso la “x:“ y finalizar con “:“.
# grep '^r\|g.*x:[0-9]\{1,2\}:' /etc/passwd
root:x:0:0:root:/root:/bin/bash
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
Aquí se muestra las lineas que empiezan con r o g, que contengan cualquier caracter, seguido
de x:, uno o dos dígitos en la parte de UID seguido de “:”.
284 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
5. Procesamiento de flujo de texto
Editor de lineas ed
Durante mucho tiempo, el “ed” fue el editor estándar de las diversas versiones del UNIX, antes
que apareciera el vi (y luego los editores pertenecientes a entornos visuales).
La sintaxis de este comando es:
# ed archivo
Con esta linea se puede abrir un archivo ya existente para editarlo o crear uno. Una vez dentro
de editor ed existen comandos útiles para guardar, salir, escribir, etc, cada comando de ed es
un solo caracter, aunque, podemos hacer uso de una combinación de ellos. La mayor parte
están precedidas por uno o dos números de linea, que indican que “renglones” resultan
afectadas por el comando, estos comandos son:
Fundamentos de Linux 285
Uso de Expresiones Regulares
Procesamiento de texto
● Para procesar archivos de texto ( modificar patrones, sustituir texto,etc) se cuenta con las siguientes opciones
● ed editor linea por linea● sed procesamiento de flujo de texto● vi editor● awk utilería del sistema con programación propia
(fuera del alcance de este capítulo)
Capítulo 10 Uso de Expresiones regulares
• a (append) comienza a escribir o añade lineas. Si el archivo existe, añade lineas al final del
texto.
• w (write) graba el archivo abierto.
• w “archivo“ graba en en el archivo indicado.
• “.” termina de escribir (tiene que estar en una línea nueva y sin ningún otro caracter).
• q (quit) salimos de la sesión del ed.
• Q salimos, pero sin grabar los cambios.
• n muestra la linea n.
• $ muestra la última linea.
• 1,$p muestra el archivo de la primera a la última linea.
• ! “comando“ permite salir de ed temporalmente para ejecutar otros comandos. Una vez
ejecutado el comando, se vuelve a ed con ! (el signo de admiración)
• s permite la sustitución de un parámetro por otro.
286 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
La sintaxis de estos comandos es:
dirección1, dirección2 comando parámetros
donde dirección1 es donde se desea iniciar el comando y dirección2 es donde finaliza la
operación del comando.
Para realizar la sustitución por medio de ed es necesario conocer su sintaxis:
dirección1, dirección2 s/sustituir/por
esta linea realiza la sustitución de la primera ocurrencia del parámetro “sustituir“ por el
parámetro “por“, para realizar la sustitución en todas la ocurrencias en el rango establecido se
utiliza el comando “g” al final de la linea
dirección1, dirección2 s/sustituir/por/g
Un ejemplo de esto es:
Fundamentos de Linux 287
Uso de Expresiones Regulares
Comando ed
● Sintaxis– ed archivo
● Una vez abierto el archivo contamos con comandos para actuar en el– .
– w
– q
– etc.
Capítulo 10 Uso de Expresiones regulares
1,$ s/root/ROOT/g
esta linea sustituye desde la linea 1 hasta el final del archivo la palabra root por ROOT.
1,20 s/nologin/NL/g
Esta linea sustituye solo los primeros veinte renglones del archivo.
1,20 s/\(^d.*\)nologin/\1NL/g
El ejemplo anterior cambia la palabra nologin por NL en aquellas lineas que comienzan con una
“d“.
1,$ g/\(^d.*\)nologin/d
En este caso se eliminan todas las lineas que contengan “nologin“ y empiecen con la letra “d“.
288 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
Comando sed
Sed, acrónimo de “Stream Editor”, es un editor de texto que acepta como entrada un archivo, lo
lee y modifica linea a linea mostrando el resultado en pantalla. Su sintaxis es:
# sed [opciones] archivo...
Las opciones que puede tomar son:
• -n indica que se suprima la salida estándar.
• -e script indica que se ejecute el script que viene a continuación. Si no se emplea la opción -f
se puede omitir -e.
• -f archivo indica que los comandos se tomarán de un archivo
Para la aplicación de expresiones regulares con sed la sintaxis es la siguiente:
Fundamentos de Linux 289
Uso de Expresiones Regulares
Comando sed
● Sintaxis– sed [opciones] archivo
● Procesa un flujo de texto y envía el resultado a salida estándar.
● Normalmente con expresiones regulares se realizan substituciones– sed [opciones] comando/exp_reg/sustitución/comando
Capítulo 10 Uso de Expresiones regulares
# sed [opciones] comando/expr_regular/sustituir/comando archivo...
Donde las opciones son las mencionadas anteriormente, comando se refiere a las acciones que
pueden realizarse en la expresión regular, dichas acciones son:
• a añade texto al espacio patrón
• b ramifica a un rótulo, se emplea de forma similar a un goto
• c añade texto
• d borra texto
• i inserta texto
• l lista el contenido del espacio patrón
• n añade una nueva línea al espacio patrón
• p imprime el espacio patrón
• r lee un archivo
• s sustituye patrones
• w escribe a un archivo
En el caso de la sustitución existen algunos comandos adicionales que van al final de la linea
que permiten un mejor funcionamiento de dicha acción, estos comandos son:
• g (global) reemplaza todas las ocurrencias en el texto.
• i (insensitive) no diferencía entre minúsculas y mayúsculas.
• m (múltiples lineas) Acepta strings de varias lineas
290 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
Para explicar mejor el uso de las expresiones regulares con sed se listarán algunos ejemplos:
# sed s/root/SuperU/ pruebas
SuperU:x:0:0:root:/root:/bin/bash
...
operator:x:11:0:operator:/SuperU:/sbin/nologin
...
En este ejemplo, con el comando “s“ de sed se pide que sustituya la palabra “root“ por
“SuperU“, pero como se ve en la primera linea solo cambia la primera ocurrencia, para que
cambia la palabra en toda la linea se utiliza otro comando de sed, “g“, al final de la expresión
regular;
# sed s/root/SuperU/g pruebas
SuperU:x:0:0:SuperU:/SuperU:/bin/bash
...
operator:x:11:0:operator:/SuperU:/sbin/nologin
...
Se pueden cambiar varias palabras al mismo tiempo, esto se muestra en el siguiente ejemplo:
# sed 's/root/SuperU/g;s/bash/shell/g' pruebas
SuperU:x:0:0:SuperU:/SuperU:/bin/shell
...
operator:x:11:0:operator:/SuperU:/sbin/nologin
...
rpm:x:37:37::/var/lib/rpm:/bin/shell
...
Se pueden especificar otras opciones para que la sustitución sea mas precisa:
# sed 's/root/SuperU/g;/^d.*/s/nologin/NL/g' pruebas
SuperU:x:0:0:SuperU:/SuperU:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/NL
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
Fundamentos de Linux 291
Capítulo 10 Uso de Expresiones regulares
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/SuperU:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/NL
Como se observa se realizó el cambio de la palabra root por SuperU en todas las lineas en las
que aparecía, mientras que el cambio de nologin por NL solo se dió en las lineas que
comienzan con “d“.
Se pueden eliminar lineas con el comando de sed “d“, como se ve en el siguiente ejemplo.
# sed '/root/d;/nologin/d' pruebas
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
news:x:9:13:news:/etc/news:
rpm:x:37:37::/var/lib/rpm:/bin/bash
292 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
Con esta linea de comando se eliminaron todas las lineas del archivo que contenían la palabra
root y la palabra nologin.
# sed /^d.*nologin/c/NOLOGIN pruebas
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
/NOLOGIN
adm:x:3:4:adm:/var/adm:/sbin/nologin
...
gdm:x:42:42::/var/gdm:/sbin/nologin
/NOLOGIN
En este ejemplo se sustituye las lineas que comiencen con la letra d y contengan la palabra
nologin por la palabra NOLOGIN.
# sed /^d.*nologin/i/prueba_de_comando_i pruebas
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
/prueba_de_comando_i
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
...
gdm:x:42:42::/var/gdm:/sbin/nologin
/prueba_de_comando_i
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
Con el comando “i” se inserta una linea en el lugar en donde estaba la linea que contiene las
especificaciones, en este caso que comience con la letra d y contenga la palabra nologin.
# sed /^d.*nologin/a/prueba_del_comando_a pruebas
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
/prueba_del_comando_a
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
...
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
/prueba_del_comando_a
Fundamentos de Linux 293
Capítulo 10 Uso de Expresiones regulares
El comando “a” inserta una línea abajo de la línea que se le especifica con las expresión
regular.
# sed "/^d/ w salida" pruebas
En este ejemplo con el comando w manda las lineas que comiencen con d del archivo pruebas
al archivo salida.
294 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
6. Uso de expresiones regulares en vi
En el modo de última línea de el editor vi se pueden utilizar las expresiones regulares, para la
búsqueda, sustitución o eliminación de texto, la forma de utilizar las expresiones regulares es:
:<prim>,<ult>comando/<busca>/<sust>/comando
:/patron/comando
donde:
• : es la indicación de que se está en modo de última línea
• <prim> es un número entero el cual indica desde donde se empieza la búsqueda,
• <ult> es la linea en donde se termina la búsqueda
• comando es un comando de expresiones regulares
Fundamentos de Linux 295
Uso de Expresiones Regulares
Expresiones regulares en “vi”
● Vi puede utiliza expresiones regulares en modo comando en el caso de búsquedas– /^u
● o en modo última linea para sustitución– direccion/comando/patrón/sustitución/comando
– donde dirección puede ser un rango de lineas o un patrón a buscar
Capítulo 10 Uso de Expresiones regulares
• <busca> es el patrón a buscar
• <sust> es el patrón por el que se va a sustituir
Para ver con mayor claridad estos conceptos se verán algunos ejemplos:
:1,$s/root/ROOT/g
ROOT:x:0:0:ROOT:/ROOT:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/ROOT:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
4 substitutions on 2 lines
Para mantener los cambios realizados se debe salvar el archivo.
296 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
En el ejemplo se sustituyó la palabra root por ROOT desde la linea 1 hasta la última linea ($),
sustituyendo cualquier número de ocurrencias.
:%s/root/ROOT/g
ROOT:x:0:0:ROOT:/ROOT:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/ROOT:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
4 substitutions on 2 lines
EL simbolo “%“ tiene la misma función que “1,$“, busca en todo el texto.
:%s/nologin/NL/gc
root:x:0:0:root:/root:/bin/bash
Fundamentos de Linux 297
Capítulo 10 Uso de Expresiones regulares
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
replace with NL (y/n/a/q/l/^E/^Y)?
Con el comando “c“ se pide la confirmación de cada sustitución.
:% s/\(^d.*\)nologin/\1NL/g
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/NL
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
298 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
rpm:x:37:37::/var/lib/rpm:/bin/bash
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/NL
En el ejemplo anterior se especifica que solo se cambie el patrón nologin en las lineas que
comienzan con la letra d, los paréntesis se utilizan para agrupar lo que contienen dentro, y “\1“
se utiliza para especificar que se tomará lo mismo que se agrupó la primera vez.
:% g/^r.*/d
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
Fundamentos de Linux 299
Capítulo 10 Uso de Expresiones regulares
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
nfsnobody:x:65534:65534:Anonymous NFS User:/var/lib/nfs:/sbin/nologin
mailnull:x:47:47::/var/spool/mqueue:/sbin/nologin
smmsp:x:51:51::/var/spool/mqueue:/sbin/nologin
pcap:x:77:77::/var/arpwatch:/sbin/nologin
xfs:x:43:43:X Font Server:/etc/X11/fs:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
gdm:x:42:42::/var/gdm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
6 fewer lines
En este ejemplo se eliminan las lineas que comienzan con la letra r.
:% g/^[f-z]/d
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
desktop:x:80:80:desktop:/var/lib/menu/kde:/sbin/nologin
Se elimina todas las líneas que empiecen con una letra del rango de f a z.
El comando “h“ dentro del editor vi nos despliega una página de ayuda, que nos dice desde
como movernos en el editor, así como algunos comandos básicos como el guardar, salir, etc.
300 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
7. Evaluación del capítulo
1. ¿Qué es una expresión regular?
2. ¿Qué utilidad tienen las expresiones regulares?
3. Explique brevemente que son:
1. metacaracteres
2. clases
3. literales
4. cuantificadores
5. anclajes
Fundamentos de Linux 301
Capítulo 10 Uso de Expresiones regulares
4. En que comandos se utilizan expresiones regulares
5. ¿Cuál es la diferencia entre “sed” y “ed”.
6. ¿Cuáles son las distintas formas de especificar en que lineas se aplicará un comando de
“sed” o “ed”
7. Revise la página de “man” del comando “ed” y diga que realizan los comandos:
1. g/reg_exp/comandos/
2. v/reg_exp/comandos/
302 Fundamentos de Linux
Capítulo 10 Uso de Expresiones regulares
8. Explique que realizan los siguientes comandos en modo última linea de “vi”
1. :/^[0-9]\./s/^/<TAB>/
2. :%s/^[0-9]\./<TAB>/
3. :%s/\(^[0-9]\.\)/<TAB>\1/
Fundamentos de Linux 303
Capítulo 10 Uso de Expresiones regulares
página vacia
304 Fundamentos de Linux
Capítulo 11 Control de Procesos
Capítulo 11 Control deProcesos
Fundamentos de Linux 305
Capítulo 11 Control de Procesos
306 Fundamentos de Linux
Control de Procesos
Descripción
Definición de un ProcesoCiclo de Vida
EstadosVisualización (ps)
Control de ProcesosPrioridades
Ejecución no atendidaEjecución en un tiempo futuro
Ejecución periódica
Capítulo 11 Control de Procesos
1 Descripción del capítulo
El control de Procesos nos va a permitir interactuar y visualizar los programas que se están
corriendo en sistema , lo que conocemos como procesos. Esto es una parte vital del manejo del
sistemas pues no permite controlar lo que estemos ejecutando en este. Los tópicos a cubrir
son:
Definición de Procesos
Ciclo de Vida
Estados de un Proceso
Visualización de Procesos mediante el comando PS
Control de Procesos
Manejo de Prioridades
Ejecución no atendida
Ejecución en un tiempo posterior
Ejecución periódica
Fundamentos de Linux 307
Capítulo 11 Control de Procesos
2 Definición de proceso
Antes de ver lo que es un proceso se debe definir lo que es un programa, un programa es una
secuencia de instrucciones escrita en un lenguaje dado.
Un proceso es una instancia de un programa en ejecución, todo comando en estado de
ejecución en un proceso, cuando un programa es cargado en memoria y se le asignan recursos
para su ejecución.
Cada proceso en el momento de su creación se le asocia un número único que lo identifica del
resto llamando PID.
308 Fundamentos de Linux
Control de Procesos
Definición
● Programa:– Secuencia de Instrucciones a ejecutar escritas en un
lenguaje dado
● Proceso– Instancia de un programa en ejecución, todo comando en
ejecución es un proceso, a cada proceso se le asignan recursos de memoria y cpu para su ejecución
Capítulo 11 Control de Procesos
3 Ciclo de vida
En esta sección se presentará brevemente como se genera un proceso, si se quiere saber algo
mas complejo acerca de este tema se puede revisar la página de Internet citada al final de la
sección.
Todo proceso tiene un proceso padre con su respectivo PID (número identificador del proceso)
a partir del cual se generan los otros procesos, los pasos que se mencionan a continuación
representan al ciclo de vida que recorre el proceso hijo.
• Al crear el nuevo proceso, se le asigna su entrada en la tabla de procesos y su identificador.
• Se le pone en estado listo para ejecutarse.
• El proceso hijo es inicialmente exactamente igual que el padre, copia su segmento de datos,
pila y estructura de usuario. La única forma de distinguir al padre del hijo es mediante el
retorno de fork: para el hijo es 0 y para el padre el PID del hijo.
Fundamentos de Linux 309
Control de Procesos
Ciclo de Vida
PID 100
PID 101
fork()
exec()
wait()
exit()
Capítulo 11 Control de Procesos
• A medida que el hijo va ejecutando otro código, su memoria, pila y estructura se va
diferenciando del padre, mientras tanto el padre queda en espera.
• El hijo no termina, hasta que el padre recoge su código de finalización (devuelto con exit)
• El hijo queda “zombie“ si el padre termina y no ha recogido su código de finalización. El
padre debe esperar a sus hijos.
• El hijo queda huérfano si el padre muere cuando el hijo aún está en ejecución.
310 Fundamentos de Linux
Capítulo 11 Control de Procesos
4 Estados de un proceso
Linux implementa tareas o procesos que pueden existir en uno de 6 estados:
• Ejecutándose: Este estado le indica al núcleo que el proceso debe estar en la cola de
ejecución.
• Proceso con interrupciones: En este estado el proceso se encuentra esperando (o
durmiendo) pero puede ser despertado por una señal o por termino del tiempo.
• Proceso sin interrupciones: El proceso también se encuentra dormido pero a diferencia del
anterior, el proceso no puede ser despertado por eventos externos.
• Proceso Zombi: Este estado se presenta cuando la tarea ha terminado pero aún faltan por
liberar algunos recursos por lo que el proceso aún puede considerarse como «vivo» dentro
del sistema.
Fundamentos de Linux 311
Control de Procesos
Estados de un proceso
● Durante se ejecución un proceso puede pasar por varios estados, los mas comunes o importantes son:– Ejecutandose
– Durmiendo● Con interrupciones● Sin interrupciones
– Parado
– Zombie
– Terminado
Capítulo 11 Control de Procesos
• Proceso Parado: El proceso se encuentra parado bien sea por una señal de control de
trabajo o por la señal de sistema ptrace.
• Terminado: Cuando el proceso a concluido satisfactoriamente se puede decir que ha entrado
en este estado.
312 Fundamentos de Linux
Capítulo 11 Control de Procesos
5 Visualización de procesos
Comando ps
El comando ps permite mostrar todos los procesos que están corriendo en nuestro sistema. Su
sintaxis es:
# ps [opciones]
Este comando trabaja en sistemas BSD y SYSV, por lo que las opciones entre estos sistemas
varía, en Linux se soportan ambas opciones en la actualidad la mayoría de distribuciones
utilizan por defecto las opciones del sistema SYSV.
Algunas de las opciones más comunes se especifican a continuación
Fundamentos de Linux 313
Control de Procesos
Visualización de Procesos
● Visualización a través del comando ps– $ ps [opciones]
ej.ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.2 12 72 ? S 16:00 0:04 init [5]
root 2 0.0 0.0 0 0 ? SW 16:00 0:01 [keventd]
root 3 0.0 0.0 0 0 ? SW 16:00 0:00 [kapmd]
Capítulo 11 Control de Procesos
• -a muestra los procesos más frecuentemente solicitados
• -u muestra los usuarios que están ejecutando esos procesos. Si se le agrega un nombre de
usuario solo despliega los procesos de dicho usuario
• -f muestr mas información sobre los procesos
• -e muestra todos los procesos que se están ejecutando en el sistema
• -l utiliza un formato más largo (muestra más información).
• -p PID muestra la información de un proceso en particular
Algunas de estas opciones también se pueden ejecutar en el sistema BSD:
• f muestra las relaciones jerárquicas entre los procesos
• e muestra la terminal de cada proceso
• a muestra todos los procesos que se están ejecutando en todas las consolas
• x muestra los procesos que no están asignados a ninguna consola
Un ejemplo de lo que despliega este comando es lo siguiente:
# ps -aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.2 12 72 ? S 16:00 0:04 init [5]
root 2 0.0 0.0 0 0 ? SW 16:00 0:01 [keventd]
root 3 0.0 0.0 0 0 ? SW 16:00 0:00 [kapmd]
Las columnas contienen la siguiente información:
• USER nos dice que usuario está ejecutando el proceso
• PID es su número de proceso
• %CPU es el porcentaje de CPU que está utilizando
• %MEM es el porcentaje de memoria.
314 Fundamentos de Linux
Capítulo 11 Control de Procesos
• RSS También incluye la cantidad de memoria en kylobytes que ha utilizado
dicho proceso.
• TTY muestra la consola desde la que se está ejecutando
• STA nos muestra el estado del proceso: S(drmiendo), R(corriendo), T(parado),
Z(zombie). Las opciones W y N son especiales para procesos del kernel
• START muestra la hora a la que empezó el proceso
• TIME muestra el tiempo de CPU que ha usado el proceso desde que se inició
• COMMAND muestra el nombre del comando que se está ejecutando.
Fundamentos de Linux 315
Capítulo 11 Control de Procesos
6 Control de procesos
6.1 Procesos en “Foreground” y “Background”
El shell bash permite ejecutar los procesos en “foreground” o “background”. Los primeros son
únicos por terminal y es la forma en que se ejecuta un proceso por defecto. Solo se retorna al
prompt una vez que el proceso termine, sea interrumpido o detenido. En cambio, en
“background” pueden ejecutarse muchos procesos a la vez asociados a la misma terminal. Para
indicar al shell que un proceso se ejecute en “background”, se utiliza la construcción:
# comando &
Para modificar el estado de un proceso en “foreground” desde bash existen dos combinaciones
de teclas muy importantes que este interpreta:
• Ctrl-c : trata de interrumpir el proceso en “foreground”. Si es efectivo, el proceso finaliza su
ejecución.
316 Fundamentos de Linux
Control de Procesos
Background/foreground
● Foreground:– Cuando un proceso toma el control de la terminal y no
se regresa este hasta su finalización (modo normal de ejecucion de comandos)
● Background:– Cuando un proceso deja libre la terminal para seguir
introduciendo comandos● $ comando &● Importante el redireccionamiento si no se quiere ver salida en
la terminal que se mezcle con las tareas que en esta se realizen● $comando > salida.out
Capítulo 11 Control de Procesos
• Ctrl-z : trata de detener el proceso en “foreground”. Si es efectivo el proceso continua activo
aunque deja de acceder al procesador.
Fundamentos de Linux 317
Capítulo 11 Control de Procesos
Comando jobs
Para ver los procesos detenidos o en background en un shell se emplea el comando jobs, que
mostrará una lista con todos los procesos en dichos estados mediante los comandos asociados
y un identificador numérico especial. Su sintaxis es:
# jobs
y mostraría algo como lo que sigue:
[1] Running sleep 10000 &
[2]- Stopped cp /var/log/messages /tmp
[3]+ Stopped updatedb
•
• 1ª columna Corresponde al número de orden en que se van a ejecutar los comandos, no es
318 Fundamentos de Linux
Control de Procesos
jobs
● Bash permite el control de procesos en bg y fg mediante el uso de jobs– $ jobs
[1] Running sleep 10000 &
[2] Stopped cp /var/log/messages /tmp
[3]+ Stopped updatedb
– Mediante los comandos fg y bg se puede cambiar de foreground a background y viceversa
– Señales de teclado permiten terminar y detener procesos:● <CTRLC> termina el proceso actual● <CTRLZ> detiene temporalemente el proceso actual
Capítulo 11 Control de Procesos
el mismo que el PID.
• 2ª columna Puede estar en blanco, o contener un signo más (+), o un signo menos (-):
• El signo + indica el último trabajo que se ha parado.
• El signo - indica el penúltimo trabajo que se ha parado.
• 3ª columna Indica si el trabajo está corriéndose en “background” (Running) o se ha parado
(Stopped).
• 4ª columna Contiene el nombre del comando que se está corriendo en “background” o que
está parado.
Las opciones que maneja este comando son:
• -l Lista PIDs además de la información normal.
• -n Muestra información solamente sobre trabajos que han cambiado de estado desde que se
notificó al usuario por última vez de su estado.
• -r Restringe la salida a los trabajos en ejecución.
• -s Restringe la salida a los trabajos parados.
Comandos bg y fg
Los procesos detenidos se pueden llevar al “background” y estos a su vez pueden trasladarse
al “foreground”. Para ello se emplean respectivamente los comandos: “bg” y “fg”, pasándoles
como argumento el identificador especial del proceso. Si no se especifica un argumento se
asumirá el trabajo marcado con un signo ``+'' que sería el último detenido o llevado al
“background”. Su sintaxis es:
# bg [num]
# fg [num]
Fundamentos de Linux 319
Capítulo 11 Control de Procesos
Al ejecutar el comando “bg” sobre un trabajo que esta detenido, es como si se hubiera
arrancado con “&“ desde el inicio.
Reanudar un trabajo en primer plano con fg lo hace ser el trabajo en curso.
Si se comenzara a ejecutar un proceso y este se demora mucho y no interesan por el momento
sus resultados se puede detener y enviarlo al “background” haciendo Ctrl-z y luego, bg.
320 Fundamentos de Linux
Capítulo 11 Control de Procesos
6.2 Envío de señales
Las señales de Linux son un mecanismo para anunciar a un proceso que ha sucedido cierto
evento que debe ser atendido. La lista de posibles señales de comunicar a los procesos está
fija, con algunas variaciones dentro de las distribuciones de Linux.
La recepción de una señal en particular por parte de un proceso provoca que se ejecute una
subrutina encargada de atenderla. A esa rutina se le llama el "manejador" de la señal (signal
handler). Un proceso puede definir un manejador diferente para sus señales o dejar que el
kernel tome las acciones predeterminadas para cada señal.
Cuando un proceso define un manejador para cierta señal se dice que "captura" (catch) esa
señal.
Fundamentos de Linux 321
Control de Procesos
Señales
● Adicionalmente a CTRLz y CTRLc existen variedad de señales que se pueden enviar con el comando – $kill señal PID
● Señales comunes:– HUP (1)
– INT (2)
– QUIT (3)
– KILL (9)
– TERM (15)
Capítulo 11 Control de Procesos
Si se desea evitar que determinada señal sea recibida por un proceso se puede solicitar que
dicha señal sea ignorada o bloqueada. Una señal ignorada simplemente se descarta sin ningún
efecto posterior. Cuando alguien envía a cierto proceso una señal que está bloqueada la
solicitud se mantiene encolada hasta que esa señal es explícitamente desbloqueada para ese
proceso. Cuando la señal es desbloqueada la rutina de manejo de la señal es invocada una
sola vez aunque la señal haya sido recibida más de una vez mientras estaba bloqueada.
Si bien un proceso tiene ciertas libertades para configurar como reacciona frente a una señal
(capturando, bloqueando o ignorando la señal), el kernel se reserva ciertos derechos sobre
algunas señales. Así, las señales llamadas KILL y STOP no pueden ser capturadas, ni
bloqueadas, ni ignoradas y la señal CONT no puede ser bloqueada.
Comando kill
El comando kill sirve para enviar señales a los procesos a través de sus ID (PID mostrado en
ps). Para poder ejecutar este comando se deben tener permisos de “root” o ser el propietario
del proceso. Su sintaxis es:
# kill -señal PID
si no se le asigna un número de señal manda la señal por defecto, que es la 15 SIGTERM, que
intenta terminar cualquier proceso.
Algunas de la señales mas utilizadas por el comando kill son:
• 15 SIGTERM Esta señal solicita la terminación del proceso que la recibe.
• 9 SIGKILL Esta señal termina el proceso que la recibe de forma inmediata. Se usa sólo para
detener procesos que no terminan con la señal SIGTERM.
• 2 SIGINT Es la misma señal que se produce cuando un usuario en un programa
interactivo presiona, Control-C para solicitar su terminación.
• 3 SIGQUIT La misma señal producida por Control-\, su efecto es análogo al de SIGINT
pero además actúa como si el programa hubiera provocado algún error
interno (volcando el contenido de memoria a un archivo core).
322 Fundamentos de Linux
Capítulo 11 Control de Procesos
• 20 SIGTSTP La misma señal producida por Control-z, su efecto es suspender la
ejecución de un proceso ---para reanudarla después.
• 18 SIGCONT Reanuda un proceso suspendido previamente por la señal SIGTSTP.
• 1 SIGHUP Esta señal es enviada por bash a todas las tareas que se ejecutan en
segundo plano, cuando el usuario cierra la sesión.
Estas solo son las señales más utilizadas, con la opción “-l “ se muestra en pantalla otras
señales asociadas con el comando.
Una variante de este comando es “killall” que cuanta con las mismas señales, la diferencia es
que en vez de mandar el numero identificador del proceso se envía el nombre. A diferencia del
ID, el nombre de un proceso no es único, o sea pueden existir muchos procesos con el mismo
nombre y de ahí la utilidad de este comando. Su sintaxis es:
# [opciones] nombre
Algunas opciones que maneja son:
• -i forma interactiva. Pregunta para cada proceso si se desea enviar la señal o no.
• -v reporta si fue exitoso el envío de la señal.
• -l lista el nombre de todas las señales
• -w espera para que todos los procesos que se les mando la señal mueran
Fundamentos de Linux 323
Capítulo 11 Control de Procesos
6.4 Manejo de prioridades
En Linux existe la posibilidad de iniciar los procesos con prioridades distintas a las asignadas
por parte del sistema. Para ello se puede emplear algunos comandos que se mencionan a
continuación:
Comando nice
Este comando al invocarse sin argumentos imprime la prioridad asignada por defecto (10) a los
procesos del usuario actual. La otra forma de emplear a “nice” es indicando la nueva prioridad
precedida del signo “-” y la linea de comando que desencadena el proceso. Sólo el usuario root
puede asignar a sus procesos prioridades con valores inferiores a cero.
La sintaxis de este comando es:
324 Fundamentos de Linux
Control de Procesos
Prioridades
● Modificación de Prioridades de ejecución de procesos mediante modificación del valor nice– Valores de nice de 20 a 20
● Comandos:– Nice
– Renice
Capítulo 11 Control de Procesos
# nice -prioridad comando
Un ejemplo de su funcionamiento es:
# nice -prioridad comando
# nice tar cvf /tmp/etc.tgz /etc # incrementa en 10 la prioridad por defecto
del comando
# nice -10 updatedb # ejecuta un comando con prioridad 10
# nice --10 updatedb # ejecuta un comando con prioridad -10
Comando renice
Si se deseara reajustar la prioridad de un proceso ya en ejecución se puede utilizar el comando
“renice”. En este caso el valor de la prioridad no va precedido por el signo “-” como es en “nice”.
También se puede cambiar la prioridad de todos los procesos de uno o de varios usuarios a la
vez. La sintaxis del comando renice es:
# renice prioridad [[-p] pid ...] [[-g] pgrp ...] [[-u] usuario ...]
Donde:
prioridad es el valor de la prioridad
pid es el ID del proceso
pgrp es el ID de grupo del proceso
usuario es el nombre de usuario del dueño del proceso.
Las opciones son:
• -p para múltiples procesos
• -g si son varios grupos
• -u para más de un usuario
El funcionamiento se ejemplifica a continuación:
Fundamentos de Linux 325
Capítulo 11 Control de Procesos
# renice -19 1001 # ajusta la prioridad de un proceso a -19
# renice 1 602 # ajusta la prioridad de un proceso a 1
# renice 10 -u pepe # ajusta a 10 la prioridad de todos los procesos del
usuario pepe
# renice 5 -g ppp uucp # ajusta a 5 la prioridad de todos los procesos de los
usuarios miembros de los grupos ppp y uucp
Las prioridades de los procesos sólo se pueden disminuir, nunca aumentar con excepción de
“root” que puede hacerlo indistintamente.
326 Fundamentos de Linux
Capítulo 11 Control de Procesos
7 Programación de procesos para su ejecución posterior
Los procesos de los usuarios, por defecto, se asocian a la terminal actual. Es en ella donde
muestran su salida estándar si esta no ha sido redireccionada. Si la sesión en una terminal
termina, los procesos activos asociados a esta recibirán la señal HUP. En caso de que no
trataran dicha señal se les enviará la señal TERM y por último, KILL. Para evitar este
tratamiento por parte del sistema se puede emplear el comando “nohup” que ejecuta un
comando cuyo proceso no recibirá la señal HUP correspondiente, una vez terminada la sesión.
Por defecto “nohup” reduce la prioridad del proceso en 5 y envía su salida a un fichero llamado
nohup.out.
Fundamentos de Linux 327
Capítulo 11 Control de Procesos
Comando nohup
El comando nohup ejecuta un comando de manera que éste siga su ejecución incluso si la
terminal es desconectada o se sale de la terminal. Su sintaxis es:
# nohup comando [argumento]
# nohup [opciones]
Las opciones que maneja son:
• --help despliega la ayuda del comando
• --versión despliega la información de la versión
Si la salida estándar es el monitor, “nohup” la redirecciona hacia un fichero llamado nohup.out.
La salida de error la redirecciona hacia la salida, es decir, a nohup.out; sino se especifica otra
cosa. Si el directorio en el que esta no permite crear el fichero nohup.out (por estar protegido
328 Fundamentos de Linux
Control de Procesos
Nohup
● Desasociar los procesos de la terminal para que continuen su ejecucion aun cuando el usuario salga de sesion– $ nohup comando [argumentos]
– $ nohup [opciones]
● Salida enviada por default al $HOME/nohup.out
Capítulo 11 Control de Procesos
contra escritura), entonces lo crea en $HOME/nohup.out.
Un ejemplo de su funcionamiento seria:
# nohup ps-l
al momento de salir de la terminal y volver a entrar se encontrara en el directorio del usuario el
archivo nohup.out con la salida del comando.
Fundamentos de Linux 329
Capítulo 11 Control de Procesos
Comando at y batch
Estos comandos programan un proceso para que inicie su ejecución en un tiempo determinado,
con “at” se especifica cuando debe ejecutarse el proceso; con “batch”, el sistema es el que
determina cuando debe ejecutarse, por lo general “batch” es apropiado para trabajos largos y
de baja prioridad. La sintaxis de “at” es:
# at tiempo
donde tiempo es el tiempo para ejecutar el comando, este argumento puede ser uno de los
siguientes:
• formato HH:MM. Por ejemplo, 04:00 especifica 4:00AM. Si se inserta el tiempo, se
ejecuta en el tiempo específico el día después.
330 Fundamentos de Linux
Control de Procesos
At y batch
● Ejecución en un tiempo posterior– $ at [opciones] TIEMPO
● Ejecución cuando la carga del sistema lo permita– $ batch [opciones]
Capítulo 11 Control de Procesos
• midnight — Especifica 12:00AM.
• noon — Especifica 12:00PM.
• formato del nombre-mes, día y año. Por ejemplo, Enero 15 del año 2002. El año es opcional.
• formato MMDDYY, MM/DD/YY, o MM.DD.YY. Por ejemplo, 011502 para el día 15 de Enero
del año 2002.
• now + tiempo. El tiempo está en minutos, horas, días o semanas. Por ejemplo, now + 5 days,
especifica que el comando debería ser ejecutado a la misma hora en 5 días.
Tras haber escrito el comando at con el argumento del tiempo, el prompt at> será visualizado.
Se escribe el comando a ejecutar y se teclea Ctrl-D. Se puede especificar más de un comando
escribiendo cada comando seguido de la tecla. Después de haber escrito todos los comandos,
en una línea en blanco teclea Ctrl-D. Alternativamente, se puede introducir un script de shell en
el intérprete de comandos y teclear Ctrl-D en una línea en blanco para salir
El comando batch funciona para ejecutar una tarea no repetitiva cuando el promedio de carga
está por debajo de 0.8. La sintaxis para el comando batch es la siguiente:
#batch
at > comandos
ctrl+d
Se puede introducir de forma alternativa un script de shell en el intérprete de comandos y
escribir Ctrl-D en una línea en blanco para salir.
Tan pronto como el promedio de carga está bajo 0.8, se ejecutará la configuración del comando
o el script.
El resultado de esta programación se enviara por correo al usuario que lo asigno.
Fundamentos de Linux 331
Capítulo 11 Control de Procesos
9. Programación de procesos para ejecución periódica
En esta sección a diferencia de la anterior se programarán procesos para que se ejecuten
periódicamente, ya sea en un periodo de minutos, horas, días o meses.
Comando crontab
El comando “crontab” al igual que “at” especifica el tiempo al cual se ejecutará un proceso o un
"script", “crontab” tiene la siguiente forma:
“minutos horas dia_mes mes dia_semana nombre_de_usuario instrucción argumentos“
Para especificar trabajos con “crontab” cada usuario mantiene un archivo en el directorio /
var/spool/cron/, este directorio es modificado por cada usuario con el comando crontab -e
Otras opciones que puede tomar el comando “crontab” son:
332 Fundamentos de Linux
Control de Procesos
Cron y crontabs
● Para la ejecución periódica de comandos sin intervención de usuario se crean archivos crontabs ejecutados periódicamente por el demonio cron– $ crontab [opciones]
– Con “crontab e” creación de archivos crontabs con el siguiente formato por linea
minutos horas dia_mes mes dia_semana [nombre_de_usuario] instrucción argumentos
Capítulo 11 Control de Procesos
• -r remueve el presente crontab
• -l despliega el presente crontab en pantalla.
Un ejemplo de el uso de crontab es el siguiente:
# crontab -e
30 13 * * 7 ps
en donde:
• 30 indica los minutos, puede tomar valores desde 0 hasta 59
• 13 indica la hora, toma valores de 0 a 23
• * indica el día del mes en que se ejecutará el proceso, puede valer de 1 hasta 31
• * indica el mes en que se ejecutará el proceso, toma valores de 1 a 12 o las tres primeras
letras del mes en ingles
• 7 indica el día de la semana, toma valores de 0 a 7, siendo 0 y 7 domingo.
Los asteriscos (*) sirve para especificar todos los valores posibles, también se puede asignar un
rango de valores, por ejemplo si se quiere que el proceso se ejecute de lunes a viernes se pone
la opción “1-5“ en los días de la semana, o se puede utilizar la coma (,) para asignar valores
separados, por ejemplo si se quiere ejecutar el proceso lunes y viernes se coloca en los días de
la semana la opción “1,5“.
Fundamentos de Linux 333
Capítulo 11 Control de Procesos
Evaluación Capítulo
1. ¿Cuál es la diferencia entre programa y proceso?
2. ¿En que estados se puede encontrar un proceso?
3. ¿Qué comando(s) utilizamos para la visualización de procesos?
4. ¿Qué entendemos por procesos en “Foreground” y “Background”?
334 Fundamentos de Linux
Capítulo 11 Control de Procesos
5. ¿Qué es una señal?
6. ¿Qué señales envían las combinaciones de teclado <CTRL-Z> y <CTRL-C>
7. ¿Qué comando me permite enviar señales?
8. ¿Qué herramientas proporciona Linux para alterar la importancia en que el “Scheduler” de
procesos va corriendo a los procesos que están en el sistema?
Fundamentos de Linux 335
Capítulo 11 Control de Procesos
9. ¿Cómo mandamos a ejecutar el comando “find / -type f” de tal forma que este siga corriendo
si nos salimos de sesión durante su ejecución?
10.¿Cuál es la diferencia entre el comando “at” y el comando “crontab”?
11.Describa la sintaxis de un archivo crontab
336 Fundamentos de Linux
Capítulo 12 Documentación
Capítulo 12Documentación
Fundamentos de Linux 337
Capítulo 12 Documentación
338 Fundamentos de Linux
Descripción
Ayuda del sistema(man, apropos,whatis)
Configuración manDocumentación en el sistemaDocumentación en internet
Documentacion
Capítulo 12 Documentación
1 Descripción del capítulo
En este capítulo se verán las formas de conseguir ayuda en el sistema para ejecutar de manera
adecuada los comandos y las opciones que tengan. Se verán los puntos siguientes:
Ayuda del Sistema (man, whatis, apropos)
Configuración man (Manual del sistema)
Documentación en el sistema
Documentación en Internet.
Fundamentos de Linux 339
Capítulo 12 Documentación
2 Ayuda del Sistema
UNIX tiene un sistema de visualización de manuales y páginas de ayuda específico. El principal
comando para acceder a dichas páginas es man. Dicho comando es el punto de entrada en una
base de datos que controla todas las páginas de manual incluidas en cualquier distribución de
Linux. Las páginas mismas de manual están escritas en TROFF/NROFF, un lenguaje un tanto
antiguo de formato de páginas. Cada versión de UNIX tiene las páginas de manual en un
directorio particular. El estándar adoptado por la comunidad Linux opta por instalar las páginas
en el directorio /usr/man.
2.1 Comando man
El comando “man” sirve para desplegar en pantalla las páginas de manual, que proporcionan
ayuda en linea acerca de cualquier comando, función de programación, archivo de
configuración, etc.
340 Fundamentos de Linux
Ayuda del sistema
● Comando man: despliegue de páginas del manual (comandos, archivos, etc.)
● Se cuenta con las siguientes páginas de man● Programas ejecutables y guiones del intérprete de comandos. ● Llamadas del sistema (funciones servidas por el núcleo). ● Llamadas de la biblioteca (funciones contenidas en las bibliotecas del
sistema). ● Archivos especiales (se encuentran generalmente en /dev). ● Formato de archivos y convenios, por ejemplo /etc/passwd. ● Juegos. ● Paquetes de macros y convenios, por ejemplo man(7), groff(7) ● Comandos de administración del sistema (generalmente solo son para root). ● Rutinas del núcleo.
Capítulo 12 Documentación
Hay diferentes tipos de páginas de manual, cada tipo se diferencia por un número, que en lo
siguiente se detallan:
1. Programas ejecutables y guiones del intérprete de comandos.
2. Llamadas del sistema (funciones servidas por el núcleo).
3. Llamadas de la biblioteca (funciones contenidas en las bibliotecas del sistema).
4. Archivos especiales (se encuentran generalmente en “/dev”).
5. Formato de archivos y convenios, por ejemplo “/etc/passwd”.
6. Juegos.
7. Paquetes de macros y convenios, por ejemplo “man(7)”, “groff(7)”
8. Comandos de administración del sistema (generalmente solo son para root).
9. Rutinas del núcleo.
La sintaxis de este comando es:
# man [opciones] comando
Las opciones que toma este comando son:
• -k “cadena“obtendrás una lista de todos los comandos que contienen en su descripción la
palabra “cadena“. Actualmente, este comando realiza la misma función que el comando
“apropos”.
• -f esta opción hace que man muestre la definición del comando en una sola línea.
• -h página de ayuda
• -w [comando] ubicación del archivo del manual
Este comando desplegaría lo siguiente:
Fundamentos de Linux 341
Capítulo 12 Documentación
# man man
NAME
man - format and display the on-line manual pages
manpath - determine user’s search path for man pages
SYNOPSIS
man [-acdfFhkKtwW] [--path] [-m system] [-p string] [-C config_file]
[-M pathlist] [-P pager] [-S section_list] [section] name ...
DESCRIPTION
man formats and displays the on-line manual pages. If you specify sec-
tion, man only looks in that section of the manual. name is normally
the name of the manual page, which is typically the name of a command,
function, or file. However, if name contains a slash (/) then man
interprets it as a file specification, so that you can do man ./foo.5
or even man /cd/foo/bar.1.gz.
See below for a description of where man looks for the manual page
files.
OPTIONS
-C config_file
Specify the configuration file to use; the default is
/etc/man.config. (See man.conf(5).)
...
...
CAT PAGES
Man will try to save the formatted man pages, in order to save format-
ting time the next time these pages are needed. Traditionally, format-
ted versions of pages in DIR/manX are saved in DIR/catX, but other map-
pings from man dir to cat dir can be specified in /etc/man.config. No
cat pages are saved when the required cat directory does not exist. No
cat pages are saved when they are formatted for a line length different
from 80. No cat pages are saved when man.conf contains the line
NOCACHE.
It is possible to make man suid to a user man. Then, if a cat directory
has owner man and mode 0755 (only writable by man), and the cat files
have owner man and mode 0644 or 0444 (only writable by man, or not
342 Fundamentos de Linux
Capítulo 12 Documentación
writable at all), no ordinary user can change the cat pages or put
other files in the cat directory. If man is not made suid, then a cat
directory should have mode 0777 if all users should be able to leave
cat pages there.
The option -c forces reformatting a page, even if a recent cat page
exists.
SEARCH PATH FOR MANUAL PAGES
man uses a sophisticated method of finding manual page files, based on
the invocation options and environment variables, the /etc/man.config
configuration file, and some built in conventions and heuristics.
First of all, when the name argument to man contains a slash (/), man
assumes it is a file specification itself, and there is no searching
involved.
But in the normal case where name doesn’t contain a slash, man searches
a variety of directories for a file that could be a manual page for the
topic named.
If you specify the -M pathlist option, pathlist is a colon-separated
list of the directories that man searches.
...
...
END
Una vez en una página, tenemos a nuestra disposición diversas instrucciones. Al final de la
pantalla siempre vemos dos puntos, que es el prompt donde tecleamos las opciones
disponibles.
• q Salir de la pantalla
• h Despliega la pantalla de ayuda
• e Avanza una linea
• y Regresa una linea
• [Barra espaciadora] avanza una pantalla
Fundamentos de Linux 343
Capítulo 12 Documentación
• d Avanza media pantalla
• u regresa media pantalla
• [Flecha a la derecha] Mueve media pantalla a la derecha
• [Flecha a la izquierda] Mueve media pantalla a la izquierda
• ?[cadena] Busca una cadena de texto hacia adelante
• /[cadena] Busca una cadena de texto hacia atrás
• g Avanza el puntero al inicio del manual
• G Avanza el puntero al final del manual
• m[letra] Marca o crea un marcador en esta posición
• '[letra] Mueve el puntero al marcador
• '' Regresa el puntero a la posición original
344 Fundamentos de Linux
Capítulo 12 Documentación
2.2 Comandos apropos y whatis
Comando apropos
Este comando trabaja igual que la opción -k del comando man, devuelve un listado de páginas
de manual que contengan la palabra especificada. Su sintaxis es:
# apropos [palabra]
Comando whatis
Este comando es igual que si se teclea “man -f“, despliega la definición del comando en una
sola línea. Su sintaxis es:
# whatis [comando]
Fundamentos de Linux 345
Ayuda del sistema (cont. )
● Acceso a páginas de man– Man [opciones] comando
● Descripción breve de un comando– Whatis comando
● Despliegue de páginas de man referente a una llave de búsqueda– Apropos llave_búsqueda
Capítulo 12 Documentación
2.3 Configuración del man
Para configurar nuevas paginas de manuales se utiliza el archivo /etc/man.config.o /
etc/manpath.config dependiendo de la distribución de Linux Este archivo contiene información
para la construcción de la dirección de los manuales que utiliza el comando man. Los
parámetros que maneja son:
• MANPATH, su valor determina cual es la ruta de búsqueda para las páginas del manual.
• MANROFFSEQ, su valor determina el conjunto de preprocesadores que filtran cada página
de manual. La lista predeterminada de preprocesadores depende del sistema.
• MANSECT, su valor es una lista de secciones delimitadas por "dos puntos" que permite
determinar qué secciones de manual se usan en la búsqueda y en qué orden.
• PAGER, su valor determina el nombre del programa usado para presentar la página de
manual. El sistema, de forma predeterminada, usará exec /usr/bin/pager -s .
• SYSTEM, tiene el mismo efecto que la opción -m cadena donde cadena es el contenido de la
346 Fundamentos de Linux
Configuración man
● Realizada en el archivo /etc/man.config ó /etc/manpath.config– Modificacion de las siguientes variables
● MANPATH● MANOPT● MANSECT● PAGER● SYSTEM● MANROFFSEQ● LANG, LC_MESSAGEs
Capítulo 12 Documentación
variable $SYSTEM.
• MANOPT, se analiza antes que la línea de órdenes de man, suponiéndose que el formato es
similar. Como quiera que todas las demás variables de entorno específicas de man pueden
expresarse como argumentos de la línea de órdenes y pueden por tanto ser incluidas en
$MANOPT, se espera que se vuelvan obsoletas. Todos los espacios que formen parte del
argumento de una opción deben ir precedidos de '´.
• LANG, LC_MESSAGES Dependiendo del sistema y la implementación, una o ambas $LANG
y $LC_MESSAGES son usadas para determinar los mensajes locales que se van a usar.
man imprime los mensajes en dichos “locales” (si están disponibles).
Este archivo solo es modificable por el usuario root, aunque los usuarios pueden redefinir las
variables de ambiente mencionadas para su sesión.
Fundamentos de Linux 347
Capítulo 12 Documentación
3. Acceso a documentos en el sistema
Para buscar documentación, no necesita estar conectado a Internet, su sistema Linux incluye
gran cantidad de información, además del man, que le permitirá aprender y solucionar sus
problemas,. En particular puede consultar los siguientes tipos de documentación:
• Manuales info. Son libros o manuales que documentan algunos programas. Para
consultarlos en pantalla puede emplear el programa info seguido del nombre del manual que
desea consultar. Si emplea el comando info sólo, entrará a un índice de los manuales
disponibles.
• Varios programas pueden mostrar una corta ayuda cuando se invocan desde una consola
seguidos de un espacio y la opción –help.
• En los directorios /usr/doc y /usr/share/doc, podrá encontrar ayuda para varios programas, en
diversos formatos. Los formatos de cada documento varían y usualmente están
348 Fundamentos de Linux
Documentación en el sistema
● Documentos diversos, instalados por cada paquete de software del S.O.– Formatos pdf, html, ps
– /usr/share/doc
● Comando info– Info permite ver manuales y ayuda de comandos
Capítulo 12 Documentación
comprimidos, si lo están el nombre terminará en .gz y en ese caso, antes de consultar el
documento comprimido debe copiarlo a su directorio y descomprimirlo con el programa gzip
seguido de -d y a continuación el nombre del documento. Si el documento es un archivo de
texto (el nombre suele termina en .txt) puede emplear un editor de texto para consultarlo, o
desde un intérprete de comandos el programa more o el programa less (también puede usar
zless para consultar un archivo tipo texto comprimido). Si el archivo es tipo .dvi puede
emplear el programa xdvi para consultarlo. Si el archivo es Postscript (.ps o .eps) emplee el
programa gv para verlo o imprimirlo. Si es un documento HTML (.html) consúltelo con un
navegador, con el sistema de ayuda de Gnome o desde un intérprete de comandos con el
programa lynx o con w3m. Si el documento está en formato PDF (.pdf) puede emplear bien
gv o bien xpdf.
Entre los documentos del directorio /usr/doc hay unos documentos tipo texto que describen de
manera informal cómo administrar o configurar diversos componentes de un computadores con
Linux, tales guías se llaman HOWTOs, y son un buen punto de referencia para quienes desean
administrar un sistema Linux.
Fundamentos de Linux 349
Capítulo 12 Documentación
4. Documentación en Internet
Las siguientes son solo algunas páginas en donde puede encontrar documentación interesante,
sin embargo se puede teclear en el buscador de su preferencia y encontrara mas páginas.
• Uno de los principales sitios de Linux es http://www.linux.org, donde se encontraran, noticias
y información genérica de Linux así como varias ligas interesantes
• Hay una vasta colección de información para diversas distribuciones de Linux, así como
guías HOWTO en el sitio web de The Linux Documentation Project http://www.tldp.org,
considerado como el principal sitio de documentación de Linux
• Varios de los manuales de usuario tipo info están disponibles en
http://www.gnu.org/manual/manual.html
350 Fundamentos de Linux
Documentacion en Internet
● www.tldp.org● www.linux.org● www.linux.com● www.linuxsxs.org
Capítulo 12 Documentación
• El “Debian Documentation Project” produce documentación para la distribución Debian Linux.
Los libros y documentos de este proyecto están disponibles en
http://www.debian.org/doc/ddp
• http://www.linux.com es un sitio también muy conocido de Linux enfocado principalmente a
artículos y noticias de Linux genéricos, es una buena fuente para empezar a leer noticias de
Linux y tips
• http://www.linux-sxs.org conocido como “Linux Step by Step” es un sitio con una gran
cantidad de guias donadas por la comunidad para la resolución de problemas comunes en
Linux.
Fundamentos de Linux 351