Material de Gestión de Sistemas (página 2)

CAPITULO III

Sistema de Archivos en UNIX

El sistema de archivos de UNIX, desde el punto de vista del usuario, tiene una organización jerárquica o de árbol invertido que parte de una raíz conocida como "/" (diagonal). Es una diagonal al revés que la usada en DOS. Internamente se usa un sistema de direccionamiento de archivos de varios niveles, cuya estructura más primitiva se le llama 'información node' (i-node) cuya explicación va más allá de este trabajo. El sistema de archivos de UNIX ofreceun poderoso conjunto de comandos y llamadas al sistema. En la tabla 8.2 se muestran los comandos más útiles para el manejo de archivos en UNIX vs. VMS.

Tabla 8.2 Manejo de Archivos en UNIX y VMS

La protección de archivos en UNIX se maneja por medio de una cadena de permisos de nueve caracteres. Los nueve caracteres se dividen en tres grupos de tres caracteres cada uno.

El primer grupo (1) especifica los permisos del dueño del archivo. El segundo grupo especifica los permisos para aquellos usuarios que pertenecen al mismo grupo de trabajo que el dueño y finalmente el tercer grupo indica los permisos para el resto del mundo. En cada grupo de tres caracteres pueden aparecer las letras RWX en ese orden indicando permiso de leer (READ), escribir (WRITE) y ejecutar (EXECUTE). Por ejemplo, la cadena completa RWXR-XR– indica que el dueño tiene los tres permisos (READ,,WRITE,EXECUTE), los miembros de su grupo de trabajo tienen permisos de leer y ejecutar (READ,EXECUTE) y el resto del mundo sólo tienen permiso de leer (READ). Las llamadas al sistema más útiles en UNIX son 'open', 'close' e 'ioctl'. Sirven para abrir, cerrar archivos; y establecer las características de trabajo. Por ejemplo, ya que en UNIX las terminales se accesan a través de archivos especiales, el 'ioctl' (input output control) sirve para establecer la velocidad, paridad, etc; de la terminal.

El sistema de archivos

Como hemos visto anteriormente, el sistema de archivos está organizado como un árbol con un único nodo raíz llamado root (se escribe "/"); todos los nodos que no son hojas de la estructura del sistema de archivo son directorios de archivos, y los archivos que están en las hojas del árbol son directorios, archivos regulares o archivos de dispositivos. El nombre de un archivo se obtiene por su camino que describe como localizarlo dentro de la jerarquía del sistema de archivos. El camino, o path name, es una secuencia de nombres de componentes separados por el carácter barra "/"; un componente es una secuencia de caracteres que identifican a un nombre de archivo único contenido en el componente (directorio) anterior. Un camino absoluto comienza con el carácter barra y especifica un archivo que pude ser encontrado empezando en la raíz del sistema de archivos y recorriendo el árbol de archivos, siguiendo las ramas que conducen a los sucesivos componentes del camino. De esta forma los caminos "/etc/passwd", "/bin/who" y "/usr/src/cmd/who.c" identifican archivos en el árbol mostrado en la figura 4, mientras que "/bin/passwd" y "/usr/src/date.c" no lo hacen. Un camino no tiene que empezar en el nodo raíz, también puede ser identificado con respecto al directorio actual de un proceso que se está ejecutando, por omisión del carácter barra inicial en el camino. Así, empezando desde el directorio "/dev", el camino "tty01" identifica al archivo cuyo camino absoluto es "/dev/tty01".

      Los programas en UNIX no tienen conocimiento del formato interno en el que el kernel almacena los datos, tratando los datos como un flujo de bytes. Los programas deben interpretar el flujo de datos como ellos deseen, pero la interpretación no interviene en como el sistema operativo almacena los datos. De esta forma, la sintaxis del acceso a los datos en un archivo está definido por el sistema y es idéntico para todos los programas, sin embargo la semántica de los datos está impuesta por el programa.

      Los directorios son iguales a los archivos regulares en este sentido; el sistema trata los datos en un directorio como un flujo de bytes, pero los datos contienen los nombres de los archivos en el directorio en un formato predefinido tal que el sistema operativo y los programas puedan descubrir los archivos de un directorio.

      Para el usuario, el sistema UNIX trata a los dispositivos como si fuesen archivos. Los dispositivos, identificados por archivos de dispositivos, ocupan posiciones en la estructura de directorios del sistema de archivos como nodos. Los programas acceden a los dispositivos con la misma sintaxis que se usa cuando acceden a archivos regulares; la semántica de la lectura y escritura de los dispositivos es la misma que la de la lectura y escritura de archivos regulares. Los dispositivos están protegidos de la misma forma que los archivos regulares están protegidos: por su propio conjunto de permisos de acceso. Como los nombre de los dispositivos aparecen iguales que los nombres de los archivos regulares y las mismas operaciones trabajan para dispositivos y archivos regulares, muchos programas no tienen conocimiento internamente del tipo de archivo con el que está trabajando.

Reglas para el manejo de directorios

Las dos órdenes que necesitamos para manipular directorios son mkdir y rmdir. La forma de trabajar de estas órdenes es la misma que en DOS.

mkdir nom_directorio

rmdir nom_directorio

mkdir (make directory) permite crear un nuevo directorio, mientras que rmdir (remove directory) lo elimina. Para eliminar un directorio, este tiene que estar vacío. Ejemplo:

Apis:~$ ls -F c/ personal/ pruebas.c xxx Apis:~$ rmdir c Apis:~$ mkdir tmp Apis:~$ ls -F personal/ pruebas.c tmp/

Reglas del uso de archivos

En UNIX existe un conjunto de órdenes que entre otras funciones, permiten visualizar el contenido de archivos. Si bien otras aplicaciones se explicarán más adelante en otros capítulos, aquí se introduce su utilización como visores.

Orden cat

