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