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


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


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


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


Capítulo 1 Introducción

Capítulo 1Introducción




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


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.



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


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


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.



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.


Introduccion

Historia de Unix

● Timeline:


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.



• 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.



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:


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


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.



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.



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


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


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.



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.



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.



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”.



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.



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


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


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.



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.


Introduccion

Características de Linux

● Tipo Unix (No Unix)● Multiusuario● Multitarea● Confiable● Múltiples Arquitecturas soportadas● OpenSource


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.



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


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.


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



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.



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.



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


Introduccion

Estándares

● Linux Standard Base (LSB)● File Hierachy Standard (FHS)● Linux Internationalization Specification (Li18nux)● Posix● Otros


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



• 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



• /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.



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.


Introduccion

Ambientes

● Shells o Lineas de Comandos– Bash

– Zsh

– Tcsh

● GUI (Graphical User Interface)– Xfree86

– GNOME

– KDE

– etc.


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>








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.



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.



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!



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



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.


Introduccion

Acceso al Sistema

● ShellWelcome to Linux (i586) - Kernel 2.4.19-64GB-SMP (0).

zeus login: rootPassword:#


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?



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?



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



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?


Capítulo 2 Manipulación de Archivos

Capítulo 2 Manipulación deArchivos




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


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



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



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


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.



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.



Estructura de directorios

/

etcbin dev tmpsbinmntlib optboot root varprochome usr


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).



• /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).



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.



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


• 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



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



Manejo de Directorios

● Navegando entre directorios– cd, pwd, ., ..

● Listado de directorios– Ls

● Creado y Borrado de Directorios– Mkdir, rmdir, rm


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>



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


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



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



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á.



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


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



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 (..)


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



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.



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


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:



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>


#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.



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.



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


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,



# 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:



• -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



#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



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,



Visualización de archivos

● Texto– cat, more y less

– tail y head

● Datos– od

– strings


# 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



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


• -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.



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



• -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).



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



Expansión de nombres

● Metacaracteres de expansion de nombres, permiten la sustitucion de nombres y caracteres cuando se hace referencia a varios 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".



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



Busqueda de Archivos

● Mediante uso de base de datos indexada– Updatedb

– Locate

● Mediante una busqueda explicita y por patrones– find [camino] [opciones]


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



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.



Comparación y verificación de Archivos

● Comparación– cmp

– diff

● Verificación mediante algoritmos de “checksum”– sum

– md5sum


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.



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.




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



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?



9. Mencione la diferencia entre ruta absoluta y ruta relativa.

10.Mencione la diferencia entre liga fuerte y liga suave .


Capítulo 3 Edición de Archivos

Capítulo 3 Edición deArchivos




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


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



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,



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.)


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



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



# 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



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



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 ...]


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.



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.



Terminación de Vi

● Modo Comandos– ZZ:

● Modo de– :wq

– :q

– :q!

– :w


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



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


• $ 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.



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


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.



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)


• 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.



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.



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


• 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.



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.



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


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.



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)


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:



Opciones de Configuración

● Comando set– set opcion [= valor]

● Set all● Set number● Set tabstop=5

● Archivo .exrc


• 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 “.



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



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?


Capítulo 4 Linea de comandos

Capítulo 4 Linea decomandos




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


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.



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


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)


• las construcciones condicionales y los ciclos

• las variables para crear abreviaturas



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.


Linea de comandos

Shells comúnes

● Unix– Sh

– Ksh

– Csh

● Linux– Bash

– Zsh

– tcsh


• 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,



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



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.



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


Linea de comandos

Bash

● Bash (Bourne Again shell)– Variante de Borne Shell compatible

– GNU

– Compatible con sh, ksh y con características adicionales


• Control de la entrada y la salida

• Expansión de nombres de ficheros



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/


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


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$



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


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


• !!“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



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


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


HISTCMD no está definido, pierde sus propiedades especiales, incluso si posteriormente es

redefinido.



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>.


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


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.



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


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\$ '


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



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



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.


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


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



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"



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:


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