Se utiliza para visualizar el contenido de un archivo de texto (ASCII) por la pantalla. Si a cat no le pasamos como argumento ningún archivo de texto, entonces leerá de la entrada estándar (teclado) hasta que pulsemos Ctrl+d (^d). Una vez hecho esto, visualizará lo que acabamos de escribir. Por lo tanto, cat es una orden que por defecto (si no le pasamos parámetro alguno) lee de la entrada estándar y dirige su salida a la salida estándar (la pantalla). Ejemplo:

Apis:~$ cd Apis:~$ cat /etc/motd OSF/1 V2.0 (Rev. 240); Fri Aug 5 11:54:48 GMT 1994 OSF/1 V2.0 Worksystem Software (Rev. 240)

############################################# # BIENVENIDO AL LABORATORIO DE ARQUITECTURA # #############################################

Apis:~$ cat mensaje Lo que estoy escribiendo es un mensaje que se muestra por pantalla con el uso de la orden "cat". Apis:~$

Orden more

La orden imprime por pantalla el contenido del archivo de texto que le pasemos como argumento. Su sintaxis es:

more [archivo1 …]

A diferencia de la orden cat, la visualización se hace pantalla a pantalla. Para avanzar en la visualización línea a línea, se debe pulsar retorno ( ). Para visualizar la siguiente pantalla, se pulsará la barra espaciadora, y para finalizar se pulsará la tecla q (quit).

La tabla de opciones vista para la orden man es aplicable también a esta orden.

Órdenes head y tail

En muchas ocasiones no se pretende visualizar el archivo de texto completo, sino que con algunas líneas sería suficiente (por ejemplo para identificarlo). Las órdenes head y tail se pueden utilizar para visualizar las primeras o las últimas N líneas de un archivo de texto. Su sintaxis es:

head [-N] archivo1

tail [-N] archivo1

En esta sección se introducen las órdenes básicas necesarias para poder gestionar los archivos bajo UNIX.

Orden cd

Se utiliza para cambiar el directorio de trabajo actual.

Su sintaxis es la siguiente:

cd [path_name]

Cuando se utiliza sin parámetros, el directorio de trabajo actual pasa a ser el directorio propio (el del arranque), también conocido como directorio HOME, dicho de otro modo, si nuestro directorio act /usr/local, dando la orden cd nos colocamos en nuestro directorio HOME.

HOME es el directorio en el que iniciamos sesión de trabajo, es decir el CWD que tenemos al entrar en el sistema.

Tanto cd, como pwd son ordenes internas del intérprete, no existe ningún archivo ejecutable en el que estén programadas.

Apis:~$ cd /usr/so Apis:~$ pwd /usr/so Apis:~$ cd Apis:~$ pwd /users/so/tel/so01

Orden cp

Se utiliza para copiar archivos. Su sintaxis es:

$ cp archivo1 [archivo2 …] destino

Como mínimo necesita dos argumentos. El primero es el archivo existente que queremos copiar en otro lugar, y el segundo es el nombre del archivo destino. Las rutas de ambos archivos se pueden dar tanto en forma absoluta como relativa. En caso de que el archivo destino exista, su contenido se perderá, quedando sustituido por el contenido de archivo1. Ejemplo:

Apis:~$ cd Apis:~$ pwd /users/so/tel/so25 Apis:~$ ls -F c/ personal/ pruebas.c pruebas xxx Apis:~$ cp pruebas.c prnew.c Apis:~$ ls -F c/ personal/ pruebas.c prnew.c pruebas xxx

Orden rm

Se utiliza para borrar un conjunto de archivos. Su sintaxis es:

$ rm [-irf] archivo1 archivo2 …

Esta orden opera silenciosamente en ausencia de problemas, lo c especialmente peligroso si se tiene en cuenta que en UNIX un archivo borrado no puede ser recuperado de manera alguna.

Las opciones tienen el siguiente significado:

-i (interactive) antes de borrar cada uno de los archivos, rm preguntará si realmente queremos hacerlo.

-f (force) fuerza el borrado de los archivos, incluso si estos están protegidos contra escritura (el archivo debe pertenecer al usuario que quiere borrarlo). Ejemplo:

Apis:~$ ls -F c/ personal/ pruebas.c prnew.c pruebas xxx Apis:~$ rm prnew.c Apis:~$ ls -F c/ personal/ pruebas.c pruebas xxx

Orden mv

Su funcionalidad es idéntica a cp, salvo que mv provoca que los archivos o directorios origen desaparezcan de su localización inicial. Su sintaxis es:

$ mv origen1 [origen2 …] destino

Ejemplo:

Apis:~$ mv pruebas personal Apis:~$ ls -F c/ personal/ pruebas.c xxx Apis:~$ ls personal pruebas

Tipos de Permisos, propietario y grupo de un archivo

Como hemos visto anteriormente, a cada archivo se le asocian un conjunto de permisos de acceso (rwx) asociados a cada uno de los tres niveles de la jerarquía de usuarios existente: nivel de usuario, nivel de grupo y el nivel formado por el resto de los usuarios del sistema.

La orden chmod (change mode) permite cambiar los permisos de un archivo. La utilización de esta función está restringida exclusivamente al propietario del archivo cuyos permisos (modo) se desean alterar o al administrador del sistema. La sintaxis es la siguiente:

chmod modo archivo1 [archivo2 … ]

donde modo supone el modo de acceso al archivo que se desea asignar. Hay dos formas diferentes de utilizar la orden:

• Modo absoluto. Consiste en fijar con un número de tres dígitos los permisos de los tres niveles de la jerarquía de usuarios. Para ello, la cadena de 9 caracteres que indican los permisos de acceso al archivo que se quieren asignar, se convierten a dígitos binarios, poniendo un 1 en el caso de que se quiera activar el campo (rwx) o un 0 en el caso de querer desactivarlo. Así, si se desea asignar al archivo prog.c permisos rwxr-xr–, la secuencia de dígitos será: 111101100. Con estos nueve dígitos se forman 3 grupos, cada uno perteneciente a los permisos asociados a cada uno de los niveles de la jerarquía de usuarios (111- usuario, 101- grupo, 100- otros), y se asocia a cada uno su valor en octal (7- usuario, 5- grupo, 4- otros). Ejemplo:

• Apis:~$ pwd /users/so/infges/so00 Apis:~$ ls -l prog.c -rw-r—– 1 so00 users 1024 Sep 3 14:58 prog.c Apis:~$ chmod 754 prog.c Apis:~$ ls -l -rwxr-xr– 1 so00 users 1024 Sep 3 14:58 prog.c

 Modo relativo. En este caso la referencia a los permisos asignados al archivo se realiza de acuerdo con la siguiente sintaxis:

chmod quién qué dequémodo

El primer campo indica a quién se le modifica el permiso: u(usuario), g (grupo), o (otros) y a (todos).

El segundo campo indica si se activa (+), se desactiva (–) o se fija (=) un permiso. Cuando se utiliza = los permisos que no aparecen se eliminan.

El tercer campo indica sobre que modos de acceso se actúa (r, w, x). Ejemplo:

Apis:~$ chmod a-x prog.c Apis:~$ ls -l prog.c -rw-r–r– 1 so00 users 1024 Sep 3 14:58 prog.c Apis:~$ chmod go+w prog.c Apis:~$ ls -l prog.c -rw-rw-rw- 1 so00 users 1024 Sep 3 14:58 prog.c Apis:~$ chmod gu-rw prog.c Apis:~$ ls -l prog.c ——-rw- 1 so00 users 1024 Sep 3 14:58 prog.c Apis:~$ chmod u=r prog.c Apis:~$ ls -l prog.c -r——– 1 so00 users 1024 Sep 3 14:58 prog.c

Por otro lado, la orden  umask  permite fijar los permisos que tendrá por defecto cualquier archivo que cree un determinado usuario. Su estructura es:

umask [###]

• Llamado sin parámetros, el resultado son tres dígitos octales que indican de izquierda a derecha el valor de la máscara que determina los permisos iniciales para el propietario, el grupo y para el resto de usuarios. Cada dígito octal de la máscara contiene tres dígitos binarios, un 1 binario indica que cuando se cree un nuevo archivo, el permiso asociado (rwx) será borrado y un 0 binario indica que se utiliza el permiso implícito.

Si no se desea que por defecto los archivos y directorios se creen con estos valores, se puede cambiar el valor de la máscara de usuario pasando como argumento a la orden umask un número de tres dígitos en octal. Este número es el resultado de fijar a 1 aquellos permisos que se desean limpiar y dejar a 0 los bits de los permisos que no se quieren limpiar (es decir, justo del revés a como se construían los permisos en octal para chmod). Así, si se desea que a partir de este momento los archivos y directorios que se creen tengan todos los permisos desactivados para los niveles de grupo y de otros y que no se limpie ningún permiso para el nivel de propietario, la orden a introducir será:

$ umask 077

Cambio del propietario de un archivo. Orden chown

La sintaxis de chown es la siguiente:

$ chown propietario_nuevo archivos

Ejemplo:

Apis:~$ ls -l a.out -rwxr-xr-x 1 so13 so 2894 Nov 11 16:51 a.out Apis:~$ chown so00 a.out Apis:~$ ls -l a.out -rwxr-xr-x 1 so00 so 2894 Nov 11 16:51 a.out

En muchos sistemas esta orden sólo puede ser ejecutada por el administrador del sistema.

Cambio de permisos

Los archivos y directorios tienen asignados una serie de permisos que muestran quién puede leer, ejecutar y modificar dicho archivo o directorio. Para poder ver los permisos asignados se utiliza el comando ls -l :

Por ejemplo:

nodo5.cecalc.ula.ve>ls -l

drwxr-xr-x 2 hector ciencias 512 Apr 19 17:50 Miscellaneous

-rw-r–r– 1 hector ciencias 860 Dec 12 1996 index.html

lrwxrwxrwx 1 root ciencias 10 Apr 25 15:44 index.shtml -> index.html

La información mostrada tiene la siguiente forma:

-rw-r–r– usuario grupo tamaño HH:MM nombre

La notación: d rwx r-x r-, indica la clase de permiso y quién tiene asignado los diferentes tipos de permisos:

El usuario puede cambiar los permisos por medio del comando chmod. Los cambios de permisos sólo lo puede hacer el dueño del archivo y el administrador del sistema.

donde

En el siguiente ejemplo se le coloca permiso de escritura y ejecución, para todos los usuarios, al archivo index.html.

nodo5.cecalc.ula.ve>chmod a+wx index.html

Para verificar los cambios simplemente escriba el comando ls -l

nodo5.cecalc.ula.ve>ls -l

-rwxrwxrwx 1 hector ciencias 860 Dec 12 1996 index.html

Capítulo IV

Editores de Texto Vi, Pico y Ed.

El sistema UNIX viene con varios editores de texto. Un editor de textos, permite incluir o modificar textos en un archivo.

Entre ellos se tienen algunos muy robustos como los editores de línea ed, ex o más complejos como el editor visual vi .

Editor Visual vi.

El editor vi viene incluído en casi todas las versiones del sistema operativo UNIX. Por ello es útil conocerlo, pues no siempre tendremos otras opciones.

vi archivo

Si el archivo existe, entonces aparecarán las primeras líneas en la pantalla. De no ser así, un archivo con ese nombre será creado.

Una vez dentro del programa vi, el ambiente de trabajo es muy distinto que el del interpretador de comandos. Dentro de vi, se pueden crear textos, hacer cambios, etc. Para salir del vi y guardar el archivo con las modificaciones, se utiliza el comando vi:

ZZ (Guardar archivo y salir de vi)

que guarda los cambios y nos regresa al nivel del interpretador de comandos. Si se desea salir de la sesión de vi sin guardar los cambios, escriba el comando de vi:

:q! (salir de vi sin guardar)

seguido de RETURN. Digamos que qeueremos editar un archivo llamado archivo. Escribimos el comando vi archivo

Si el archivo no existe, la pantalla se pondrá en blanco, excepto mostrando tildes (~) en la primera columna de los renglones y el cursos en el primer renglón. También mostrará un mensaje en el último renglón.

El editor vi tiene dos modos: el modo de comandos y el inserción. El modo de comandos, permite mover el cursor con las flechas, borrar textos, mover textos, etc. El modo de inserción permite entrar a modificar el texto.

El editor vi, siempre comienza en modo de comandos. Para cambiar al modo de inserción se presión la i (sin necesidad de hacer el RETURN). Cuando se termina de hacer los cambios, se termina de hacer los cambios, se regresa al modo de comandos con la tecla Esc. Presentamos enseguida una serie de comandos básicos para trabajar en vi:

Movimientos de Cursor

Borrado.

Inserción

Existe un comando adicional de utilidad. Este comando sirve para buscar palabras o secuencias de cararcteres, a partir del cursor hasta el final del archivo. Por ejemplo, /salida(Esc) busca la primera aparición de la palabra salida. Se puede utilizar el RETURN en lugar del Esc. El comando ?salida(Esc) busca hacia atrás la primera aparición de la palabra salida El comando de interrupción Ctrl-C del UNIX, sirve también para evitar una señal al vi para que abandona el último comando y regrese al modo de comandos.

Figura 3.1: Movimiento de cursor en vi

Referencia rápida del editor de textos VI

Vi es una abreviación de visual. Es un editor de textos que se incluye en todas las versiones del sistema operativo UNIX. Fue uno de los primeros que se utilizaron y entre sus ventajas está la de ser muy compacto y no requerir por lo tanto mucha memoria del sistema para su ejecución.

Existen dos modos de trabajo: de Mandos y de Edición.

Para llamar al modo de mandos presionar Esc y para llamar al modo de edición presionar i.

% vi nombre de archivo -> edita el archivo o lo crea si acaso no existe

Movimiento

h —> Mueve el cursor a la izquierda

l —> Mueve el cursor a la derecha

k —> Mueve el cursor hacia arriba

j —> Mueve el cursor hacia abajo

CTRL-d –> Avanza una pantalla hacia abajo

CTRL-u –> Avanza una pantalla hacia arriba

/expresión –> Localiza expresión a partir del cursor

Edición

dd —> borra la línea donde esta el cursor

[n]dd -> borra n líneas a partir de la posición del cursor

[n]x –> borra n caracteres a partir del cursor

o —> crea una nueva línea abajo del cursor

O —> crea una nueva línea arriba del cursor

A —> agrega texto al final de una línea

Inserción de texto

CTRL-W —> Borra la palabra anterior

CTRL-U —> Borra la línea actual

ENTER —> comienza una línea nueva

Salir de vi

Estando en modo de mandos teclear el caracter " : "

:q! —> termina la sesión sin guardar cambios

:w —> graba la modificaciones sin salirse

ZZ ó 😡 -> termina la sesión y salva los cambios

Nociones básicas del editor vi

Este editor a primera vista es confuso y por eso muchos de nosotros preferimos ignorarlo, y usar otros editores, por ejemplo yo prefiero el emacs. Pero lo que tiene este editor es que esta absolutamente en todos las distribuciones, si ya se que el emacs también, pero en muchos casos no se instala por defecto y además ocupa mucho tamaño. Mientras que el vi siempre esta y siempre va estar, ósea lo que quiero hacerles llegar es que si las X fallan o si el sistema es antiguo o si no tienen lugar en el disco rígido y no instalaron un editor de texto, como el emacs, o etc.y necesitan editar un archivo, EL QUE VA A ESTAR AHI PARA SALVARLOS ES " vi ".Por lo que me parece una buena idea tener al menos una leve y pequeña idea de como utilizar este editor y eso lo que voy a dar una pequeña reseña de este editor. Para mas información pueden leer el capitulo que dedica L.I.P.P a vi.

Nota: cuando utilizo {} no hay que teclearlo, solo las uso para facilitar la explicación.

Bueno lo primero que tienen que saber es como comenzar, se comienza llamando al editor y al archivo que queremos editar, si el archivo es nuevo ponemos el nombre que le queramos dar. El esquema basico es:

vi {nombre del archivo}

Esto lo que hace es abrir el archivo y situarnos en el modo ingresar ordenes en este modo no podemos editar el texto para hacer esto hay que dar la orden necesaria, esta orden es:

i sin enter

Ahora ya puede editar el texto ósea agregar, borrar, corregir etc. Puede moverse por el texto usando las flechas.

Para salir de este modo solo tiene que teclear Esc

De esta manera vuelve a estar en el modo ingresar ordenes, pueden volver a entrar al modo ingresar texto cuando quieran como les indique antes. Bueno ahora lo que tienen que saber es como irse sin grabar o grabando los cambios, para esto hay que ingresar en el modo última orden esto se hace tecleando:

:

El cursor aparece abajo de todo, es ahí donde tiene que ingresar según lo que quieran lo siguiente

Para irse sin guardar los cambios:

q! [enter]

Para irse guardando los cambios:

wq [enter]

Para guardar el archivo sin irse de vi:

w [enter]

Para abrir otro archivo sin irse de vi:

e {archivo nuevo} [enter]

Nota: previamente guarde el archivo en el que esta trabajando, sino aparecera un mensaje de error.

Bueno con estas ordenes ya puede medianamente editar un archivo con vi, les recuerdo que yo solo comente lo basico para poder usarlo.Pero vi tiene muchísimas ordenes mas que facilitan la tarea de edición continuación voy a explicar dos ordenes que ayudan mucho. La primera es como insertar el texto de otro archivo sin tener que copiarlo a mano palabra por palabra. Para esto se teclea:

:r {nombre del archivo a insertar}

Nota el texto se insertara en el lugar donde este el cursor.

Funcionamiento general del vi

Al invocar este editor aparece en el monitor la pantalla de edición. En ella aparece la posición del cursor resaltada, las líneas en blanco señaladas con el carácter ~ y en la parte inferior de la pantalla aparece la línea de estado, que muestra el nombre del fichero y el número de caracteres que contiene.

Si se invoca el vi   pasándole como parámetro el nombre de un fichero en la pantalla de edición aparecerá su contenido. Cuando se invoca este editor con el nombre de un fichero que no existe, se crea automáticamente.

Existen dos modos de operación en el vi  :

Para añadir texto al fichero

Modo Comando:

Para introducir órdenes que realizan funciones específicas del vi  .

Cuando se edita un fichero con el vi  , los cambios no se hacen directamente sobre el fichero. En realidad, se aplican a una copia del fichero que el vi   crea en un espacio de memoria temporal llamado buffer. La copia en disco del fichero se modifica sólo cuando se graban los contenidos del buffer.

Esto tiene sus ventajas y sus inconvenientes. Por un lado, significa que se puede salir de la edición de un fichero y descartar todos los cambios hechos durante una sesión, dejando la copia de disco intacta. Por otro lado, se podría perder el contenido no grabado del buffer de trabajo si el sistema cae.

Lo más aconsejable es grabar el trabajo frecuentemente, especialmente cuando se hacen cambios importantes. Para grabar el fichero que se está editando sin salir del vi  , basta pulsar en modo comando la orden :w

Para terminar la sesión caben varias posibilidades, siempre en modo comando:

:q

Salir cuando no se han hecho modificaciones

:q!

Salir y descartar los cambios

:wq

Salir y guardar los cambios

IMPORTANTE: Hay que procurar no editar un fichero con varias copias del vi  al mismo tiempo, pues de este modo no se está seguro de cuál es la copia que está realmente grabada en disco.

Modo Edición:

Cuando se arranca el vi  , siempre está en modo comando, por lo que antes de poder escribir texto en el fichero se debe teclear uno de los comandos de entrada del vi  , tales como i  (insert), para insertar texto en la posición actual del cursor, o a  (append) para insertar texto después de la posición actual del cursor.

Para regresar la modo comando, basta con presionar Esc. Si en un momento determinado no se sabe en qué modo se está, simplemente pulsando Esc se asegura uno de que está en modo comando, y se podrá continuar con el trabajo.

Modo Comando:

Cuando se abre un fichero con vi  , se está en modo comando. En este modo se pueden introducir comandos que implementan un amplio rango de funciones. Muchos de estos comandos constan de una o dos letras y un número opcional relacionado con distintas funciones.

Muchos comandos no requieren pulsar Return para que se ejecuten, pero todas las órdenes que empiezan por dos puntos (:) requieren pulsar Return para que se ejecuten.

Editor de línea ed

El editor ed fue hecho con la idea de tener un editor rápido y pequeño con lo mínimo indispensable. Es, además, un editor confiable y que puede ser usado en las peores condiciones: con terminales lentas, en conexiones por modem y, quizá la más interesante, desde archivos por bloques. La mayoría de los editores asumen que toman la entrada directa desde el teclado y que controlan una terminal, por esto no pueden ser empleados como ed.

En su modo de operación normal, trabajan sobre una copia del archivo, para sobre escribirlo, hay que dar una instrucción específica. Trabaja sobre una línea o un grupo de líneas que cumplan con un patrón. Cada comando es un solo carácter, típicamente una letra. Cada comando puede ser precedido por uno o dos números de línea, que indican la línea o el rango de líneas al que serán aplicados. De no ser dado el número de línea, actúa sobre la actual. Veamos un ejemplo:

$ ed

a

Cuando abandonaste el cielo

?Donde dejaste tus alas?

Cuando abandonaste el cielo

Quisiera saberlo, ?perdiste el halo?

¿Como encontraste el camino?

¿Aun te escondes cuando sale el sol?

Cuando abandonaste el cielo

? Perdiste las alas?

.

w ángel

233

q

$

Después de invocar a ed inmediatamente le pedimos que añada el texto con el comando a y comenzamos a guardar el texto de un pequeño poema. Terminamos poniendo un. Como único carácter en la línea y después le pedimos que salve el archivo con el nombre de ángel. ed nos responde con el número de caracteres que contiene, y terminamos la sesión de edición con una q.

Si quisiéramos añadir unas cuantas líneas más, podríamos hacerlo con:

$ ed angel

233

a

Ahora veo a un largo tren venir despacio

y una muerte agradecida que me reconforta

dime Reina Ines ?vendras a verme?

El amigo del diablo es amigo mio

.

q

?

w

384

q

$

En esta ocasión, invocamos a ed directamente con el nombre de un archivo que ya existe, así que nos responde con el número de caracteres que contiene el archivo. Comenzamos a añadir unas líneas, nos detenemos y tratamos de salirnos. Esta vez ed nos avisa con ? que el archivo no ha sido salvado. No debemos esperar una comunicación más comprensible de ed. Su manera de avisarnos que algo no le gusta o que las cosas no van bien es con un críptico ?. En este caso una segunda q le indicaría que realmente nos queremos salir sin salvar los cambios que hicimos. En todo momento una Q le indica a ed que deseamos terminar la sesión sin guardar los cambios.

Cuando queremos revisar el texto ya escrito, le podemos pedir que imprima las líneas en un cierto rango con la instrucción a,bp donde a y b son números de línea. Por ejemplo, para ver la segunda estrofa:

$ ed angel

384

6,9p

?Como encontraste el camino?

?Aun te escondes cuando sale el sol?

Cuando abandonaste el cielo

?Perdiste las alas?

.,$p

?Perdiste las alas?

Ahora veo a un largo tren venir despacio

y una muerte agradecida que me reconforta

dime Reina Ines ?vendras a verme?

El amigo del diablo es amigo mio

q

$

Los caracteres. y $ tienen el significado especial de ser la línea actual y la última línea respectivamente como podemos ver en la segunda parte del ejemplo.

Si damos un enter por si sólo o un – seguido de un enter, nos lista la siguiente línea y la anterior respectivamente, moviéndose hacia adelante y hacia atrás en el archivo. No permite moverse más allá de la primera y de la última línea, ni imprimirlas en orden inverso.

Podemos hacer búsquedas utilizando los operadores /patron/ y ?patron? hacia adelante y hacia atrás respectivamente. Una vez que encontramos el primero, podemos traer el siguiente con las formas // y ??.

$ ed angel

384

/con/

?Como encontraste el camino?

//

?Aun te escondes cuando sale el sol?

//

y una muerte agradecida que me reconforta

?alas?

?Donde dejaste tus alas?

??

¿Perdiste las alas?

q

$

Y podemos usar una búsqueda como parte de un rango:

1,/saber/p

Cuando abandonaste el cielo

¿Donde dejaste tus alas?

Cuando abandonaste el cielo

Quisiera saberlo, ?perdiste el halo?

.-1,.+3p

Cuando abandonaste el cielo

Quisiera saberlo, ?perdiste el halo?

¿Como encontraste el camino?

¿Aun te escondes cuando sale el sol?

Y como vemos, también podemos usar el. Como ancla e imprimir de la línea anterior a tres más adelante de la actual.

La forma genérica de los comandos es número de línea o rango seguido del comando. Para añadir a partir de una línea a partir de línea se usa #a, para insertar antes de la línea #i. Para borrar el rango de líneas de la i-ésima a la j-ésima i,jd y i,jc para reemplazar el rango de líneas por las que se dan a continuación.

Para hacer reemplazos en base a patrones se utiliza s/viejo/nuevo/:

2p

¿Donde dejaste tus alas?

2s/alas/celtas/

2p

¿Donde dejaste tus celtas?

Después del cambio se puede usar el modificador g para que haga el reemplazo en todas las ocurrencias de la línea o en todas las ocurrencias en el rango de las líneas: s/viejo/nuevo/g. Por supuesto que la sintaxis es extensible a rangos delimitados por patrones de búsqueda: 4,9s/viejo/nuevo/, 1,$s/viejo/nuevo/, 1,/viejo/s/viejo/nuevo/, etc.

Cuando necesitamos incluir el patrón viejo dentro del nuevo, no necesitamos reteclearlo, el carácter & toma el valor:

2p

?Donde dejaste tus alas?

2s/alas/& marchitas/p

?Donde dejaste tus alas marchitas?

Y como vemos, la p después del comando de reemplazo imprime la línea.

Para copiar y mover bloques, tenemos las instrucciones i,jtk i,jmk donde el primero copia las líneas en el rango de la i-ésima a la j-ésima después de la línea k-ésima. Igual en el segundo caso, pero borrándolas de su posición original.

También podemos incluir un archivo en el actual con la instrucción r en la forma nr archivo con la cual lo insertamos en el actual a partir de la línea n-ésima.

Con i,jw archivo copiamos de la línea i-ésima a la j-ésima en el archivo denominado. Con i,jW archivo copiamos de la línea i-ésima a la j-ésima al final del archivo denominado.

EDITOR PICO

El editor pico es un editor simple pero poderoso.

Sintaxis: pico [opciones] [fichero]

Algunas opciones:

-w :

Deshabilita el picado automático de las líneas.

-m :

Habilita la funcionalidad del Mouse en entornos gráficos, para posicionarse en el texto.

+<n> :

se establece el comienzo de la edición en la línea n-ésima.

Algunas opciones durante la edición:

Ctrl k :

borra y copia la línea actual en el clipboard.

Ctrl u :

inserta el contenido del clipboard en el texto.

Ctrl o :

salva el texto.

Ctrl x :

sale del editor. Pregunta si se desea salvar primero en caso de haberse modificado el texto.

CAPITULO V

Programación Shell

La programación del shell es una de las herramientas mas apreciadas por todos los administradores y muchos usuarios de Linux/Unix ya que permite automatizar tareas complejas, comandos repetitivos y ejecutarlas con un solo llamado al script o hacerlo automáticamente a horas escogidas sin intervención de personas.

La programación shell en Unix/Linux es, en cierto sentido, equivalente a crear archivos .BAT en DOS. La diferencia es que en Unix/Linux es mucho mas potente. Estos scripts pueden usar un sinnúmero de herramientas como:

• Comandos del sistema Linux/Unix (ejm: ls, cut)
• Funciones intrínsecas del shell (ejm: kill, nice)
• Lenguaje de programación del shell (ejm: if/then/else/fi) 3 (ver tabla )
• Programas y/o lenguajes de procesamiento en línea. (ejm: awk, sed, Perl)
• Programas propios del usuario escritos en cualquier lenguaje.

El lenguaje de programación de cada shell provee de una amplia gama de estructuras de control como se muestra en la tabla 

• for name [ in word; ] do list ; done
• select name [ in word ; ] do list ; done
• case word in [ pattern [ | pattern ]ldots ) list ;; ]ldots esac
• if list then list [ elif list then list ]ldots [ else list ] fi
• $while list do list done
• $until list do list done
• [ function ] name () { list; }