# alias

alias c='clear'



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.


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


• .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.



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.


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


• 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.



#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.

.

.

.




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



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:



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



ejecutable del sistema?


Capítulo 5 Interfaces Gráficas

Capítulo 5 InterfacesGráficas




Interfaces Gráficas

Descripción

Conceptos BásicosEvolución Gui's

X WindowsInicio de X Windows

Configuración de X WindowsKDE

GNOME



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



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



Conceptos Básicos

● GUI's● X Windows● Manejador de Ventanas● Escritorio


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.



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.



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.



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).



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.



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.



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



Manejadores de Ventanas


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.



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



Escritorios


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.



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/



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



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



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/.



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.



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



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.



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



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.



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:



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.



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.



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:



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.



• 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.



pagina vacia


Capítulo 6 Impresión de Archivos

Capítulo 6 Impresiónde Archivos




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


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.



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”.



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


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



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



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.



• 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.



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).



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.


• -m hace que lp le envíe un mensaje por correo electrónico cuando se termine su trabajo de



Impresión

● Practicamente mismo comando en ambos sistemas● En LPRNG

– lpr [opciones] archivo ....

● En CUPS– lp [opciones] archivo ....


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))



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:



Visualización Cola de Impresión

● En LPRNG se utiliza– lpq

– lpc

● En Cups se tiene– lpstat


• -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:



• -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



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



Cancelación de Trabajos de Impresión

● LPRNG– Lprm

● CUPS– cancel


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



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:



página vacia


Capítulo 7 Manejo de Permisos

Capítulo 7 Manejo dePermisos




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



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.



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.



• 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).



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.



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.


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


• 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.



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.


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


• 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.



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.


Manejo de Permisos

/etc/group

● Archivo en el que se define los grupos de usuarios del sistema– Formato:

– grupo:password:gid:lista de usuarios


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


Manejo de Permisos

Manejo de Propietarios de archivos

● Cambio de propietario– Chown [opciones] usuario[:grupo] archivo1[, ....]

● Cambio de grupo– Chgrp [opciones] grupo archivo1[, ....]


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.



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.


# 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.



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


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)


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



conoce, pero no le permite averiguarlos. Normalmente se asigna el permiso “r“ cuando se

asigna el permiso “x“.



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:


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


• 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



• 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.



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


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


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-------



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”?



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”?



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



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?


Capítulo 8 Manejo de entrada/salida

Capítulo 8 Manejo deentrada/salida




Manejo de Entrada/salida

Descripción

Descriptores de ArchivosEntrada EstandarSalida EstandarError Estandar

RedireccionamientoTuberias

Comando Tee



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



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.



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.


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



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


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.



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.



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


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



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



opt

proc

prueba

root

sbin

tftpboot

tmp

usr

var

cache

db

empty

gdm

lib

local

lock

log

mail

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



Un ejemplo de esto es:

# ls /home/hola 2> error

# more error

ls: /home/hola: No such file or directory



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



Combinacion de Salidas

● $ comando > salida 2> error● $ comando > salida 2>&1● $ comando &> archivo● $ comando > salida 2>error <entrada


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



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


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:



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


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?



4. ¿A que comando/secuencia es equivalente la siguiente:

comando >& archivo1

5. Explique como funciona una tubería

6. ¿Que realiza el comando “tee”?



página vacia


Capítulo 9 Procesamiento de Archivos de texto confiltros

Capítulo 9Procesamiento de

Archivos de texto confiltros




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



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



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



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


• tr para alterar la entrada en forma ordenada

• comm y diff para comparar dos entradas

• wc para cortar la entrada



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:



Extracción de Información

● Para visualización/extracción de información se tienen lo siguientes filtros:– Cut

– Head

– Tail

– Uniq

– grep


• -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:



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



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:



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



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



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



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


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











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











2004-12-15 13:27 /etc/passwd Page 2





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



Combinación de Archivos

● Comandos que permiten combinar dos o mas archivos horizontal o verticalmente– Paste

– Cat