Instrucciones bash para programación shell tbl_instr_bash

Un sencillo ejemplo es realizar un backup de solo ciertos directorios (prog_dir1 y prog_dir2), luego comprimirlos usando bzip2 y enviarlos a un area de almacenamiento (digamos una unidad ZIP previamente montada en /mnt/zipdrive), y además con que el nombre del archivo contenga la fecha del día. Suena difícil? Realmente no lo es.

Se crea un archivo texto con cualquier nombre, por ejemplo mibackup que contenga las instrucciones que se desea ejecutar.

#!/bin/sh

#

echo "———- Captura fecha ———–"

fecha=`date +%Y%m%d`

#

echo "———- Haciendo Tar ———–"

tar cvf backup$fecha.tar prog_dir1 prog_dir2

#

echo "———– Comprimiendo ———–"

bzip2 backup$fecha.tar

#

echo "———- Enviándolos a zip ——-"

cp ./backup$fecha.tar /mnt/zipdrive

#

echo "———– Limpiando ————–"

rm -f ./backup$fecha.tar

#

echo "———– Final ————-"

Luego, se le asigna permisos de ejecución con el comando

chmod +x mibackup

y esta listo para ser ejecutado.

En el script aquí mostrado es importante resaltar varios principios importantes: la primera línea determina el shell que se esta usando (sh o bash); las variables no se declaran solo se asignan; su valor es retornado usando el símbolo $.

Si desea mas información acerca de programación en shell se puede consultar los manuales en línea del shell: bash o cts..

Intérprete de comandos: Shell

El intérprete de comandos es el programa que recibe lo que se escribe en la terminal y lo convierte en instrucciones para el sistema operativo.

En otras palabras el objetivo de cualquier intérprete de comandos es ejecutar los programas que el usuario teclea en el prompt del mismo. El prompt es una indicación que muestra el intérprete para anunciar que espera una orden del usuario. Cuando el usuario escribe una orden, el intérprete ejecuta dicha orden. En dicha orden, puede haber programas internos o externos: Los programas internos son aquellos que vienen incorporados en el propio intérprete, mientras que los externos son programas separados (ej: aplicaciones de /bin,/usr/bin,…).

En el mundo Linux/Unix existen tres grandes familias de Shells como se muestra en la tabla 3.4. Estas se diferencian entre sí básicamente en la sintaxis de sus comandos y en la interacción con el usuario.

Re-utilización de comandos

El shell almacena una historia de los comandos que el usuario ha escrito. Por medio de esta historia es posible volver a ejecutar una orden que ya se ha escrito anteriormente sin tener que escribirla de nuevo.

El comando history muestra la secuencia de comandos, con un número a su izquierda. Con este número es posible llamar de nuevo el comando utilizando el carácter admiración “!''; Por ejemplo history retorna