– join


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:$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:!!:12746:0:99999:7:::

nscd:x:28:28:NSCD Daemon:/:/sbin/nologin nscd:!!:12746:0:99999:7:::


sshd:!!:12746:0:99999:7:::

rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin rpc:!!:12746:0:99999:7:::


rpcuser:!!:12746:0:99999:7:::


nfsnobody:!!:12746:0:99999:7:::


mailnull:!!:12746:0:99999:7:::



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:!!: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:!!: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:$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:::



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.



• -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:



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

.

.

.



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.




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)


# 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



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



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


• -r orden inverso

• +n ordena a partir de la columna especificada

• -t indica el separador de campo

• -u elimina lineas iguales adyacentes


# sort -r /etc/passwd































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:



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


• -1 indica que solo muestre la primera columna.

• -2 solo muestra la segunda columna

• -3 muestra la tercer columna solamente

# comm passwd passwd1




















sshd:x:74:74:Privilege-separated

SSH:/var/empty/sshd:/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.


• -c Contar bytes (donde los bytes son elementos alfanuméricos y espacios en blanco y saltos



de linea)

• -l Contar lineas

• -w Contar palabras

Un ejemplo es:

# wc passwd

39 53 1711 passwd




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”?.



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”?



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”?


Capítulo 10 Uso de Expresiones regulares

Capítulo 10 Uso deExpresiones

regulares




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



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.



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.



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


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.



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.



Construcción

● La construcción de expresiones regulares se basa en– Metacaracteres

– Clases

– Literales

– Cuantificadores

– Anclajes

– Alternativas


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:


\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



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:


\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"



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 "?".



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:


^ 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 “ | ”.



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)



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 )


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:



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


# grep '^r'/etc/passwd





En este ejemplo se despliega todas las lineas del archivo passwd que comiencen con la letra

“r“.

# grep '^r.*h$' /etc/passwd



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


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






















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








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 “:”.



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:



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)


• 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.



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:



Comando ed

● Sintaxis– ed archivo

● Una vez abierto el archivo contamos con comandos para actuar en el– .

– w

– q

– etc.


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“.



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:



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


# 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



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

...


...

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

...


...

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


daemon:x:2:2:daemon:/sbin:/sbin/NL





























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








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



/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



/prueba_de_comando_i



...


/prueba_de_comando_i


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




/prueba_del_comando_a



...



/prueba_del_comando_a



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.



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



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


• <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











operator:x:11:0:operator:/ROOT:/sbin/nologin



















4 substitutions on 2 lines

Para mantener los cambios realizados se debe salvar el archivo.



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











operator:x:11:0:operator:/ROOT:/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

































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



daemon:x:2:2:daemon:/sbin:/sbin/NL





























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





























6 fewer lines

En este ejemplo se eliminan las lineas que comienzan con la letra r.

:% g/^[f-z]/d





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.



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



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/



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/



página vacia


Capítulo 11 Control de Procesos

Capítulo 11 Control deProcesos




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



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



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.


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


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.


Control de Procesos

Ciclo de Vida

PID 100

PID 101

fork()

exec()

wait()

exit()


• 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.



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.


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


• 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.



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


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]


• -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.



• 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.



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.


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


• Ctrl-z : trata de detener el proceso en “foreground”. Si es efectivo el proceso continua activo

aunque deja de acceder al procesador.



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


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


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]



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.



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.


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)


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).



• 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



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.



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


# 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:



# 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.



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.



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


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


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.



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.


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]


• 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.



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:


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


• -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“.




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”?



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?



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


Capítulo 12 Documentación

Capítulo 12Documentación




Descripción

Ayuda del sistema(man, apropos,whatis)

Configuración manDocumentación en el sistemaDocumentación en internet

Documentacion



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.



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.


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.


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.


# man [opciones] comando


• -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:



# 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



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



• 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



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]


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


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


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


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.



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


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


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.



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


Documentacion en Internet

● www.tldp.org● www.linux.org● www.linux.com● www.linuxsxs.org


• 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 ver.0.9

Documents