1 history

2 ls

3 cd public_html

4 ls

5 rm *.bak

6 history

y para ejecutar nuevamente el comando rm *.bak solo es necesario escribir !5. También se puede pedir el último “rm'' que se ha ejecutado escribiendo !rm.

El último comando se repite con doble admiración “!!''. Es posible también editar el último comando utilizando el carácter “^'' pero este conocimiento se esta volviendo poco útil, ya que los nuevos shells permiten viajar por la “historia'' y editar los comandos usando únicamente las flechas del teclado.

Tuberías o pipes

En la línea de comandos la integración entre diferentes programas se realiza por medio de la re-dirección de las entradas y salidas a través de pipes o tuberías.

Una tubería o pipe es una combinación de varios comandos que se ejecutan simultáneamente, donde el resultado del primero se envía a la entrada del siguiente. Esta tarea se realiza por medio del carácter barra vertical “''. Por ejemplo si se quiere ver todos los archivos que hay en el directorio /usr/bin, se ejecuta lo siguiente: ls /usr/bin | more. De este modo, la salida del programa ls (listado de todos los archivos del directorio /usr/bin) irá al programa more (modo paginado, es decir, muestra una pantalla y espera a que pulsemos una tecla para mostrar la siguiente).

Dentro de esta estructura se han construido una serie de programas conocidos como “filtros'' los cuales realizan procesos básicos sobre textos (ver tabla 3.6).

Algunos Filtros en línea de comandos Linux/Unix tbl_filtros

Algunos filtros han llegado a ser tan complejos que son en si, un lenguaje de procesamiento de texto, de búsqueda de patrones, de construcción de scripts, y muchas otras posibilidades. Estas herramientas pasan a ser parte de la siguiente sección. Entre ellos podemos mencionar herramientas tradicionales en Linux/Unix como awk y sed y otras mas modernas como Perl.

Variables de entorno

Una variable de entorno es un nombre asociado a una cadena de caracteres.

Dependiendo de la variable, su utilidad puede ser distinta. Algunas son útiles para no tener que escribir muchas opciones al ejecutar un programa, otras las utiliza el propio shell (PATH, PS1,…). La tabla 3.5 muestra la lista de variables más usuales.

Variables de entorno más usuales tbl_var_ent

La forma de definir una variable de entorno cambia con el interprete de comandos, se muestra tcsh y bash siendo los dos mas populares en el ámbito Linux:

bash:

export VARIABLE=Valor

tcsh:

setenv VARIABLE Valor

Por ejemplo, para definir el valor de la variable DISPLAY:

bash:

export DISPLAY=localhost:0.0

tcsh:

setenv DISPLAY localhost:0.0

SHELL SCRIPTS

Como se vió al principio del curso, la shell nos permite acceder al kernel del sistema operativo. La shell en reaildad lo que hace es interpretar la línea de comandos y ejecutar los programas que ésta indica. Sin embargo, además de leer la línea de comandos, también puede ejecutar los comandos que se encuentren en un fichero. Cualquier comando que pueda ser tecleado en la línea de comandos puede ser incluido en un fichero al que se le denomina como shell script o shell programa.

Un shell script es un fichero donde hemos introducido cualquier comando que se puede ejecutar en la shell. Se pueden incluir comandos UNIX, utilidades, emplear pipes, redireccionar entradas y salidas, definir y utilizar variables, además del uso de una serie de comandos UNIX creados para ser usados fundamentalmente en los shell scripts, como son condicionales y comandos para controlar el flujo del programa.

Si queremos poner comentarios en nuestros scripts, lo hacemos con el símbolo #

Declaración de variables

Para definir variables se utilizan las palabras reservadas set y setenv seguidas de la variable que queramos definir. Set sirve para declarar variables locales y setenv para variables de entorno. Variables del mismo tipo pueden declararse juntas al principio del programa (Ej: set name,  name1). Antes de darle un valor a una variable, ésta debe estar definida.

1.1- Asignar números a variables ->Para asignar un valor numérico a una variable se utiliza @ variable = valor, dejando los espacios. 1.2.- Asignar palabras a variables -> Se utiliza set name = "Esto es una frase" 1.3.- Asignar variables a otras variables -> Se utiliza el símbolo del dollar set name1 = $name Crear arrays ->  Para definir arrays, se hace también con set. Los datos que componen el array hay que separarlos por espacios y deben ir encerrados entre paréntesis. Ej: set direction = (Norte Sur Este Oeste)      echo $direction      echo $direction[1]      echo $direction[1-3]

Interacción con el usuario

Leer un valor desde teclado -> Para introducir una palabra desde teclado se utiliza $<, y para un número  es similar.             Ej: #!/bin/csh              clear              echo " "              echo " Cual es tu nombre?:"              set nombre = $<              echo "Y tu edad?:"              @ edad = $< Escribir en un fichero -> Para escribir algo en un fichero se utiliza el pipe >. Si el fichero ya existe y se quiere añadir algo al final, se utiliza >>.            Ej: #!/bin/csh              clear              echo " "              echo " Cual es tu nombre?:"              set nombre = $<               echo "Tu nombre es:" $nombre > fichero.dat              echo "Y tu edad?:"              @ edad = $<               echo "Tienes" $edad "años" >> fichero.dat

Operaciones

Operadores matemáticos  

Ej: @ a = 47       @ b = 32       @ suma = $a + $b       @ resta = $a – $b       @ producto = $a * $b       @ divide = $a / $b       @ resto = $a % $b

Operadores lógicos

Operadores de comparación

 Condicionales

La instrucción para el condicional es if. Es interesante utilizar el condicional cuando queremos que nuestro programa  chequee si una condición es verdadera o falsa. La forma del condicional es la siguiente:

if (condición) then   instrucción end if

Si queremos ejecutar diferentes instrucciones de pendiendo de si la condición es verdadera o falsa, se utiliza el comando else

if (condición) then    instrucción1 else    instrucción 2 endif

También podemos hacer condionales con varias condiciones

if (condición1) then    instrucción1 else if (condición2) then    instrucción2 endif endif

Operadores

PHP nos ofrece una gran variedad de operadores, desde los aritméticos hasta operadores a nivel de bits. Podemos llevar a cabo la siguiente clasificación:

• Aritméticos
• Lógicos
• De comparación
• Lógicos
• De cadenas
• A nivel de bits
• De asignación
• De incremento y decremento
• De control de errores
• De ejecución

Operadores aritméticos

Operadores lógicos

En principio nos va a llamar la atención el hecho de que existan dos operadores AND y dos OR. La explicación es que cada operador AND tiene diferente recedencia; con los operadores OR ocurre lo mismo.

Operadores de comparación

Operadores de cadenas

El operador ofrecido por PHP para las cadenas es el de concatenación, que se corresponde con el símbolo"." (punto).

También podemos considerar a los corchetes [ ] como operador para las cadenas, ya que cumple una función análoga a la que lleva a cabo con los vectores.

$c = $a.$b; /* $c tendrá como valor la concatenación $a y $b */

$cadena = "prueba";

$caracter = $cadena[3]; /* $caracter valdrá 'e' */

Operadores a nivel de bits

Operadores de asignación

El operador de asignación por excelencia es "=". Se trata del más sencillo de los operadores de asignación:

$a = $b + 1; /* $a vale $b + 1 */

Decimos que es el más sencillo porque PHP, al igual que C, nos ofrece gran variedad de operadores de asignación, por medio de la combinación del símbolo "=" con otros operadores.

$a += 5; /* $a = $a + 5; */

$b .= "Concatena"; /* $b = $b."Concatena"; */

$a -= 3; /* $a = $a – 3; */

$a *= $a /* $a = $a * $a; */

$a /= 2; /* $a = $a / 2; */

Otro aspecto a destacar de los operadores de asignación en PHP es que, además de producirse la asignación de un valor, se devuelve él mismo.

$a = ($b = 3); /* $b = 3 devuelve 3. Por tanto $a = $b = 3; */

$a = $b = 3;

$a = ($b *= 3) + 5; /* $b = $b * 3;

$a = $b * 3 + 5; */

Operadores de incremento y decremento (++, –)

Estos operadores han estado siempre ligados a C, lenguaje con el cual vieron la luz. Se trata de incrementar en una unidad el valor de la variable sobre la que se aplican: $a++ equivale aritméticamente a $a = $a + 1, o bien, a $a += 1. Pero estos operadores tienen algo más: si se colocan antes de la variable (preincremente/predecremento) se incrementa/decrementa el valor de $a y luego se utiliza su valor. Si se ponen como sufijo de la variable, primero se utiliza el valor de $a y luego se opera sobre ésta.

$a = 1;

$a++; /* $a vale 2 */

$a–; /* $a vale 1 */

++$a; /* $a vale 2 */

–$a; /* $a vale 1 */

Hasta aquí, nada especial. Pero en el siguiente ejemplo vemos lo que explicábamos, la importancia de su posición:

$a = 1; /* $a vale 1 */

$b = $a++; /* $b vale 1 y $a vale 2 */

Primero se utiliza el valor de $a para la asignación y, después, se incrementa $a.

$a = 1; /* $a vale 1 */

$b = –$a; /* $a y $b valen 0 */

Primero se decrementa $a y luego se utiliza su valor en la asignación.

Operador de control de errores

El signo @, colocado antes de una expresión, hace que cualquier mensaje de error de esa expresión se ignore. Dicho mensaje se almacenará en la variable global $php_errormsg.

Operador de ejecución

Por medio de la utilización de backquotes `, se comunica a PHP la ejecución de un comando del shell.

$date = `date`;

echo $date; /* la salida será

Fri Sep 15 00:54:51 WEST 2000 */

Bibliografía:

Texto:

– Cómo usar UNIX Sistema V, versión 4.0. Stan Kelly-Bootle

Grupo Noriega Editores (Megabyte),1997

Referencia:

– The UNIX System. Bourne Stephen R., Addison-Wesley 1992

– Introducing the Unix System. McGilton, Henry, and Rachel Morgan,

McGraw-Hill, 1994

– Manual guía de Usuarios Unix, Datocentro, Unisys

Carolina Azar

UNIVERSIDAD TECNOLOGICA DE SANTIAGO

"UTESA"

CARRERA DE INFORMATICA

Programa Analítico de : Gestión de Sistemas

Nombre de la Asignatura : Gestión de Sistemas

Clave de la Asignatura : INF-205

Total horas teóricas/ciclo : 45

Total horas prácticas/ciclo :

Número de créditos : 3

Pre-requisitos : INF-100, MAT-100