linux original courseware

LOC: Linux Original Courseware

(*) Originaly Developed for Premiere IT S.R.L. Versión: 5.0a - Revisión: 2006-05-01 - 195 Páginas

LOC: Linux Original Courseware*

Correspondiente al Curso LX1: Fundamentals and Operation LX2: System Administrator LX3: Network Administrator


Premiere IT S.R.L. Página 1

Tabla de Contenidos Capítulo 1.................................................................................................................................................................... 5

Instalación ............................................................................................................................................................... 5 Capítulo 2.................................................................................................................................................................. 35

Administración de Usuarios ................................................................................................................................. 35 El archivo de Passwords................................................................................................................................... 35 Crear Usuarios .................................................................................................................................................. 36 Otros archivos importantes para la administración de usuarios ...................................................................... 39 Borrar usuarios.................................................................................................................................................. 40 Modificar atributos de usuario ......................................................................................................................... 40 Otros comandos de usuario .............................................................................................................................. 41

Grupos................................................................................................................................................................... 41 Permisos ................................................................................................................................................................ 43

Comando chmod............................................................................................................................................... 44 Comando chgrp................................................................................................................................................. 45 Comando chown ............................................................................................................................................... 45 Sticky bit ........................................................................................................................................................... 45 Atributo SUID: (Para Archivos)....................................................................................................................... 46 Atributo SGID: (Para archivos)........................................................................................................................ 46 Atributo SGID: (Para directorios) .................................................................................................................... 46 SUID Shell Scripts............................................................................................................................................ 46

Capítulo 3.................................................................................................................................................................. 47 El Sistema Operativo Linux/Unix ........................................................................................................................ 47

¿Qué son las consolas virtuales? ...................................................................................................................... 47 Sistema de archivos (filesystems) ........................................................................................................................ 47

Archivos y directorios ...................................................................................................................................... 47 Tipos de archivos y directorios............................................................................................................................. 49

Archivos normales (files) ................................................................................................................................. 49 Directorios (directory) ...................................................................................................................................... 49 Enlaces duros (hard-links)................................................................................................................................ 49 Enlace simbólicos (soft-links) .......................................................................................................................... 50 Dispositivos de bloque (block devices)............................................................................................................ 50 Dispositivos de carácter (carácter devices) ...................................................................................................... 50 Pipes con nombre (named pipes)...................................................................................................................... 50

Comandos de Linux.............................................................................................................................................. 50 Comandos básicos para la gestión de archivos ................................................................................................ 50 Ver el contenido de archivos ............................................................................................................................ 52 Otros comandos ................................................................................................................................................ 53

Runlevels............................................................................................................................................................... 54 ¿Cómo arranca Linux?...................................................................................................................................... 54 Como cambiar de runlevel................................................................................................................................ 59

Procesos ................................................................................................................................................................ 62 Envío de una señal a un proceso ...................................................................................................................... 64 Control de Procesos .......................................................................................................................................... 65

Montaje y Desmontaje de Discos y de Sistemas de Archivos............................................................................. 67 El archivo /etc/fstab .......................................................................................................................................... 69

Capítulo 4.................................................................................................................................................................. 71 Instalación de Software ........................................................................................................................................ 71 Descompresión y compresión de archivos........................................................................................................... 71

Comando tar...................................................................................................................................................... 71 Comando gzip ................................................................................................................................................... 72 Comando gunzip............................................................................................................................................... 72 El comando unzip ............................................................................................................................................. 72 Comando bzip2................................................................................................................................................. 72

Paquetes DEB ....................................................................................................................................................... 73 Paquetes RPM....................................................................................................................................................... 78

Instalación ......................................................................................................................................................... 79



Actualización .................................................................................................................................................... 79 Consulta ............................................................................................................................................................ 79 Desinstalar un paquete...................................................................................................................................... 80 Verificación ...................................................................................................................................................... 80

Compilación de código fuente.............................................................................................................................. 81 Capítulo 5.................................................................................................................................................................. 82

¿Qué es el kernel? ................................................................................................................................................. 82 Tipos de kernel.................................................................................................................................................. 82 Versiones del kernel (Numeración).................................................................................................................. 82 Compilación del kernel..................................................................................................................................... 83 ¿Qué quiere decir compilar?............................................................................................................................. 83 ¿Para qué compilar el kernel?........................................................................................................................... 83 Empecemos con la compilación del kernel...................................................................................................... 83

Estructura del kernel modular .............................................................................................................................. 88 Módulos Cargables ........................................................................................................................................... 88 ¿Que es un módulo cargable?........................................................................................................................... 88 El archivo /etc/modules.conf ............................................................................................................................ 88 El archivo /etc/modules .................................................................................................................................... 89

Capítulo 6.................................................................................................................................................................. 90 Redes..................................................................................................................................................................... 90

Conceptos Básicos ............................................................................................................................................ 90 LAN, WAN y enlaces........................................................................................................................................... 90 El modelo de referencia OSI ................................................................................................................................ 91

Capa 7: Capa de aplicación .............................................................................................................................. 91 Capa 6: Capa de presentación .......................................................................................................................... 91 Capa 5: Capa de sesión..................................................................................................................................... 91 Capa 4: Capa de transporte............................................................................................................................... 91 Capa 3: Capa de red.......................................................................................................................................... 92 Capa 2: Capa de enlace de datos ...................................................................................................................... 92 Capa 1: Capa de física ...................................................................................................................................... 92 Comunicación entre capas................................................................................................................................ 92

Conjunto de Protocolos TCP/IP ........................................................................................................................... 92 Su relación con el Modelo OSI ........................................................................................................................ 92

Dirección IP .......................................................................................................................................................... 92 Fundamentos de la dirección IP ....................................................................................................................... 93 Coordinación de dirección IP ........................................................................................................................... 93 Organizando direcciones .................................................................................................................................. 93 Clasificación de redes ....................................................................................................................................... 94 Direcciones especiales...................................................................................................................................... 95 Redes Privadas.................................................................................................................................................. 95 Fundamentos de subredes................................................................................................................................. 96 ¿Porqué subredes? ............................................................................................................................................ 96 Números binarios y direcciones IP................................................................................................................... 96 AND.................................................................................................................................................................. 97 Subredes............................................................................................................................................................ 97 Subredes clase B ............................................................................................................................................... 98 Subredes clase C ............................................................................................................................................... 98

Ejemplos de subredes ........................................................................................................................................... 98 Ejemplo de subredes clase C ............................................................................................................................ 98 Ejemplo de subredes clase B ............................................................................................................................ 99

Ejemplos de rangos de dirección.......................................................................................................................... 99 Ejemplo de clase C ........................................................................................................................................... 99 Otro método para determinar rangos de dirección......................................................................................... 100

SuperNetting - Combinando direcciones ........................................................................................................... 101 Classless Internet Domain Routing (CIDR)....................................................................................................... 102

Capítulo 7................................................................................................................................................................ 103 Configuración de red en Linux........................................................................................................................... 103

Instalación de la placa de red.......................................................................................................................... 103 Configuración de una interfaz de red ............................................................................................................. 104

Encaminamiento (Routing) ................................................................................................................................ 107



Capítulo 8................................................................................................................................................................ 110 Programación en la shell de Linux ..................................................................................................................... 110

¿Que es la shell? ............................................................................................................................................. 110 ¿Qué es un script? ........................................................................................................................................... 110

Creación de scripts.............................................................................................................................................. 110 ¿Qué se escribe en un script?.......................................................................................................................... 111

Sintaxis de los scripts.......................................................................................................................................... 111 Comentarios .................................................................................................................................................... 111 Variables ......................................................................................................................................................... 111 Pasaje de argumentos...................................................................................................................................... 112 Redireccionamiento ........................................................................................................................................ 113 La orden read .................................................................................................................................................. 113 Estructuras de control ..................................................................................................................................... 114 Efectuando comparaciones............................................................................................................................. 115 La sentencia case ............................................................................................................................................ 116 La sentencia for............................................................................................................................................... 117 La sentencia while .......................................................................................................................................... 117 Depuración...................................................................................................................................................... 118

Capítulo 9................................................................................................................................................................ 119 El demonio xinetd............................................................................................................................................... 119 ¿Cómo instalar el xinetd? ................................................................................................................................... 120 Configuración ..................................................................................................................................................... 120 Configurando un servicio ................................................................................................................................... 121

El directorio /etc/xinetd.d/ .............................................................................................................................. 121 Capítulo 10.............................................................................................................................................................. 124

Introducción a Samba ......................................................................................................................................... 124 Servidor Samba................................................................................................................................................... 124 Instalación de Samba .......................................................................................................................................... 124 Configuración de Samba .................................................................................................................................... 126

Globales .......................................................................................................................................................... 126 Seguridad ........................................................................................................................................................ 127

Usuarios válidos para Samba.............................................................................................................................. 135 Acceso a los recursos compartidos..................................................................................................................... 135 Acceso a los recursos compartidos: montaje ..................................................................................................... 136 Samba-SWAT..................................................................................................................................................... 136

Capítulo 11.............................................................................................................................................................. 139 Servidor DHCP................................................................................................................................................... 139

Capítulo 12.............................................................................................................................................................. 142 Firewalls.............................................................................................................................................................. 142

Introducción .................................................................................................................................................... 142 Fundamentos sobre el Filtrado de Paquetes................................................................................................... 142 ¿Y para que necesito un Firewall? ................................................................................................................. 143

Netfilter/Iptables ................................................................................................................................................. 143 Historia............................................................................................................................................................ 143

¿Cómo? - ipchains .............................................................................................................................................. 144 Enmascaramiento (masquerading o NAT)..................................................................................................... 146 Cerrando servicios .......................................................................................................................................... 146 Negación ......................................................................................................................................................... 146 Consultando las reglas .................................................................................................................................... 147 Borrando reglas............................................................................................................................................... 147 Estableciendo políticas ................................................................................................................................... 147 Guardando información de eventos................................................................................................................ 147 Especificando una interface............................................................................................................................ 147 Guardando y recuperando las reglas .............................................................................................................. 148

Algunas consideraciones .................................................................................................................................... 148 Manipulando el Tipo de servicio (Type Of Service) ..................................................................................... 148 Filtrando el Ping de la Muerte ........................................................................................................................ 149 Hand Shaking.................................................................................................................................................. 149

¿Cómo? - iptables ............................................................................................................................................... 149 Consultando las reglas .................................................................................................................................... 153



Borrando reglas............................................................................................................................................... 153 Guardando y recuperando las reglas .............................................................................................................. 154 Módulos con opciones de coincidencias adicionales..................................................................................... 154

Capítulo 13.............................................................................................................................................................. 155 DNS..................................................................................................................................................................... 155

Introducción .................................................................................................................................................... 155 Clasificación de Servidores ............................................................................................................................ 155 Servidor de solo caché.................................................................................................................................... 156 Tipos de Resolución ....................................................................................................................................... 156 Configuración del servidor ............................................................................................................................. 157 Servidores Raiz ............................................................................................................................................... 158

Archivos de zona ................................................................................................................................................ 159 Ejemplos ......................................................................................................................................................... 159 El registro SOA............................................................................................................................................... 160 El registro A.................................................................................................................................................... 161 El registro NS.................................................................................................................................................. 161 El registro PTR ............................................................................................................................................... 161 El registro MX ................................................................................................................................................ 161 El registro CNAME ........................................................................................................................................ 161

Configuración del cliente.................................................................................................................................... 161 Verificaciones ..................................................................................................................................................... 162 Ejemplo de búsqueda.......................................................................................................................................... 162

Capítulo 14.............................................................................................................................................................. 165 Apache ................................................................................................................................................................ 165

Introducción .................................................................................................................................................... 165 Instalación de Apache2....................................................................................................................................... 165 Configuración ..................................................................................................................................................... 166

Veamos otras variables de configuración ...................................................................................................... 167 Virtual Hosts ................................................................................................................................................... 170

Prueba de Apache ............................................................................................................................................... 170 Páginas protegidas .............................................................................................................................................. 171

Capítulo 15.............................................................................................................................................................. 173 Programando tareas con at y cron ...................................................................................................................... 173

Introducción .................................................................................................................................................... 173 Uso de at ......................................................................................................................................................... 173 Uso de cron ..................................................................................................................................................... 173 Opciones de crontab ....................................................................................................................................... 174 Crontab para los usuarios ............................................................................................................................... 175 Contol de accesos y uso de crontab................................................................................................................ 175

Apéndice A ............................................................................................................................................................. 176 Utilizando vi........................................................................................................................................................ 176

Introducción .................................................................................................................................................... 176 Invocando a vi................................................................................................................................................. 176 Cómo funciona vi ........................................................................................................................................... 176 Desplazarse por el archivo.............................................................................................................................. 177 Introducir texto ............................................................................................................................................... 177 Borrar texto ..................................................................................................................................................... 177 Reemplazar texto ............................................................................................................................................ 178 Copiar, Cortar y Pegar texto.......................................................................................................................... 178 Deshacer y Repetir.......................................................................................................................................... 178 Factor de repetición ........................................................................................................................................ 178 Búsqueda de una cadena................................................................................................................................. 178 El menú “:” ..................................................................................................................................................... 178

Apéndice B.............................................................................................................................................................. 179 Propuesta de Laboratorio.................................................................................................................................... 179

Apéndice C.............................................................................................................................................................. 180 Preguntas Exámen LPI ....................................................................................................................................... 180 Respuestas Exámen LPI ..................................................................................................................................... 191



Capítulo 1

Instalación Podemos comenzar la instalación, arrancando la PC con el CD N° 1 puesto en la lectora. Recuerde setear en su BIOS que arranque desde la unidad de CD-ROM. Si su máquina tiene varios años, puede ser que su BIOS no pueda arrancar desde CD, entonces debe hacerlo desde diskette. Paso 1. Elegir el kernel con el cual realizamos la instalación. Ahora sí comenzamos con la instalación. Lo primero que aparece es una pantalla donde nos presenta varias opciones de arrancar. Si presionamos Enter, empezamos con la instalación típica que es con un kernel de la serie 2.4. Lo ideal en este paso es leer bien para elegir otro kernel, el 2.6, que es el que viene con la serie actual. Simplemente, escribimos linux26 y presionamos Enter. NOTA: El kernel es el núcleo de un sistema operativo.

Paso 2. Elegir el idioma de la instalación. Aquí nos pide elegir el idioma de la instalación, podemos elegir Español. Con las flechas (están entre los teclados de letras y números).



Ahora nos va a pedir que configuremos la variante, dentro del español.

Paso 3. Configuración del teclado.

.



Después de estas configuraciones iniciales, el sistema empieza a detectar el hardware instalado, analiza el CD-ROM y carga los módulos que necesitará el instalador de Debian. Paso 4. Configuración de la red. Este paso es útil configurarlo en este momento si vamos a hacer una instalación básica o mínima con el 1° cd de instalación de Debian y luego continuamos instalando el sistema desde la red, por ejemplo si vamos bajando de Internet los paquetes que queremos instalar. Lo primero que hace es buscar si en la red hay algún servidor DHCP, que nos asigne una dirección IP automáticamente. Si no detecta ningún DHCP, podemos asignar la dirección IP manualmente, como vemos en la pantalla siguiente.

Luego aparecerán otras pantallas para definir la máscara de red, la dirección IP del gateway, si hubiera y, por último la dirección IP del servidor de nombres (DNS). Ahora decidimos el nombre de nuestra máquina. Si lo dejamos en blanco, por defecto, el nombre será localhost NOTA Los servidores DNS, o servidores de nombres se escriben en la misma línea y separados por un espacio. Esta información se puede obtener llamando a su compañía de Internet.



Luego aparece una pantalla donde nos pregunta el dominio al que pertenecemos. Si es una máquina local, en nuestra casa y no tenemos un dominio, dejamos el espacio en blanco. Paso 5. Particionamiento de disco. Llegamos a una parte crítica de la instalación. Crear las particiones donde instalaremos el sistema. Nos aparece la pantalla que vemos abajo, con varias opciones. Veamos que significan. -Configurar RAID por software: en algunos servidores se replica la información, es como hacer un espejado de los discos. RAID son las siglas en inglés de Redundant Array of Inexpensive Disks, o sea, conjunto redundante de discos baratos. En Linux armar el RAID se hace a nivel de partición, por ejemplo: podremos montar un RAID 5 con 3 particiones en 3 discos diferentes (podría ser el mismo disco, pero no tendría sentido y perderíamos las capacidades de redundancia y rendimiento de los dispositivos RAID ). -Configurar el Gestor Lógico de Volúmenes (LVM): Esto se usa cuando queremos que una misma partición ocupe varios discos, por ejemplo.LVM es una forma de alocar espacio de disco duro en volúmenes lógicos que pueden ser fácilmente redimensionados en vez de particiones. Con LVM, el disco duro o grupo de discos duros está alocado para uno o más volúmenes físicos. Un volumen físico no abarca más de una unidad. Los volúmenes físicos están combinados en grupos de volúmenes lógicos, a excepción de la partición /boot. -Particionado guiado y Ayuda del particionado: Estas 2 opciones nos ayudan en el proceso de particionamiento, mediante cuadros de dialogo, lo hacen más automatizado. -Maestro IDE (hda) Esta última línea nos muestra el disco que detectó. En este caso, tenemos un solo disco duro, Maestro IDE (hda), si tuviera más discos vería diferentes renglones con todos los discos duros de mi máquina. Ejemplo: Si tuviéramos dos discos, tendríamos en esta pantalla dos renglones que dirían hda y hdb. En Windows existe el drive C:\, aquí se llama /dev/hda. Si tuviera discos SCSI, sería /dev/sda. Aclaración: Así se designan en Linux, los discos rígidos, hd viene de Hard Disk, sd viene de SCSI disk, y las letras a y b designan al disco según como está enchufado en la IDE.

hda: es el disco primario o master de la ranura primaria. hdb: es el disco secundario o esclavo de la ranura primaria. hdc: es el disco primario o master de la ranura secundaria. hdd: es el disco secundario o esclavo de la ranura secundaria.



Elegimos la opción de disco:

Maestro IDE (hda) – 10.7 GB VMware Virtual IDE Hard Drive Ya que vamos a editar manualmente la tabla de particiones. Entonces nos muestra una pantalla de advertencia, donde confirmamos que sí, lo haremos.



Entonces, para comenzar a crear nuestra tabla de particiones nos posicionamos sobre la línea que nos muestra ESPACIO LIBRE

Este es el espacio libre que Debian detectó en nuestro disco duro.

NOTA: En esta pantalla, vería todas mis particiones en el disco duro si las tuviera. Si quisiera que Debian fuera el único sistema operativo instalado en la máquina, debería borrar todas esas particiones una por una. Para hacer esto debemos posicionarnos en la partición que deseamos borrar y, del menú que aparece en la parte inferior de la pantalla elegimos “Borrar la partición”.



Repetimos los pasos con las demás particiones que queremos borrar. Vamos a empezar a crear las particiones. Al dar Enter sobre la línea que nos muestra ESPACIO LIBRE nos aparece la siguiente pantalla:

Elegimos

Crear una partición nueva



La primer partición será Primaria.

Elegimos que comience al principio del espacio libre que encuentra.

Aquí seleccionamos el tamaño.



En esta pantalla vamos a definir varias características de la partición.

Filesystem: vamos a formatear la partición, debemos decirle con qué filesystem o sistema de archivos la vamos a formatear. En este caso elegimos ext3, podría ser ext2, reiserfs,etc

Punto de montaje: el filesystem o sistema de archivos debe montarse en algún directorio para funcionar. El primer filesystem a montar debe ser /. NOTA: este tema lo veremos en detalle en capítulos posteriores. Opciones. Son opciones de montaje, por ejemplo si se monta como solo lectura o lectura/escritura, otra opción puede ser qué permisos tienen los usuarios para montar dicho filesystem. En este caso, le ponemos defaults.

Etiqueta: como se llama el filesystem. En este caso, /, es el directorio principal o raíz.

Bloques reservados. Esto lo define el administrador del sistema operativo, tiene que ver con la estructura del filesystem, Linux utiliza inodos para armar la jerarquía del árbol de directorios.

Uso habitual: estándar

Marca de arranque. Puede estar activada o desactivada. La activo si quiero que esa partición arranque.

Tamaño: es el tamaño que queremos tenga la partición.

Cuando terminamos de configurar estos parámetros, seleccionamos

“Se ha terminado de definir la partición” del menú abajo en la pantalla.

Los cambios en las particiones no tomarán efecto hasta que no sean escritos al disco duro.



En un disco se pueden hacer hasta cuatro particiones (1ª-4ª) “primarias”. Si se necesitan más, una de ella debe ser de un tipo especial: “extendida” y va a contener particiones adicionales (5º en adelante). En nuestro caso, el disco (hda) tendrá tres particiones primarias, y una extendida (no necesariamente debe ser la 4ª) que contendrá tres particiones más. Las particiones creadas dentro de la extendida se denominan particiones lógicas. Ejemplo de una tabla de particiones con tres primarias y la cuarta extendida, conteniendo adentro tres particiones más.

Device Boot Start End Blocks Id System /dev/hda1 1 614 4931923+ 83 Linux /dev/hda2 615 1027 3317422+ c Win95 FAT32 (LBA) /dev/hda3 1229 1842 4931955 82 Linux swap /dev/hda4 1843 2481 5132767+ 5 Extended /dev/hda5 1843 2456 4931923+ 83 Linux /dev/hda6 2457 2479 184716 83 Linux /dev/hda7 2480 2481 16033+ 83 Linux

Así particionaremos nuestro disco. Crearemos 3 particiones primarias y 3 particiones lógicas que contendrán: hda1 / hda2 /boot hda3 swap hda5 /var hda6 /tmp hda7 /usr Debemos decidir cuánto tamaño darle a cada partición. La partición que vamos a usar para swap, la haremos de tamaño similar al doble de la memoria RAM (siempre que tengamos menos de 256 Mb, sino conviene dejarla más o menos del mismo tamaño). También es bueno crear una partición donde alojar /boot para tener en un espacio físico separado las imágenes de booteo. El directorio /tmp conviene guardarlo en una partición porque en esa partición puede escribir todo el mundo y como consecuencia, a menos que estemos implementando quotas cualquiera nos puede llenar el disco. A /usr le damos una partición especial porque a medida que va creciendo nos saca espacio de /. Cuantos más programas instalemos, más crecerá /usr. Para /var tenemos una consideración parecida. Si lo que estamos instalando es un servidor de correo, por ejemplo debemos darle más espacio. Igualmente todo esto le quedará más claro, cuando lea más abajo como es el árbol de directorios. Directorios / (barra) Se encuentra en todos las estructuras de archivos tipo Linux. De aquí comienza todo el

árbol. Es el directorio raíz, el principal del árbol. /tmp Aquí se guardan archivos temporales que crean los programas que son ejecutados. /lib Librerías del sistema, algo parecido a las dll de Microsoft. /dev Aquí se almacenan todos los archivos que representan dispositivos. Los archivos contenidos son

los device drivers y se utilizan para acceder a los dispositivos del sistema y recursos, como discos duros, módems, memoria, etc.

/etc Contiene los archivos de configuración del sistema. Éstos incluyen administración del arranque del sistema, de servicios, de usuarios, etc.

/bin Aquí encontramos los comandos principales del sistema que son fundamentales para el inicio del equipo y que los usuarios pueden utilizar.

/sbin A diferencia del /bin, acá están los comandos también fundamentales para el inicio del equipo, pero exclusivos del administrador del equipo.

/home Contiene los directorios home de los usuarios. /root Directorio de la cuenta de usuario root. Es el /home de root, por seguridad está separado de los

home de los demás usuarios. /proc Es un directorio virtual, no existe en el disco, los archivos que contiene residen en memoria. Está

íntimamente relacionado con el kernel. /usr Aquí es donde se ubican los programas instalados, sus bibliotecas, su documentación, sus

archivos, etc. y son accesibles para los usuarios. /usr contiene la mayoría de los paquetes grandes de programas y sus archivos de configuración. Por ejemplo, /usr/share/man y /usr/share/doc contienen páginas man y documentos variados sobre el software instalado.



/var Contiene directorios que tienden a crecer y/o son datos volátiles. Ejemplos son: colas de impresión, colas de mail, archivos log.

/media Lo utiliza los dispositivos que se montan, es el punto de montaje temporal de dispositivos removibles. Contiene cdrom y floppy como subdirectorios.

/boot Contiene las imágenes de booteo para arrancar el sistema. /lost+found Aquí aparecen los archivos que luego de un corte del sistema, de un mal apagado del equipo,

son restaurados por un chequeo de integridad del disco. Paso 6. Creando la partición boot.

Nos posicionamos donde dice ESPACIO LIBRE para crear una nueva partición, le indicamos el tamaño 130MB



Aquí elegimos el filesystem /boot, y vamos a la pantalla siguiente para montarla y configurar demás características. Entre ellas, hacer esta partición, capaz de iniciar/arrancar el sistema operativo (bootable), para esto activar la opción “marca de arranque”




“Se ha terminado de definir la partición” del menú abajo en la pantalla.

Paso 7. Creación de la partición de intercambio (swap) Nos posicionamos donde dice ESPACIO LIBRE, damos Enter y elegimos el tamaño



Ahora necesitamos decirle a Linux que esta partición es para utilizar como swap, de otra manera Linux no la puede usar. Esto lo hacemos en la siguiente pantalla, la relativa a los montajes y configuración del filesystem.

Cuando terminamos de configurar estos parámetros, seleccionamos “Se ha terminado de definir la partición” del menú abajo en la pantalla.



Paso 8. Creación de la partición extendida Recordemos, si creo la 4ª partición como primaria, ya no puedo crear más particiones. Por lo tanto, la 4ª partición debemos crearla extendida, y así, crear luego particiones lógicas.

Cuando nos posicionamos donde dice ESPACIO LIBRE, damos Enter y elegimos el tamaño, nos pregunta si la partición será lógica o extendida.

Elegimos, lógica Montamos /var

Cuando terminamos de configurar estos parámetros, seleccionamos “Se ha terminado de definir la partición” del menú abajo en la pantalla



Ahora crearemos otra partición lógica, para /tmp

Este directorio no aparece en el listado que nos muestra, debemos tipearlo nosotros.




“Se ha terminado de definir la partición” del menú abajo en la pantalla

Y por último, creamos la partición para /usr

Paso 9. Hacer definitivos los cambios en el disco Hasta ahora, nada ha sido modificado, hasta que se escriban los cambios en el disco. Para hacer esto, seleccionamos “Finalizar el particionado y escribir los cambios en el disco” del menú abajo en la pantalla.



Luego veremos el mensaje: "Desea escribir los cambios en los discos?” Si estamos seguros, decimos que Si, y listo.

NOTA: En caso de errores o dudas siempre tenemos en las pantallas la opción <Volver>

Paso 10. Instalación del sistema básico Cuando terminamos el particionado, el sistema crea la nueva tabla de particiones, y arma el filesystem. Ahora entonces empieza a instalar el sistema base Tarda unos minutos hasta que el sistema básico sea instalado. Paso 11. Hacer el sistema arrancable (bootable) Para arrancar nuestro sistema debemos instalar GRUB Aquí nos parece una diferencia importante con la instalación de Debian versión 2.4. Ya no nos da a elegir qué programa queremos usar para arrancar nuestro sistema, si LILO o GRUB. Esta distribución Debian 2.6, solo permite instalar GRUB.



En esta pantalla nos pregunta si queremos instalar GRUB en el MBR o registro principal de arranque. Si queremos usar GRUB para arrancar todos los sistemas operativos (en caso que hubiéramos tenido instalado Windows, por ejemplo) entonces, elegimos la opción de instalar GRUB en el MBR (Master Boot Record).

Si hubiera contestado que <No>, entonces me va a preguntar en que partición quiero instalarlo. En este caso después debemos bootear con un diskette o con un CD-ROM



Paso 12. Reiniciar la máquina Finalizó la instalación! Después de esta pantalla estamos listos para reiniciar el sistema. Una vez que reiniciamos, haremos una configuración final del sistema. Asegurémonos de sacar el CD-ROM y/o diskette y seleccionamos <Continuar> para reiniciar Debian. Al arrancar nuestro sistema veremos la siguiente pantalla:

Paso 13. Configuración de la zona horaria

Vamos a definir la hora del sistema. En esta pantalla nos pregunta si la máquina está configurada con la hora Greenwich o la hora local. Elijan lo que más les convenga.



En la próxima pantalla, también titulada "Configuración de zona horaria", muestra una lista de países y ciudades. Escogemos la nuestra, que aparece en el listado.

Paso 14. Configuración de la contraseña

En esta pantalla es donde vamos a escribir la contraseña de la cuenta del usuario principal o superusuario root.



Esta es la contraseña que vamos a necesitar para poder entrar al sistema como root, para poder administrar todo el sistema. Por ejemplo, necesitará entrar al sistema como root para "bajar" (descargar) e instalar paquetes y programas usando el programa apt. Por consiguiente, no queremos que cualquiera adivine mi contraseña de administrador del sistema. Por favor recuerde esta contraseña, la va a necesitar al final de estas instrucciones. Y muchas veces más ;-)

La próxima pantalla nos pide otra vez la misma contraseña para asegurarse, y si no hay error de tipeo, listo, ya tomó la contraseña de root. Si hubiera error, las contraseñas serían distintas, entonces el sistema nos obligará a repetir este paso.

La próxima pantalla nos presenta la opción de crear una cuenta de usuario, como no es bueno entrar siempre como root , la crearemos. Escribamos nuestro nombre completo, por ejemplo y pulsamos <Aceptar>.

Luego nos pide un nombre para la cuenta. Este será el nombre que utilizará el usuario para entrar al sistema. Por lo tanto, también necesita una contraseña. Son las pantallas siguientes.



NOTA: escriba una contraseña diferente que la de root, así si alguien se entera de su contraseña como usuario, todavía no pueden entrar al sistema como root y hacer de las suyas.

Paso 15. Configuración de APT

Como ya tenemos la red configurada, desde los primeros pasos de la instalación, exactamente en el Paso 4, podemos utilizar la red para hacer la instalación de paquetes. Si tenemos conexión a alguna red, ADSL, Cable, u otro sistema de banda ancha, nos encontramos en la pantalla de "Configuración de apt". APT es el programa que usa Debian para administrar los paquetes, para instalar, eliminar, buscar, etc. En esta pantalla, lo que vamos a configurar es la fuente de instalación o repositorio, o sea, a donde va apt a buscar los paquetes para instalar. Si no tenemos internet, igual nos encontramos con esta pantalla, pero en este caso, la única fuente de instalación que tenemos son los CD-ROMs.

Aclaración: El software a instalar puedo traerlo desde los CD-ROM de Debian, desde internet, ya sea por http como por ftp, o también desde un repositorio local, una máquina especialmente destinada a esta tarea. En este caso, vamos a usar los CD-ROM de instalación de Debian. Elegimos la opción cdrom y presionamos <Aceptar> Luego aparece la siguiente pantalla, donde apt analiza el CD-ROM y guarda la información que necesita en la base de datos del programa apt



Si elegimos "FTP" o "HTTP" para tener acceso a los recursos de apt, nos aparece una pantalla donde pregunta si se va a usar recursos de apt NON-US. Si aceptamos, tendremos acceso a software que no se encuentra en los servidores apt de EEUU en materia de criptografía.

Luego pregunta si vamos a usar recursos de apt dirigidos a software non-free (no pueden tener, compartir, o modificar el código, pero son GRATIS) han sido incorporados a Debian.

La próxima pantalla pregunta si se va a usar "contrib software" que es también gratis y depende de non-free software para funcionar.

En la próxima pantalla, tenemos que elegir el repositorio de Debian al que nos vamos a conectar para bajar los paquetes. Podemos escoger un país en el continente nuestro, por ejemplo Argentina, que hay un mirror. Entonces elegimos, y Enter.

La siguiente pantalla muestra una lista de servidores y "espejos" o mirrors para bajar los paquetes de Debian. En teoría, no importa cual elegimos, sin embargo, hay algunos que no funcionan. Si esto pasa, tendremos la oportunidad de repetir la operación hasta que encontremos uno que trabaje bien. Uno seguro, es el servidor de debian.org. Seleccionamos y Enter.

Conviene agregar alguno más, de Estados Unidos o Brasil, por ejemplo, por las dudas que el primer repositorio no funcione en algún momento

En la siguiente pantalla pregunta si quieren tener acceso a los recursos apt de seguridad para actualizarse. Le decimos que Si.



Paso 16. Tasksel En esta pantalla tenemos que tomar una decisión. Una de las ventajas que tiene Debian es que se puede instalar un sistema limpio, básico y luego instalarle todos los programas que queramos. Tasksel es un programa que nos permite seleccionar grupos de programas y hasta paquetes individuales, También puede seleccionar todo si no sabe qué es cada paquete, o quiere conocer todo lo que trae Debian



La otra opción es que mi sistema sólo tenga las cosas que yo intencionalmente elija. Habiendo dicho esto, me salteo este paso, y luego instalo lo que quiero, terminando así con un sistema limpio y magro. Seleccionamos "No" para continuar, y luego veremos como agregar los programas que queramos.

Paso 17. Aptitude Si en la pantalla anterior, elegimos la opción “selección manual de paquetes” vamos a usar el programa aptitude. Algunos preferirán hacer esto, pero como lo veremos más adelante ahora salteamos este tema en la instalación. Caso contrario, si quiere elegir qué instalar, paquete a paquete seleccione la opción “selección manual de paquetes” en tasksel. Se llamará a aptitude con la opción --visual-preview si selecciona al mismo tiempo una o más tareas. Lo que significa que podrá revisar los paquetes que se van a instalar. Si no selecciona ninguna tarea se mostrará la pantalla habitual de aptitude. Debe pulsar “g” después de haber hecho su selección para empezar la descarga e instalación de los paquetes.

NOTA: Aptitude es un programa moderno para gestionar paquetes. Nos permite seleccionar paquetes individualmente, conjuntos de paquetes que concuerdan con un criterio dado (para usuarios avanzados) o tareas completas. Las combinaciones de teclas más básicas son:

Tecla Acción Arriba, Abajo Mueve la selección arriba o abajo. Enter Abre/colapsa/activa un elemento. + Marca el paquete para su instalación. - Marca el paquete para su eliminación.D Muestra las dependencias del paquete.G Descarga/instala/elimina paquetes. Q Sale de la vista actual. F10 Activa el menú.

Puede consultar más órdenes con la ayuda en línea si pulsa la tecla “?” Paso 17. Comienza la instalación de paquetes

Si han escogido instalar paquetes con tasksel o aptitude, éstos serán instalados por apt ahora, lo cual tomará algún tiempo. Si no lo hicieron este paso será rápido porque sólo tienen que desinstalar un solo paquete.

No se preocupen por los mensajes de alerta que reciban, no son importantes.

Se verá algo de este estilo:



Paso 18. Exim Exim es un servidor de correo como Sendmail, Qmail, etc.

La mayoría de las personas no lo van a necesitar, a menos que quieran tener un servidor de correo propio debido a su trabajo, etc.



Si después lo quieren configurar, la documentación se encuentra en: en el archivo /usr/share/doc.

Paso 19. Fin de la configuración

Esta última pantalla simplemente explica que han terminado la instalación de Debian con éxito.

Si queremos entrar al sistema, entramos, nos logueamos, escribimos nombre de usuario, Enter. Luego nos pide password, ponemos la contraseña de usuario y pulsamos Enter.



Ahora estaremos en una pantalla sin entorno gráfico, estrictamente de consola. Bienvenidos! Hemos terminado la instalación de Debian. Nos encontramos con la desventaja de no tener modo gráfico. Para solucionar esto rápidamente, pueden decirle al sistema que lo instale. Para esto, como usuario root, escribimos:

apt-get install x-window-system

Luego nos hará una serie de preguntas relativas a la configuración de las Xs. Para esto lo ideal es consultar la página http:// www.xfree.org donde vamos a tener información completa para ayudarnos en la instalación y configuración.



Capítulo 2

Administración de Usuarios Linux es un sistema operativo multiusuario, por lo tanto el administrador del sistema, que puede ser root o algun otro usuario con nivel de administrador, tiene que asignar un nombre de usuario (login) y una contraseña (password) a los usuarios para que puedan empezar a trabajar. Cada usuario, tiene su propio login y su propia password para acceder al sistema. Esto permite prevenir que otro usuario utilice un login que no le corresponde, pues es secreto. El archivo donde están almacenados los passwords de los usuarios es /etc/passwd. Para que un password sea válido debe contener como mínimo 6 caracteres, y el primero debe ser alfabético; pero únicamente los 8 primeros son significativos. El password puede contener letras en mayúsculas o minúsculas, caracteres numéricos y caracteres especiales. Para crear un nuevo password o cambiar uno ya existente se utiliza el comando passwd, cuya sintaxis es:

# passwd [NombreUsuario] El archivo de Passwords Linux guarda la información de todos los usuarios junto con sus passwords (lógicamente cifrados) en un archivo. Es el archivo passwd, dentro del directorio /etc. Es muy simple en Linux leer este archivo, ya que es accesible a cualquier usuario. Tiene la siguiente forma:

ale:heJuwMrBVa6mg:1001:202:Alejandra Garcia:/home/ale:/bin/sh pepe:GezuA6krN/BsE:1002:202:Jose Alvarez:/home/pepe:/bin/sh juan:ze7EPYLjRYX9I:1003:202:Juan Jose Cao:/home/juan:/bin/ksh

Vamos a ver qué significa todo esto. Podemos decir que el formato de cada línea es:

campo1:campo2:campo3:campo4:campo5:campo6:campo7 donde:

campo1) login del usuario campo2) password encriptado campo3) número UID (identificación de usuario) campo4) número GID (identificación de grupo) campo5) datos del usuario campo6) directorio de trabajo campo7) directorio del shell

Nota: Los usuarios tienen su número de usuario (UID), también tienen un número de grupo (GID). Cada usuario debe pertenecer a un grupo. Los grupos están numerados en el archivo /etc/group.

Como el archivo passwd es accesible por cualquier usuario, lo que siempre se hace es activar el shadow. ¿Recuerda, cuando instalamos que en una de las pantallas de instalación nos permitía habilitar MD5 y shadow?. Bueno, es el mismo shadow. Shadow quiere decir sombra en inglés, lo puedo asociar a ocultar o esconder. El archivo shadow también se encuentra dentro del directorio /etc, y a diferencia de passwd, éste no es visible para cualquier usuario. Compruébelo en su sistema logueándose como un usuario cualquiera y verá que no le da permiso de lectura. Este archivo no puede ser accedido por cualquier usuario, sólo el superusuario o root tiene permiso de acceder a él. Veamos como es este caso, en donde el archivo de passwords está protegido con el archivo shadow. El archivo shadow es el que contiene las contraseñas encriptadas, y el archivo passwd, en el campo que antes guardaba las contraseñas, ahora tiene una X, significando esto que, este usuario tiene una contraseña, es una marca. La contraseña no está aquí.



Ejemplo ale:heJuwMrBVa6mg:11750:0:99999:7:-1:-1:134529868

Esta es una línea del archivo shadow. Vamos a ver ahora el significado de cada campo.

campo1) Nombre de usuario campo2) Contraseña encriptada campo3) Cantidad de días desde el 1/1/1970 que se habilitó la contraseña campo4) Cantidad de días antes de cambiar la contraseña campo5) Cantidad de días después, que se debe cambiar la contraseña campo6) Cantidad de días antes de que expire la contraseña, y avisa al usuario campo7) Cantidad de días después de que expire la contraseña, y se inhabilita la cuenta. campo8) Cantidad de días después, desde 1/1/1970, que la cuenta está deshabilitada. campo9) Campo reservado

Nota: Los campos que contienen un –1, significa, que la cantidad de días es infinita.

Crear Usuarios El comando para agregar un usuario es:

useradd [opciones] <NombreUsuario> useradd NombreUsuario

Esta es la forma más simple del comando useradd. Como la mayoría de los comandos en Linux, se puede usar con varios identificadores, las opciones más usuales del comando useradd son:

-c comentario para especificar un comentario para la nueva cuenta.

-d directoriodeusuario para establecer el directorio de trabajo del usuario. Es conveniente, a fin de tener un sistema bien organizado, que este se localice dentro del directorio /home.

-e fechaexpiracion para establecer la fecha de expiración de la cuenta de usuario. Esta debe ingresarse en el siguiente formato: AAAA-MM-DD.

-g grupoinicial para establecer el grupo inicial al que pertenecerá el usuario. De forma predeterminada se establece como único grupo. Nota: El grupo asignado ya debe existir.

-G grupo1,grupo2 para establecer grupos extra a los que pertenecerá el usuario. Se deben separar utilizando una coma y sin espacios. Esto es muy conveniente cuando se desea que el usuario tenga acceso a determinados recursos del sistema, como acceso a la unidad de disquetes, administración de cuentas PPP y POP. Nota: los grupos asignados deben existir.

-m para especificar que el directorio de trabajo del usuario debe ser creado , y dentro se copiarán los archivos especificados en /etc/skel. Para cambiar esto, hay que completar la opción -m con –k <nuevodirskel> donde nuevodirskel es la carpeta de la cual se sacarán los perfiles de usuario.

-s shell Se utiliza para establecer la shell que podrá utilizar el usuario. De forma predeterminada, se establece bash como shell predeterminado.

-u uid Se utiliza para establecer el UID, es decir, la ID del usuario, el número de identificación de usuario. Este debe ser único. Cuando se crea una cuenta de usuario por primera vez, generalmente se asignará 500 como UID del usuario. Los UID entre 0 y 99 son reservados para las cuentas de los servicios del sistema.



Ejemplo: # useradd -u 500 -d /home/alexa -G floppy,pppusers,popusers alexa Nota: No crea el directorio de usuario /home/alexa . Debe existir con anterioridad

Esto creará una cuenta de usuario llamada alexa, que se encuentra incluida en los grupos floppy, pppusers y popusers, que tendrá un UID=500 y tendrá un directorio de trabajo en /home/alexa. Otro ejemplo:

# useradd -m –s /bin/bash jjlopez

Aquí crearé un usuario jjlopez con su directorio de usuario /home/jjlopez y usará bash como shell. Existen más opciones y comentarios adicionales para el comando useradd, estas se encuentran especificadas en los manuales, las páginas man. Para acceder a esta información, utilice el comando man useradd.

Nota: Este comando lo usa solamente root. En el caso de saltar todas estas opciones, useradd va a tomar las opciones por default desde un archivo: /etc/default/useradd en caso de Redhat /etc/adduser.conf en caso de Debian

Nota: En Debian nos conviene usar el comando interactivo adduser para crear usuarios. Otra forma de crear usuarios es directamente, agregar la entrada en /etc/passwd. Edite este archivo y agréguelo a mano. Tenga cuidado, no repita un nombre de usuario. Los nombres de usuario y UID deben ser únicos. Se debe especificar el GID, nombre completo y resto de información. Se debe crear el directorio inicial (/home/usuario, por ejemplo), y poner los permisos en el directorio para que el usuario sea el dueño. Se deben suministrar archivos de comandos de inicialización en el nuevo directorio y se debe hacer alguna otra configuración del sistema (por ejemplo, preparar un buzón para el correo electrónico entrante para el nuevo usuario en /var/spool/mail). Todo esto es lo que hace el comando useradd o adduser dependiendo del software que esté instalado. El programa /usr/sbin/useradd usa una serie de valores por defecto. Los leerá del archivo /etc/default/useradd, si este existe. Si no existe, entonces utiliza algunos valores internos por defecto, que pueden verse ejecutando /usr/sbin/useradd -D. Vamos a ver que contiene el archivo /etc/default/useradd: GROUP=100 Grupo de usuario cuando se utilice useradd -n. Sino en RedHat®, el número 100

significa que se creará un GID igual al UID, si no se indica lo contrario. HOME=/home Donde se guardarán los directorios de todos los usuarios INACTIVE=-1 Número de días a los cuales se volverá inactiva la cuenta del usuario, contadas a partir del

día del desactivamiento EXPIRE= Día en el que será desactivada la cuenta SHELL=/bin/bash El shell por defecto para el usuario SKEL=/etc/skel Lugar de donde se deben copiar archivos al nuevo directorio del usuario Ejemplo:

# cat /etc/default/useradd GROUP=100 HOME=/home INACTIVE=-1 EXPIRE= SHELL=/bin/bash SKEL=/etc/skel

Si estas opciones no son de nuestro agrado debemos cambiarlas por los valores que consideremos oportunos. Si por ejemplo preferimos que el grupo por defecto sea el 100, que el password expire a fin de año, no queremos bloquear una cuenta debido a que haya expirado el password y deseamos como shell por defecto /bin/bash, utilizaríamos la siguiente orden:

# useradd -D -g100 –e2006-12-31 -f0 -s/bin/bash



Estos valores serán almacenados por defecto en el fichero /etc/default/useradd. Nota: El archivo /etc/default/useradd se puede abrir con un editor de texto y corregirlo, en vez de usar el comando anterior.

Entonces, si ahora creo un usuario de esta forma:

# useradd -m -c "Usuario Invitado" invitado Esto creará una entrada en el fichero /etc/passwd con el siguiente formato:

invitado:x:505:100:Usuario Invitado:/home/invitado:/bin/bash Pero también creará una entrada en el fichero /etc/shadow con el siguiente formato:

invitado:!:0:0:60:0:0:0:0 Además se creará el directorio de usuario (home directory) y los contenidos de /etc/skel serán copiados en él. Como no especifiqué un UID para el usuario, el sistema asumirá el siguiente que tenga disponible. La cuenta del usuario invitado ha sido creada, pero todavía no está disponible ya que no se le ha definido una contraseña. Para establecer la contraseña hacemos lo siguiente:

# passwd invitado Changing password for user invitado New UNIX password: Retype new UNIX password: passwd: all authentication tokens updated successfully

Veamos un ejemplo de cambio de contraseña:

# passwd alexa Cambiará la clave de alexa. Solo root puede cambiar la clave de otro usuario de esta forma. Cada usuario puede cambiar su propia clave con passwd también.

Nota: ¡Cuidado! Si esta logueado como root, y al usar el comando passwd, se olvida de poner el nombre de usuario al que le desea cambiar la contraseña, lo que sucederá es cambiar su propia contraseña (la del usuario root).

El comando adduser que utilizamos en Debian, toma las opciones por defecto que están configuradas en el archivo /etc/adduser.conf. Veamos: # /etc/adduser.conf: `adduser' configuration. # See adduser(8) and adduser.conf(5) for full documentation. # The DSHELL variable specifies the default login shell on your # system. DSHELL=/bin/bash # The DHOME variable specifies the directory containing users' home # directories. DHOME=/home # If GROUPHOMES is "yes", then the home directories will be created as # /home/groupname/user. GROUPHOMES=no # If LETTERHOMES is "yes", then the created home directories will have # an extra directory - the first letter of the user name. For example: # /home/u/user. LETTERHOMES=no # The SKEL variable specifies the directory containing "skeletal" user # files; in other words, files such as a sample .profile that will be # copied to the new user's home directory when it is created. SKEL=/etc/skel # FIRST_SYSTEM_UID to LAST_SYSTEM_UID inclusive is the range for UIDs # for dynamically allocated administrative and system accounts.



FIRST_SYSTEM_UID=100 LAST_SYSTEM_UID=999 # FIRST_UID to LAST_UID inclusive is the range of UIDs of dynamically # allocated user accounts. FIRST_UID=1000 LAST_UID=29999 # The USERGROUPS variable can be either "yes" or "no". If "yes" each # created user will be given their own group to use as a default, and # their home directories will be g+s. If "no", each created user will # be placed in the group whose gid is USERS_GID (see below). USERGROUPS=no # If USERGROUPS is "no", then USERS_GID should be the GID of the group # `users' (or the equivalent group) on your system. USERS_GID=100 # If QUOTAUSER is set, a default quota will be set from that user with # `edquota -p QUOTAUSER newuser' QUOTAUSER="alexa" Otros archivos importantes para la administración de usuarios Cuando se agrega un usuario o grupo con los comandos useradd o groupadd respectivamente, el contenido de los siguientes archivos es de interés.

Nota: Ya vimos el comando useradd. No se preocupe por groupadd, lo veremos después. /etc/skel es un directorio, contiene todos los archivos (ejemplo: .bashrc, .kde) u otros que serán colocados en el directorio de un usuario (home directory) al generar al usuario. El directorio /etc/skel es bastante simple de configurar y usar. Proporciona una forma de estar seguro de que todos los nuevos usuarios del sistema tienen la misma configuración inicial. El directorio /etc/skel es usado por el programa /usr/sbin/useradd. Para empezar, creamos un directorio /etc/skel. La mejor forma de hacerlo es como usuario root. Después copiamos en /etc/skel aquellos archivos que queremos que cada nuevo usuario tenga en su directorio home. Por ejemplo, .bash_profile, .bashrc, .bash_logout, dircolors, .inputrc, y .vimrc. /etc/default/useradd ya lo explicamos en párrafos anteriores. /etc/login.defs (si se utilizan shadow passwords) especifica varios parámetros en la configuración del proceso de entrada al sistema (login), o “logueo”. Entre las opciones que podemos configurar en este archivo están: permisos de los usuarios para cambiar su información de usuario, temas relativos a la expiración de passwords, consolas desde la que se permite login como root, en que archivo se fijan diversas variables de entorno, valor inicial para el PATH (ruta de búsqueda de archivos), carácter de borrado, registro de entradas correctas e intentos de entrada incorrectas, tiempo de espera tras cada login fallido, etc. Suele venir bien comentado y con valores que no requieren cambios, pero es bueno darle una mirada al menos para estar al tanto de estos valores. Aquí tenemos un ejemplo de este archivo:

# *REQUIRED* # Directory where mailboxes reside, _or_ name of file, relative to the # home directory. If you _do_ define both, MAIL_DIR takes precedence. # QMAIL_DIR is for Qmail # #QMAIL_DIR Maildir MAIL_DIR /var/spool/mail #MAIL_FILE .mail # Password aging controls: # # PASS_MAX_DAYS Maximum number of days a password may be used. # PASS_MIN_DAYS Minimum number of days allowed between password changes. # PASS_MIN_LEN Minimum acceptable password length. # PASS_WARN_AGE Number of days warning given before a password expires.



# PASS_MAX_DAYS 99999 PASS_MIN_DAYS 0 PASS_MIN_LEN 5 PASS_WARN_AGE 7 # # Min/max values for automatic uid selection in useradd # UID_MIN 500 UID_MAX 60000 # # Min/max values for automatic gid selection in groupadd # GID_MIN 500 GID_MAX 60000 # If defined, this command is run when removing a user. # It should remove any at/cron/print jobs etc. owned by # the user to be removed (passed as the first argument). # #USERDEL_CMD /usr/sbin/userdel_local # # If useradd should create home directories for users by default # On RH systems, we do. This option is ORed with the -m flag on # useradd command line. # CREATE_HOME yes

Nota: Existe la página man de este archivo. Podemos consultarlo con el comando man login.defs.

Borrar usuarios De forma parecida, borrar usuarios puede hacerse con los comandos userdel o deluser dependiendo de que software fuera instalado en el sistema. Para eliminar un usuario del sistema, debe ingresar:

userdel [opciones] nombreUsuario Un Ejemplo:

# userdel ale (Siendo ale el usuario que deseo eliminar.) Este comando, al igual que la mayoría de los comandos Linux, soporta varias opciones. Si lo uso así, sin ningún identificador, elimina al usuario del archivo /etc/passwd y también de /etc/shadow y /etc/group. A partir de ese momento el usuario en cuestión ya no puede loguearse, es decir, que ya no puede entrar al sistema. El usuario desaparece del sistema, pero no desaparecen su directorio de usuario ni su buzón de mensajes. Si quiero que un usuario se vaya con todo su bagaje, debo usar:

# userdel -r ale Si se desea "deshabilitar" temporalmente un usuario para que no se conecte al sistema (sin borrar la cuenta del usuario), se puede prefijar con un asterisco ("*") el campo de la clave en /etc/passwd. Por ejemplo, cambiando la linea de /etc/passwd correspondiente al usuario ale:

ale:*Xv8Q981g71oKK:102:100:Alejandra Garcia:/home/ale:/bin/bash Esto evitará que ale se conecte. Modificar atributos de usuario Para modificar la información asociada con un usuario se utiliza el comando usermod. Su sintaxis es similar a la del comando useradd. Por ejemplo si quisiéramos cambiar el intérprete de comandos del usuario agarcia, deberíamos utilizar algo como esto:

# usermod -s /bin/csh agarcia El único cambio que se produciría en el archivo /etc/passwd, sería en su último campo, el relativo a la shell. Si nuestra intención fuera modificar la fecha de expiración de la cuenta al día 9/12/2003 emplearíamos el siguiente comando:

# usermod -e 12/09/2003 agarcia



Nota: El formato de la fecha es MM/DD/YYYY

En este caso el único fichero modificado sería el /etc/shadow. Cambio de UID del usuario

# usermod -u UID usuario Cambio el default GID de cierto usuario .También podría poner un nombre de grupo.

# usermod -g GID usuario Otros comandos de usuario id: Muestra el nombre y grupo del usuario en números (el UID y GID) y a que grupos pertenecen.

id [opciones] [usuario] Opciones:

-u Muestra solo el número de usuario. -g Muestra solo el número de grupo. -G Muestra solo los grupos al que pertenece ese usuario. [usuario] es para ver la información de cierto usuario.

su: Sirve para loguearse como otro usuario.

su [opciones] [usuario] Opciones:

- Obtiene un login de ese usuario. Es igual que poner -l o -login. -c Pasa un comando al shell con el usuario especificado.

Nota: Restrinja los permisos de /bin/login y /bin/su. Vea más adelante para la explicación de por qué.

Aquí vemos un ejemplo de cómo debe hacerse. Antes de restringir su a un grupo privilegiado, primero debe crear ese grupo con groupadd. Por ejemplo, "redes" es el nombre de grupo que voy a utilizar. Asegúrese de añadir a su usuario o a cualquier usuario privilegiado al grupo "redes" creado. Ejecute los siguientes comandos:

chmod 0700 /bin/login chgrp redes /bin/su chmod o-rx /bin/su

Grupos El objetivo de los grupos es dar o restringir permisos sobre algunos archivos a ciertos usuarios (vea la siguiente sección sobre Permisos en Unix). Por ejemplo un archivo apunte.txt que pertenezca al grupo profesores, que tenga permiso de lectura para el grupo y no para otros usuarios, podrá ser leído únicamente por el dueño y por usuarios que pertenezcan al grupo profesores. Cada usuario tiene un grupo principal (puede especificarse durante la creación con la opción GID, -g nombregrupo de useradd), puede pertenecer a diversos grupos y si conoce la clave de algún grupo con clave puede volverse miembro durante una sesión. Los programas relacionados con grupos son:

groupadd Para agregar un grupo groupdel Para borrar un grupo groupmod Para modificar un grupo groupmod –n Cambiar el nombre de un Grupo groupmod –g Cambiar el nombre de un GID groups Un usuario puede ver los grupos a los que pertenece con este programa newgrp Para cambiarme a otro grupo (al que debo pertenecer, por supuesto)

Cuando un usuario pertenece a más de un grupo, al entrar el sistema siempre será asignado al que aparece en el archivo /etc/passwd y para poderse cambiar a otro tendrá que hacerlo con el comando: newgrp otro_grupo donde otro_grupo es otro de los grupos a los que pertenece. El archivo /etc/group es el que contiene información acerca de los grupos. El formato de cada línea es:

nombre_de_grupo:clave:GID:otros miembros El campo clave es la clave del grupo transformada con DES o MD5. Si el grupo tiene clave shadow en este archivo aparecerá el carácter 'x' y la clave transformada estará en otro archivo (por defecto /etc/gshadow).



Algunos ejemplos de grupos pueden ser: root:*:0: usuarios:*:100:alexa,pepe,cor invitados:*:200: otros:*:250:sauron

El primer grupo, root, es un grupo especial del sistema reservado para la cuenta root. El siguiente grupo, usuarios, es para usuarios normales. Tiene un GID de 100. Los usuarios alexa, pepe y cor tienen acceso a este grupo. Recuerde que en /etc/passwd cada usuario tiene un GID por defecto. Sin embargo, los usuarios pueden pertenecer a más de un grupo, añadiendo sus nombres de usuario a otras líneas de grupo en /etc/group. El comando groups lista a qué grupos se tiene acceso. El tercer grupo, invitados, es para usuarios invitados, y otros es para "otros" usuarios. El usuario sauron tiene acceso a este grupo. Como se puede ver, el campo clave de /etc/group raramente se utiliza. A veces se utiliza para dar una clave para acceder a un grupo. Pocas veces esto es necesario. Para evitar que los usuarios cambien a grupos privilegiados (con el comando newgrp), se pone el campo de la clave a "*". No es recomendable editar directamente estos archivos, sino más bien emplear los programas presentados en esta sección. Como hemos citado anteriormente, cada usuario pertenece a uno o más grupos. La única importancia real de las relaciones de grupo es la perteneciente a los permisos de archivos. Cada archivo tiene un grupo propietario y un conjunto de permisos de grupo que define de que forma pueden acceder al archivo los usuarios del grupo. Hay varios grupos definidos en el sistema, como pueden ser bin, mail, y sys. Los usuarios no deben pertenecer a ninguno de estos grupos; se utilizan para permisos de archivos del sistema. En su lugar, los usuarios deben pertenecer a un grupo individual, como usuarios. Si quiere ser detallista, se pueden mantener varios grupos de usuarios como por ejemplo estudiantes, soporte y facultad. Se pueden usar los comandos addgroup o groupadd para añadir grupos a su sistema. Normalmente es más sencillo añadir líneas a /etc/group uno mismo, puesto que no se necesitan mas configuraciones para añadir un grupo. Para borrar un grupo, solo hay que borrar su entrada de /etc/group.

Nota: Verifique que en el archivo /etc/passwd no haya usuarios perteneciendo a ese grupo que va a eliminar.

Ejemplo: contable::101:cguerra,jpaz personal::102:agarcia,jpaz

Aquí, se han creado los grupos contable, con identificador de grupo 101 y personal, con GID 102. Los miembros del grupo personal son los usuarios agarcia y jpaz, si por alguna razón quiere integrar otro usuario en cualquier grupo, solo agregue una coma después del último miembro y escriba el nombre_de_usuario que le corresponda. Es conveniente indicar que si en el sistema de archivos se encuentra un directorio como:

drwxrwx--- 2 root personal 1024 Abr 29 11:32 confidencial/ entonces sólo: root, agarcia y jpaz tendrán acceso a él.



Permisos Haga un listado largo de cualquier directorio y vera algo como lo siguiente:

[alexa@linux]$ ls -la total 13 drwxr-sr-x 2 alexa user 1024 May 2 09:04 . drwxrwsr-x 4 root staff 1024 Apr 17 21:08 .. -rw------- 1 alexa user 2541 May 2 22:04 .bash_history -rw-r--r-- 1 alexa user 164 Apr 23 14:57 .bash_profile -rw-r--r-- 1 alexa user 55 Apr 23 14:44 .bashrc -rwxrwxr-x 1 alexa user 0 Apr 14 19:29 a.out -rwxrwxr-x 1 alexa user 40 Apr 30 12:14 hola.pl -r-------- 1 alexa user 64 Apr 29 14:04 hola -rwxrw-r-- 1 alexa user 902 Apr 29 13:57 prueba -rw-rw-r-- 1 alexa user 50 Apr 30 12:31 probador -rwxrwxr-x 1 alexa user 175 Apr 30 12:30 prue.sh -rwxrwxr-x 1 alexa user 56 Apr 23 15:08 quetal.sh

Como se puede apreciar en este listado, también están el directorio actual, representado por un punto "." y el directorio padre representado por dos puntos "..". Ellos también poseen permisos y atributos que son mostrados. El primer campo que aparece en el listado es la máscara de permisos. Vamos a explicar qué significa esta máscara de 10 bits.

Esta máscara de 10 dígitos la puedo dividir en partes para entender mejor. Veamos unas tablas que nos esclarecerán un poco mas que significa cada uno de estos caracteres. Primero vamos a ver aquellos caracteres que podrían aparecer en el primer bit, que en el ejemplo anterior podemos ver que es un guión, esto nos indica que es un archivo común. La tabla siguiente explica el significado del primer símbolo de acuerdo al tipo de archivo:

Los siguientes 9 bits se toman en grupos de tres y cada grupo pertenece a una clase de permisos. Nos quedan tres grupos, entonces.

Primer grupo usuario dueño al que pertenece el archivo/directorio (u) Segundo grupo grupo al que pertenece dicho archivo/directorio (g) Tercer grupo todos los demás usuarios del sistema (o)



Los 3 tipos de permisos, tienen una correspondencia numérica. r (en octal 4) lee (read) archivo o directorio w (en octal 2) modifica/borra (write) archivo o directorio x (en octal 1) ejecuta (execute) archivo o busca el directorio

El dueño de un archivo controla que usuarios tienen permiso de acceso y de que manera pueden hacerlo; el comando ls -l despliega los permisos de acceso asociados a un archivo, el primer campo de 10 caracteres describe los permisos asociados con ese archivo, un campo típico se ilustra a continuación :

-rwxrw-r-- 1 alexa user 902 Apr 29 13:57 prueba El primer símbolo nos esta indicando que el archivo es un archivo común, generalmente de texto. El primer grupo de tres símbolos representa los permisos para el dueño del archivo (owner) que en este caso posee permisos de lectura, escritura y ejecución. El segundo grupo de tres símbolos representa los permisos para el grupo al cual pertenece el archivo (group), que en este caso tienen permisos de lectura y escritura. El tercer grupo de tres símbolos representa los permisos para todo el resto de los usuarios (other), en este caso es solo de lectura. El numero que sigue (1) representa el numero de punteros o inodos que el archivo posee. Esto representa la cantidad de enlaces que existen a este archivo y no interesa demasiado en este momento. A continuación está el nombre del dueño del archivo y del grupo al cual pertenece el archivo. El "902" representa el tamaño del archivo expresado en bytes. Lo siguiente es la fecha y hora de modificación del archivo e inmediatamente después está el nombre del mismo. Para comprender exactamente la máscara de permisos en formato numérico veamos la siguiente tabla, donde tenemos la correspondencia de cada permiso con la numeración en octal y en binario. Todo esto nos será útil cuando queramos cambiar atributos de un determinado archivo o directorio. Por ejemplo para sacar permisos de lectura a los usuarios en archivos de configuración de un servidor.

Octal Binario Número Número Permisos Descripción

0 000 --- Ningún permiso garantizado 1 001 --x Ejecutable 2 010 -w- Modificable 3 011 -wx Modificable/Ejecutable 4 100 r-- Legible 5 101 r-x Legible/Ejecutable 6 110 rw- Legible/Modificable 7 111 rwx Legible/Modificable/Ejecutable

Los permisos para estos 3 tipos de usuarios puede estar dado por una cadena de 9 caracteres. Veamos estos ejemplos:

Octal Dueño Grupo Otros Completo Número Columna Columna Columna Código 777 rwx rwx rwx rwxrwxrwx 755 rwx r-x r-x rwxr-xr-x 700 rwx --- --- rwx------ 666 rw- rw- rw- rw-rw-rw-

Veamos unos detalles más Permisos: Son bits que definen el acceso a un fichero o directorio. Los permisos para directorio tienen un

sentido diferente a los permisos para archivos. Más abajo se explican algunas diferencias. Lectura (r): Archivo: Poder acceder a los contenidos de un archivo

Directorio: Poder leer un directorio, ver qué ficheros contiene Escritura (w): Archivo: Poder modificar o añadir contenido a un archivo

Directorio: Poder borrar o mover ficheros en un directorio Ejecución(x): Archivo: Poder ejecutar un programa binario o guión de shell

Directorio: Poder entrar en un directorio

Nota: Tenga mucho cuidado con aquellos directorios que tengan permiso de escritura. Cualquiera podría borrar un archivo, aunque no sea de su propiedad y esto puede ser un riesgo, tanto para el sistema como para los datos de los usuarios.

Comando chmod Para cambiar la máscara de permisos de un archivo o directorio, usamos el comando chmod. La sintaxis de este comando es la siguiente:

chmod [permisos] archivo



[permisos] puede estar en formato numérico, o en formato alfabético. El formato numérico es el que ya vimos, los tres números en octal. El formato alfabético contiene los tipos de permisos en letras (r,w,x), en vez de números y tengo que especificar a quien o quienes se lo voy a aplicar (u,g,o). Sería así: con letras [ugo][+-=][rwx] con números [0-7][0-7][0-7] El método para cambiar un permiso con letras es el siguiente : Las letras u, g y o representan el Usuario, el Grupo, y Otros (todos los demás). El signo + significa que el permiso se va a conceder, mientras que el signo - significa que el permiso se va a revocar. El signo = significa que se instalen los permisos como se muestra a continuación, algunos ejemplos de cambio de permisos son:

$ chmod u+x,g-w,o-w archivo1 $ chmod u=rx archivo1

El segundo método interpreta el número puesto como su equivalente en binario (nueve dígitos binarios), activando el permiso donde se haya puesto un 1 y desactivándolo donde se haya puesto un 0; por ejemplo:

$ chmod 755 archivo1 Significa que a archivo1 se le asignaron permisos de la siguiente manera:

7 5 5 111 101 101 rwx r-x r-x

Nota: En caso de duda, consulte en las tablas vistas, la correspondencia entre números octales y binarios.

Ejercicio: Veamos la máscara de permisos de un archivo llamado estudio:

$ ls -l estudio -rw-rw-r-- 1 alexa alexa 57 May 5 16:47 estudio

El siguiente comando elimina todos los permisos de acceso para el grupo y el resto de usuarios:

$ chmod go-rw estudio $ ls -l estudio -rw------- 1 alexa alexa 57 May 5 16:47 estudio

El administrador puede cambiar los permisos de todos los archivos del sistema y puede fijar una política inicial para la máscara de permisos que todos los usuarios tendrán. Comando chgrp Además de chmod se emplean los siguientes programas para realizar estas labores:

chgrp grupo archivos Cambia el grupo de el o los archivos especificados. Por ejemplo:

# chgrp profesores notas* tps* cambiará todos los archivos con prefijos notas y tps al grupo profesores. Como opción puede recibir -R para aplicar el cambio recursivamente en un directorio (es decir a subdirectorios también). Este programa puede ser usado por cualquier usuario para cambiar el grupo de sus archivos a otro grupo al que el mismo usuario pertenezca. Comando chown Cambia el usuario (y opcionalmente el grupo) de los archivos especificados.

chown usuario[:grupo] archivos Al igual que chgrp con la opción -R efectúa el cambio recursivamente en subdirectorios. Por ejemplo

# chown -R ale:administra tpgnutella/ Pondrá al usuario ale como dueño de todos los archivos y subdirectorios del directorio tpgnutella, todos quedarán con el grupo administra. También puede usarse para cambiar el grupo de un archivo (si no se especifica el nombre del usuario). Además tenemos otros bits de permisos que no podemos pasar por alto cuando estamos tratando de temas de seguridad. Sticky bit El sticky bit tiene significado cuando se aplica a directorios. Si el sticky bit está activo en un directorio, un usuario sólo puede borrar archivos que son de su propiedad o para los que tiene permiso de escritura, incluso cuando tiene acceso de escritura al directorio. En un directorio evita que un usuario que no sea el dueño del directorio pero que tenga permiso de escritura, pueda borrar o renombrar archivos que no le pertenecen.



Esto está pensado para directorios como /tmp, que tienen permiso de escritura global, pero no es deseable permitir a cualquier usuario borrar los archivos que quiera. El sticky bit aparece como 't' en los listados largos de directorios. O sea cuando se hace un ls –l veremos:

drwxrwxrwt 19 root root 8192 Jun 20 11:40 tmp Atributo SUID: (Para Archivos) Este bit describe permisos al usuario del archivo. Cuando el atributo SUID (poner id de usuario) está activo en los permisos del propietario, y ese archivo es ejecutable, los procesos que lo ejecutan obtienen acceso a los recursos del sistema basados en el usuario que crea el proceso (no el usuario que lo lanza). Resumiendo esta explicación, podemos decir: el bit SUID empleado con archivos ejecutables cambia la identificación del usuario por la del dueño del archivo. Por ejemplo: /usr/bin/passwd es un ejecutable propiedad de root y con el bit SUID activo. ¿Por qué? Este programa lo puede usar cualquier usuario para modificar su clave de acceso, que se almacena en

-rw-r--r-- 1 root root 1265 Jun 29 19:41 /etc/passwd pero según los permisos que vemos en este archivo, sólo root puede escribir y modificarlo. Entonces sería imposible que cualquier usuario pudiera cambiar su clave si no puede modificar este archivo. La solución para este problema consiste en activar el bit SUID para este archivo:

-r-s--x--x 1 root root 10704 Apr 19 13:15 /usr/bin/passwd Entonces, cuando se ejecute, el proceso generado por él es un proceso propiedad de root con todos los privilegios que ello acarrea. Esto puede ser un riesgo para la seguridad. Por tal razón debemos prestar atención, ya que en este tipo de programas se pueden producir buffer overflow, que comprometan el sistema. Este permiso puede ser útil para que usuarios normales ejecuten programas que requieren ser ejecutados por root y por lo mismo debe usarse con precaución. Con chmod se modifica empleando u y s. Por Ejemplo:

$ chmod u+s cvs Esto indica que cuando el programa cvs se ejecute, debe cambiarse la identificación por la del dueño de ese programa. Consejos:

• Asignar el bit SUID solo cuando sea estrictamente necesario. • Comprobar que los programas con este bit activo no tiene ningún desbordamiento de buffer (conocido). • Jamás asignarlo si el programa permite salir a la shell.

Atributo SGID: (Para archivos) Si está activo en los permisos de grupo, este bit controla el estado de "poner id de grupo" de un archivo. Trabaja como SUID, pero, en vez de aplicarse al usuario, se aplica al grupo. El archivo tiene que ser ejecutable para que esto tenga algún efecto. Se establece con g y s. Por Ejemplo

$ chmod g+s cvs Atributo SGID: (Para directorios) Si activa el bit SGID en un directorio, los archivos creados en ese directorio tendrán puesto su grupo como el grupo del directorio. Los ficheros de configuración del sistema (normalmente en /etc) es habitual que tengan el modo 640 (-rw-r-----), y que sean propiedad de root. Dependiendo de los requisitos de seguridad del sistema, esto se puede modificar. Nunca deje un fichero del sistema con permiso de escritura para un grupo o para otros. Algunos ficheros de configuración, incluyendo /etc/shadow, sólo deberían tener permiso de lectura para root, y los directorios de /etc no deberían ser accesibles, al menos por otros. SUID Shell Scripts Los scripts de shell SUID son un serio riesgo de seguridad, y por esta razón el núcleo no los acepta. Sin importar lo seguro que piense que es su script de shell, puede ser utilizado para que un cracker pueda obtener acceso a una shell de root.



Capítulo 3

El Sistema Operativo Linux/Unix El Sistema Operativo es un conjunto de programas, cuyo objetivo final es ofrecer una interfaz entre el hardware y los usuarios, de forma que el usuario no necesite conocer las peculiaridades de utilización de las diferentes componentes del hardware. Su tarea consiste principalmente en gestionar los recursos del sistema informático (memoria, procesador, dispositivos de entrada/salida, etc.). Además de los programas propios del Sistema Operativo, uno de los programas de aplicación más importantes es el intérprete de comandos ó shell, puesto que hace las funciones de intermediario entre el usuario y el Sistema Operativo. La shell se encarga de leer, interpretar y ejecutar las órdenes de los usuarios. Por lo tanto conociendo el conjunto de comandos que sabe interpretar la shell es posible acceder a todas las prestaciones que ofrece el sistema. Linux (así como UNIX) es un sistema que soporta la multitarea esto significa que puede haber varios programas ejecutándose simultáneamente, y multithreading (varios hilos de ejecución por programa). Además es un sistema interactivo, lo que proporciona una comunicación directa entre el usuario y el sistema (el intermediario será la shell) y multiusuario, lo que permite que varios usuarios trabajen simultáneamente. También permite que un mismo usuario trabaje en varias consolas a la vez. En este capítulo veremos los comandos más generales y útiles en lo que respecta a la administración del sistema, los comandos elementales para la gestión de archivos y otros comandos generales.

Nota: Los comandos son programas. ¿Qué son las consolas virtuales? Las consolas virtuales aparecieron por primera vez en minix y en FreeBSD, proveen acceso a multiple login sessions, lo que significa que varios usuarios pueden loguearse en el sistema y cada uno de ellos pueden ejecutar diversas tareas a la vez. Con Alt + alguna de las teclas F1, F2, F3, etc. nos cambiamos a otra virtual terminal. Normalmente hay un máximo de 6 virtual terminals disponibles. Linux permite trabajar al mismo tiempo en varias consolas de texto. Para pasar de una a otra, pulse Alt + Fn donde n es el número de la ventana virtual y Fn una tecla de función (por ejemplo F1, F2, etc.). Puede configurar el número de ventanas en el archivo /etc/inittab. Si está usando X-Windows, la parte gráfica , con la combinación de teclas: Ctrl + Alt + Fn vuelve a la consola de texto. Para regresar a X-Windows use Alt+F7, accediendo así a la consola empleada (la primera libre, es decir no manejada por un getty). Por ejemplo, si tiene 6 consolas virtuales (de Alt+F1 hasta Alt+F6), con Alt+F7, volveremos al modo gráfico.

Sistema de archivos (filesystems) El Sistema Operativo proporciona un punto de vista lógico y uniforme de almacenamiento de la información. El Sistema Operativo hace abstracción de las propiedades físicas para definir una unidad de almacenamiento lógico, el fichero o archivo. Y es el propio Sistema Operativo quién se encarga de la relación entre ficheros y dispositivos físicos. Archivos y directorios Un archivo es una colección de información definida por su creador, relacionada y agrupada bajo un nombre común. Todo el trabajo que hacemos está almacenado en archivos y éstos pueden representar programas, textos, datos, etc. Para elegir un nombre de archivo normalmente se utiliza una secuencia de caracteres alfanuméricos (letras y dígitos), un punto “.” y otra secuencia de letras (extensión) que representa el tipo de fichero. Por ejemplo: pract1.p, donde la extensión p indica que es un programa en Pascal. Hay que evitar utilizar caracteres en los nombres de fichero que tengan un significado especial para el intérprete de comandos (la shell), por ejemplo "/", "#", "$", etc. El sistema operativo ofrece la posibilidad de organizar los archivos en directorios. Básicamente un directorio es un contenedor de un grupo de archivos. Además de archivos los directorios pueden a su vez contener otros directorios, que a vez pueden contener otros y así sucesivamente.



Así es como se va armando el árbol de directorios, la jerarquía que conforma al sistema, o lo que podríamos llamar filesystem. La estructura de directorios jerárquica en forma de árbol, ya la nombramos en el Capítulo 1. Ya dijimos también que el árbol se va formando debido a que cada directorio puede bifurcar hacia otros directorios y archivos.

/

bin etc usr

//

dev practicas tmp

Cuando un usuario accede al sistema se ubica automáticamente en su propio directorio, que se denomina directorio de trabajo o home directory. A través de los comandos adecuados se puede desplazar hacia arriba o hacia abajo en el árbol de directorios, modificando el directorio actual. En Linux puedo especificar nombres de archivos incluyendo los nombres de los directorios donde están ubicados, es decir, todo el camino (o path). Generalmente, se denomina pathname, porque representa una lista del camino a lo largo del árbol de directorios que hay que seguir desde la raíz hasta llegar al archivo o directorio. El sistema de archivos comienza por la raíz (/), y los nombres de directorios y ficheros en un camino se separan por slashes (/). Por ejemplo el nombre del camino desde la raíz para el archivo ejem.p, sería el siguiente:

usuario1

/

bin

dev

etc usr

tmppracticas

ad1 ad2 ad3

usuario2 …

practica1ejem.p datos

usuarioN…

pract.p

4

1

2

5

3

6

/practicas/ad1/usuario1/ejem.p

Nota: Pese a que el nombre de un archivo o directorio lo identifica unívocamente, es posible tener nombres iguales siempre que su nombre de camino desde la raíz sea diferente.



No siempre es necesario especificar pathnames completos para hacer referencia a archivos, se puede indicar el camino relativo a partir del directorio actual o el inmediatamente superior al actual:

Si el pathname empieza por "/" se parte del directorio raíz Si el pathname empieza sin "/" se parte del directorio en que estemos en ese instante

Con "." se indica el directorio actual Con ".." se indica el directorio inmediatamente superior al actual.

Ciertos caracteres del pathname son interpretados por la shell de una forma especial:

* equivale a cualquier cadena de caracteres. ? equivale a un carácter cualquiera. [ ] indica uno de entre un conjunto de posibles caracteres.

Ejemplo: suponga que tenemos un directorio con los siguientes archivos: tp1.c, tp2.c, tp3.c, tp4.c, tp1.o, tp2.o, tp3.o, gdb.

tp* indicaría cualquier fichero salvo gdb * indicaría cualquier fichero tp?.c indicaría los ficheros tp1.c, tp2.c, tp3.c y tp4.c tp1.? indicaría tp1.c y tp1.o ??? indicaría gdb (es el único compuesto de 3 caracteres) ????? indicaría cualquiera excepto gdb (el resto tiene 5 caracteres) tp[123].c indicaría tp1.c, tp2.c y tp3.c tp[14].c indicaría tp1.c y tp4.c tp[1-3].c indicaría tp1.c, tp2.c y tp3.c tp[1-4].c indicaría tp1.c, tp2.c, tp3.c y tp4.c

En el caso que se permita el acceso de múltiples usuarios a los archivos, sería deseable controlar quién y en que forma puede acceder a los mismos. Para ello LINUX asocia a cada archivo y directorio permisos de lectura, escritura y ejecución.

Nota: El tema de permisos de archivos y directorios está incluido en el capítulo Administración de usuarios.

Tipos de archivos y directorios Bajo GNU/Linux (y en Unix), cualquier cosa se abstrae en forma de un archivo. Veamos de qué tipo pueden ser. Archivos normales (files) Los archivos contienen datos o son ejecutables, y el sistema operativo no hace suposiciones sobre su contenido. Ejemplo: los archivos de configuración del sistema, archivos de texto. Directorios (directory) Los archivos directorios son una instancia especial de los archivos normales. Los directorios listan las localizaciones de otros archivos, algunos de los cuales pueden ser otros directorios. En párrafos anteriores encontrará una descripción más completa. Enlaces duros (hard-links) Cada archivo en el sistema de archivos de GNU/Linux tiene su propio i-nodo. Un i-nodo guarda los atributos del archivo y su posición en el disco. Si necesita referirse a un archivo usando dos nombres de archivos distintos, puede crear un enlace duro. El enlace duro tendrá el mismo i-nodo que el archivo original y guarda el mismo aspecto y comportamiento que el original. Con cada enlace duro creado, se incrementa la cuenta de referencia. Cuando se borra un enlace duro, se decrementa la cuenta de referencia. Hasta que la cuenta de referencia no alcanza a cero, el archivo permanece en el disco.

Nota: un enlace duro no puede existir entre dos archivos de particiones separadas. Esto es debido a que el enlace duro se refiere al archivo original por i-nodo y el i-nodo de un archivo difiere entre sistemas de archivos.



Enlace simbólicos (soft-links) A diferencia de los enlaces duros, que apuntan a un archivo por su i-nodo, un enlace simbólico apunta a otro archivo por su nombre. Esto permite que los enlaces simbólicos apunten a archivos localizados en otras particiones, discos, incluso en otras unidades de red. Dispositivos de bloque (block devices) Se usan como interfaz con dispositivos tales como discos. Un archivo de dispositivo de bloque tiene tres características: el major number, el minor number y el carácter identificatorio de tipo de archivo, que es una b. Ejemplo:

# ls –l /dev/hda brw-rw---- 1 root disk 3 0 May 5 2006 /dev/hda

La b representa que es un dispositivo de bloques. El 3 representa al major number y el 0 al minor number. El major number de un archivo de dispositivo de bloque representa el controlador de dispositivo. Cuando se accede a este archivo, el minor number se pasa al controlador de dispositivo como parámetro que le dice a que dispositivo se accede. Por ejemplo, si hay dos puertos serie, compartirán el mismo controlador de dispositivo y de esta forma el mismo major number, pero cada puerto serie tendrá un minor number único. Dispositivos de carácter (carácter devices) Similares a los dispositivos de bloques, los dispositivos de caracteres son archivos especiales que le permiten acceder a dispositivos a través del sistema de archivos. La diferencia es que los dispositivos de bloques trabajan con grandes volúmenes (disco rígidos, etc.), en cambio los dispositivos de carácter trabajan a un carácter por vez (módem, terminales, etc.). Comienzan con la letra c. Tienen tanto un major number y un minor number. Ejemplo:

# ls –l /dev/ttyS0 crw------- 1 root tty 4 64 May 5 2006 /dev/ttyS0

Pipes con nombre (named pipes) Permiten comunicación interprocesos. Usando el comando mknod, puede crear un archivo de tipo pipe nombrado que puede abrir un proceso para lectura y otro para escribir, permitiendo a su vez que estos dos se comuniquen con un tercero. El primer carácter de los permisos de archivos es una p. Ejemplo:

# ls –l mi_pipe prw-r--r-- 1 root root May 5 2006 11:55 mi_pipe

Comandos de Linux Cuando entramos al sistema, luego de loguearnos, nos encontramos en nuestro directorio de trabajo por defecto. Si me logueé en el sistema como root, estaré en /root, si me logueé como pepe, voy a estar en /home/pepe. El home del usuario es el camino relativo o virtual, desde la raíz del árbol hasta nuestra ubicación actual, es decir el directorio actual. Si ejecutamos la instrucción pwd (print working directory) veremos como respuesta nuestro home. A partir de ese punto podemos movernos por el árbol de directorios. Comandos básicos para la gestión de archivos Cambio de directorio (change directory): cd [pathname] Hace que el directorio actual pase a ser el especificado en el pathname que se indica como parámetro. Ejemplos:

$ cd .. cambia al directorio inmediatamente superior $ cd /tmp se sitúa en el directorio tmp del nivel más alto, o sea el que cuelga de / $ cd practicas se sitúa en el directorio practicas, que está dentro del directorio actual. Preste

atención que no lleva “/”, por lo tanto seguimos en la misma rama del árbol, estamos bajando en la jerarquía del árbol.

Listado de un directorio (list): ls [opciones] [directorio ó ficheros] Es uno de los comandos más utilizados. Se usa para listar lo que contiene un directorio. Si ejecutamos ls sin argumentos obtendremos un listado de todos los archivos que contiene el directorio en que el usuario está posicionado.

Nota: Considere que un directorio es un tipo especial de archivo. Sus opciones más usadas son:



-a Nos muestra también los archivos ocultos (los que empiezan con .) -l Hace un listado más detallado, especificando para cada archivo sus permisos, el número de enlaces

rígidos ,el nombre del propietario, el nombre del grupo al que pertenece, el tamaño en bytes y la fecha de modificación. Para una explicación más detallada vea Administración de usuarios.

-F Coloca al lado de cada nombre listado un asterisco si es un archivo ejecutable (programa), o una barra si es un directorio.

Ejemplo: Haciendo un ls tendremos algo similar a lo siguiente:

$ ls Shell Shell.sgml

Si deseamos ver más información sobre los archivos, hacemos esto:

$ ls -la total 56 drwxr-sr-x 3 alexa alexa 4096 May 4 16:33 . drwxr-s--- 94 alexa alexa 8192 May 4 16:31 .. drwxr-sr-x 2 alexa alexa 4096 May 4 16:32 Shell -rw-r--r-- 1 alexa alexa 5888 May 4 16:31 Shell.sgml

En cambio, si hacemos esto:

$ ls -l Shell total 2 -rwxrw-r-x 1 alexa alexa 48 May 6 21:38 archivo1 -rwxrw-r-- 1 alexa alexa 156 May 6 21:40 archivo2

Copiar ficheros (copy): cp [opciones] arch_origen [o archivos_origen] destino Un usuario puede copiar un archivo si tiene permiso de lectura sobre ese archivo. El comando cp puede ser usado para copiar el contenido de un archivo a otro archivo. El arch_origen y destino no pueden ser el mismo, y si destino es un archivo, entonces su contenido es destruido. Es decir, lo que está en arch_origen se copia en destino. Si destino es un directorio, entonces los archivos_origen son copiados a ese directorio destino. El comando cp es no-destructivo, porque el archivo fuente nunca es alterado. Las opciones más comunes son:

-f borra los archivos de destino ya existentes sin preguntar al usuario. -p preserva permisos usuario y grupo del archivo a copiar. -R copia recursivamente.

Ejemplos:

$ cp programa.c otro.c el archivo otro.c pasa a tener el contenido de programa.c. El archivo programa.c no se modifica.

$ cp programa* .. copia todos los ficheros que empiecen por la secuencia de caracteres programa al directorio superior.

Renombrar y mover ficheros (move): mv [opciones] arch_origen arch_destino Este comando tiene dos funciones: mover archivos a otro lugar y/o cambiarles el nombre. Ejemplo:

$ mv arch1 arch2 Si arch2 no existe, equivale a renombrar arch1 como arch2. Si arch2 existe, destruye arch2 y arch1 pasa a llamarse arch2.

Sus opciones principales son: -f Borra los archivos de destino existentes sin preguntar al usuario. -i Lo contrario que -f. Pregunta al usuario.

Ejemplo: $ mv tp.txt tpnuevo.txt el archivo tp.txt pasa a llamarse tpnuevo.txt. Si ya existía un

archivo de nombre tpnuevo.txt, su contenido se pierde. $ mv tp.txt ../tp.txt traslada el archivo tp.txt al directorio situado encima del actual.

Eliminar un fichero (remove): rm [opciones] archivos(s) Este comando elimina el archivo (o los archivos) mandados como parámetro. Para que este comando funcione es necesario tener permiso de escritura y, por lo tanto, de borrado sobre los archivos. Ejemplo:



$ rm datos.jj elimina el archivo de nombre datos.jj. Las opciones más comunes son:

-f Fuerza el borrado de un archivo sin pedir confirmación. -i Forma interactiva, ahora sí pide confirmación para archivo o directorio a borrar. -r Borra los contenidos de directorios recursivamente. Esta opción se utiliza cuando quiero eliminar

un directorio que contiene información. Más adelante verá la forma de borrar un directorio con otro comando.

Ejemplo: $ rm webserver.c repetidor.c elimina los archivos webserver.c y repetidor.c $ rm -i webserver.c repetidor.c lo mismo, pero pide confirmación para el borrado.

Ver el contenido de archivos Los comandos que tenemos para mostrar contenido de archivos son: more, less y cat (del inglés concatenate: poner uno atrás del otro). Son visores de texto, no editores. Más adelante veremos el programa editor por excelencia, el vi. cat [opciones] [archivo1 [archivoN]] Vuelca en pantalla el contenido de uno o más ficheros de texto. Si hay más de un fichero, el resultado es la concatenación de los contenidos de cada uno de ellos. Si el fichero (o los ficheros) no existen, devuelve un mensaje de error. Si ningún archivo es proporcionado, o se encuentra el argumento - , cat lee de la entrada standard.

Nota: Se pueden desplegar varios archivos en el monitor uno después de otro separando los nombres de archivo por medio de un espacio.

Si el archivo tiene más líneas que una pantalla, ésta se recorrerá automáticamente hasta que se haya llegado al final del archivo, para ver el contenido de un archivo por páginas se puede utilizar el comando more. more archivo(s) Vuelca en pantalla el contenido de uno o más archivos, adecuando su presentación al número de líneas de la terminal. Si hay más de un archivo, el resultado es la representación concatenada de los contenidos de cada uno de ellos. Si el archivo no existe, devuelve un mensaje de error. Con el comando more podemos ver el contenido del archivo desde el comienzo de éste, y podemos ir bajando en el texto hasta el final. Pero si queremos volver el comienzo del archivo, no nos deja. En estos casos el comando adecuado es less. less archivo Aquí sí podemos recorrer el archivo completamente, de principio a fin, y del final al principio. Podemos scrollear el archivo.

Nota: Combinando las teclas Shift y Page-Up o Page-Down se utilizan para pasearse o navegar en la pantalla, o sea, subir y bajar la pantalla. Esto funciona también bajo xterm.

Consulta acerca del actual directorio (print working directory): pwd Indica en que directorio se encuentra el usuario en ese momento. Por ejemplo:

alexa@par:~/Seminario$ pwd /home/alexa/Seminario

Creación de un nuevo directorio (make directory): mkdir directorio Crea un directorio vacío con el nombre directorio Ejemplo:

$ mkdir dir1 $ ls tp.txt datos dir1 practica

Crea el directorio dir1 en el directorio actual (Para verlo hago el listado con ls). Eliminar un directorio (remove directory): rmdir directorio



Este comando es para eliminar el directorio de nombre directorio sólo si éste está ya vacío. Para borrar un directorio que contiene archivos en su interior, debe primero eliminar el contenido y luego usar rmdir para borrar el directorio. Otra forma es borrar el directorio con su contenido usando el comando rm con las opciones –rf. Creación de un archivo vacío: touch archivo Vimos como crear un directorio, con mkdir. Ahora, ¿Cómo se hace para crear un archivo, sin depender de un editor como el vi? Puede usar el comando touch para crear un archivo vacío. En realidad este programa tiene otras utilidades, por ejemplo para cambiar las fechas de acceso o modificación de un determinado archivo. Otros comandos Tenemos en GNU/Linux la posibilidad de concatenar comandos, de redireccionar la salida de un comando a otro, o a archivos. Esto se llama según las traducciones al español, plomería o fontanería, porque para muchas de estas tareas se utiliza el símbolo pipe, también llamado cañería o tubo. Los símbolos que se utilizan son “<”, “>”, “>>”, “|”, “;”, “ ` ` ” Redirección de E/S: < > >> A través de la redirección podemos tomar la salida de un programa y enviarla automáticamente a un archivo. Este proceso lo maneja la propia shell en lugar del programa. Hay tres formas de redirección: tomar de un archivo, devolver a un archivo o añadir al final de un archivo. Para recoger la salida de un programa en un archivo, finalice la línea del comando con el símbolo mayor (>) y el nombre del archivo en el cual quiere guardar la salida redirigida. También es posible desviar la salida de pantalla hacia un archivo cualquiera mediante los símbolos “>“ y “>>”. Ejemplos:

$ cat arch1 > arch2 vuelca el contenido de arch1, pero en lugar de hacerlo en pantalla, lo hace en arch2.

$ ls -l > prueba en lugar de mostrar por pantalla el listado "largo" del directorio actual, lo vuelca al archivo prueba. Si tuviera datos en el archivo prueba, me pisa con la nueva información.

$ ls -l >> prueba debe hacer esto si desea que la información nueva se agregue a lo que ya contiene el archivo prueba.

$ echo “Listado de Directorios y Archivos” >> prueba En este ejemplo agregaremos al archivo prueba el comentario Listado de Directorios y Archivos al final del archivo.

Veamos algunos ejemplos más: $ date > arch1 $ ls >> arch1

vuelca en arch1 la fecha actual (eso es lo que hace el comando date) y luego añade al final del fichero arch1 un listado del directorio actual.

$ cat arch1 arch2 > arch3

deja en arch3 el contenido de arch1 y arch2.

$ cat arch1 > arch3 $ cat arch2 >> arch3

es equivalente al ejemplo anterior. También es posible suministrar los datos de entrada de un programa desde un archivo, y no desde el teclado, mediante “<”. Ejemplo:

$ grep root < /etc/passwd Acá lo que hace es buscar en el archivo /etc/passwd si hay un usuario llamado root. (el comando grep se verá mas adelante)

$ ls > arch $ wc < arch

cuenta el número de palabras (wc por word count) que hay en arch, y lo que hay en arch no es más que el resultado de hacer ls.



Utilización de pipes: | Las pipes son un mecanismo por el cual la salida de un programa se puede enviar como entrada de otro programa. Los programas individuales se pueden encadenar juntos para convertirse en unas herramientas extremadamente potentes. Ejemplo:

$ cat /etc/passwd | less El comando cat nos muestra el contenido del archivo /etc/passwd. El archivo se nos va de pantalla, entonces si se lo enviamos a less, podremos navegar por todo el contenido del archivo.

Nota: Este pipe es muy útil para abrir archivos muy grandes.

$ ls -l | more

Aquí hacemos el listado de un directorio y para ir viéndolo pantalla a pantalla, envío la salida a more.

$ comando1 [argumento1] | comando2 [argumento2]

Esta línea genera el mismo resultado que la siguiente secuencia: $ comando1 [argumentos] > temporal $ comando2 [argumentos] < temporal $ rm temporal

Si quisiera concatenar comandos, de forma que no tenga que esperar el resultado de un comando para ejecutar el siguiente, lo que puede hacer es escribirlos todos, separándolos con el símbolo “punto y coma” (;). Ejemplo:

$ cd /etc ; ls –l Filtro de búsqueda grep expresión_a_buscar archivo El comando grep, que apareció anteriormente se usa como filtro de búsqueda. Este programa me devuelve la línea del archivo que contiene la cadena especificada. Ejemplo:

$ grep programacion materias busca las apariciones de la expresión programación en el archivo materias.

$ grep -n programación materias además de buscar esa expresión, la opción n (de numerado) indica el número de cada una de las líneas en que aparece en el archivo materias.

Apóstrofes de ejecución A veces necesitamos ejecutar algún comando que necesita de otro antes. Esto, sobre todo es muy útil cuando programe scripts. Veamos ejemplos para que se entienda mejor.

var1=`ps -ax | grep $1 | cut –c=1-5` En este ejemplo, si no pusiera todo lo que está del lado derecho de la igualdad, entre apóstrofes, el sistema daría error. Los apóstrofes lo que hacen, es encerrar la expresión, de forma que se ejecute completa, y luego lo asigna a la variable var1.

Veamos otro ejemplo: kill -9 `cat /var/run/gdm.pid`

En este caso, quiero matar una tarea (gdm). Pero el programa kill, para terminar una tarea necesita sí o sí el número de proceso (pid). Como no lo sé, lo que hago es decirle que lo saque del archivo gdm.pid. El comando cat me despliega el archivo. Este archivo solo contiene un número, que es lo que le llega a kill -9.

Runlevels ¿Cómo arranca Linux? Al prender la PC, lo primero que inicia es el BIOS. Todo lo que tiene que ver con reconocimiento de hardware. En el setup (BIOS), el sistema lee cual es el dispositivo o el orden de dispositivos donde va a buscar el arranque. Por ejemplo: cdrom, floppy, hard disk. Si arranca el disco rígido, lo primero que lee es el MBR (master boot



record) que es la primera porción del disco que contiene información. En el MBR va a estar el programa LILO o GRUB, que son boot loader, programas arrancadores o booteadores. Lo enunciado anteriormente es, si en la instalación de Linux, elegimos la opción de instalar LILO o GRUB en el MBR. Recuerde que teníamos una segunda opción de instalar LILO en una partición del disco. Al elegir esta opción, para arrancar nuestro Linux, necesitamos un disco de booteo. Una vez iniciado LILO, vemos los sistemas operativos que podemos arrancar. Seleccionamos Linux. Ahora, entonces comienza la carga del kernel en memoria. El kernel se debe cargar entero en el primer megabyte de la RAM disponible. Por esto, el kernel se comprime. Podemos decir que el kernel es un archivo. La cabecera del archivo contiene el código necesario para llevar a la CPU a modo protegido (así se elimina la restricción de memoria) y entonces, se descomprime el resto del kernel. Con el kernel en memoria, entonces puede empezar la ejecución. Acá es donde se construyen todas las funcionalidades, por ejemplo, algunos módulos del kernel no son accesibles en este punto. Luego deberán levantar a mano los módulos deseados. Como mínimo, el kernel debe tener el código para configurar el sistema de archivos raíz o una imagen initrd. Una imagen initrd es, como lo es el kernel, un archivo. La particularidad de este archivo es que es un pseudo filesystem root pequeño que es montado en lugar del verdadero filesystem root y que contiene lo mínimo indispensable para que luego de ser montado por el kernel tenga las herramientas básicas para poder cargar más módulos, que son necesarios para dar soporte al verdadero filesystem root. Esto se suele usar, por ejemplo, cuando queremos tener un root en un dispositivo raid, lvm o usb. Como ya dijimos, el otro filesystem primordial para arrancar nuestro sistema es el raíz, el /. Una vez iniciado el kernel, vemos en la pantalla una sucesión de líneas donde va reconociendo y chequeando el hardware y determina qué controladores de dispositivos se deben inicializar. Luego de este paso, el kernel monta el sistema de archivos raíz en read only. Y ahora sí, se inicia un programa llamado init. El programa init tiene la función de iniciar todos los procesos que necesita el sistema. Los más importantes entre éstos son los programas que permiten que los usuarios puedan iniciar una sesión. Estos programas se denominan getty. Normalmente funcionará una copia de getty por cada consola virtual que tengamos habilitada y por cada terminal que esté conectada al sistema. El init es el primer proceso no kernel que se inicia y siempre tiene el número de proceso 1 (pid=1). init para comenzar lee su archivo de configuración, /etc/inittab, y determina el nivel de ejecución donde debe iniciar. Veamos qué es el nivel de ejecución, o runlevel, como generalmente se lo llama. Esencialmente un nivel de ejecución dice como se va a comportar el sistema, describe un modo de operación. Cada nivel (designado por un número entre 0 y 6) especifica un comportamiento distinto. El init busca en este archivo el runlevel indicado para arrancar. Si no hay un nivel de arranque por defecto lo pide por pantalla sino no sabe en qué runlevel arrancar, por lo tanto no arrancará. Los runlevels son los siguientes:

0 Detiene el sistema (halt) 1 Monousuario(no está disponible la red). 2 Multiusuario, pero sin NFS. 3 Multiusuario completo (modo de operación normal). 4 Sin uso. 5 Multiusuario completo con entorno gráfico (modo de operación normal). 6 Reinicia el sistema.

Nota: Los runlevels del 2 al 5 son todos multiusuario y Debian , por default utiliza el runlevel 2.

Cuando sabe el nivel de ejecución, init ejecuta el script que se le indica en el archivo /etc/inittab. El nivel de ejecución por defecto depende de lo que le haya indicado al sistema durante la fase de instalación. Vamos a ver ahora como es el archivo /etc/inittab: # /etc/inittab: init(8) configuration. # $Id: inittab,v 1.91 2002/01/25 13:35:21 miquels Exp $ # The default runlevel. id:2:initdefault: # Boot-time system configuration/initialization script. # This is run first except when booting in emergency (-b) mode. si::sysinit:/etc/init.d/rcS



# What to do in single-user mode. ~~:S:wait:/sbin/sulogin # /etc/init.d executes the S and K scripts upon change # of runlevel. # # Runlevel 0 is halt. # Runlevel 1 is single-user. # Runlevels 2-5 are multi-user. # Runlevel 6 is reboot. l0:0:wait:/etc/init.d/rc 0 l1:1:wait:/etc/init.d/rc 1 l2:2:wait:/etc/init.d/rc 2 l3:3:wait:/etc/init.d/rc 3 l4:4:wait:/etc/init.d/rc 4 l5:5:wait:/etc/init.d/rc 5 l6:6:wait:/etc/init.d/rc 6 # Normally not reached, but fallthrough in case of emergency. z6:6:respawn:/sbin/sulogin # What to do when CTRL-ALT-DEL is pressed. ca:12345:ctrlaltdel:/sbin/shutdown -t1 -a -r now # Action on special keypress (ALT-UpArrow). #kb::kbrequest:/bin/echo "Keyboard Request--edit /etc/inittab to let this work." # What to do when the power fails/returns. pf::powerwait:/etc/init.d/powerfail start pn::powerfailnow:/etc/init.d/powerfail now po::powerokwait:/etc/init.d/powerfail stop # /sbin/getty invocations for the runlevels. # # The "id" field MUST be the same as the last # characters of the device (after "tty"). # # Format: # <id>:<runlevels>:<action>:<process> # # Note that on most Debian systems tty7 is used by the X Window System, # so if you want to add more getty's go ahead but skip tty7 if you run X. # 1:2345:respawn:/sbin/getty -f /etc/issue.linuxlogo 38400 tty1 2:23:respawn:/sbin/getty 38400 tty2 3:23:respawn:/sbin/getty 38400 tty3 4:23:respawn:/sbin/getty 38400 tty4 5:23:respawn:/sbin/getty 38400 tty5 6:23:respawn:/sbin/getty 38400 tty6 # Example how to put a getty on a serial line (for a terminal) # #T0:23:respawn:/sbin/getty -L ttyS0 9600 vt100 #T1:23:respawn:/sbin/getty -L ttyS1 9600 vt100 # Example how to put a getty on a modem line. # #T3:23:respawn:/sbin/mgetty -x0 -s 57600 ttyS3

Comentarios Como ya habrá visto el archivo /etc/inittab está organizado en líneas. Cada línea tiene el siguiente formato:

identificador:niveles_de_ejecución:acción:programa El identificador puede ser un número o una letra, o una combinación de ambos.



Ejemplo: id:2:initdefault:

Esta línea es muy importante, es la que setea el runlevel por defecto. El identificador es id, el runlevel es el 2 y la acción es el arranque por defecto. No tiene un programa asociado porque debe fijarse en los scripts de arranque que corresponden al runlevel 2. Más adelante hablaremos de los scripts de arranque en cada nivel. Para cambiar el runlevel por defecto solo se debe cambiar el número que aparece en esta línea por el nivel que se desee.

Si tiene instalado LILO en el sistema puede iniciar en el modo que desea al momento de elegir el Sistema Operativo que iniciará, agregando el número del runlevel que desea precedido por el nombre con que identifica LILO a Linux. Por ejemplo: Linux 1 o Linux s o Linux single. Si tiene instalado GRUB, debe editar el arranque con la letra “e”, y, en la línea que empieza con la palabra kernel, al final escriba “single”. Vamos a comentar algunas acciones. respawn el proceso reinicia si termina wait el proceso se inicia una vez que el runlevel se introduce, e init espera a su terminación once el proceso se ejecuta una sola vez. Sin embargo, init no espera que termine antes de

ejecutar otros programas en el runlevel particular boot el proceso se ejecuta en el arranque del sistema. En este caso, el campo runlevel se ignora bootwait el proceso se ejecuta al arrancar el sistema, e init espera su terminación antes de continuar

con el proceso siguiente ondemand el proceso se ejecuta cuando ocurre una petición de un nivel de ejecución determinado. No

ocurre un cambio de nivel de ejecución sysinit el proceso se ejecuta durante el arranque del sistema, antes de cualquier entrada boot o

bootwait powerwait si init recibe una señal de otro proceso que tiene problemas con la alimentación, se

ejecutará este proceso. Antes de continuar, init espera que este proceso termine powerfail Igual que powerwait, excepto que init no espera que el proceso acabe powerokwait si init recibe el mismo tipo de señal que en powerwait, y existe un archivo llamado

/etc/powerstatus con la cadena OK en él, este proceso se ejecuta e init espera a su terminación

ctraltdel el programa se ejecuta cuando init recibe la señal indicando que el usuario ha pulsado la combinación de teclas CTR-ALT-DEL. Tenga en cuenta que muchos servidores X-Windows capturan esta combinación de teclas, y así init no recibe esta señal si esta activo X-Windows

Una aclaracion final, en RedHat hay al final del archivo inittab una línea como la siguiente: x:5:respawn:/etc/X11/prefdm -nodaemon Esta línea lo que hace es que en el runlevel 5 arranque el modo gráfico. Es decir, RedHat define al runlevel 5 exclusivamente para iniciar el modo gráfico. Esto en Debian no sucede, en Debian el runlevel 1 es single user, el runlevel 2 es multiusuario. Para que arranque el modo gráfico, simplemente hay que configurar el modo gráfico en el runlevel 2 como cualquier otro servicio. La ventaja de esto es que si el modo gráfico no está bien configurado, no va a estar eternamente intentando arrancar como en RedHat con la opción “respawn”. De esta forma, si falla, simplemente tirará el error y el equipo seguirá funcionando como corresponde. Sripts de arranque rc El archivo /etc/inittab especifica qué scripts ejecutar en cada nivel de ejecución. Estos scripts son los responsables de arrancar o parar los servicios particulares de ese nivel de ejecución. Como los servicios a manejar en cada nivel son numerosos, se usan los scripts rc. El principal, /etc/init.d/rc, es el que llama a los scripts apropiados en el orden adecuado para cada nivel de ejecución. Para cada nivel de ejecución, existe un subdirectorio en el directorio /etc/rcN.d. Donde “N” es el numero de runlevel de 0 a 6 y un S para single user en modo mantenimiento. Entonces podemos encontrar algo como lo siguiente: alexa:/etc/default# cd /etc



alexa:/etc# ls -ld rc* drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc0.d drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc1.d drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc2.d drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc3.d drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc4.d drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc5.d drwxr-xr-x 2 root root 4096 Mar 8 03:58 rc6.d drwxr-xr-x 2 root root 4096 Feb 5 14:37 rcS.d alexa:/etc# Este es el formato estandar que se usa en un sistema System V. Otras distribuciones, usan un directorio en /etc/rc.d y ahí dentro guardan estos archivos. Pero el estandar sigue siendo el que usa Debian, de hecho es muy común que hagan links simbólicos al estandar o del formato de ellos al estandar. Hay varios directorios que se llaman rcN.d, donde N es un número de 0 a 6. Son los runlevels. En cada uno de ellos, están los procesos que se van a ejecutar en el runlevel correspondiente. Por ejemplo, todos los scripts del nivel de ejecución 2 están en /etc/rc2.d. Ahora veamos que hay dentro de uno de estos directorios a modo de ejemplo:

alexa:/etc/rc2.d# ls -l total 0 lrwxrwxrwx 1 root root 18 Feb 22 23:50 S10sysklogd -> ../init.d/sysklogd lrwxrwxrwx 1 root root 17 Feb 22 23:50 S11hotplug -> ../init.d/hotplug lrwxrwxrwx 1 root root 22 Feb 22 23:50 S20bootclean.sh -> ../init.d/bootclean.sh lrwxrwxrwx 1 root root 14 Feb 22 23:50 S45alsa -> ../init.d/alsa lrwxrwxrwx 1 root root 17 Feb 22 23:50 S45makedev -> ../init.d/makedev lrwxrwxrwx 1 root root 13 Feb 22 23:50 S45ssh -> ../init.d/ssh lrwxrwxrwx 1 root root 13 Feb 22 23:50 S45xfs -> ../init.d/xfs lrwxrwxrwx 1 root root 16 Feb 22 23:50 S45xinetd -> ../init.d/xinetd lrwxrwxrwx 1 root root 13 Feb 22 23:50 S55atd -> ../init.d/atd lrwxrwxrwx 1 root root 14 Feb 22 23:50 S89cron -> ../init.d/cron lrwxrwxrwx 1 root root 18 Feb 22 23:50 S90vmware -> /etc/init.d/vmware lrwxrwxrwx 1 root root 23 Feb 22 23:50 S99bootsplash.sh -> ../init.d/bootsplash.sh ojo aca, un enter faltaba-------------- lrwxrwxrwx 1 root root 13 Mar 8 02:37 S99kdm -> ../init.d/kdm lrwxrwxrwx 1 root root 19 Feb 22 23:50 S99linuxlogo -> ../init.d/linuxlogo lrwxrwxrwx 1 root root 19 Feb 22 23:50 S99rmnologin -> ../init.d/rmnologin lrwxrwxrwx 1 root root 23 Feb 22 23:50 S99stop-bootlogd -> ../init.d/stop-bootlogd En este directorio de nivel de ejecución 3, hay links, enlaces simbólicos a los scripts del directorio /etc/rc.d/init.d. Los enlaces simbólicos tienen el prefijo S que sirven para arrancar los servicios (viene de Start) o el prefijo K que sirven para parar un servicio (viene de Kill). En muchos casos, el orden en que estos scripts se ejecutan es importante (no puede usar DNS para resolver nombres de máquinas si no ha configurado primero la red). Para cumplir el orden, hay un número de dos dígitos como sufijo de la S o de la K. Los números más bajos se ejecutan antes que los números más altos. Por ejemplo: /etc/rc3.d/S10network se ejecuta antes que /etc/rc3.d/S80postfix. Es lógico, para arrancar los servicios que usan la red, primero debe levantar la red. Primero ejecuta los scripts que empiezan por K y después los scripts que empiezan con S. Para los scripts que empiezan con K, se les pasa un parámetro stop y a los que empiezan con S, se les pasa un parámetro de start. Cuando se invoca K15httpd, realmente esta haciendo:

/etc/init.d/httpd stop Y cuando se invoca S10network, realmente esta haciendo:

/etc/init.d/network start Si quieren simplificarse la vida con respecto a la creación de los links simbólicos para agregar o sacar servicios del arranque, pueden usar una aplicación propia de Debian que se llama rcconf.



Ahora veamos el directorio /etc/init.d. Acá es donde están todos los servicios, también llamados demonios. Aquí es donde están apuntando los links. Los links se crearon para no tener que copiar cada script en cada directorio de runlevel. (esta muestra es parcial y a modo de ejemplo) alexa:/etc/init.d# ls -l total 384 -rw-r--r-- 1 root root 853 Nov 3 13:36 README -rwxr-xr-x 1 root root 4687 Mar 5 16:40 alsa -rwxr-xr-x 1 root root 1074 Jan 18 2002 atd -rwxr-xr-x 1 root root 988 Dec 11 2002 binfmt-support -rwxr-xr-x 1 root root 2136 Nov 4 11:49 bootclean.sh -rwxr-xr-x 1 root root 1558 Jan 27 01:38 bootlogd -rwxr-xr-x 1 root root 1242 Nov 2 09:32 bootmisc.sh -rwx------ 1 root root 652 Jan 27 02:04 bootsplash.sh -rwxr-xr-x 1 root root 894 Oct 5 2001 checkfs.sh -rwxr-xr-x 1 root root 4791 Dec 20 21:22 checkroot.sh -rwxr-xr-x 1 root root 4939 Feb 26 08:34 console-screen.sh -rwxr-xr-x 1 root root 1086 Jan 18 18:23 cron -rwxr-xr-x 1 root root 1172 Nov 28 2002 devfsd -rwxr-xr-x 1 root root 749 Oct 26 23:09 devpts.sh -rwxr-xr-x 1 root root 1346 Oct 1 2002 etc-setserial -rwxr-xr-x 1 root root 837 Nov 17 08:53 fam -rwxr-xr-x 1 root root 4665 Feb 25 21:29 fetchmail -rwxr-xr-x 1 root root 1959 Aug 22 2003 gdm -rwxr-xr-x 1 root root 641 Dec 20 21:24 halt -rwxr-xr-x 1 root root 1573 Sep 21 09:04 hddtemp -rwxr-xr-x 1 root root 2960 Jan 30 15:15 hdparm -rwxr-xr-x 1 root root 165 Feb 26 2001 hostname.sh -rwxr-xr-x 1 root root 1602 Feb 6 12:54 hotplug Para poder arrancar un servicio por ejemplo samba, realizamos lo siguiente:

# /etc/init.d/smb start Para poder parar un servicio por ejemplo samba, realizamos lo siguiente:

# /etc/init.d/smb stop Para poder ver si esta corriendo el proceso por ejemplo samba, realizamos lo siguiente:

# /etc/init.d/smb status Para poder restaurar el proceso por ejemplo samba, realizamos lo siguiente:

# /etc/init.d/smb restart La opción restart ejecuta un stop primero y luego un start. Como cambiar de runlevel Si mi archivo /etc/initttab tiene seteado el initdefault, por ejemplo en runlevel 2 y quisiera cambiar al modo S para realizar tareas de mantenimiento de hardware se puede usar el mismo init de la siguiente forma:

# init S

Se suele recomendar usar el telinit para esta tarea, pero no hace falta dado que es un link simbólico al init. Con lo cual funciona exactamente igual y si nos acostumbramos a usar el init en lugar del telinit vamos a seguir usando una herramienta que está en todos los unix en lugar del telinit que es exclusiva de Linux y nuevamente, no es mas que un link simbólico. Este comando lo que hace es cambiar el runlevel. Pasa al modo S, y para ello se fija en su script rcS.d qué servicios debe detener y qué servicios debe iniciar. Ud. Verá en la pantalla algunos mensajes del estilo de los que aparecen cuando arranca el sistema. En el caso particular del runlevel S finalmente les va a solicitar el password de root como única posiblidad, dado que es un runlevel single user (S) y todo lo que hagamos solo debería poder hacerlo root.



Conociendo init, alcanza con saber que queremos hacer y solo escribir “init runlevel” (donde runlevel es uno de los números del 0 al 6 o la S) y de esta forma, reiniciar el equipo, apagarlo, entrar en modo mantenimiento, etc. Comandos de Linux (continuación) Búsqueda de archivos: find directorio [opciones] Cuando necesitamos buscar un archivo, usamos el comando find. Este comando permite hacer búsquedas por varios criterios, por nombre, por tipo de archivo, por fecha de modificación, etc. Donde directorio es el directorio desde el cual empieza la búsqueda. Ud. pensará qué directorio elegir para comenzar la búsqueda. Si uno ya sabe que busca un archivo de configuración, directorio puede ser /etc, que es donde está todo lo relativo a configuración del sistema o de usuarios. Las opciones pueden ser:

-name nombre Para buscar un archivo que se llame nombre. -print Imprime los archivos que encuentra. -perm modo Los permisos del archivo son exactamente iguales a los indicados por modo. -atime n Archivos accedidos en las ultimas n*24 horas. -ctime n Archivos cambiados en las ultimas n*24 horas. -amin n Archivos accedidos en los últimos n minutos. -cmin n Archivos cambiados en los últimos n minutos. -empty Archivos vacíos. -mmin n Archivos modificados en los últimos n minutos. -mtime n Archivos modificados en las ultimas n*24 horas. -size n [bloque] Archivo que tiene al menos n bloques/caracteres/kilobytes. Un bloque

equivale a 512 bytes. -exec comando \; Por cada archivo que encuentra, ejecuta comando.

Ejemplos:

# find / -name archivo2 Esto lo que hace es buscar archivo2 en el directorio / y todos los directorios que pertenecen a / (/boot, /root, /etc, /usr, etc), y muestra los archivos encontrados que coincidan con archivo2.

# find . -name archivo2 –print Ídem al ejemplo anterior pero esta vez busca en el directorio en que me encuentro, esto es lo que indica el punto (.), y también lo imprime.

# find / -name *.conf En este caso, buscaremos todos los archivos que terminen en .conf # find /usr/src -name core –exec rm {} \; Este ejemplo lo que hace es buscar los

archivos de nombre core en el directorio /usr/src y todos los directorios que pertenezcan a este, y ejecuta el comando rm por cada archivo que encuentra.

# find /home -iname *.jpg –size 100k Este ejemplo busca cualquier archivo que termine con extensión .jpg en el directorio /home y sus directorios con un tamaño inferior a 100k.

Nota: Recuerde que en Linux todo es un archivo, por ejemplo, los comandos son archivos ejecutables.

¿Quiénes están en el sistema? Una vez que algún usuario se encuentra dentro de un sistema Linux/UNIX, puede saber quien más está usando el sistema con uno de los siguientes comandos:

who [opciones] Este comando, utilizado sin opciones, lista el nombre del usuario, la terminal que está usando, y la hora en que el usuario entró. Las diferentes opciones de este comando despliegan más información acerca de los usuarios que están actualmente dentro del sistema. Alguna información disponible mediante opciones es, por ejemplo, la cantidad de tiempo que ha pasado desde que esa terminal ha tenido actividad, el identificador de procesos (PID) del proceso de login, comentarios e información de salida. Ejemplo:

# who root tty1 May 20 19:54 root tty2 May 20 19:53 root tty3 May 20 19:56



Nos muestra que el administrador (root) está conectado en las terminales tty1, tty2 y tty3 el 20 de Mayo a las 19:54, 19:53 y 19:56. El comando w nos muestra todos los usuarios que están conectados, a diferencia del comando who este da mucha más información como por ejemplo: en que consola está logueado, a que hora entró, que está ejecutando, etc. Ejemplo:

# w 9:53am up 3 days, 16:17, 2 users, load average: 0.00, 0.00, 0.00 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT alexa tty2 - 9:24am 0.00s 0.11s 0.05s w root tty3 - 9:25am 26.11 0.06s 0.06s -bash

¿Quién soy? Este comando muestra quienes somos (con qué usuario estamos logueados). Ejemplo:

# whoami root

Enlace de archivos El comando ln nos permite establecer enlaces duros y enlaces débiles o simbólicos. El formato general de ln es el siguiente:

# ln archivo_original archivo_nuevo Con la opción –s, crea un enlace simbólico en lugar de un enlace duro. Ejemplo:

# ln –s /home/pepe pepe # ls –l pepe lrwxrwxrwx 1 pepe pepe 9 May 11 2oo3 18:16 pepe -> /home/pepe

Nota: Recuerde que en este capítulo ya vimos la diferencia entre hard links y symbolic links.

Espacio en disco: df [opciones] El comando df se utiliza para ver el espacio libre y ocupado que tengo en el/los disco(s), pero sólo en las unidades mapeadas, es decir en cada partición que tengo, y a su vez, está montada. Este comando permite utilizar opciones, entre ellas tenemos:

-k Muestra la salida en bytes, como bloques de 1024. -m Muestra la salida en megabytes como bloques de 1048576. -i Muestra la información de i-nodos en lugar de bloques. -h Imprime los tamaños en formato legible (ej.: 1K 234M 2G)

Ejemplos:

# df Filesystem 1k-blocks Used Available Use% Mounted on /dev/md7 9732968 2122856 7115696 23% / /dev/md6 29621 10579 17513 38% /boot /dev/md1 4031616 42064 784756 2% /home none 127920 0 127920 0% /dev/shm /dev/md4 2015440 34032 1879028 2% /tmp /dev/md0 7055096 3334440 3362268 50% /usr /dev/md2 3023504 340376 2529544 12% /var /dev/md3 3023504 199608 2670312 7% /www

# df -h Filesystem Size Used Avail Use% Mounted on /dev/md7 9.3G 2.1G 6.7G 23% / /dev/md6 29M 11M 17M 38% /boot /dev/md1 3.8G 42M 3.6G 2% /home none 125M 0 124M 0% /dev/shm /dev/md4 1.9G 34M 1.7G 2% /tmp /dev/md0 6.7G 3.2G 3.2G 50% /usr



/dev/md2 2.9G 333M 2.4G 12% /var /dev/md3 2.9G 195M 2.5G 7% /www

Espacio en disco (disk usage): du [opciones] [ficheros | directorios] Este comando informa la cantidad de espacio que ocupa el directorio especificado, con los subdirectorios, si los tuviera, y los archivos contenidos. Si uso du sin argumentos muestra el espacio ocupado por el directorio actual, o sea donde estoy parado. Las opciones pueden ser:

-k Muestra la salida en kbytes, como bloques de 1024. -b Muestra la salida en bytes -m Muestra la salida en megabytes como bloques de 1048576. -h Imprime los tamaños en formato legible (ej.: 1K 234M 2G) -s Muestra solo para el argumento dado, no para sus subdirectorios.

Ejemplo:

# du -s -b /home/jose 16384 /home/jose

# du -s -b /home/maria 36864 /home/maria

Procesos Un proceso es una instancia de un programa en ejecución y también la unidad básica de planificación en Linux/UNIX. Lo consideraremos como un programa en ejecución. Tanto bajo GNU/Linux como en Unix en general, cada programa en ejecución se compone de al menos, un proceso. Desde el punto de vista del sistema operativo, cada proceso es independiente del resto. Al menos que se le diga específicamente que comparta recursos con otros procesos, un proceso está confinado a la asignación de memoria y CPU que se le ha hecho. Los procesos que se exceden en su asignación de memoria (que podría corromper a otros programas en ejecución y hacer el sistema inestable) mueren inmediatamente. Las aplicaciones de usuarios no pueden corromper otros programas de usuarios o de sistema operativo. Listar procesos: ps [opciones] Este comando lista todos los procesos del sistema, su estado, tamaño, nombre, propietario, tiempo de CPU, tiempo de reloj y otros. Sin argumentos muestra el identificador de proceso (PID) de la shell sobre la que se está ejecutando, y también el propio PID del comando ps lanzado.

$ ps PID TTY TIME CMD 45 pts/0 00:00:00 bash 84 pts/0 00:00:00 ps

Tiene múltiples opciones, las más usadas son:

-a Muestra todos los procesos con consola controlada, excepto el proceso de usuario actual. -r Muestra solo los procesos en ejecución. -x Muestra los procesos que no tienen una terminal controlada. -u Muestra los propietarios de los procesos. -f Visualiza las relaciones padre/hijo entre los procesos. -l Produce un listado en formato largo. -w Muestra los parámetros de la línea de comandos de los procesos (hasta media línea). -ww Muestra todos los parámetros de la línea de comandos de los procesos, independientemente de

su longitud. Ejemplo:

# ps –aux | more USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.5 0.3 1368 476 ? S 19:43 0:0 init root 2 0.0 0.0 0 0 ? SW 19:43 0:00 [keventd] root 3 0.0 0.0 0 0 ? SW 19:43 0:00 [kapmd] root 4 0.0 0.0 0 0 ? SWN 19:43 0:00 [ksoftirqd_CPU0]



root 5 0.0 0.0 0 0 ? SW 19:43 0:00 [kswapd] root 6 0.0 0.0 0 0 ? SW 19:43 0:00 [bdflush] root 7 0.0 0.0 0 0 ? SW 19:4 0:00 [kupdated] root 8 0.0 0.0 0 0 ? SW 19:43 0:00 [mdrecoveryd] root 12 0.0 0.0 0 0 ? SW 19:43 0:00 [kjournald] root 91 0.0 0.0 0 0 ? SW 19:43 0:00 [khubd] root 186 0.0 0.0 0 0 ? SW 19:44 0:00 [kjournald] root 187 0.0 0.0 0 0 ? SW 19:44 0:00 [kjournald] root 188 0.0 0.0 0 0 ? SW 19:44 0:00 [kjournald] root 563 0.0 0.4 1428 560 ? S 19:44 0:00 syslogd –m 0 root 568 0.0 0.3 1364 444 ? S 19:44 0:00 klogd -x root 624 0.0 0.3 1360 480 ? S 19:44 0:00 usr/sbin/apmd -p named 678 0.0 1.8 10400 2368 ? S 19:44 0:00 named -u named named 680 0.0 1.8 10400 2368 ? S 19:44 0:00 named -u named named 681 0.0 1.8 10400 2368 ? S 19:44 0:00 named -u named named 682 0.0 1.8 10400 2368 ? S 19:44 0:00 named -u named named 683 0.0 1.8 10400 2368 ? S 19:44 0:00 named -u named root 703 0.0 0.7 2212 924 ? S 19:44 0:00 xinetd -stayalive root 723 0.0 0.8 2400 1124 ? Ss+ 19:44 0:00 /bin/sh /usr/bin/ root 760 0.0 0.3 1400 452 ? S 19:44 0:00 gpm -t ps/2 -m /d

Veamos la primera línea de la salida que nos muestra los títulos de las columnas del listado. Su significado es el siguiente:

USER El propietario de cada proceso. PID El numero de identificación del proceso. %CPU Porcentaje de CPU ocupado por el proceso. Aclaración: Para un sistema con varios

procesadores, esta columna puede tener un valor mayor del 100%. %MEM Porcentaje de memoria ocupada por el proceso. VSZ Cantidad de memoria virtual ocupada por el proceso. RSS Cantidad de memoria residente ocupada por el proceso. TTY La consola controlada por el proceso. Un signo de interrogación en esta columna significa

que no está conectada a ninguna terminal. STAT El estado del proceso. Y pueden ser:

S El proceso está dormido. Todos los procesos preparados para ejecutarse. R El proceso está actualmente en CPU. T El proceso está haciendo trazas por un depurador o debugger, o ha sido

parado. Z El proceso está “zombie”. Esto significa una de las siguientes:

1. El proceso hijo murió y el proceso padre no tiene conocimiento de la muerte de su hijo. Usa la llamada al sistema wait.

2. El padre fue muerto inapropiadamente, y hasta que el padre no esté muerto completamente, el proceso init no puede liberar al propio hijo. Un proceso zombie indica normalmente un software mal escrito.

La entrada STAT puede tomar para cada proceso uno de los siguientes modificadores: W No residen páginas en la memoria. < Proceso de prioridad alta. N Proceso de prioridad baja. L Páginas en memoria bloqueadas (normalmente significa la necesidad de

funcionalidad en tiempo real). s proceso en la consola actual + proceso en foreground

START Fecha en que el proceso arrancó. TIME Cantidad de tiempo que el proceso ha gastado de CPU. COMMAND Nombre del comando y sus parámetros.

Mostrar una lista interactiva de procesos: top



El programa ps es estático, nos muestra el listado de los procesos en el momento pedido. En cambio, top es dinámico, va refrescando el listado cada una cierta cantidad segundos. El comando top es una versión interactiva del ps.

# top Esto es lo que muestra en pantalla

Nota: Es conveniente que solo root tenga permiso para la utilización de este comando, ya que si varios usuarios lo corren, se ralentiza el sistema. Recuerde como quitar permisos.

# chmod 0700 /usr/bin/top

Unos párrafos arriba, cuando explicamos los procesos zombies hablamos de señales. Ahora vamos a tratar de que se entienda mejor. Tenemos que ver las formas de comunicación entre procesos. Pueden ser varias, entre ellas tenemos:

• A través de variables de entorno: solo es posible de padres a hijos. • Mediante una señal: solo indica que algo ha ocurrido y solo lleva como información un número de

señal. • Mediante entrada salida: es la forma más corriente a nivel de shell. Ya hemos comentado el operador

pipe '|' que conecta dos procesos. • Mediante técnicas IPC u otras: Semáforos, Memoria compartida, Colas de mensajes. • Mediante sockets: este sistema tiene la peculiaridad de que permite comunicar procesos que estén

funcionando en máquinas distintas. No profundizamos sobre esto porque ahora no estamos interesados en la programación. Más adelante si comentaremos bastante sobre variables y entrada salida porque daremos nociones de programación en shell-script. Envío de una señal a un proceso Al comando kill se le pasa un número de señal. Si no se hace, la señal por defecto es TERM, la número 15.

kill [–n] nro_pid Donde n representa un número de señal y nro_pid es el número del proceso al que quiero mandarle la señal. La señal Hang-Up, que es la número 1, se utiliza para decirle a algunos servidores de aplicaciones que relean sus archivos de configuración. Con la opción –l en el comando kill nos muestra todas las señales que hay con una breve descripción y el número de señal. Para ver las señales de las que disponemos, hacemos:

# kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR 31) SIGSYS 32) SIGRTMIN 33)SIGRTMIN+1 34) SIGRTMIN+2 35) SIGRTMIN+3 36) SIGRTMIN+4 37)SIGRTMIN+5 38) SIGRTMIN+6 39) SIGRTMIN+7 40) SIGRTMIN+8 41)SIGRTMIN+9 42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45)SIGRTMIN+13 46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49)SIGRTMAX-14 50) SIGRTMAX-13 51) SIGRTMAX-12 52) SIGRTMAX-11 53)SIGRTMAX-10



54) SIGRTMAX-9 55) SIGRTMAX-8 56) SIGRTMAX-7 57) SIGRTMAX-6 58) SIGRTMAX-5 59) SIGRTMAX-4 60) SIGRTMAX-3 61) SIGRTMAX-2 62) SIGRTMAX-1 63) SIGRTMAX

Generalmente usamos la palabra kill para decir que vamos a matar procesos. En realidad, lo que hacemos es mandarle señales al proceso. Un tipo de señal sí mata procesos, es decir, los termina. La señal 9, es la forma brutal de parar un proceso, en lugar de pedirle que se pare, el sistema operativo mata el proceso. Ejemplo:

# kill -9 PID Esto lo que hace es terminar completamente con la ejecución de un proceso. Como ya dijimos, el comando no mata procesos, sino que envía señales a los procesos en ejecución. El sistema operativo, por defecto, proporciona a cada proceso un conjunto estándar de manejadores de señales para la gestión de las señales entrantes. Desde el punto de vista del administrador, el manejador más importante es para las señales número 9 y 15. El comando kill requiere al menos un parámetro, el número de identificación de proceso (PID) que se muestra en el comando ps. Cuando se pasa al comando kill solamente el PID, kill envía la señal 15. Ejemplos:

# ps –f UID PID PPID C STIME TTY TIME CMD root 1736 1733 0 19:48 pts/0 00:00:00 bash root 1796 1736 0 19:50 pts/0 00:00:00 ps -f # kill 1736

En este ejemplo manda la señal 15 al PID 1736. # kill -15 1736

Ídem al anterior. # kill -15 `cat /var/run/named.pid`

Ídem a la explicación anterior, en el directorio /var/run están los nombres de los demonios que están corriendo con su número.

Control de Procesos Control de procesos se refiere a la habilidad de poner procesos en background (segundo plano) y traerlos de vuelta al foreground (primer plano). Esto es como decir, que se quiere ser capaz de ejecutar algo mientras se hacen otras cosas, pero que estén ahí otra vez cuando se les quiera decir algo o pararlos. En Linux/Unix, la principal herramienta para el control de procesos es la shell, seguirá la pista de los procesos por Ud., si se aprende como hablar su lenguaje. Las dos palabras más importantes en ese lenguaje son fg, para primer plano, y bg, para segundo plano. Para entender como funcionan, usaremos como ejemplo el comando yes en el indicador del sistema.

$ yes Esto produce el maravilloso efecto de desplazar una larga columna de yes por la parte izquierda de la pantalla, tan rápido que no se pueden seguir. Hay buenas razones para que este extraño comando exista. Ciertos comandos esperan una confirmación, un "si" ([y]es en inglés) a una pregunta. El comando yes permite al programador automatizar la respuesta a esas preguntas. Para pararlo, se podría pulsar Control+C y matarlo, pero esta vez Ud. oprimirá Control+Z. Parece haberse detenido, pero habrá un mensaje antes del indicador de sistema, más o menos parecido a este:

[1]+ Stopped yes Significa que la tarea yes se ha suspendido en el segundo plano. Se puede hacer que siga ejecutándose tipeando fg en el indicador de sistema, que lo pondrá en primer plano otra vez. Si se desea, se pueden hacer otras cosas antes, mientras está suspendido. Pruebe unos cuantos ls o algo antes de ponerlo en primer plano nuevamente. Una vez que ha vuelto al primer plano, las yes empezarán a salir otra vez, tan rápido como antes. No hay que preocuparse de que si mientras ha estado suspendido ha "almacenado" más yes para enviarlas a la pantalla, cuando un trabajo se suspende, el programa entero no se ejecuta hasta que se lo vuelva de vuelta a la vida. Ahora pulse Control-C para matarlo de verdad. Pongamos aparte el mensaje que obtuvimos del shell:

[1]+ Stopped yes El número entre corchetes es el número de trabajo de este proceso, y se usará cuando se necesite referenciarlo específicamente. (Naturalmente, desde el momento que tengamos en ejecución múltiples trabajos, se necesita un



modo de acceder a cada uno). El "+" siguiente indica que ése es el "trabajo actual", esto es, el proceso más reciente que se ha movido del primer plano al segundo. Si tipeara fg, se pondría el trabajo con el "+" en primer plano otra vez. La palabra “Stopped” significa que el trabajo está “parado”. El trabajo no está muerto, pero actualmente no se ejecuta. Linux lo ha guardado en un estado especial de suspendido, listo para saltar a la acción cuando alguien lo solicite. Finalmente, el “yes” es el nombre del trabajo que se ha detenido. Antes de seguir adelante, matemos este trabajo y lo arrancamos otra vez de forma diferente.

$ kill %1 [1]+ Stopped yes

Ese mensaje sobre el proceso que indica "parado" otra vez induce a error. Para saber si aún está vivo (eso es, tanto en ejecución como congelado en un estado suspendido), tipee jobs:

$ jobs [1]+ Terminated yes

Ahora ya lo sabe: ¡el trabajo ha terminado!

Nota: Es posible que el comando jobs no muestre nada, lo que simplemente significa que no hay trabajos ejecutándose en segundo plano. Si se acaba de matar un trabajo, y al tipear jobs no muestra nada, se tiene la seguridad de que el comando kill se ha ejecutado correctamente. Normalmente indicará que el trabajo ha terminado.

Ahora, ejecute yes de nuevo, de esta forma:

$ yes > /dev/null Si lee la sección sobre la redirección de entrada y salida, sabrá que se está enviando la salida de yes a un archivo especial llamado /dev/null. /dev/null es un agujero negro que come cualquier salida que se le envíe, es como un recolector de basura, es como la nada, como mandarlo a ningún lado. Después de tipear esto, no se recuperará el indicador de sistema, pero tampoco saldrá esa columna de yes. Sin embargo la salida se está enviando a /dev/null, el trabajo aún se ejecuta en primer plano. Como siempre, se puede suspender pulsando Control-Z. Hágalo ahora para volver al indicador del sistema.

$ yes > /dev/null [Aquí yes se está ejecutando, y al pulsar Control-Z verá lo siguiente]

[1]+ Stopped yes >/dev/null $

Hmm... ¿Hay alguna forma de ponerlo en ejecución en segundo plano, mientras deja el indicador del sistema para trabajar de forma interactiva? El comando para hacer eso es bg:

$ bg [1]+ yes >/dev/null & $

Ahora, después de tipear bg, la tarea yes > /dev/null habrá continuado con su ejecución otra vez, pero esta vez en segundo plano. De hecho, si hace alguna cosa en el prompt, como ls u otros, se dará cuenta que su máquina se ha ralentizado un poco (¡Generar y descargar continuamente una cadena preparada de yes lleva algo de tiempo, al fin y al cabo!) Aparte de esto, no hay ningún otro efecto. Se puede hacer lo que se desee en el indicador del sistema, y yes continuará felizmente enviando su salida al agujero negro. Ahora hay dos formas diferentes de matarlo: con el comando kill que ya se explicó, o poniendo el trabajo en primer plano de nuevo e interrumpirlo con una interrupción, Control-C. Probemos la segunda forma, sólo para entender la relación entre fg y bg un poco mejor;

$ fg yes >/dev/null

Ahora está en primer plano. Pulsando Control-C para terminarlo: Se acabó. Ahora, ejecute el siguiente comando:

$ yes > /dev/null & (& = ampersand) [1] 1024

Nota: Poner un & después del comando indica al shell que el trabajo se ejecute en segundo plano desde el momento en que se inicia. (Es una forma



de evitarse tener que ejecutar el programa, pulsar Control-Z, y luego teclear bg.)

Tabla Resumen

Comando Explicación fg %nº_trabajo Comando del shell que devuelve un trabajo al primer plano. Para saber cuál es

éste por defecto, se tipea jobs y se busca el que tiene el +. Parámetros: número de trabajo opcional. El trabajo por defecto se identifica con el +.

& Cuando se añade un & al final de la línea de comandos, indica al comando que se ejecute en segundo plano automáticamente. Este trabajo está entonces sujeto a todos los métodos usuales para el control de tareas aquí detallados.

bg %nº_trabajo Este es un comando del shell que manda a un trabajo suspendido ejecutarse en segundo plano. Para saber cual es éste por defecto, se tipea jobs y se busca el que tiene el +. Parámetros: número de trabajo opcional. El trabajo por defecto se identifica con el +.

kill %nº_trabajo PID Comando del shell que obliga a un trabajo en segundo plano, ya sea suspendido o en ejecución, a terminar. Se debe siempre especificar el número de trabajo o PID, y si se están usando números de trabajo, no hay que olvidar poner el %. Parámetros: El número de trabajo (a continuación del %) o el PID (no es necesario el %). Se puede especificar más de un proceso o trabajo en una línea.

jobs Este comando del shell lista información sobre los trabajos que están en ese momento en ejecución o suspendidos. A veces también dice cuáles son los que acaban de salir o han terminado.

Control-C Este es el carácter genérico de interrupción. Normalmente, si se pulsa mientras un programa se está ejecutando en primer plano, matará al programa (puede que haya que hacerlo varias veces). Sin embargo, no todos los programas responderán a este método de terminación.

Control-Z Esta combinación de teclas normalmente suspende un programa, puede que algunos programas lo ignoren. Una vez suspendido, el trabajo se puede reiniciar en el segundo plano o se puede matar.

Nota: Es importante entender que el control de procesos lo hace el shell. No hay ningún programa en el

sistema llamado fg; por eso, fg, bg, & y jobs son internos al shell. Esto es una forma lógica de hacerlo: ya que cada usuario quiere su propio espacio de control de tareas, y cada usuario ya tiene su propio shell, es más fácil que el shell siga la pista de los trabajos usuario. Por otro lado, cada número de trabajo de usuario sólo tiene significado para ese usuario: mi trabajo número [1] y su trabajo número [1] son probablemente dos procesos totalmente diferentes. De hecho, si se está conectado más de una vez, cada uno de los shells tendrá datos únicos sobre el control de trabajos, así como también un usuario puede tener dos trabajos diferentes con el mismo número ejecutándose en dos shells diferentes.

Montaje y Desmontaje de Discos y de Sistemas de Archivos Un sistema de archivos (o filesystem) es información almacenada en un dispositivo de almacenamiento, organizada siguiendo una convención, la cual permite al sistema operativo manejar la información cuando el usuario lo requiere, es decir, leer, escribir, consultar directorios, etc. Hay diversos tipos (o convenciones) de sistemas de archivos, Linux cuenta con controladores para varios tipos creados específicamente para Linux , por ejemplo ext2, ext3, ReiserFS, así como controladores para tipos de sistemas de archivos creados para otros sistemas operativos, como affs, hpfs, ntfs, msdos y vfat. Los tipos que pueden emplearse con Linux están incluidos en el kernel o son módulos en el subdirectorio fs del directorio con módulos de su sistema (es decir, el directorio de módulos es de la forma /lib/modules/2.6.x/kernel/fs/ reemplazando x por la versión de su kernel). Los que puede usar dependen de la forma como se haya compilado el kernel y de los módulos que estén cargados. Puede examinar los tipos que soporta su sistema viendo el contenido de /proc/filesystems y puede emplear otros tipos de sistemas de archivos cargando los módulos apropiados -mientras sean soportados-. Aunque toda la estructura de directorios presentada en la sección anterior podría estar en un sólo sistema de archivos, es posible distribuirla en varios. Para poder emplear un sistema de archivos primero debe montarse en algún directorio con el comando mount o debe configurarse el sistema para que lo monte automáticamente



durante el arranque (el primer directorio que debe montarse es la raíz /). Para desmontar un sistema de archivos de un directorio se emplea el comando umount. El programa mount sin argumentos presenta los sistemas de archivos que están montados, de cada uno presenta el dispositivo en el que reside, el directorio en el que está montado, el tipo de sistema de archivos y algunos parámetros del montaje, por ejemplo, la siguiente es una salida del comando mount:

/dev/hda1 on / type ext2 (rw,errors=remount-ro,errors=remount-ro) proc on /proc type proc (rw) devpts on /dev/pts type devpts (rw,gid=5,mode=620) /dev/hda2 on /var type ext2 (rw) /dev/hda3 on /home type ext2 (rw)

En el ejemplo se muestran 5 sistemas de archivos montados en los directorios /, /proc, /dev/pts, /var y /home. Tres de ellos son de tipo ext2 y residen en tres particiones del disco rígido (/dev/hda1, /dev/hda2 y /dev/hda3), los otros dos son virtuales, es decir, no residen en dispositivo de almacenamiento alguno (son creados por el kernel). Las opciones de montaje de todos indican que pueden leerse y escribirse (rw), el sistema montado en la raíz en caso de fallas será montado con permiso de sólo lectura (errors=remount-ro) y el sistema montado en /dev/pts tendrá todos sus archivos como pertenecientes al grupo 5 (tty) y permisos de escritura y lectura para el usuario y sólo de escritura para el grupo (modo 620). Para montar un sistema de archivos se emplea:

mount -t tipo -o opciones dispositivoFisico dispositivoVirtual Donde dispositivoFisico es el nombre del dispositivo que contiene el sistema de archivos (ej: /dev/hda1 o /dev/fd0), tipo es el tipo del sistema de archivos y dispositivoVirtual es la ruta donde se quiere acceder la raíz del sistema montado, es un directorio (si el directorio donde se monta contiene datos, estos serán escondidos mientras el nuevo sistema de archivos permanezca montado). Por esta razón se debe cumplir la condición de que el directorio donde se efectuará el montaje, esté vacío. Las opciones de mount pueden ser:

-a Monta todos los sistemas de archivos listados en /etc/fstab. -t tipo-de-sistema-archivo Especifica el tipo de sistema de archivos que se montará por

ejemplo: FAT, VFAT, FAT32, ISO9660, ext2. -o opciones Especifica opciones al proceso mount.

ro Monta la partición como solo lectura. rw Monta la partición como lectura y escritura. exec Permite la ejecución de binarios (por defecto). noatime Deshabilita la actualización de la fecha de acceso a los i-nodos.

Para particiones donde la fecha de acceso no es importante (como en los spools de noticias), esta opción mejora su rendimiento.

noauto Deshabilita el montaje automático de esta partición cuando se especifica la opción –a (se aplica solo en el archivo /etc/fstab).

nosuid Anula la aplicación de los bits de programa setuid en la partición montada.

sb=n Le dice a mount que use el bloque n como superbloque en el sistema de archivo ext2.

La información sobre un sistema de archivos, su directorio de montaje y opciones pueden especificarse en el archivo /etc/fstab. De hacerlo puede emplear

mount dispositivoVirtual para montar el sistema de archivos en el directorio especificado por dispositivoVirtual (el resto de información debe estar en /etc/fstab). Además, por defecto, los sistemas de archivos especificados en ese archivo serán montados automáticamente durante el arranque del sistema. Más adelante nos dedicaremos a este archivo. Ejemplo:

# mount /dev/hda1 /win -t vfat Esta línea lo que hace es montar mi dispositivo físico, que es una parte de disco rígido, la partición1, en un dispositivo virtual, que es el directorio /win y le digo que lo monte como filesystem vfat para que me tome los nombres largo de windows.



Nota: El sistema de archivos por default es ext2. Para los tipos de filesystem con que se crearon las particiones Linux-native (82) no es necesario especificarlo.

Si tengo configurado el archivo /etc/fstab con las opciones para este filesystem, puedo escribir el comando simplificado

# mount /win En el caso de disquetes, puede montarse así :

# mount /dev/fd0 /mnt/floppy -t msdos Aquí estamos diciendo que el formato del disco que insertamos en la lectora, que se llama /dev/fd0 es MSDOS.

Nota: Tenga cuidado porque el formato de MSDOS no permite nombres de archivo muy largos como es el caso de Linux y Windows95. Por lo tanto si desea copiar un sistema de archivos a un floppy es mejor crear un disco del tipo ext2 (Linux) y luego montarlo. Para esto introduzca un disco formateado MSDOS en la lectora y haga: # mke2fs /dev/fd0 1440 con lo cual estamos dando un formato especial (Linux native 82) al disco de 1.44 Mb, luego lo montamos con: # mount /dev/fd0 /mnt/floppy ó con: # mount /mnt/floppy

Tenga en cuenta que los directorios usados para montar dispositivos (particiones) deben de existir y estar vacíos antes de pretender usarlos. Cuando el sistema arranca inicialmente lee un archivo llamado /etc/inittab que a su vez lee el archivo /etc/rc.d/rc.S, el cual contiene una línea para montar automáticamente todos los dispositivos que se encuentren en el archivo /etc/fstab, así que despreocúpese, el sistema lo hará por usted, pero es bueno saber quién lo hace. Para desmontar un filesystem haga:

# umount dispositivo donde dispositivo puede ser /dev/hda1 para desmontar la partición de 400 Megas del directorio /win, Veamos otro ejemplo:

# mount –t iso9660 /dev/cdrom /mnt/cdrom ó

# mount /mnt/cdrom ó

# mount /media/cdrom Para poder desmontar

# umount /dev/cdrom ó

# umount /mnt/cdrom ó

# umount /media/cdrom El archivo /etc/fstab El archivo fstab contiene información que describe los diferentes filesystems. Los programas sólo pueden leer el fstab; por ejemplo, es el archivo que utiliza mount cuando queramos montar usando alias (vamos a hablar de esto mas adelante). El administrador del sistema es responsable de la creación y mantenimiento de este archivo. Cada línea describe un sistema de archivos; los campos en cada línea están separados por tabs o espacios. Este archivo contiene una lista de todas las particiones conocidas del sistema. Durante el proceso de arranque se lee esta lista y sus elementos se montan de forma automática si corresponde y el sistema de archivos es estable, es decir que no contenga errores irreparables. Ejemplo:



alexa:/etc# cat /etc/fstab # /etc/fstab: static file system information. # # <file system> <mount point> <type> <options> <dump> <pass> /dev/hda1 / ext3 defaults,errors=remount-ro 0 1 /dev/vg00/swap none swap sw 0 0 proc /proc proc defaults 0 0 /dev/fd0 /floppy auto defaults,user,noauto 0 0 /dev/cdroms/cdrom0 /mnt/cdrom0 auto defaults,ro,user,noauto 0 0 /dev/cdroms/cdrom1 /mnt/cdrom1 auto defaults,ro,user,noauto 0 0 /dev/vg00/usr /usr ext3 defaults 0 2 /dev/vg00/var /var ext3 defaults 0 2 /dev/vg00/home /home ext3 defaults 0 2 /dev/vg00/usr_local /usr/local ext3 defaults 0 2 tmpfs /tmp tmpfs defaults 0 0 \\alexa-vm\kazaa /mnt/smbfs/alexa-vm smbfs defaults 0 2 /dev/sg0 /mnt/mp3player vfat defaults,noauto,sync 0 0 alexa:/etc# La primera columna describe el dispositivo físico, puede ser de bloque o un sistema de archivos remoto. La segunda columna describe el punto de montaje para el sistema de archivos, lo que antes llamé dispositivo virtual. Para particiones de intercambio (swap), este campo debe decir “none”. La tercera columna describe el tipo de filesystem. Linux soporta muchos filesystems, solo para mencionar algunos, ext3, reiserfs, jfs, ntfs, smbfs, etc. La cuarta columna describe las opciones de montaje asociadas con el sistema de ficheros. Algunas opciones (comunes a todo sistema de archivos) son:

o ro para montar en modo de sólo lectura o rw para montar en modo lectura y escritura o user que indica que un usuario puede montar el sistema de archivos (por defecto sólo el

administrador puede hacerlo) o noauto para indicar que el sistema no debe montarse durante el arranque ---note que los

directorios /floppy y /cdrom no son montados automáticamente durante el arranque. o defaults incluye: rw, suid, dev, exec, auto, nouser y sync

La quinta columna lo utiliza el comando dump para determinar qué sistemas de archivos necesitan ser volcados (dumped), es decir con cuanta frecuencia se necesita hacer copia de seguridad del sistema de archivos. Si el quinto campo estuviera vacío, dump asume que el sistema de ficheros no necesita ser volcado. La sexta columna lo usa el programa fsck para determinar el orden en el cual se van a chequear los sistemas de archivos cuando el sistema arranca. Observe que todos los archivos se comprueban antes de montarse. El número que controla el chequeo con fsck indica el orden en el cual hacer chequeos, 0 (cero) indica que no se debe chequear el sistema, otros números positivos especifican una prioridad (los menores son más prioritarios y los números con el mismo número de ser posible son chequeados en paralelo). Es conveniente emplear 1 con el sistema de archivos montado en la raíz y 2 para los demás que requieran chequeo. Entonces con este archivo correctamente configurado por el administrador, un usuario solo tendrá que hacer un mount /mnt/cdrom para acceder al mismo. De esta forma, el mount lee el fstab y busca la línea que hace referencia el /mnt/cdrom y toma los parametros y dispositivos asociados correspondientes sin tener que completar totalmente el comando con los switchs que harían falta para montarlo sin haber creado el “alias” en el /etc/fstab



Capítulo 4

Instalación de Software Luego de tener nuestro sistema instalado y funcionando correctamente, vamos a querer actualizarlo con nuevos programas. O puede ser que tengamos que instalar un driver para algún dispositivo problemático, o nos guste bajar software de Internet que queramos probar. ¿Cómo actualizo, instalo o desinstalo software? Existen varios métodos que dependerán del formato utilizado para empaquetar los programas. En este capítulo veremos la descripción de los posibles métodos y algunos ejemplos. La manera más fácil de instalar software en Linux es mediante paquetes. En el mundo de Linux existen varios tipos de paquetes: “.deb” (distribuciones basadas en Debian), “.rpm” (basadas en Red Hat) y “.tgz” ó “.tar.gz” (usados por Slackware y Gentoo). Años atrás era más difícil instalar software en Linux. Al principio teníamos el código fuente y teníamos que compilarlo. ¿Cómo lo compilamos? En este capítulo veremos como hacerlo. Compilar el código fuente tiene sus ventajas, el software es optimizado para nuestro hardware pero la instalación no siempre es fácil.

Descompresión y compresión de archivos Comando tar El nombre viene de Tape Archiver y era la herramienta por excelencia a la hora de hacer backups en unidades de cintas. El comando sirve para concatenar archivos en uno solo. Con este comando podemos crear un archivo que contenga una lista de archivos concatenados, sin realizar ningún tipo de compresión. Lo que hace, realmente es una agrupación de archivos, los agrupa todos en uno. Luego veremos que podemos pasarle una serie de parámetros para que realice una compresión tanto de tipo gzip como bzip2. El formato del comando tar es:

tar <opciones> <arch1> <arch2> ...<archN> donde <opciones> es la lista de comandos y opciones para tar, y <arch1> hasta <archN> es la lista de archivos a añadir o extraer del archivo.

Las opciones que más comúnmente vamos a utilizar, son: c Crear un archivo tar x Extrae el contenido de un archivo v Muestra información en pantalla sobre lo que se está haciendo

f <archivo> Dirige la salida de tar a un archivo z Entiende que el archivo que lee o escribe está comprimido con gzip Z Entiende que el archivo que lee o escribe está comprimido con compress

j Entiende que el archivo que lee o escribe está comprimido con bzip2 Por ejemplo, el comando

# tar cvf backup.tar /etc empaquetará todos los archivos de /etc en el archivo tar backup.tar. El primer argumento es el comando tar. La letra c le dice a tar que cree un nuevo archivo. La opción v (verbose) fuerza a tar al modo detallado imprimiendo los nombres de los ficheros según se archivan. La opción f (file) le dice a tar que el siguiente argumento, backup.tar, es el nombre del archivo a crear. El resto de los argumentos de tar son los nombres de archivos y directorios a añadir al archivo backup.tar. Más ejemplos:

# tar cvf log.tar /var/log # tar cvzf log.tar.gz /var/log

Luego de probar estas dos líneas, compruebe la diferencia de tamaños entre los dos archivos creados. En el primer caso, solo está agrupado. En el segundo ejemplo, está agrupado y comprimido.

# tar cf files.tar file1 file2 Crea el archivo files.tar concatenando los archivos file1, file2 que le hemos pasado.

# tar xvf files.tar Extrae los archivos que se encontraban concatenados dentro de files.tar.

# tar czf files.tar.gz file1 file2 Crear el archivo concatenando los archivos file1, file2 que le hemos pasado y aplica una compresión de tipo gzip creando así un archivo de salida files.tar.gz.



# tar cjf files.tar.bz2 file1 file2 Crear el archivo concatenando los archivos file1, file2 que le hemos pasado y aplica una compresión de tipo bzip2 creando así un archivo de salida files.tar.bz2.

# tar xvzf files.tar.gz Realiza una descompresión de tipo gunzip para después extraer los archivos que se encontraban concatenados dentro de files.tar.gz. También puedo utilizar tar con la extensión .tgz.

# tar xvjf files.tar.bz2 Realiza una descompresión de tipo bz2 para después extraer los archivos que se encontraban concatenados dentro de files.tar.bz2.

Comando gzip Utilidad de compresión de archivos. El archivo comprimido tendrá la extensión .gz. A diferencia de lo que estamos acostumbrados a ver en windows con este comando sólo no podemos realizar la compresión de varios ficheros en un solo, para eso necesitaremos la ayuda de un segundo comando de concatenación de ficheros que es el tar que vimos anteriormente.

Nota: gzip no sirve para comprimir directorios. Por ejemplo:

$ gzip terminator.sgml Esto devuelve: terminator.sgml.gz

Si por el contrario queremos descomprimir un archivo comprimido anteriormente con este comando lo haremos de la siguiente manera:

$ gzip -d terminator.sgml.gz Comando gunzip Utilidad para descompresión de archivos. Realiza la acción contraria que gzip. Descomprime archivos .gz devolviéndolos a su tamaño original.

Nota: Es equivalente a ejecutar gzip -d archivo. $ gunzip terminator.sgml.gz

y $ gzip -d terminator.sgml.gz

son equivalentes

$ gunzip -cd blackbox.tar.gz Luego de aplicar el comando nos queda con el siguiente nombre: blackbox.tar Ahora debo utilizar el comando tar para abrir o desagrupar dicho archivo.

$ tar –xvf blackbox.tar Como vimos antes la opción x descomprime el archivo, v me muestra los archivos y directorios en la pantalla y f por el archivo. El comando unzip Otro comando de descompresión que resulta muy útil, ya que nos permite descomprimir todos aquellos .zip que los amigos de windows nos envían a través de su winzip.

$ unzip pantallazul.zip Existe un comando de compresión zip, pero no resulta útil ya que con los formatos de compresión .gz y .bz2 nos basta incluso si queremos mandárselo a algún amigo de windows ya que se podrán abrir sin problemas con cualquier tipo de utilidad de compresión como puede ser el winzip o winrar. Comando bzip2 Utilidad de compresión de archivos más potente que gzip. El modo de funcionamiento es el mismo. bzip2 archivo para comprimir.

bzip2 -d archivo para descomprimir. Los archivos comprimidos con este comando tendrán la extensión .bz2.

$ bzip2 terminator.sgml



$ bzip2 -d terminator.sgml.bz2

Paquetes DEB Debian introduce el paquete DEB como formato para la administracion de sus paquetes. Un paquete .deb tiene varias virtudes sobre el rpm, el cual tiene varias limitaciones. Muchas de las ventajas que tiene mas que nada tienen que ver con la politica de Debian. En Debian es algo de todos los dias actualizar un paquete y que siga funcionando como la versino previa, en RedHat es dificultoso. Desde la version 2.1 hasta la actual, es posible mudarse y actualizar la version que tengamos a la ultima sin reiniciar el equipo ni tener problemas de dependencias. Las dependencias son un problema que solo existe en RedHat. En Debian para instalar una aplicación simplemente hay que pedirselo al administrador de paquetes y el solo resuelve las dependencias y las instala luego de que le damos el visto bueno. El front-end principal en Debian es el apt-get. El apt-get introduce la novedad de poder decirle cuales son las fuentes de las cuales uno puede conseguir aplicaciones, paquetes deb. El archivo de configuracion principal esta en /etc/apt/sources.list y tiene un formato similar al siguiente: azrael:/etc/apt# cat sources.list #Debian official repository deb http://ftp.debian.org/debian/ sid main non-free contrib #Debian non-us official repository deb http://non-us.debian.org/ sid/non-US main non-free contrib #Debian security updates deb http://security.debian.org/ stable/updates main non-free contrib #Mplayer official repository deb ftp://ftp.nerim.net/debian-marillat/ unstable main Este archivo, contiene las direcciones de donde puede conseguir paquetes el apt-get. Estas direcciones pueden ser servidores ftp, servidores http, recursos compartidos de red, cdroms, dvds, o simplemente un directorio de nuestro equipo. Debian tiene una herramienta para configurar este archivo, se llama apt-setup y si la ejecutamos el menu en consola que nos muestra simplemente nos deja elegir de donde queremos instalar paquetes y luego prueba la fuente que le definimos. Por otro lado, podemos bajar tambien fuentes. En el ejemplo solo tenemos paquetes compilados, pero si quisieramos bajar las fuentes de los paquetes compilados solo hay que agregar una linea como esta: deb-src http://ftp.debian.org/debian/ sid main non-free contrib De esta forma, con una linea igual a la que ya habia, reemplazamos el deb por el deb-src y a partir de ahora tenemos disponibles fuentes. El tercer campo describe la version que estamos usando. Debian maneja tres versiones al mismo tiempo, stable, testing y unstable. La ideal para servidores en produccion es stable, es la que contiene todos los paquetes probados y testeados sin problemas de seguridad. La desventaja es que puede que encontremos paquetes desactualizados en cuanto a versiones, dado que para considerarse estables tienen que haber pasado una serie de pruebas y depuraciones que toman tiempo. Por otro lado, tenemos testing. En testing vamos a encontrar paquetes que si bien son estables, dependen de paquetes que todavia son inestables. Para que no haya problemas de dependencias, se los mantiene en testing hasta que sean aprobados todos los paquetes con sus dependencias. En unstable vamos a encontrar lo mas nuevo y reciente. Los paquetes son funcionales, son usables, pero mas que nada para una workstation. El motivo principal es que hay actualizaciones muy seguido y hay paquetes nuevos todo el tiempo y algunas cosas no salen 100% probadas. Las versiones de los paquetes en unstable son las mismas versiones que tiene la ultima version de RedHat o la ultima version de Mandrake. La diferencia principal es que aca Debian prueba las cosas y no las da a probar a los usuarios como hacen otras distribuciones. Si queremos buscar un paquete en la web, podemos ir a packages.debian.org donde tenemos un buscador para encontrar paquetes por version. Aca vamos a encontrar cerca de 13000 paquetes disponibles, empaquetados para Debian.



Por otro lado, existe una pagina, www.apt-get.org en donde vamos a poder conseguir fuentes para agregar a este archivo. El caso puntual de la ultima fuente que tiene el ejemplo fue sacada de esta pagina. Estas fuentes aportan los paquetes para reproducir archivos de video que no son de libre distribucion y no terminan de tener una licencia del todo clara, como el caso de los divx. Para cualquier otro tipo de aplicaciones que esten en una situacion similar y no esten en los repositorios de Debian, es posible que la encontremos aca. Hay que aclarar que estos paquetes no estan probados por el proyecto Debian, con lo cual pueden traer problemas a futuro. Bueno, hasta ahora vimos solo el archivo de configuracion y como manejarlo. Ahora vamos a ver que luego de hacer un cambio en ese archivo hace falta actualizar la base de datos de paquetes. La base de datos hace falta actualizarla para poder ver que tenemos instalado y que tenemos disponible para instalar. Para realizar esta tarea se usa el comando apt-get de la siguiente forma: azrael:~# apt-get update Hit http://mentors.debian.net unstable/main Packages Ign http://mentors.debian.net unstable/main Release Hit http://mentors.debian.net unstable/contrib Packages Ign http://mentors.debian.net unstable/contrib Release Hit http://security.debian.org stable/updates/main Packages Hit http://security.debian.org stable/updates/main Release Hit http://security.debian.org stable/updates/non-free Packages Hit http://security.debian.org stable/updates/non-free Release Hit http://security.debian.org stable/updates/contrib Packages Hit http://security.debian.org stable/updates/contrib Release Hit http://ftp.debian.org sid/main Packages Hit http://ftp.debian.org sid/main Release Hit http://ftp.debian.org sid/non-free Packages Hit http://ftp.debian.org sid/non-free Release Hit http://ftp.debian.org sid/contrib Packages Hit http://ftp.debian.org sid/contrib Release Hit http://non-us.debian.org sid/non-US/main Packages Hit http://non-us.debian.org sid/non-US/main Release Hit http://non-us.debian.org sid/non-US/non-free Packages Hit http://non-us.debian.org sid/non-US/non-free Release Hit http://non-us.debian.org sid/non-US/contrib Packages Hit http://non-us.debian.org sid/non-US/contrib Release Reading Package Lists... Done azrael:~# Ahora podemos comprar que tenemos instalado y ver si hay algo pendiente para actualizar. Para esto podemos usar nuevamente el apt-get de la siguiente forma: azrael:~# apt-get upgrade -u Reading Package Lists... Done Building Dependency Tree... Done The following packages have been kept back: kvim vim The following packages will be upgraded: abiword-common abiword-gnome abiword-plugins abiword-plugins-gnome console-common console-data console-tools dash debconf debconf-i18n debconf-utils e2fslibs e2fsprogs gnome-control-center gnome-pilot ksensors libaudiofile0 libblkid1 libcomerr2 libconsole libgal2.2-0 libgal2.2-common libgnome-pilot2 libkdegst0.6 libnet-perl libpcre3 libpq3 libss2 libstdc++2.10-glibc2.2 libtag1 libuuid1 libxfce4util-1 libxfcegui4-1 libxml2 libxrender1 portmap ssh ssh-askpass-gnome xfprint4 39 upgraded, 0 newly installed, 0 to remove and 4 not upgraded. Need to get 9954kB of archives. After unpacking 6302kB disk space will be freed. Do you want to continue? [Y/n] Aca agregamos el switch “-u” que lo que hace es una pausa antes de comenzar a bajar las aplicaciones e instalarlas. Por otro lado, podemos ver que hay 4 aplicaciones que nos avisa que no va a actualizar, pero no nos



da motivos. Seguramente no puede actualizar esas aplicaciones porque necesita a su vez paquetes que no estan disponibles todavia porque estamos usando unstable y las dependencias no se satisfacen de inmediato. La otra posiblidad es que para instalar esas aplicaciones, haya que instalar mas cosas que no tenemos. Con lo cual el switch de upgrade no nos permite instalar nuevas aplicaciones, sino solo actualizarlas. Para solucionar esto, tendriamos que paquete por paquete pedirle que los instale, de la siguiente forma: azrael:~# apt-get install kvim vim Reading Package Lists... Done Building Dependency Tree... Done The following extra packages will be installed: vim-common Suggested packages: cscope vim-doc ctags The following NEW packages will be installed: vim-common The following packages will be upgraded: kvim vim 2 upgraded, 1 newly installed, 0 to remove and 41 not upgraded. Need to get 4677kB of archives. After unpacking 77.8kB of additional disk space will be used. Do you want to continue? [Y/n] De esta forma, solucionamos el problema de paquetes que no podia actualizar porque en la misma operación tenia que tambien instalar paquetes que no tenia antes. Como instalar una aplicación? Bueno, ya vimos algo antes, para instalar una aplicación es relativamente sencillo, el apt-get tiene varios switchs y uno de ellos es install. Luego tiene que figurar el nombre del paquete a instalar. azrael:~# apt-get install nmap Reading Package Lists... Done Building Dependency Tree... Done The following NEW packages will be installed: nmap 0 upgraded, 1 newly installed, 0 to remove and 43 not upgraded. Need to get 438kB of archives. After unpacking 1466kB of additional disk space will be used. Get:1 http://ftp.debian.org sid/main nmap 3.50-1 [438kB] Fetched 438kB in 17s (24.7kB/s) Selecting previously deselected package nmap. (Reading database ... 104953 files and directories currently installed.) Unpacking nmap (from .../archives/nmap_3.50-1_i386.deb) ... Setting up nmap (3.50-1) ... De esta forma, tenemos instalado el nmap. Que pasa si queremos desinstalarlo? azrael:~# apt-get remove --purge nmap Reading Package Lists... Done Building Dependency Tree... Done The following packages will be REMOVED: nmap* 0 upgraded, 0 newly installed, 1 to remove and 43 not upgraded. Need to get 0B of archives. After unpacking 1466kB disk space will be freed. Do you want to continue? [Y/n] y (Reading database ... 104969 files and directories currently installed.) Removing nmap ... azrael:~# Listo, no mas nmap. El switch adicional “--purge” le avisa al apt-get que queremos que desintale tambien los archivos de configuracion de la aplicación, sino, por defecto no los borra.



Como sabemos que paquetes tenemos disponibles? Como buscamos un paquete? azrael:~# apt-cache search apt-get apt - Advanced front-end for dpkg apt-build - Frontend to apt to build, optimize and install packages apt-move - Maintain Debian packages in a package pool auto-apt - package search by file and on-demand package installation tool cron-apt - Automatic update of packages using apt debarchiver - Tool to handle debian package archives debwrap - Wrapper for dpkg/apt-get gnome-apt - graphical package manager jablicator - Share a set of package choices newbiedoc - Documentation by and for newbies r-base - GNU R statistical computing language and environment synaptic - Gtk GUI-frontend for APT synaptic-debtags - Gtk GUI-frontend for APT with debtags support qmail-src - Source only package for building qmail binary package azrael:~# De esta forma, buscamos entre las bases de datos que bajamos con el apt-get update y nos muestra todas las posibles respuestas. Entre ellas, podemos ver que encontro front-ends para el apt como el gnome-apt y el synaptic. Ambas aplicaciones, son para administrar los paquetes de forma grafica, ideales para actualizar, instalar y desinstalar todo desde el modo grafico. No tiene mucho valor entrar a ver estos programas en detalle porque son bastante intuitivos por estar hechos para el modo grafico, pero si conviene que hablemos un poco del aptitude. El aptitude es un front-end para consola muy bueno. Para instalarlo, ya saben, apt-get install aptitude y con aptitude alcanza para arrancarlo. La interfaz es en consola, basada en ncurses y tiene menues, metodos de busqueda, actualizacion de paquetes, sugerencia de paquetes, etc. Una herramienta que se vuelve fundamental a corto plazo para la administracion de paquetes. Por otro lado, se nos puede presentar la necesidad de saber mas informacion del paquete que buscamos. Por hay necesitamos saber que version es o algo mas basico como averiguar para que sirve. Bueno, esto se hace de la siguiente forma. azrael:~# apt-cache show aptitude Package: aptitude Priority: optional Section: admin Installed-Size: 2646 Maintainer: Daniel Burrows <[email protected]> Architecture: i386 Version: 0.2.14-3 Depends: libapt-pkg-libc6.3-5-3.3, libc6 (>= 2.3.2.ds1-4), libgcc1 (>= 1:3.3.2-1), libncurses5 (>= 5.3.20030510-1), libsigc++-1.2-5c102, libstdc++5 (>= 1:3.3.2-1) Filename: pool/main/a/aptitude/aptitude_0.2.14-3_i386.deb Size: 989972 MD5sum: e86011f47b49eacb69f4bd82f9564c8b Description: curses-based apt frontend aptitude is a curses-based apt frontend with a number of useful extended features, including: a mutt-like syntax for matching packages in a flexible manner, dselect-like persistence of user actions, the ability to retrieve and display the Debian changelog of most packages, and extreme flexibility and customization. . aptitude is also Y2K-compliant, non-fattening, naturally cleansing, and housebroken. azrael:~# Finalmente, no podemos dejar de mencionar el dpkg. En sus principios, el Debian no tenia el apt-get, tenia el dpkg. Cumple funciones similares a las que el comando rpm de RedHat, pero sigue solucionando el problema de las dependencias. La limitacion que tiene el dpkg, es que no puede acceder a internet o buscar en los repositorios de Debian que definamos en el /etc/apt/sources.list como hace el apt-get. Entonces, para instalar algo tenemos que bajarlo de internet y decirle donde lo dejamos.



azrael:/usr/src# dpkg -i kernel-image-2.4.24-azrael_1.1_i386.deb Selecting previously deselected package kernel-image-2.4.24-azrael. (Reading database ... 104953 files and directories currently installed.) Unpacking kernel-image-2.4.24-azrael (from kernel-image-2.4.24-azrael_1.1_i386.deb) ... Setting up kernel-image-2.4.24-azrael (1.1) ... A new kernel image has been installed, and usually that means that some action has to be taken to make sure that the new kernel image is used next time the machine boots. Usually, this entails running a ``bootloader'' like SILO, loadlin, LILO, ELILO, QUIK, VMELILO, ZIPL, or booting from a floppy. (Some boot loader, like grub, for example, do not need to be run on each new image install, so please ignore this if you are using such a boot loader). A new kernel image has been installed at /boot/vmlinuz-2.4.24-azrael (Size: 904kB) Symbolic links, unless otherwise specified, can be found in / LILO sets up your system to boot Linux directly from your hard disk, without the need for booting from a boot floppy. WARNING If you are keeping another operating system or another version of Linux on a separate disk partition, you should not have LILO install a boot block now. Wait until you read the LILO documentation. That is because installing a boot block now might make the other system un-bootable. If you only want to run this version of Linux, go ahead and install the boot block here. If it does not work, you can still boot this system from a boot floppy. Would you like to create a boot floppy now? [No] You already have a LILO configuration in /etc/lilo.conf Install a boot block using the existing /etc/lilo.conf? [Yes] Testing lilo.conf ... Testing successful. Installing the partition boot sector... Installation successful. azrael:/usr/src# El proceso de instalacion, no es solo desempaquetar y compiar archivos. En una gran cantidad de paquetes luego de desarmar el deb el paso siguiente es un mini wizard con preguntas para darle una configuracion minima a la aplicación. En el caso del ejemplo, estamos instalando una imagen de un kernel, entonces como paso siguiente modifica el lilo y lo ejecuta para que tome los cambios. Para terminar, nos quedan un par de aclaraciones. En el /etc/apt/sources.list se configura tambien la version del Debian que estamos usando, recuerdan el stable, testing y unstable? Bueno en este archivo le definimos que version usamos. Fijense en el ejemplo siguiente. azrael:/etc/apt# cat sources.list #Debian official repository deb http://ftp.debian.org/debian/ stable main non-free contrib #Debian non-us official repository deb http://non-us.debian.org/ stable/non-US main non-free contrib #Debian security updates deb http://security.debian.org/ stable/updates main non-free contrib En el ejemplo, estamos usando las fuentes oficiales de Debian, paquetes non-us y actualizaciones de seguridad. Las actualizaciones de seguridad no se puede cambiar la version, estamos usando stable y solo hay



actualizaciones de seguridad para stable. En cambio en los dos primeros casos, podriamos cambiar de stable por otra version de Debian, de la siguiente forma: azrael:/etc/apt# cat sources.list #Debian official repository deb http://ftp.debian.org/debian/ unstable main non-free contrib #Debian non-us official repository deb http://non-us.debian.org/ unstable/non-US main non-free contrib #Debian security updates deb http://security.debian.org/ stable/updates main non-free contrib Luego de hacer modificaciones, recuerden de actualizar la base de datos con apt-get update. Ahora el paso natural seria hacer apt-get update pero tengan presente que esto que vamos a hacer es actualizar TODO el sistema con todas sus aplicaciones. Entonces para hacer este tipo de procedimientos especiales hay un switch dedicado a mudarnos de una version a otra y es el apt-get dist-upgrade y asi tenemos actualizado nuestro sistema sin reiniciar el equipo y sin downtime de servicios. Obviamente, cuando le llegue el turno a un servicio, va a haber que reiniciarlo. Pero nada mas que reiniciar ese servicio y lo va a hacer automaticamente el apt-get previo consultarnos. El apt-get es una herramienta muy poderosa, hay muchas cosas que puede hacer y junto con el dpkg y el aptitude la administracion de los paquetes se hace muy sencilla. Podemos ver los archivos de configuracion a instalar en lugar de pisar los que ya hay, podemos ver que archivos instalo el paquete nuevo, tenemos un control de cambios, podemos programar actualizaciones de seguridad diariamente para estar al dia, hasta se puede hacer un proxy de los paquetes deb si tenemos muchos Debian instalados en nuestra red y de esta forma ahorrar ancho de banda y ganar velocidad. Todo esto y mucho mas lo vamos a poder encontrar en la documentacion en la pagina de Debian en varios idiomas por de mas explayado y con muchos ejemplos.

Paquetes RPM RPM quiere decir Redhat Package Manager, o sea, que RPM es el programa administrador de paquetes de Redhat. El formato RPM guarda dentro de cada paquete información suficiente para que el programa de gestión conozca todo sobre él, lo que incluye la versión y los archivos y directorios donde se instala, una descripción del mismo, y la lista de otros paquetes que son requeridos. La extensión de los paquetes es: .rpm. Note que los paquetes rpm, aparte de la extensión rpm en su nombre, también tienen un número, i386, i586 ó i686. Esto depende de su PC y la distribución de Linux que use. Ese número corresponde al procesador en que se compiló ese paquete.

Nota: Si tengo un paquete i386, éste se podrá instalar en cualquier procesador superior, es decir que soporta escalabilidad. En cambio si el paquete es i686 no podrá instalarse en procesadores inferiores.

Al RPM lo vamos a encontrar muchas distribuciones basadas en RedHat que adoptaron el RPM como sistema de paquetes. Escencialmente, el sistema RPM tiene una serie de problemas. Principalmente cuando nos ponemos a hablar de dependencias, el rpm no maneja dependencias. Esto se presenta cuando queremos instalar una aplicación y nos avisa que la aplicación se podria instalar si tuviera otras aplicaciones que no tiene instaladas. Para esto, tenemos que a su vez instalar esas aplicaciones que probablemente necesiten otras para funcionar y esto es un circulo interminable de cosas que necesitamos para instalar algo. En Debian, este tipo de cosas no sucede. Debian usa otro sistema de paquetes llamado (deb). Igualmente en Debian existe la posiblidad de instalar el aplicativo rpm para instalar aplicaciones rpm. Tambien esta la posiblidad de migrar un rpm a un deb con el alien. El alien es una aplicación dedicada a generar un deb a partir de un rpm y de esta forma poder instalar un rpm en Debian sin ningun problema de compatibilidad. Esta herramienta nos permite realizar varias funciones con los paquetes. RPM tiene cinco modos básicos de operación (sin contar la construcción del paquete): instalación, desinstalación, actualización, consulta y verificación. En esta sección veremos cada modo. Para opciones y detalles completos vea la página man de rpm o pruebe: # rpm -–help La sintaxis general del comando es:

rpm <opciones> <paquete.i386.rpm>



Entre las opciones a utilizar, tenemos: -i Para instalar -U De update, actualizar -h Viene de hash, tiene que ver con la base de datos donde se guardan los paquetes, guarda

una marca del progreso de la instalación. Conviene usarla con la opción v

-v Le dice a RPM que haga una salida en formato extendido (verbose) -q De query, para hacer consultas. Se puede combinar con más opciones. Vea más abajo.

--force Para forzar la instalación de un paquete Veamos ejemplos para cada opción. Instalación

# rpm –vhi package.rpm Instala package.rpm, si encuentra otra versión no hace nada. La opción i lo que hace es instalar el paquete, v muestra los archivos y directorios en la pantalla y h hace un hash.

Nota: Los paquetes RPM pueden depender de otros paquetes, lo cual significa que otros paquetes deben ser instalados para funcionar correctamente. Si intenta instalar un paquete para el cual existe una dependencia no satisfecha, usted verá: # rpm -ivh package-1.0-1.i386.rpm failed dependencies: yoyo is needed by package-1.0-1 Para arreglar este error debemos instalar los paquetes requeridos. Si deseara forzar la instalación de todas maneras (una mala idea ya que el paquete probablemente no funcionará correctamente), hay que usar --nodeps en la línea de comandos.

Actualización

# rpm –Uvh package.rpm La opción U nos permite actualizar el paquete. Actualiza o instala package.rpm. Sirve si tenemos otra versión inferior.

# rpm -Uvh yoyo-2.0-1.i386.rpm yoyo ####################################

Lo que usted ve es la instalación, lo que no ve es el hecho de que RPM desinstala automáticamente cualquier versión antigua del paquete yoyo. De hecho, usted quizá quiera usar siempre -U para instalar paquetes, ya que funciona bien incluso cuando no hay ninguna versión anterior del paquete instalada. Dado que RPM realiza actualizaciones inteligentes de los paquetes con archivos de configuración, quizás vea un mensaje como:

saving /etc/yoyo.conf as /etc/yoyo.conf.rpmsave Esto significa que sus cambios al archivo de configuración puedan no ser “reversiblemente compatibles” con el nuevo archivo de configuración en el paquete, por lo que RPM salva su archivo original, e instala uno nuevo. Usted debería investigar y resolver las diferencias entre los dos archivos tan pronto como sea posible para asegurarse de que su sistema continúa funcionando adecuadamente. Dado que actualizar es realmente una combinación de desinstalación e instalación, usted puede encontrar los errores de los dos modos, y uno más: Si RPM piensa que está intentando actualizar un paquete con una versión antigua, veremos:

# rpm -Uvh yoyo-1.0-1.i386.rpm yoyo package yoyo-2.0-1 (which is newer) is already installed error: yoyo-1.0-1.i386.rpm cannot be installed

Para obligar a RPM a actualizar de todas maneras, use --oldpackage en la línea de comandos Consulta Consultar la base de datos de paquetes instalados se realiza mediante la opción rpm -q. Ejemplo:

#rpm -q yoyo yoyo-2.0-1

Se imprimirá el nombre, versión y número de desarrollo del paquete instalado yoyo.



En lugar de especificar el nombre del paquete, puede usar las siguientes opciones con -q -a consulta todos los paquetes instalados. -f <file> consultará el paquete al que pertenece <file>. -p <packagefile> consulta el paquete <packagefile>. -i presenta información del paquete como nombre, descripción, desarrollo,

tamaño, fecha de construcción, fecha de instalación, vendedor, y otra información miscelánea.

-l presenta la lista de archivos que el paquete posee. -d presenta un lista de archivos marcados como documentación (paginas man,

paginas info, README's, etcétera). -c presenta una lista de archivos marcados como archivos de configuración. Son

los archivos que cambiamos tras la instalación para adaptar el paquete al sistema (sendmail.cf, passwd, inittab, etcétera).

Para aquellas opciones que presenten listas de archivos, podemos añadir -v a la línea de comandos para obtener la lista en el conocido formato ls -l. Ejemplos:

$ rpm -qa Consulta la base de datos RPM y lista todos los paquetes instalados.

$ rpm -qpl package.rpm Consulta package.rpm y lista todos los archivos.

$ rpm -qpi package.rpm Consulta package.rpm y muestra información.

$ rpm -qf /some/file Chequea en que paquetes se encuentra el archivo

Desinstalar un paquete

# rpm –e package.rpm borra package del sistema. Desinstalar un paquete es tan sencillo como instalarlo:

# rpm -e yoyo Nota: Hemos usado el nombre yoyo para el paquete, no el nombre del paquete original yoyo-1.0-1.i386.rpm.

Usted puede encontrar un error de dependencias cuando intente desinstalar el paquete si algún otro paquete instalado depende del que está intentando borrar. Por ejemplo:

# rpm -e yoyo removing these packages would break dependencies: yoyo is needed by package-1.0-1

Para hacer que RPM ignore el error y desinstale el paquete de todas maneras (que es una mala idea porque el paquete que depende de éste probablemente falle y no funcione correctamente), use --nodeps en la línea de comandos. Verificación Verificar un paquete es comparar la información sobre los archivos instalados desde un paquete con la misma información del paquete original. Entre otras cosas, verificar compara el tamaño, chequeo MD5, permisos, tipo, usuario y grupo de cada archivo.

# rpm -V yoyo Verifica un paquete. Es decir verifica que todas los archivos el paquete yoyo estén como cuando fueron originalmente instaladas. Se puede usar combinada con algunas de las opciones listadas para consultar. Por ejemplo: Para verificar que un paquete contiene un archivo en particular:

# rpm -Vf /bin/vi Para verificar todos los paquetes instalados:

# rpm -Va Esto puede ser útil si sospecha que su base de datos de paquetes RPM esta corrupta.



Si todo es verificado adecuadamente no habrá ninguna salida en pantalla. Si hay alguna discrepancia sí habrá información presentada. El formato de la salida es una cadena de 8 caracteres, una posible letra c denotando un archivo de configuración, y después el nombre del archivo. Cada uno de los 8 caracteres denota el resultado de la comparación de un atributo del archivo con el valor de ese atributo en la base de datos RPM. Un solo ‘.’ (punto) significa que el test ha sido pasado. Los siguientes caracteres denotan fallo de ciertos tests:

5 Chequeo MD5 S Tamaño del archivo L Enlace simbólico T Modificación de la fecha del archivo D Dispositivo U Usuario G Grupo M Modo (incluye permisos y tipos de archivo)

Si tenemos alguna salida en pantalla, debo decidir si me conviene borrar o reinstalar el paquete, o alguna manera de resolver el problema.

Compilación de código fuente Como vimos al principio del capítulo, en Linux podemos obtener paquetes de software de dos formas diferentes: o bien con el código fuente sin compilar, o bien paquetes precompilados a los que llamamos binarios. En este tema nos ocupa como compilar un paquete fuente. Una vez que tenemos el paquete fuente bajado lo descomprimimos como hemos aprendido anteriormente. Un vez hecho esto es muy conveniente, primero, leer siempre el README o el INSTALL que vienen habitualmente con los fuentes. Piense que todo programa que encontremos por ahí fue desarrollado por diferentes personas, cada una con su propio criterio y forma de programar. Allí viene claramente explicado cómo se compila. En general esta compilación la hacemos en 3 fases:

./configure Chequea en busca de librerías (mejor dicho, bibliotecas) y demás cosas necesarias para construir el Makefile que nos permitirá compilar el paquete. Con --prefix=/directorio le diremos donde queremos que deje el resultado de la operación. Cabe aclarar, que el configure viene con las fuentes, por eso el ./ para ejecutarlo, el configure no es un aplicación que venga preinstalada y que esta en el path.

make Compilación en sí del paquete en nuestra máquina. Utiliza el Makefile creado, que está incluido en todos los software para compilar todos los .c .h ,etc, etc.

Nota: En general los códigos fuente de los programas están escritos en lenguaje C. Por este motivo al hacer la compilación vamos a ver en pantalla los archivos .c, y también los archivos .h, que son los headers y contienen las bibliotecas necesarias para que el programa pueda ejecutar. Si el fuente no compila, no ejecutará. Este paso puede tardar mucho tiempo depende del software y de la máquina que tengamos. Idealmente, este tipo de cosas no se hacen en equipos productivos dado que satura el microprocesador hasta llevarlo al 100%.

make install Esto se debe hacer como root, ya que es la instalación del paquete en nuestra máquina.

Si no está el archivo configure no hay problema continuaremos sin la ultima instrucción. La instalación está completa. ¿Qué pasa si hay errores? Si, por ejemplo, el hardware no es compatible para el software veremos algunos errores cuando haga el ./configure. Esto hará que el programa falle en la compilación. Una posible solución es bajar otra versión de ese código fuente. O aprender programación y corregir el código. ¡Recordemos siempre que estamos en el mundo Open Source!



Capítulo 5

¿Qué es el kernel? El kernel es el núcleo del sistema operativo, también podemos decir que es, el sistema operativo. El sistema operativo es un programa, es software, pero es el que gestiona y administra todos los demás programas que están en el sistema. Es el intermediario entre el software y el hardware. Interactúa con los periféricos para que los programas puedan entenderse con estos dispositivos físicos. Por lo tanto maneja la administración de recursos, la sincronización entre procesos, la administración del tiempo que ocupan el procesador, la asignación de memoria, el control de los periféricos, etc. Es una idea errónea creer que Linux es Debian, Red-Hat, Suse, Slackware o cualquier otra distribución, Linux es solo el kernel. Las distribuciones comúnmente conocidas, tienen como núcleo a Linux, y conforman un sistema operativo, complementando con otros elementos de software, como utilidades y herramientas variadas, lo que es software GNU. Frecuentemente aparecen nuevas versiones de kernel. Para ver qué versiones de kernel se encuentran disponibles, o ver cual es la última versión, podemos ir a la página oficial: http://www.kernel.org. Esto es posible gracias a su naturaleza de código abierto. Ésta es precisamente, la gran fortaleza del kernel de Linux, el hecho que los programadores de cualquier parte del mundo tengan acceso a las fuentes y puedan colaborar en su desarrollo. Tipos de kernel Kernel monolítico

Todas las funcionalidades posibles están integradas en el sistema. Se trata de un programa de tamaño considerable que deberemos recompilar por completo cada vez que queramos añadir una nueva posibilidad. Esta es la estructura original de Linux. Por tratarse de una técnica clásica y desfasada el creador de Linux fue muy criticado.

Kernel modular

Se trata de la tendencia actual de desarrollo. En el kernel se centran las funcionalidades esenciales como la administración de memoria, la planificación de procesos, etc. Sin embargo no tiene sentido que el núcleo de un sistema operativo englobe toda la parafernalia para comunicarse con todas las posibles de tarjetas de video o de sonido. En otros sistemas operativos esto se soluciona con unos archivos proporcionados por el fabricante llamados drivers. En Linux se creó una interfaz adecuada para posibilitar el desarrollo de módulos que cumplieran esas funcionalidades. Esos módulos pueden ser compilados por separado y añadidos al kernel en tiempo de ejecución. Más adelante hablaremos sobre los módulos.

Nota: La parte monolítica del núcleo es la que se carga en cada arranque y está activa en todo momento, sin embargo los módulos únicamente se activan cuando se requiere utilizar ese dispositivo en concreto. Esto significa que podemos tener una serie de dispositivos soportados, pero que no están cargados en memoria durante todo el tiempo, si no que se incorporan cuando se hace una llamada a ese hardware.

Versiones del kernel (Numeración) Cada versión de kernel está identificada con una numeración. Está conformada por tres números separados por puntos, como por ejemplo 2.6.8.

• El primer número indica la versión principal del kernel. Este número cambia cuando la forma de funcionamiento del núcleo ha experimentado un cambio importante.

• El segundo número también indica cambios, pero menos significativos. Aparte también informa si la versión es de producción o desarrollo. Si el número es par, el núcleo corresponde a una versión estable. En cambio, una numeración impar significa que es de desarrollo.

• La tercera cifra especifica nuevas versiones dentro de otra versión en la que únicamente se han modificado sólo fallos de programación, conocidos como bugs.

Aclaraciones:



Versión de producción: es la más estable hasta el momento. Surge como resultado final de las versiones en desarrollo o experimentales. Cuando el equipo de desarrollo del kernel experimental decide que ha conseguido que sea estable y con la calidad suficiente, aparece la versión de producción o estable. Versión en desarrollo: es la experimental y la que utilizan los desarrolladores para programar, comprobar y verificar nuevas características y correcciones. Suelen ser inestables. Compilación del kernel La compilación del kernel es un paso muy habitual y sencillo en la configuración de Linux, y aunque en principio creamos que es un proceso complicado y que requiera conocimientos de programación, veremos que es un paso casi automatizado en su totalidad, basándose en la ejecución de comandos, sin necesidad de que nosotros hagamos nada con los archivos fuente. Compilar el kernel no tiene ningún peligro si se realiza una copia de seguridad del kernel antiguo en una unidad de diskette; o, sino al compilar el nuevo kernel guardarlo con otro nombre, de forma de no sobrescribir el actual, que ya lo tenemos funcionando. Es muy aconsejable antes de iniciar la compilación del kernel, leer el manual y/o HOW-TO.

Nota: Puede ocurrir que el kernel compilado no levante, y nos quedamos sin sistema operativo.

¿Qué quiere decir compilar? Compilar es el mecanismo que se encarga de traducir los archivos fuente, escritos en formato texto en un lenguaje de programación, a archivos binarios para que los pueda entender el procesador. El kernel es un programa. Como cualquier programa que quiero que ejecute, primero debe compilarse. Cuando la compilación termina correctamente, se crean los archivos binarios. Binario es sinónimo de ejecutable. Para compilar necesito un compilador, un programa que chequea la sintaxis del código. El compilador que se utiliza es el gcc. Anteriormente también les hablamos de Makefiles. Los Makefiles son archivos que contienen las órdenes para hacer varias compilaciones juntas, y establecer opciones especiales para la compilación. ¿Para qué compilar el kernel? Existen varias respuestas a esta pregunta. Una respuesta elegante sería:

Para tener buen rendimiento entre el software y el hardware. Esto quiere decir, voy a adaptar Linux a la arquitectura de mi equipo, voy a habilitar características que necesito o deshabilitar dispositivos que no tengo instalados. Esto proporciona rapidez y optimiza el funcionamiento. A veces hay que compilar el kernel para dar soporte a algunos dispositivos que el sistema no reconoce. Es agregarle drivers. Es una forma de optimizar, tener sólo los dispositivos que utilizamos, evitando así saturar el kernel con multitud de controladores innecesarios, que sólo entorpecen su funcionamiento. También podemos usar los módulos, los cuales sólo se cargan cuando se necesitan, con el ahorro de memoria que esto supone. Nos brinda la oportunidad de configurar manualmente nuestro sistema. Si tenemos algunos problemas y entendemos la programación en “C” (el lenguaje en el que está escrito el kernel de Linux) los podemos solucionar, ya que disponemos del código y libertad para modificarlo a nuestro gusto. De esta forma, al final tendremos un sistema hecho a medida, y sólo con los dispositivos que necesitamos.

Nota: Sólo podemos compilar el kernel como superusuario o root. Empecemos con la compilación del kernel En primer lugar para poder compilar el kernel necesitamos tener los fuentes del mismo. Si hemos cargado las fuentes del kernel precompilado de nuestra distribución, tendremos las mismas en el directorio /usr/src/linux o /usr/src/linux-2.6.8 o /usr/src/kernel-source-2.6.8 Dependiendo de la distribución. En caso de no tener los fuentes, debemos conseguirlos, ya sea de los CD-ROM de instalación, o bajarlos de internet. Recuerde que la página oficial es http://www.kernel.org. Todo el proceso de compilación debe hacerse en el directorio /usr/src/linux, que es donde están los fuentes y se basa en una serie de comandos y configuraciones que veremos a continuación. Los fuentes vienen en formato .tar.gz o .tar.bz2. Una vez que tenemos los fuentes en nuestra máquina debemos descomprimirlos en un directorio, lo común es hacerlo en /usr/src/ Debemos descomprimirlos.



# tar xvzf kernel-source-2.6.8.tar.gz ó # tar xvjf kernel-source-2.6.8.tar.bz2

Se creará un directorio llamado kernel-source.2-6.8. Nos conviene crear un link, con el comando # ln –s kernel-source.2-6.8 linux Ahora ya estamos listos para empezar. Nos ubicamos en /usr/src/linux. Para modificar las opciones que debe llevar el nuevo kernel, podemos optar entre 3 formas de configuración, cada una de las cuales es más visual que la anterior

make config basado en la consola en modo texto y funciona a base de preguntas a las que contestaremos y/n/m. Para compilar algo como parte del kernel hay que contestar "y", para compilarlo como módulo, "m", y para no compilarlo se debe contestar "n".

make menuconfig basado en modo texto, funciona a base de una ventana de menúes bastante gráfica y con ayudas, las opciones se seleccionan con la barra espaciadora.

make xconfig basado en un interface muy visual en Tcl/Tk, para ser usado en X-Window.

Elegimos uno de los tres tipeando el comando correspondiente, y el sistema nos preguntará el valor para las diferentes opciones para el kernel, a las que contestaremos con y (SI incluir en el kernel), n (no incluir en el kernel) o m (de módulo: compilarlo pero no incluirlo, para poder incluirlo en cualquier otro momento mediante comandos). Los módulos se usan para opciones que no se utilicen habitualmente, como por ejemplo una unidad zip, pero cosas como las tarjetas de sonido deberían incluirse directamente en el kernel, ocupando memoria. Las opciones se agrupan en subsecciones generales, de red, de sonido, etc. en las cuales tendremos que elegir los parámetros correspondientes al hardware instalado en nuestro PC. Si por ejemplo no tuviésemos impresora pero en el futuro pensáramos adquirir una, es posible compilar el soporte para puerto paralelo como módulo para poder insertarlo más adelante. Por otra parte, una elección casi siempre imprescindible es la de Sistema de ficheros iso9660, vfat y codepages 437, 850 y NLS ISO-8859-1 para poder montar CD-ROMs y unidades con nombres largos o FAT32. Es importante una opción llamada "loadable modules support" que nos permite agregar módulos en el sistema. Un módulo es una parte del kernel que se carga en la memoria sólo cuando se la necesita y se descarga cuando ya no es necesaria, compilar partes del kernel como módulos hará que el sistema funcione más rápido, sin embargo no es bueno compilar como módulos cosas que se van a usar constantemente ya que su continua carga y descarga ralentizaría el sistema. Además, compilar como módulos cosas que son necesarias para arrancar el sistema hará que el nuevo kernel no sea capaz de arrancar, esto se debe a que los módulos se encuentran en el sistema de archivos y no están disponibles hasta que se montan. Por ejemplo, compilar el soporte para el sistema de ficheros ext2 o ext3 como módulo en un sistema cuya partición raíz es un sistema de ese tipo nos dejará un kernel inservible. Hay muchas opciones a las que contestar, y es posible que no sepamos lo que hacen una buena parte de ellas, la ayuda que tiene cada opción es bastante buena y nos dará una idea de lo que debemos contestar. En cualquier opción podemos pulsar F1 para obtener ayuda (según el make realizado) sobre el tema en cuestión, que además normalmente nos informará el tamaño que ocuparía dicha opción en el kernel en caso de ser activado y lo que es recomendado en ese caso. Una vez marcadas todas las opciones deberemos salir guardando los cambios. Algunas de las diferentes secciones que suelen encontrarse al abrir el kernel son:

Code maturity level options: -> Opciones para permitir drivers en desarrollo. Loadable module support: -> Opciones sobre permitir la utilización de módulos. General setup: -> Cosas generales: emulado de coprocesador, tipo de procesador, etc. Floppy, IDE, and other block devices: -> Unidades IDE y ATAPI. CUIDADO: El soporte para IDE o SCSI debe ir como Y (no como módulo). Networking options: -> Opciones de red. SCSI support: -> Soporte para dispositivos SCSI. Network device support:



-> Propiedades de red. ISDN subsystem: -> Para tarjetas ISDN. CD-ROM drivers (not for SCSI or IDE/ATAPI drivers): -> Drivers CDROM para unidades no IDE, ATAPI o SCSI. Filesystems: -> Sistemas de ficheros: vfat, msdos, ext2, NTFS, etc... CUIDADO: El soporte para ext2, ext3 debe ir como Y (no como módulo). Character devices: -> Configuración de impresora, mouse no serie, etc. Sound: -> Parámetros de la tarjeta de sonido. Kernel hacking: -> Extras avanzados para desarrolladores del kernel.

Tras elegir las opciones salimos grabando, tipeamos: Save and Exit A continuación procederemos a compilar todo aquello que acabamos de marcar. Este paso suele tardar algún tiempo. Hacemos:

# make dep crea las dependencias de los módulos. # make clean borra las configuraciones anteriores. # make bzImage este paso es muy importante ya que comprime el kernel que hemos

creado. Ahora vamos a crear y a compilar los módulos:

# make modules crea los módulos que hemos definido. # make modules_install genera los directorios e instala los módulos creados en el paso

anterior.

Nota Estos pasos que vimos recién, a partir de las versiones de kernel 2.6, pueden reducirse a los siguientes: #make Llama al compilador y empieza a chequear todo el código fuente, controla la sintaxis, las dependencias y si todo dá ok, crea el kernel. #make modules Compila los módulos. #make modules_install Una vez realizada la compilación de los módulos los instala. Esto colocará los módulos en el directorio /lib/modules/2.6.8 Una vez en este punto, lo que nos queda hacer es copiar el nuevo kernel a su lugar para poder arrancarlo. La compilación deja el kernel en el directorio /usr/src/linux/arch/i386/boot/ con el nombre de bzImage. En la mayoría de distribuciones se colocan los kernels en el directorio /boot, es lo que haremos:

# cp bzImage /boot/vmlinuz-2.6.8-1

Nota: En este paso debe tener cuidado. Note que el archivo copiado a /boot tiene otro nombre, en este ejemplo, le agregamos un -1. Si lo nombramos igual que el kernel existente, sobreescribiremos el kernel que está funcionando. Ahora lo que falta para que el nuevo kernel pueda arrancar, es agregar algunas líneas en el archivo de arranque, del programa lilo o grub, el que esté utilizando en mi sistema Linux. Unas líneas más adelante lo veremos. Antes vamos a aclarar algo. Los pasos que vimos recién sirven para compilar el kernel en cualquier distribución Linux

En Debian vamos a cambiar una parte, ya que para instalar software, acuérdense que usábamos el comando apt-get install. Bueno, el kernel es un software, un programa, por lo tanto podemos usar este comando. La diferencia es que en el caso del kernel, como yo quiero compilarlo, no quiero el programa ejecutable, instalado y funcionando, como lo hace apt-get install, aquí quiero instalar el código fuente, y nosotros lo haremos ejecutable a nuestro gusto. Para ello hacemos:



# apt-get install debhelper modutils kernel-package libncurses5-dev # apt-get install kernel-source-2.6.8 # cd /usr/src # tar --bzip2 -xvf kernel-source-2.6.8.tar.bz2 (dentro del directorio /usr/src) # cd kernel-source-2.6.8 # ln –s kernel-source.2-6.8 linux # make menuconfig

Luego siguen los pasos como en el caso anterior Otra forma, válida solo en Debian # make-kpkg clean # indispensable (consultar: man make-kpkg) Edición del archivo de arranque Primero veamos como es este archivo:

# cat /etc/lilo.conf boot=/dev/hda map=/boot/map install=/boot/boot.b prompt timeout=50 message=/boot/message linear default=linux image=/boot/vmlinuz-2.6.8 label=linux initrd=/boot/initrd-2.6.8.img read-only root=/dev/hda2 other=/dev/hda1 label=dos table=/dev/hda

Lo editamos y le añadimos una nueva entrada que dirá:

image=/boot/vmlinuz-2.6.8-1 label=linuxnuevo # aquí va el nombre que quiera ponerle. read-only initrd=/boot/initrd-2.6.8-1.img

append=opciones # aquí van las opciones que necesiten. Por ejemplo: append="hdc=ide-scsi" (esto sería para una grabadora)

Nota: Si se construyó una nueva imagen initrd hay que decirle a lilo que la use.

Luego de hacer esto hay que reinstalar el lilo para ver si es tomado el nuevo kernel. Para ello tipeamos el comando lilo sin parámetros (esto hará que se verifique la configuración de lilo y además se prepare todo para el próximo booteo de la PC).

# lilo [Enter] Si hay error entonces será indicado, puede ser un error de tipeo en alguna sentencia, se modifica el /etc/lilo.conf y se vuelve a ejecutar el comando lilo. Luego se reinicia la PC y se bootea con el nuevo kernel. Si todo funciona bien, entonces no habría problemas y el nuevo kernel arrancará nuestro sistema. En caso contrario o si hay duda se puede consultar el Kernel-Como o HOW-TO. Ahora cuando el sistema arranca y se pulsa Tab en la línea de comandos de lilo boot:, las opciones disponibles se mostrarán

LILO boot: [Pulsar “Tab”] linux linuxnuevo dos



Para arrancar el kernel viejo (linux) basta con presionar Enter, o esperar a que se acabe el tiempo de espera. Si que quiere arrancar con el nuevo (linuxnuevo), tipear linuxnuevo y pulsar Enter. No conviene borrar el kernel viejo ni eliminarlo del archivo de configuración de lilo, si el nuevo kernel no funciona, lo cual es muy probable las primeras veces, siempre podremos volver a arrancar con el viejo kernel para hacer los cambios necesarios. Si el nuevo kernel es simplemente incapaz de arrancar el sistema, lo más probable es que nos hallamos contestado "n" o "m" a alguna opción en la que teníamos que haber dicho "y". Si lo que no funciona es otra cosa, algún periférico, alguna aplicación, etc. es probable que nos hayamos olvidado de compilar el soporte para ese dispositivo o que hayamos elegido una opción equivocada. En cualquier caso no pasa nada si el kernel recién compilado no funciona como queríamos, el kernel viejo seguirá funcionando igual que antes. Ahora veamos como modifico el archivo de arranque si tengo instalado GRUB El archivo de configuración es: /boot/grub/menu.lst boot=/dev/hda default=0 timeout=10 title Debian GNU/Linux (2.6.8) root (hd0,1) kernel /boot/vmlinuz-2.6.8 ro root=LABEL=/ initrd /boot/initrd-2.6.8.img title Debian GNU/Linux (2.6.8-1) root (hd0,1) kernel /boot/vmlinuz-2.6.8-1 ro root=LABEL=/ initrd /boot/initrd-2.6.8-1.img title windows root (hd0,0) chainloader +1

Aquí se llama distinto a los dispositivos. Los discos y las particiones se numeran de esta forma: (hd0,1), que se corresponde con root=/dev/hda2 hd0 es el primer disco, lo que en lilo llamamos hda 1 es la segunda partición, la que normalmente llamamos hda2. Se numeran comenzando de 0. En el primer párrafo default=0 quiere decir que arranca el primer sistema que está listado, en este caso, el sistema viejo, el de kernel sin compilar. Reiniciamos y deberíamos tener las tres opciones en el arranque. Cómo se compila un kernel en RedHat? Lo que vimos hasta ahora, es la forma tradicional de instalar un kernel desde fuentes. RedHat nos ofrece la opción de hacer un make rpm luego de compilar el kernel y los módulos que justamente hace eso, un rpm que luego podríamos instalar con el rpm -i paquete.rpm y no habría que modificar nada en el lilo. Esto igualmente tiene una limitación y es que solo se aplica a fuentes bajadas del sitio de RedHat dado que el Makefile esta modificado para poder hacer un rpm. Cómo se compila un kernel en Debian? En Debian en lugar del make rpm, tenemos una aplicación dedicada a compilar fuentes, no solo del kernel y se llama make-kpkg. Esta aplicación va a analizar el makefile y va a compilarlo (recuerden que el make rpm no lo compila) y del resultado de la compilación va a generar un paquete deb instalable con el dpkg que hará las modificaciones que correspondan en el lilo o grub. Lo bueno de este método, es que con solo pasar ese archivo que nos generó a otro equipo, vamos a poder instalar este kernel en otra máquina y de esta forma poder tener un equipo dedicado a las compilaciones de todos los equipos de nuestra red y no poner en riesgo el servicio compilando kernels en nuestro servidor productivo.



Estructura del kernel modular Módulos Cargables El núcleo de un sistema Linux/UNIX puede ser representado bajo la forma de un objeto monolítico. Sin embargo, tal objeto posee el inconveniente de ser grande y estático. Cada vez que se desee agregar un nuevo dispositivo, es necesario recompilar el núcleo. Además, si uno utiliza ciertos drivers particulares raramente, se está obligado a tenerlo en el núcleo, lo cual tiende a consumir memoria. ¿Que es un módulo cargable? Los módulos cargables, permiten reunir lo útil y lo necesario teniendo un núcleo lo más pequeño posible, cargando bajo demanda aquello que necesita, sea de una forma manual por el super-usuario, o de una manera automática, por medio del demonio kerneld o kmod. De esta forma, la ganancia de recursos no es nada despreciable. Una vez que la compilación del núcleo se ha realizado, los módulos se encuentran en el directorio /lib/modules/x.y.z donde x.y.z corresponde al número de versión del núcleo. En el caso nombrado anteriormente, sería por ejemplo 2.6.8. La administración de módulos está basada en los siguientes comandos:

insmod inserta un módulo en el núcleo. Se puede usar con opciones modprobe inserta el módulo previa prueba. Se puede usar con opciones rmmod descarga un módulo, si ningún proceso lo utiliza lsmod Lista los módulos cargados, de cada uno presenta nombre, tamaño, cuenta de usos y lista

de módulos que lo usan (es equivalente a cat /proc/modules) depmod permite calcular dependencias entre varios módulos o entre todos los disponibles con la

opción -a. Un módulo puede requerir otros, hay dependencias que deben respetarse al cargar y descargar módulos. Por defecto depmod -a escribe las dependencias en el archivo /lib/modules/2.6.8/modules.emp. Cada línea de ese archivo tiene el nombre de un módulo seguido del caracter ':' y los módulos de los cuales depende, separados por espacios.

El archivo /etc/modules.conf Puede suceder que sea necesario configurar un último archivo: el archivo /etc/modules.conf o /etc/conf.modules, según la distribución de Linux que esté utilizando. Es el archivo que usan los comandos de módulos nombrados anteriormente. Este archivo contiene las rutas donde se encuentran los módulos que deben ser cargados y a continuación los alias para los módulos. Las líneas son de este estilo:

option nombre_modulo opt1 [opt2 .. optn] Donde opt1, opt2, etc. son las opciones o parámetros del módulo. Una configuración interesante es la creación de sobrenombre o alias a los módulos. Sirve para no tener que recordar nombres como via82cxxx_audio y en reemplazo usar placa_sonido por ejemplo. Su sintaxis es:

alias nombre_alias nombre_modulo Algunos scripts de configuración del sistema tienen palabras definidas para cargar los módulos correspondientes y es necesario que el usuario edite /etc/modules.conf y asigne alias al modulo. Un ejemplo clásico sería:

alias sound sb alias eth0 ne2k-pci

que asigna el alias sound a un módulo de Sound Blaster y eth0 al módulo ne2k-pci para la placa de red.

Nota: Puede suceder que al momento del primer arranque obtenga este mensaje: Cannot locate module for net-pf-3 Cannot locate module for net-pf-4 Cannot locate module for net-pf-5

¡No se asuste! Este mensaje significa que no encuentra los alias. Para no tenerlo más, añada en el archivo /etc/conf.modules:

alias net-pf-3 off alias net-pf-4 off alias net-pf-5 off



Puede suceder que ciertos dispositivos tengan necesidad de ciertos parámetros particulares. Consulte el documento Kernel HOW-TO. El archivo /etc/modules En este archivo, vamos a encontrar la lista de módulos que se cargan en el arranque, con solo sacar o poner el nombre del módulo el mismo no va a volver a cargarse en el siguiente arranque. Para administrar este archivo o también para cargar módulos en el momento podemos usar una aplicación llamada modconf. Parches para el kernel A veces en vez de instalar un kernel completo, nos alcanzaría con solo instalar el parche que necesitamos Cuando lo tenemos, por ejemplo porque lo descargamos de internet, lo movemos al directorio /usr/src Aquí lo descomprimimos #gunzip patch-2.6.9.test2 Luego aplicamos el comando: #patch -po <patch-2.6.9.test2 Ahora vamos al directorio /usr/src/linux y tipeamos #make menuconfig y seguimos con los pasos ya vistos de compilación.



Capítulo 6

Redes Conceptos Básicos Esta sección ofrece una mirada básica a términos y conceptos relacionados con TCP/IP que serán usados durante el curso. Algunos términos y conceptos básicos: Paquete Se denomina así a la información que se envía a través de la red. Un mensaje generalmente

contiene varios paquetes, que deben ser distribuidos en orden con sus datos intactos. Los niveles de protocolos superiores, TCP y UDP, son usados para ayudar a asegurar la entrega y orden apropiados.

Protocolo Un protocolo es un conjunto de reglas que rigen el funcionamiento de algunas funciones de comunicación. Por ejemplo, IP consiste en un conjunto de reglas para encaminar datos y TCP incluye reglas para la entrega fiable de datos en secuencia.

Protocolo TCP Protocolo para el control de la transmisión. Protocolo de la capa de transporte orientado a conexión que provee una transmisión confiable de datos de full duplex. TCP es parte del stack de protocolo TCP/IP.

Protocolo UDP Protocolo de datagrama de usuario. Protocolo sin conexión de la capa de transporte del stack (pila) de protocolo TCP/IP. UDP es un protocolo simple que intercambia datagramas sin confirmación o garantía de entrega y que requiere que el procesamiento y retransmisión de errores sean manejados por otros protocolos.

Protocolo ICMP Protocolo de mensajes de control en Internet. Protocolo Internet de capa de red que informa errores y brinda información relativa al procesamiento de paquetes IP.

Host También designado nodo final, el término host se refiere a los dispositivos configurados como parte de una red. Un host puede ser un mainframe, una minicomputadora, una PC hogareña, workstations, servidores de archivos, y cualquier otro dispositivo periférico como impresoras, etc.

Dirección Cada nodo debe tener una dirección única para comunicarse vía TCP/IP. La dirección debe seguir el formato de dirección IP. Los cuatros octetos de la dirección IP identifican el host y a la red donde ese host reside. Cada host tendrá además una dirección MAC (Media Access Control) de 6 bytes, que está codificada en la tarjeta de red.

Nombres Cada host debe tener un nombre único. Un método común para manejar nombres es DNS (Domain Name System). Los servidores DNS mapean direcciones IP a nombres DNS.

Nota: Los servidores DNS se verán en próximos capítulos.

Routers Los routers conectan redes entre sí, usando una parte de la dirección IP en la red para

identificar la subred apropiada. Una vez localizada, habiéndole pasado el paquete a un router directamente conectado a la red, el paquete es entregado usando la dirección del host. Como el router encamina datos por una red, quienes escribieron las normas de TCP/IP adoptaron la palabra pasarela (Gateway).

Internet Es un conjunto de redes, locales y/o públicas, conectadas a través de routers en una red de área extensa.

Broadcasting Se refiere a la transmisión de un paquete que se recibe por cada dispositivo en la red. (difusión) En la práctica, el broadcast estará limitado al llamado broadcast domain, es decir a un area

lógica separada de otra por un router y a aquellos dispositivos que compartan la misma subred y gateway adres.

Unicast Es el evnío de paquetes a un solo destino. Unicast se deriva de la palabra broadcast. Unicast

es el extremo opuesto: uno solo envía y uno solo recibe.

LAN, WAN y enlaces Una red de área local (LAN-Local Area Network) es una red de datos cuyo objetivo es dar servicio a un área relativamente pequeña, normalmente de unos pocos kilómetros, cuadras, o menos distancia. Una red de área extensa (WAN-Wide Area Network) cubre una mayor área geográfica y normalmente se construye utilizando líneas serie telefónicas y servicios de conmutación de paquetes. El término enlace es más general, e incluye cualquier medio, de área local o extensa, que utilizan los nodos para comunicarse mediante un protocolo de nivel de enlace.



El modelo de referencia OSI El modelo OSI divide el problema de la comunicación entre equipos a través de redes en siete problemas más simples. Estos siete problemas simples fueron elegidos debido a que son razonablemente independientes y, por lo tanto, más sencillos de resolver. Estos siete problemas simples originan las siete capas del modelo OSI.

7 Aplicación -> Proceso de red hacia las aplicaciones6 Presentación -> Representación de datos5 Sesión -> Comunicación entre host4 Transporte -> Conexiones de extremo a extremo

Capas de host: Controlan la entrega de datos precisa entre equipos

3 Red -> Direcciones y mejor ruta2 Enlace de datos -> Acceso a los medios1 Física -> Transmisión binaria

Capas de medios: Controlan la entrega física de mensajes a través de la red

Las capas más bajas del modelo (de 1 a 3) controlan la transmisión física de mensajes a través de la red, a menudo se las denomina capas de medios. Por otro lado las capas superiores (de 4 a 7) se encargan de la transmisión precisa de datos entre equipos de la red, por lo cual se las denomina capas host. Breve explicación de las capas del modelo OSI Capa 7: Capa de aplicación Es la capa más cercana al usuario, esta capa brinda servicios de red a las aplicaciones del usuario. Las aplicaciones hablan con esta capa. Ejemplo de dichos procesos de aplicación son:

• SMTP - Simple Mail Transfer Protocol (Protocolo Simple de Transferencia de Mail) • FTP - File Transfer Protocol (Protocolo de Transferencia de Archivos) • SMB - Server Message Block (Bloque de Mensajes de Servidor)

Capa 6: Capa de presentación Asegura que la capa de aplicación de un sistema pueda leer la información enviada por la capa de aplicación de otro sistema. Si fuera necesario, esta capa realiza una traducción entre varios formatos de representación de datos utilizando un formato de representación de datos común. Por ejemplo realiza traducción de datos, encriptación, compresión, conversión de juegos de caracteres. Ejemplos pueden ser:

• El redirector de red • SMB y FTP

Capa 5: Capa de sesión Establece, administra y finaliza las sesiones entre aplicaciones. Cada sesión es un diálogo entre dos o más entidades de presentación. Esta capa brinda servicios a la capa de presentación. Además, la capa de sesión sincroniza el diálogo entre las entidades de la capa de presentación y administra el intercambio de datos. Proporciona los recursos para la sincronización de unidades de diálogo, clase de servicio e informes de excepciones relacionados con problemas de las capas de sesión, de presentación y de aplicación. Ejemplos:

• Nombres NetBIOS • Sockets TCP/IP

Capa 4: Capa de transporte Segmenta y reensambla los datos en un flujo de datos. Es como decir, reensambla paquetes en mensajes. Anteriormente dijimos que las capas de aplicación, presentación y sesión están relacionadas con asuntos de aplicación, mientras que las cuatro capas inferiores se encargan del transporte de los datos. Esta capa suministra un servicio de transporte de datos que proteja a las capas superiores de los detalles de implementación del transporte. Proporciona mecanismos para el establecimiento, mantenimiento y finalización ordenada de los circuitos virtuales, la detección y recuperación de fallos de transporte y el control del flujo de información. Asegura que los paquetes sean: Libres de Errores, en Secuencia Correcta, No Duplicados y, por sobre todo, que No se Pierdan. Ejemplos:

• TCP - Transmision Control Protocol (Protocolo de Control de Transmisión) • UDP - User Datagram Protocol (Protocolo de Datagramas de Usuario) • SPX - Sequenced Packet eXchange (Intercambio Sequencial de Paquetes)



Capa 3: Capa de red Es una capa compleja que proporciona conectividad y selección de ruta entre dos sistemas finales que pueden estar ubicados en redes geográficamente distintas. Provee Ruteo y Direcciones Lógicas para traducción a Direcciones físicas. Ejemplos:

• IP - Internet Protocol (Protocolo de InterNet) • IPX - Internetwork Packet eXchange (Intercambio de Paquetes entre Redes)

Capa 2: Capa de enlace de datos Ofrece un tránsito confiable de la información a través del enlace de datos pasando por un enlace físico. Para hacerlo, la capa de enlace de datos se ocupa de direccionamiento físico, notificación de errores, entrega ordenada de tramas y control de flujo. Ejemplos:

• Ethernet • Token Ring

Capa 1: Capa de física Define las especificaciones eléctricas, mecánicas, de procedimiento y funcionales para activar, mantener y desactivar el enlace físico entre sistemas finales. En esta capa se definen características tales como niveles de tensión, sincronización máxima, conectores físicos y atributos similares. La capa física es la que traduce bits en los signos apropiados para el medio. Ejemplos:

• Adaptador de Red • Fibra Óptica • Cable 10Base100 • Conexión Inalámbrica

Comunicación entre capas La comunicación entre capas se da a nivel vertical, lo que vimos anteriormente. La informacion pasa por todas las capas en orden y sin saltearse ninguna. Todas las capas son requeridas para que se dé la comunicación. También hay una relación entre capas a nivel horizontal. En los sistemas para ejecutar tareas de comunicación, una capa debe comunicarse con su capa de igual nivel del otro sistema. El protocolo de cada capa intercambia información, denominada unidad de datos de protocolo (PDU), entre capas iguales.

Aplicación Aplicación Presentación Presentación Sesión Sesión Transporte Segmentos Transporte Red Paquetes Red Enlace de datos Tramas Enlace de datos Física Bits Física

Conjunto de Protocolos TCP/IP Su relación con el Modelo OSI En la actualidad, las funciones propias de una red de computadoras pueden ser divididas en las siete capas propuestas por ISO para su modelo de sistemas abiertos (OSI). Sin embargo la implantación real de una arquitectura puede diferir de este modelo. Las arquitecturas basadas en TCP/IP proponen cuatro capas en las que las funciones de las capas de Sesión y Presentación son responsabilidad de la capa de Aplicación y las capas de Enlace de Datos y Física son vistas como la capa de Interface a la Red. Por tal motivo para TCP/IP sólo existen las capas Interface de Red, la de Intercomunicación en Red, la de Transporte y la de Aplicación. Como puede verse TCP/IP presupone independencia del medio físico de comunicación, sin embargo existen estándares bien definidos a los nivel de Enlace de Datos y Físico que proveen mecanismos de acceso a los diferentes medios y que en el modelo TCP/IP deben considerarse la capa de Interface de Red; siendo los más usuales el proyecto IEEE802, Ethernet, Token Ring y FDDI.

Dirección IP Esta sección introduce los fundamentos del direccionamiento IP. Se presentará la forma en que una dirección IP debe ser organizada. Los siguientes puntos son argumentados dentro de esta sección:

• Fundamentos de la dirección IP



• Coordinación de la dirección IP • Organizando direcciones • Clasificación de redes • Direcciones especiales • Fundamentos de subredes

Fundamentos de la dirección IP Cada host es asignado a una dirección IP única para cada conexión de red (placa de red instalada). La dirección IP se utiliza para identificar un origen de paquetes y hosts de destino. Una dirección IP es un valor de 32 bits escrito en forma de cuatro octetos. Un octeto es un byte, por lo tanto los valores que puede tomar cada octeto varían de 0 a 255. La forma correcta de escribir la dirección IP es poniendo puntos separando los 4 octetos. Por Ejemplo: 192.168.67.2 Cada dirección tendrá además una máscara de red o subred asociada, dividiendo la dirección en el prefijo de su red y el sufijo del host. Por ejemplo: 255.255.255.0 La máscara de subred se utiliza para identifica las porciones de red y host de la dirección.

Red Host 255.255.255 0

La porción de red identifica dónde está localizado el host, y la porción del host identifica el dispositivo conectado a esa red. Coordinación de dirección IP La asignación de direcciones IP en Internet debe ser cuidadosamente coordinada. Con millones de hosts operando en miles de redes, el problema de duplicar direcciones es significativo. Una red conectada a Internet debe obtener una clase de dirección oficial y, recién entonces una dirección de red única. Oficialmente, las direcciones se obtienen de DDN-NIC (Defense Data Network - Network Information Center). En realidad, prácticamente usted recibirá su dirección de su proveedor de Internet (ISP – Internet Service Provider). A una organización se le asigna una dirección de red. La organización puede en un futuro dividirla en sus propias subredes asignando direcciones de host. La razón principal para esto se relaciona con el funcionamiento de la red y el ancho de banda disponible. Sin separar las redes, cada transmisión sería un broadcast a través de la red interna, esperando que el sistema de destino responda. A medida que la red crece, el tráfico se incrementa hasta que excede al ancho de banda disponible. Cuando una red está dividida en subredes, todos los miembros de la subred tendrán el mismo prefijo de red. Los routers dividen las redes y proveen comunicaciones entre redes. Los paquetes dirigidas a un destino dentro de la red local son mantenidos dentro. Sólo los paquetes dirigidos a otras redes son propagados a través de la red, moviéndose de router a router. Los niveles totales de tráfico son reducidos. Organizando direcciones Antes de ver cómo se implementan direcciones IP, veamos algunos límites teóricos. Si todos los bits disponibles en una dirección fueran usados para direcciones de hosts, una dirección de 32 bits debería soportar más de 4 billones de hosts (2 elevado a la 32). hhhhhhhh.hhhhhhhh.hhhhhhhh.hhhhhhhh El problema es que el total de los sistemas deberían estar en una red simple. Esto resultaría en una situación similar a 4 billones de personas hablando al mismo tiempo. Ya hemos mencionado, TCP/IP logra algo como esto mediante subredes. Si el primer octeto fuera dado a direcciones de redes, usted podría, en teoría, direccionar 256 redes y alrededor de 16 millones de hosts en cada una. nnnnnnnn.hhhhhhhh.hhhhhhhh.hhhhhhhh Esto podría causar algunos problemas obvios, uno es el muy limitado número de redes y el otro es el alto número de hosts en cada red.



El tamaño de cada red puede ser disminuido dedicándole por ejemplo dos octetos a la dirección del host. Con esta configuración, se pueden direccionar 65.536 redes con 65.536 hosts cada una. nnnnnnnn.nnnnnnnn.hhhhhhhh.hhhhhhhh Las grandes organizaciones encontrarían en esto una solución apropiada, pero para muchos negocios, esto produciría muchas más direcciones de host de las necesarias. Llevando el proceso a un paso más, los primeros tres octetos podrían estar dedicados a la dirección de red. nnnnnnnn.nnnnnnnn.nnnnnnnn.hhhhhhhh Potencialmente, esto soportaría hasta 16 millones de redes con 256 hosts en cada una. Recuerde que estas son fórmulas teóricas. Los valores del mundo real son menores. Obviamente, ninguna solución cubre las necesidades de cada empresa. Las direcciones IP han sido clasificadas para diferenciar los niveles de direccionamiento. Clasificación de redes Para definir la clase de red, debemos ver en qué rango se encuentra el primer octeto de la dirección. Pero para que la clase de red esté totalmente determinada, lo que debo conocer además de la dirección IP, es su máscara (netmask).

Direcciones de Red Cantidad Clase Inicio Fin Mascara de Red Redes Nodos A 0.0.0.0 127.255.255.255 255.0.0.0 128 16777214 B 128.0.0.0 191.255.255.255 255.255.0.0 16384 65534 C 192.0.0.0 223.255.255.255 255.255.255.0 2097152 254 D: Multicast 224.0.0.0 239.255.255.255 E: Experimental 240.0.0.0 254.255.255.255

Red Clase A En una red clase A, el primer octeto define la porción de dirección para la red (de 0 a 127). Los últimos tres octetos son usados para realizar subneting y la dirección de host. En el primer octeto, el primer bit (llamado también “el más importante” o de “alta categoría”) debe ser seteado como cero. Sólo los últimos siete bits significativos son usados para direccionar y pueden ser seteados como cero o como uno. Esto define 128 redes clase A con direcciones de red que van de 0 a 127. Fuera de esto, sólo 126 son direcciones utilizables, 0 y 127 se reservan. Una máscara de subred por defecto “255.0.0.0” se asigna a redes clase A. Esto significa que usted no debería cambiar el valor de ningún número posicionado en el primer octeto, el asignado a dirección de red. El primer octeto siempre determina al menos una porción de la dirección de red ya que este número no puede ser cambiado una vez asignado. Las redes clase A direccionan hasta 16.777.214 (224-2) hosts. No se puede usar “.0.0.0” o “.255.255.255” como la parte de la dirección para el host. La dirección de host de todos ceros representa “esta red”, y una dirección de host de todos unos representa “difusión a todos los nodos” (broadcast). Red Clase B En una red clase B, los primeros dos octetos son usados para la dirección de red. Los últimos dos octetos son usados para subredes y direcciones de host. El bit más importante del primer octeto debe ser seteado como uno. El segundo más importante debe ser seteado como cero. Los siguientes 14 bits son utilizados para determinar la dirección de red. Esto nos da 16.384 (214) redes clase B, que se extiende de “128.0” a “191.255”. Una máscara de red por defecto “255.255.0.0” es asignada a una red clase B. Esto significa que no podemos cambiar el valor de un número posicionado en los primeros dos octetos. Las redes clase B direccionan 65.534 (216-2) hosts. El valor de todos ceros o todos unos no puede ser usado como valor para una dirección. A dirección de host de todos ceros representa “esta red”, y una dirección de host de todos unos representa “difusión a todos los nodos”.



Red clase C En una red clase C los tres primeros octetos son usados para la dirección de red. El último octeto es usado para las subredes y direcciones de host. Los primeros dos bits del primer octeto deben ser seteados como uno y el bit siguiente debe ser un cero. Los últimos 5 bits del primer octeto, más los 16 bits de los próximos 2 octetos son usados para determinar la dirección de red. Esto nos provee 2.097.152 (221) redes clase C, extendiéndose desde “192.0.0” a “223.255.255”. Una máscara de red por defecto “255.255.255.0” es asignada a una red clase C. Esto significa que no podemos cambiar el valor de un número posicionado en los primeros tres octetos. Las redes clase C direccionan 254 (28-2) hosts. El valor cero o 255 no puede ser usado como valor para una dirección en el último octeto. El número cero representa “esta red”, y el número 255 representa “difusión a todos los nodos”. Red Clase D Este tipo de red se usa para transmisiones multicast, por ejemplo para transmitir voz y datos, o video y datos. Se usa en casos especiales que no corresponden al nivel de este curso. Red clase E Se usan direcciones IP dentro de esta categoría para desarrollo de nuevas tecnologías, protocolos, etc. Es experimental. Direcciones especiales Hay varias estructuras de direcciones especiales sobre las que tiene que conocer. Esto se rige bajo ciertas pautas de principios generalmente aceptados. Estas convenciones están documentadas y utilizados en Internet y son parte del Protocolo de Internet.

Destino Red Host Host en esta red Todos CEROS ID del host

Difusión local Todos UNOS Todos UNOS Difusión dirigida ID de la red Todos UNOS

Loopback 127 Cualquier cosa Como estas direcciones se definieron para un uso específico, no están disponibles para ser direcciones de hosts. Otras direcciones inválidas serían las siguientes:

• Máscara de subred inapropiada • Direcciones clase D • Direcciones clase E • Direcciones duplicadas • Dos sistemas, separados por un router, con la misma dirección de red. • Dos sistemas, en la misma red física, con diferentes direcciones de red.

Una dirección válida es única, genere una dirección de red en la clase correspondiente, y tendrá una máscara de subred apropiada. Redes Privadas Una red interna privada es una red que no estará directamente conectada a Internet, el término Intranet es comúnmente usado para definir redes de este tipo. Los dos ejemplos más comunes de Intranet son:

• Redes que no necesitan conectarse a Internet • Redes conectándose a Internet a través de aplicaciones gateway (como servidores proxy) que remapean

direcciones IP. La IANA (Internet Assigned Numbers Authority) ha apartado tres grupos de direcciones para utilizar en intranets:

• 10.0.0.0 – 10.255.255.255 • 172.16.0.0 – 172.31.255.255 • 192.168.0.0 – 192.168.255.255



Hay algunas desventajas obvias al usar estas direcciones, la primera sería que es imposible conectarse directamente a Internet o referenciar estas direcciones desde Internet. No tienen ningún significado en la comunidad global de Internet. Los routers que se conectan a Internet deberían filtrar cualquier referencia a estas direcciones. Fundamentos de subredes Antes de adentrarnos en subredes, reveamos las configuraciones de direcciones y redes.

• Cada red debe tener su propia dirección de red. • Las redes están ligadas por routers. • Las máscaras de subred identifican a la red y las direcciones de host. • Una clase de dirección asignada, utilizando la máscara de subred por defecto, provee una dirección de

red simple. Si usted está limitado a las definiciones de la máscara de subred provistas con clases de direcciones, debería posicionar todos sus hosts en una sola red. Mientras se puede realizar esto con algunas configuraciones clase C, es realmente inverosímil hacerlo con configuraciones clase A o B. En realidad, muchas empresas hasta encuentran necesario subdividir una dirección clase C en dos o más subredes. Se puede utilizar la máscara de subred para identificar las direcciones de su propia subred dentro de la dirección de red que le ha sido asignada. Esto se logra agregando bits adicionales a la máscara de subred por defecto. Los bits adicionales, son entonces utilizados para identificar la subred física. ¿Porqué subredes? ¿Por qué es necesario definir subredes adicionales a una Intranet? Con el uso apropiado de las subredes usted puede mejorar la eficiencia de su red y diseñar mejor por ejemplo una Intranet para resolver requisitos particulares. En el diseño deberá:

• Mantener el tráfico local como local: Esto se hace seteando las subredes y manteniendo juntos los sistemas que necesitan compartir información.

• Localizar exactamente los hosts remotos: En una red bien organizada, es mucho más fácil setear y administrar routers.

• Hacer el mejor uso de las direcciones asignadas: Usted puede organizar la red para resolver mejor los requisitos de su negocio.

En el momento en que usted se quiera comunicar con un host remoto en una Intranet, necesitará estos tres tipos de información:

• Dirección IP: Para identificar al host. • Máscara de subred: Esto identifica a la red o subred donde está localizado el host. • Gateway por defecto (Default Gateway): Esta es la ruta que debe ser usada si se está comunicando con

un host en una subred diferente y la ruta no está específicamente identificada.

Nota: Con la dirección IP y la máscara de subred ya podemos localizar un host en una subred local.

Números binarios y direcciones IP Un número binario está formado por una serie de bits, o dígitos binarios. Cada bit puede ser seteado como 0 (cero) o como 1 (uno). Los valores de los números binarios están basados en potencias de 2 y en la posición de cada dígito. Las direcciones IP están agrupadas en octetos, o grupos de 8 bits

Octeto (8 bits) Octeto (8 bits) Octeto (8 bits) Octeto (8 bits) Binario 1 1 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 1 1 0 1 1 1 0 0 0 0 1 0 1 1 1

↓ ↓ ↓ ↓ Base 2 27 26 25 24 23 22 21 20 27 26 25 24 23 22 21 20 27 26 25 24 23 22 21 20 27 26 25 24 23 22 21 20

↓ ↓ ↓ ↓ Decimal 192. 168. 110. 23 Como el sistema de numeración binaria se basa en las potencias del número 2, cada posición dentro de cada octeto representa una potencia de 2 diferente. Para determinar la potencia de 2 que utilizaremos para representar cada lugar en el número binario, comenzamos por el extremo derecho del número binario y nos fijamos a qué valor corresponden las posiciones seteadas en 1. Para obtener el número binario, debemos sumar estos valores.



Ejemplo: El número binario “11000000” corresponde al “192” decimal. Se calcula así:

• 0 valores de 20 (1) => 0 • 0 valores de 21 (2) => 0 • 0 valores de 22 (4) => 0 • 0 valores de 23 (8) => 0 • 0 valores de 24 (16) => 0 • 0 valores de 25 (32) => 0 • 1 valores de 26 (64) => 64 • 1 valores de 27 (128) => 128

11000000 = 128+64 => 192

128 64 32 16 8 4 2 1 1 1 0 0 0 0 0 0

AND Otro concepto que necesitamos comprender es el AND lógico. Es una operación matemática, específicamente lógica y es para comparar dos valores. Los siguientes son los posibles resultados:

Valor 1 0 1 0 1 AND ↓ ↓ ↓ ↓

Valor 2 0 0 1 1 Resultado 0 0 0 1

El AND se utiliza para encontrar direcciones de subred desde una dirección IP. La operación AND lógico la utilizaremos para calcular direcciones de principio y fin de subredes. Para más simplicidad veamos un ejemplo con el último octeto de una dirección. Usted tiene una dirección IP “199.121.30.67” y una máscara de subred de “255.255.255.192”. La siguiente tabla apunta al último octeto.

Decimal 192 en Binario 1 1 0 0 0 0 0 0 Decimal 67 en Binario 0 1 1 0 0 0 1 1 Resultado Operación AND 0 1 0 0 0 0 0 0

Esto da un valor de 64, o una subred completa de “199.121.30.64”. Esto quiere decir que el host “199.121.30.67” se encuentra en la subred que comienza en la IP “199.121.30.64” y termina en “199.121.30.127”. Subredes Supongamos que se le ha asignado una dirección clase B “155.110.0.0”, que tiene una máscara de subred por defecto “255.255.0.0”. Esto le brinda un potencial de 65.534 hosts, pero todos los hosts deben estar conectados a la misma red física. ¿Que pasaría si necesitara más redes con menos clientes por red?

Puede hacerse especificando una máscara de subred con la máscara por defecto. Por ejemplo, puede usar lo siguiente:

255.255.255.0

Esto le brinda 254 subredes disponibles, cada una capaz de direccionar hasta 254 sistemas de host. Recuerde que todos ceros y todos unos (255) no son valores de una dirección válida. Utilizando una máscara de subred para dividir una dirección asignada es común con direcciones clase A y clase B y está llegando a ser más común en redes clase C.

Cuando usamos subredes, puede ser útil pensar en la dirección de esta manera:

Dirección de red Redes físicas Sufijo del host



La máscara de red por defecto identifica la porción de la dirección de red en la dirección IP. La porción de la máscara que ha agregado identifica la subred. La porción sin máscara es utilizada para direcciones de host. Este tipo de direccionamiento a veces se refiere a direccionamientos jerárquicos. Subredes clase B Con una dirección clase B, las siguientes combinaciones se encuentran disponibles para definir subredes:

Máscara de subred ID de subred Longitud en bits

ID del host Longitud en bits Máximo de subredes Máxima cantidad de Hosts

por cada subred 255.255.192.0 2 14 2 16.382 255.255.224.0 3 13 6 8.190 255.255.240.0 4 12 14 4.094 255.255.248.0 5 11 30 2.046 255.255.252.0 6 10 62 1.022 255.255.254.0 7 9 126 510 255.255.255.0 8 8 254 254

255.255.255.128 9 7 510 126 255.255.255.192 10 6 1.022 62 255.255.255.224 11 5 2.046 30 255.255.255.240 12 4 4.094 14 255.255.255.248 13 3 8.190 6 255.255.255.252 14 2 16.382 2

Como puede verse en la tabla, tanto el tercer octeto, como el tercer y cuarto octeto pueden ser utilizados para definir subredes. A medida que el número de subredes crece, hay un decrecimiento proporcionado en el número de direcciones de host disponibles. Subredes clase C Si se presenta la necesidad, es posible dividir en subredes una red clase C. Las siguientes combinaciones serían correctas:

Máscara de subred ID de subred Longitud en bits

ID del host Longitud en bits Máximo de subredes Máxima cantidad de

Hosts por cada subred 255.255.255.192 2 6 2 62 255.255.255.224 3 5 6 30 255.255.255.240 4 4 14 14 255.255.255.248 5 3 30 6 255.255.255.252 6 2 62 2

Como en el ejemplo Clase B, el número disponible de direcciones de host decrece a medida que el número de subredes crece.

Ejemplos de subredes Ejemplo de subredes clase C Volviendo al primer ejemplo, pongamos algunos números juntos. Necesita direccionar cinco subredes con hasta veinte hosts en cada una. Ya tiene determinado que puede usar una licencia clase C para cubrir sus necesidades, así que, elijamos una dirección.

198.214.7.0 Su máscara de subred por defecto sería:

255.255.255.0 Necesita cambiar su máscara de subred para direccionar 5 (cinco) subredes. Para lograr esto necesitará 3 bits para la dirección de subred. En binario esto sería algo así:

11111111.11111111.11111111.11100000 Convirtiendo esto nuevamente a decimal, obtendría lo siguiente:

255.255.255.224



Esto da 6 (seis) (23-2) posibles subredes y 30 (treinta) (25-2) direcciones de host. Recuerde que ninguna dirección puede contener todos ceros ni todos unos. Ejemplo de subredes clase B Para el siguiente ejemplo, necesita direccionar veinte subredes con hasta 300 hosts en cada una. Esto puede ser realizado utilizando una dirección clase B, así que, elegimos una.

131.142.0.0 La máscara de subred por defecto para esta dirección es la siguiente:

255.255.0.0 Tiene 16 bits disponibles para definir las direcciones de subred y host. Se necesita un mínimo de 14.

20 = 10100 (5 bits) 300 = 100101100 (9 bits) Esto le deja dos bits adicionales para usar a su gusto. Esto significa que se tiene cierta flexibilidad al setear la máscara de subred.

Para maximizar la posible expansión de hosts, debería seleccionar la cantidad mínima posible de subredes. Los valores binarios y decimal son los siguientes:

11111111.11111111.11111000.00000000 255.255.248.0 Esto le da una máscara de subred de 21 bits total. Esto direcciona hasta 30 (25-2) subredes y hasta 2.046 (211-2) hosts.

También está la opción de partir la diferencia entre ellos, como se muestra abajo:

11111111.11111111.11111100.00000000 255.255.252.0 Esto le ofrece hasta 62 (26-2) subredes y 1.022 (210-2) direcciones de host.

Finalmente, puede elegir maximizar el potencial de crecimiento de las subredes en sus redes.

11111111.11111111.11111100.00000000 255.255.252.0 Esto direcciona 126 (27-2) subredes y 510 (29-2) hosts.

Ejemplos de rangos de dirección Veamos algunos ejemplos de cómo se calcula el rango de direcciones. Ejemplo de clase C Supongamos que se tiene una dirección clase C de “193.25.141.0” y una máscara de subred de “255.255.255.192”. Como sólo el último octeto va a cambiar a clase C, sólo necesita calcular esa porción de la dirección. Primero determinamos las direcciones válidas para subredes seteando los bits de la dirección de host en cero. Obtendríamos lo siguiente:

01000000 o 64 decimal y 10000000 o 128 decimal La siguiente tabla nos muestra los valores válidos de direcciones de host para la red:

Dirección de host mínima

Dirección de host máxima

Comienzo de dirección (decimal)

Final de dirección (decimal)

Subred 64 01000001 01111110 65 126 Subred 128 10000001 10111110 129 190

Su rango completo de dirección para cada subred debería ser “193.25.141.65” a través de “193.25.141.126” para la subred 64, y “193.25.141.129” a través de “193.25.141.190” para la subred 128.



También necesita calcular la dirección de distribución de la subred (Subnetwork Broadcast Address). Esto significa que la distribución de una subred será siempre calculada de la siguiente forma:

Subnetwork_Broaqdcast_Address = Maximum_Host_Address + 1 En el caso de estas dos subredes, la dirección de distribución sería “193.25.141.127” y “193.25.141.191”, respectivamente. Otro método para determinar rangos de dirección Veamos un método alternativo para determinar rangos de direcciones válidos. Se asume que se tiene una dirección de clase C “200.200.201.0” y hemos determinado que la máscara de subred más apropiada es “255.255.255.224”. En binario, el último octeto sería el siguiente:

11100000 Tres bits, el número en la máscara de subred, direcciona hasta 32 valores diferentes (256/8). No se preocupe todavía por las direcciones inválidas. Para determinar el rango de direcciones de subred simplemente cuente hasta 32, comenzando desde cero.

• 0-31 • 128-159 • 32-63 • 160-191 • 64-95 • 192-223 • 96-127 • 224-255

El primer y último rango deben ser dejados de lado, ya que son inválidos. En el primero, el valor de subred son todos ceros, y en el último, el valor es todos unos. Esto nos deja lo siguiente:

• 32-63 • 128-159 • 64-95 • 160-191 • 96-127 • 192-223

Desafortunadamente, este resultado todavía contiene valores no válidos. El primero es la dirección de red, con la dirección de host de todos ceros. EL último es la dirección de distribución de red, con la dirección de host seteada a todos unos. Nuestro rango válido final sería:

Dirección de red Rango de direcciones Distribución 32 33 - 62 63 64 65 - 94 95 96 97 - 126 127 128 129 - 158 159 160 161 - 190 191 192 193 - 222 223

Probemos otra más. Se asume que se tiene una dirección de clase C “220.136.17.0” y hemos determinado que la máscara de subred más apropiada es “255.255.255.240”. En binario, el último octeto sería el siguiente:

11110000 Cuatro bits, el número en la máscara de subred, direcciona hasta 16 valores diferentes. Para determinar el rango de direcciones de subred (no se preocupe todavía por las direcciones inválidas) simplemente cuente hasta 16, empezando desde cero.

• 0-15 • 64-79 • 128-143 • 192-207 • 16-31 • 80-95 • 144-159 • 208-223 • 32-47 • 96-111 • 160-175 • 224-239 • 48-63 • 112-127 • 176-191 • 240-255

El primer y último rango deben ser dejados de lado, ya que son inválidos. En el primero, el valor de subred son todos ceros, y en el último, el valor es todos unos. Esto nos deja lo siguiente:

• 16-31 • 80-95 • 144-159 • 208-223 • 32-47 • 96-111 • 160-175 • 224-239 • 48-63 • 112-127 • 176-191 • 64-79 • 128-143 • 192-207



Recuerde que esto todavía contiene valores no válidos. El primero es la dirección de red, con la dirección de host de todos ceros. EL último es la dirección de distribución de red, con la dirección de host seteada a todos unos. Nuestro rango válido final sería:

Dirección de red Rango de red Distribución 16 17 - 30 31 32 33 - 46 47 48 49 - 62 63 64 65 - 78 79 80 81 - 94 95 96 97 - 110 111 112 113 - 126 127 128 129 - 142 143 144 145 - 158 159 160 161 - 174 175 176 177 - 190 191 192 193 - 206 207 208 209 - 222 223 224 225 - 238 239

SuperNetting - Combinando direcciones Hasta ahora, este capítulo se ha concentrado en quebrar una dirección en subredes. El proceso también trabaja en otra dirección, Usted tiene la habilidad de combinar direcciones consecutivas mediante el uso de máscaras de subred, una técnica conocida cono Supernetting. No es poco común tener más de un host que usted pueda direccionar con una simple dirección clase C, pero muy pocos justificarían una dirección clase B. Una solución sería combinar dos o más direcciones clase C dentro de una simple subred. Para hacer esto necesita dos o más direcciones clase C consecutivas. Por ejemplo:

• 200.23.217.0 • 200.23.218.0 • 200.23.219.0

El primer paso es convertir el tercer octeto a binario para cada dirección, como se muestra abajo:

217 => 11011001 218 => 11011010 219 => 11011011

Busque la porción de la dirección que no cambia. Esto se convierte en su máscara de subred. En el ejemplo, los seis bits más importantes no cambian, brindándole una máscara de subred para el tercer octeto de lo siguiente:

11111100 Esto se convierte en el valor decimal de lo siguiente:

252 Su máscara de subred completa debería ser:

255.255.252.0 Es importante recordar que, aún cuando las estamos tratando como subredes en una dirección clase B con el propósito de definir una subred, estas todavía son direcciones clase C. Usted tiene sólo el cuarto octeto disponible para definir direcciones de hosts.



Classless Internet Domain Routing (CIDR) Es un esquema de direccionamiento IP (IP addressing) posterior al sistema de clase A, B, C, D y E. El direccionamiento usando CIDR también usa el modelo tradicional para representar al número IP (Ejemplo: 200.400.12.6) pero destaca cual es la parte de la red usando un “slash” (/) seguido de un número: 192.168.3.15/26 172.21.165.1/19 El número que sigue al “slash” es el número de bits que representan la parte de la red del número IP. CIDR se desarrolló para incrementar la eficiencia de la alocación de direcciones y para aliviar a los routers. Usándolo, las tablas de rutas se simplifican.



Capítulo 7

Configuración de red en Linux Instalación de la placa de red Compramos una placa de red, la instalamos. Veamos ahora como hacemos para que el sistema la reconozca. A veces no tenemos diskette de instalación o cdrom; los drivers ya están incluidos en el kernel. Hasta que el controlador del dispositivo inicializa la tarjeta y la registra con el kernel, el sistema no sabe de la existencia de la tarjeta. Normalmente, el dispositivo Ethernet se registra como ethX, donde X es el número de dispositivo. El primer dispositivo es eth0, el segundo es eth1, etc. Los controladores de dispositivo o drivers de las placas de red se pueden compilar como módulo. Recuerde que lo describimos en el capítulo sobre kernel. Para la mayoría de las aplicaciones, este es el mecanismo por defecto, ya que así es más fácil subir y bajar los drivers. Si el controlador se configura como módulo, y también seteamos en el kernel la opción de módulos cargables automáticamente, necesitamos decirle al kernel el mapeo entre los nombres de dispositivos y el módulo a cargar en el archivo /etc/modules.conf. Por ejemplo, si mi dispositivo eth0 es una tarjeta Ethernet 3Com 3C905, debería añadir la línea siguiente en el archivo /etc/modules.conf.

alias eth0 3c59x Donde 3c59x es el nombre del controlado de dispositivo.

alias eth0 ne2k-pci así sería si la placa es una ne2000 (o ne2000 compatible) El próximo paso es levantar el módulo a memoria. Esto se hace con el comando modprobe, su sintaxis es:

# modprobe nombreModulo Seguramente Ud. se estará preguntando:

• ¿Y cuál es el nombre del módulo? • ¿Cómo hago para saber el nombre del dispositivo que reconoce el kernel? • Si yo compré mi placa marca/modelo Realtek 8139. ¿Cómo hago para buscar en Linux esa

marca/modelo? Lo ideal en estos casos es usar el comando lspci. Este nos va a devolver la lista de hardware conectado a nuestro equipo. arwen:/etc# lspci 00:00.0 Host bridge: nVidia Corporation nForce2 AGP (different version?) (rev c1) 00:00.1 RAM memory: nVidia Corporation nForce2 Memory Controller 1 (rev c1) 00:00.2 RAM memory: nVidia Corporation nForce2 Memory Controller 4 (rev c1) 00:00.3 RAM memory: nVidia Corporation nForce2 Memory Controller 3 (rev c1) 00:00.4 RAM memory: nVidia Corporation nForce2 Memory Controller 2 (rev c1) 00:00.5 RAM memory: nVidia Corporation nForce2 Memory Controller 5 (rev c1) 00:01.0 ISA bridge: nVidia Corporation nForce2 ISA Bridge (rev a4) 00:01.1 SMBus: nVidia Corporation nForce2 SMBus (MCP) (rev a2) 00:02.0 USB Controller: nVidia Corporation nForce2 USB Controller (rev a4) 00:02.1 USB Controller: nVidia Corporation nForce2 USB Controller (rev a4) 00:02.2 USB Controller: nVidia Corporation nForce2 USB Controller (rev a4) 00:04.0 Ethernet controller: nVidia Corporation nForce2 Ethernet Controller (rev a1) 00:05.0 Multimedia audio controller: nVidia Corporation nForce MultiMedia audio [Via VT82C686B] (rev a2) 00:06.0 Multimedia audio controller: nVidia Corporation nForce2 AC97 Audio Controler (MCP) (rev a1) 00:08.0 PCI bridge: nVidia Corporation nForce2 External PCI Bridge (rev a3) 00:09.0 IDE interface: nVidia Corporation nForce2 IDE (rev a2) 00:0c.0 PCI bridge: nVidia Corporation nForce2 PCI Bridge (rev a3) 00:0d.0 FireWire (IEEE 1394): nVidia Corporation nForce2 FireWire (IEEE 1394) Controller (rev a3) 00:1e.0 PCI bridge: nVidia Corporation nForce2 AGP (rev c1)



01:07.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8139/8139C/8139C+ (rev 10) 02:01.0 Ethernet controller: 3Com Corporation 3C920B-EMB Integrated Fast Ethernet Controller (rev 40) 03:00.0 VGA compatible controller: nVidia Corporation NV34 [GeForce FX 5200] (rev a1) arwen:/etc# Para distinguir una placa de red, tenemos que buscar donde diga “Ethernet controller”. Luego de esto, podemos ver marca, modelo. Con estos datos, vamos a la documentación del kernel y verificamos que módulo corresponde a que placa. En principio, el código fuente del kernel tiene su documentación en el subdirectorio Documentation y de no encontrar lo que buscamos ahí lo ideal es arrancar el entorno de configuración de las fuentes del kernel y leer la ayuda de los módulos de red para ver cual corresponde a nuestro hardware. Los módulos del kernel son archivos objeto, tienen la extensión “.o” y se encuentran en el directorio /lib/modules/versión/kernel/drivers/net. Si listamos los módulos vemos que existen dos que pueden ser para la placa Realtek 8139, uno es 8139too y el otro 8139cp. Uno de esos dos debe ser el correcto. En este ejemplo probaremos el 8139too. Hacemos:

# modprobe 8139too Este comando prueba si un determinado módulo funcionará con el dispositivo, si es así, lo instala.

Nota: También podemos utilizar el comando insmod para insertar módulos Con el comando lsmod veremos una lista de los diferentes módulos instalados. Si el módulo se instaló debe aparecer en el listado

# lsmod Module Size Used by nfs 79872 4 (autoclean) lockd 53168 1 (autoclean) [nfs] sunrpc 64816 1 (autoclean) [nfs lockd] binfmt_misc 6448 1 autofs 11584 2 (autoclean) 8139too 16480 1 (autoclean) ipchains 39392 0 imm 9712 1 parport_pc 17808 1 (autoclean) parport 25856 1 (autoclean) [imm parport_pc] usb-uhci 21696 0 (unused) usbcore 51808 1 [usb-uhci] ext3 62480 7 jbd 41056 7 [ext3]

Configuración de una interfaz de red Al decir configurar una interfaz de red nos referimos al proceso de asignar direcciones IP apropiadas a un dispositivo y asignar valores adecuados a otros parámetros configurables. El programa más usado para hacer esto es la orden ifconfig (interface configure). La sintaxis del comando ifconfig es:

ifconfig dev num-ip netmask num-mascara broadcast num-broadcast accion Veamos las opciones

up esta opción activa una interfaz (y es la opción por defecto). down esta opción desactiva una interfaz. [-]arp esta opción activa o desactiva el uso del protocolo de resolución de

dirección (Address Resolution Protocol) sobre la interfaz [-]promisc habilita o no el modo promiscuo de la interfaz. Si se activa, todos los

paquetes serán recibidos por esta interfaz. [-]allmulti esta opción activa o desactiva multicast por hardware. El multicast

por hardware permite que varios grupos de interfaces reciban



paquetes remitidos a destinos especiales. Esto puede ser de importancia si está usando aplicaciones como videoconferencia, pero normalmente no se usa.

mtu N este parámetro le permite especificar la MTU del dispositivo. (MTU = Maximum Transfer Unit).

netmask <direc> este parámetro permite asignar la máscara de red a la que pertenece el dispositivo.

irq <direc> este parámetro sólo trabaja con ciertos tipos de hardware, y permite especificar la IRQ del dispositivo.

[-]broadcast [direc] este parámetro le permite activar y asignar la recepción de datagramas destinados a la dirección de difusión, o desactivarla por completo.

[-]pointopoint [direc] permite asignar la dirección de la máquina en el otro extremo de un enlace punto a punto, como en SLIP o PPP.

hw <tipo> <direc> este parámetro le permite asignar la dirección del hardware de ciertos tipos de dispositivos de red. Esto no suele ser útil para Ethernet, pero lo es para otras redes como X.25.

Ejemplos:

# ifconfig eth0 192.168.1.4 netmask 255.255.255.0 broadcast 192.168.1.255

# ifconfig eth0 192.168.0.1 netmask 255.255.255.0 up En este ultimo caso estoy configurando la interfaz Ethernet eth0, con dirección IP “192.168.0.1” y máscara de red “255.255.255.0”. El up del final de la orden le dice a la interfaz que debería activarse, pero normalmente se puede omitir, ya que es el valor por defecto. Para desactivar una interfaz, simplemente tiene que ejecutar:

# ifconfig eth0 down Puede usar la orden ifconfig sobre cualquier dispositivo de red. Algunos programas de usuario, como pppd y dip configuran automáticamente los dispositivos de red al crearlos, por lo que es innecesario el uso de ifconfig con ellos. Si ejecutamos el comando ifconfig sin parámetros, veremos algo como lo siguiente:

# ifconfig eth0 Link encap:Ethernet HWaddr 00:D0:59:10:6C:B5 inet addr:192.168.0.1 Bcast:192.168.0.255 Mask:255.255.255.0 UP BROADCAST MULTICAST MTU:1500 Metric:1 RX packets:0 errors:0 dropped:0 overruns:0 frame:0 TX packets:4 errors:0 dropped:0 overruns:4 carrier:0 collisions:0 txqueuelen:100 RX bytes:0 (0.0 b) TX bytes:168 (168.0 b) Interrupt:11 Base address:0x5000 lo Link encap:Local Loopback inet addr:127.0.0.1 Mask:255.0.0.0 UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:0 errors:0 dropped:0 overruns:0 frame:0 TX packets:0 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)

Veamos que significa cada cosa: El primer párrafo o bloque, eth0, representa la interfaz física de hardware para Ethernet de 100 Mbps. El segundo, lo, es la interfaz de ciclo de retorno, que se utiliza principalmente para comunicación interna y diagnósticos. La interfaz de loopback (ciclo de retorno) se usa para determinar si el software TCP/IP esta operando correctamente a nivel local. Entre los datos volcados encontramos la dirección IP, la dirección de broadcast y la máscara, y la dirección física de la placa, comúnmente llamada MAC, que da el fabricante de la placa. Lo que sigue es información específica de la transmisión y los paquetes.



Teniendo asignada la IP, vamos a probar si funciona correctamente. El comando más simple para hacer una prueba es el ping. Ejecutamos:

# ping 192.168.0.1 Y veremos lo siguiente:

PING 192.168.0.1 (192.168.0.1) from 192.168.0.1: 56(84) bytes of data. 64 bytes from 192.168.0.1: icmp_seq=1 ttl=255 time=0.042 ms 64 bytes from 192.168.0.1: icmp_seq=2 ttl=255 time=0.034 ms 64 bytes from 192.168.0.1: icmp_seq=3 ttl=255 time=0.032 ms

Presionamos Ctrl-C para detenerlo. Lo que dará como resultado:

--- 192.168.0.1 ping statistics --- 3 packets transmitted, 3 received, 0% loss, time 1998ms rtt min/avg/max/mdev = 0.032/0.036/0.042/0.004 ms

Esto indica que todo funciona bien. A partir de ahora podemos conectar este host con otro/s.

Nota: La asignación de la dirección IP también se puede hacer directamente en un archivo de configuración.

En Debian el archivo principal de la configuración de las interfaces de red se encuentra en /etc/network/interfaces # Used by ifup(8) and ifdown(8). See the interfaces(5) manpage or # /usr/share/doc/ifupdown/examples for more information. auto lo iface lo inet loopback auto eth0 iface eth0 inet static address 10.0.0.1 netmask 255.255.255.0 auto eth1 iface eth1 inet static address 192.168.1.1 netmask 255.255.255.0 En esta configuracion, definimos tres interfaces. Una interfaz de loopback y dos interfaces ethernet. A estas interfaces les asignamos las direcciones 192.168.1.1 y 10.0.0.1 con la mascara de subred en 255.255.255.0. Aparte, con el tag “auto” le estamos pidiendo que esta interfaz arranca cuando inicia el equipo. Para realizar modificaciones avanzadas podemos consultar el man del archivo interfaces que nos da varios ejemplos concretos. En RedHat los archivos de configuración de red se encuentran en el directorio:

/etc/sysconfig/network-scripts/ Aquí es donde debemos entrar para cambiar la dirección IP de una máquina. Por ejemplo, el archivo ifcfg-eth0 contiene:

ONBOOT=yes DEVICE=eth0 BOOTPROTO=static IPADDR=192.168.1.4 NETMASK=255.255.255.0 BROADCAST=192.168.1.255 NETWORK=192.168.1.0

En este directorio también están los scripts ifdown e ifup, que se usan para reiniciar la configuración de la red. Por ejemplo: ifdown ifcfg-eth0



En el directorio /etc/init.d/ se encuentran todos los demonios o servicios. Por ejemplo: network, xinetd, httpd, smb. Recordar que se ejecutan con “./network start”, por ejemplo para levantar el servicio de red.

Encaminamiento (Routing) El encaminamiento o ruteo es un tema amplio. Comencemos con una definición. ¿Qué es el encaminamiento IP?

El Encaminamiento IP es el proceso por el que una máquina con múltiples conexiones de red decide por dónde dirigir un datagrama IP que haya recibido.

Sería útil ilustrar esto con un ejemplo. Imagine una oficina con el encaminamiento típico, que podría constar de un enlace PPP con Internet, varios segmentos Ethernet alimentando las estaciones de trabajo, y un enlace PPP hacia otra oficina. Cuando el encaminador recibe un datagrama en cualquiera de sus conexiones de red, el mecanismo que usa para determinar qué interfaz debería enviar el datagrama, es el encaminamiento. Las estaciones sencillas también necesitan encaminar. Todas las estaciones en Internet tienen dos dispositivos de red: uno es la interfaz de pruebas descrita anteriormente (loopback), y la otra es la que usa para comunicarse con el resto de la red, quizá una Ethernet, quizá una interfaz serie PPP o SLIP. Entonces, ¿cómo funciona el encaminamiento? Cada máquina tiene una lista de reglas, llamada tabla de encaminamiento o de ruteo. Esta tabla contiene columnas que suelen contener al menos tres campos:

1. es una dirección de destino 2. es el nombre de la interfaz a la que se va a encaminar el datagrama 3. es (opcionalmente) la dirección IP de otra máquina que tomará el datagrama en su siguiente paso a

través de la red En Linux puede ver esta tabla usando la siguiente orden:

# /sbin/route –n ó

# /bin/netstat -r

Destination Gateway Genmask Flags Metric Ref Use Iface 192.168.1.0 * 255.255.255.0 U 0 0 0 eth0 2 127.0.0.0 * 255.0.0.0 U 0 0 0 lo 1default 192.168.1.254 0.0.0.0 UG 0 0 0 eth0 3

Veamos que significa cada columna.

Columna Descripción Flags Estado de conexión. Cada letra tiene un significado:

U : la conexión está activa.(up) H : el destino es una máquina.(host) G : el destino es la pasarela.(gateway)

Metric El costo de una ruta, medida en saltos. Los sistemas que tienen varias rutas para llegar a un destino, cada una tiene un costo. Generalmente se prefiere una ruta sobre el resto, la que tiene métrica baja. El kernel de Linux no usa esta información, pero sí lo hacen algunos protocolos de enrutamiento avanzados.

Ref El número de referencias de la ruta. Esto no se usa en el kernel Linux. Está aquí debido a que la propia herramienta route es de plataformas cruzadas. Así se muestra este valor, pues otros sistemas operativos lo usan.

Use El número de bucles de cache de rutas utilizados con éxito. Para ver este valor, use la opción –F cuando invoque route.

La instrucción route toma sus argumentos en línea de órdenes y los convierte en llamadas al sistema del kernel, que le piden que añada, borre o modifique entradas en la tabla de encaminamiento. Como ya dijimos, el proceso de encaminado es relativamente simple: se recibe un datagrama que llega, se examina la dirección de destino (para quién es) y se compara con cada entrada en la lista. Se selecciona la entrada que más se parezca y se reenvía el datagrama a la interfaz especificada. Si el campo de pasarela (gateway) está descrito, el datagrama se reenvía a esa máquina mediante la interfaz especificada, y si no, se asume que la dirección de destino está en la red a la que se accede mediante la interfaz correspondiente.



En el caso donde una máquina ni siquiera tiene una pista sobre donde enviar el paquete, se usa una ruta por defecto. Este camino apunta a un enrutador, que idealmente tiene idea de donde debería ir el paquete o, al menos, sabe por otra ruta que pueda tomar. Una maquina típica Linux conoce al menos tres rutas:

Ruta de bucle local que simplemente apunta a su dispositivo de loopback Ruta a la red de área local de forma que los paquetes destinados a las máquinas de esa misma red se

envían directamente a ellas Ruta por defecto esta ruta se usa para paquetes que necesitan abandonar la red de área local

para comunicarse con otras redes Ejemplo: Imagine que tiene una red Ethernet. Le han dicho que pertenece a una red clase C con dirección “192.168.1.0”. Le han dado la dirección IP “192.168.1.10” para su uso y también le han informado que “192.168.1.1” es un encaminador conectado a Internet. El primer paso es configurar la interfaz como se describió anteriormente. Puede usar una orden como:

# ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up ó la orden abreviada siguiente:

# ifconfig eth0 192.168.1.10 Ahora necesita añadir una entrada en la tabla de ruteo para decirle al núcleo que los datagramas destinados a todas las máquinas con direcciones que se ajusten a “192.168.1.*”, deberán ser enviados al dispositivo Ethernet. Debería usar una orden similar a:

# route add -net 192.168.1.0 netmask 255.255.255.0 eth0 Fíjese en el uso del parámetro -net para especificar al programa route que esta entrada es una regla para una red completa. Otra opción es -host, que indica una vía específica a una dirección IP en particular. Esta ruta le permitirá establecer conexiones IP con todas las estaciones de su segmento Ethernet. Pero ¿qué pasa con todas las máquinas con dirección IP que no están en su segmento Ethernet? Sería bastante engorroso, por no decir imposible, tener que añadir caminos para cada red de destino posible, por lo que existe un truco que se usa para simplificar la tarea. A este truco se le llama camino por defecto. El camino por defecto se ajusta a todo destino posible, pero con prioridad mínima, por lo que si existe cualquier otra entrada que se ajuste a la dirección requerida, será la que se use en lugar del camino por defecto. La idea del camino por defecto es como decir: “y todo lo demás debería ir por aquí”. En el ejemplo anterior podría usar una orden como:

# route add default gw 192.168.1.1 eth0 El parámetro gw le dice a la orden route que lo que le sigue es la dirección IP, o nombre, de una pasarela, gateway u otra máquina enrutadora a la que se deberían enviar todos los datagramas que se ajusten a esta entrada para futuro encaminamiento. Por lo tanto, la configuración completa debería parecerse a:

# ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up # route add -net 192.168.1.0 netmask 255.255.255.0 eth0 # route add default gw 192.168.1.1 eth0

Veamos ahora como quedó la tabla de ruteo

# route Kernel IP routing table Destination

Gateway Genmask Flags

Metric Ref Use Iface

10.10.2.0 * 255.255.255.0

UH 0 0 0 eth1

192.168.1.0

* 255.255.255.0

U 0 0 0 eth0

127.0.0.0 * 255.0.0.0 U 0 0 0 lo default 192.168.1.1 0.0.0.0 UG 0 0 0 eth0



Como resumen, la sintaxis típica del comando route es de esta forma:

# route cmd tipo direccion netmask masc gw gatew dev destino

Parámetro Descripción cmd Puede ser add o del dependiendo de si añade o borra una ruta. Si elimina

una ruta, solo necesita otro parámetro, la dirección. tipo –net o –host dependiendo si dirección representa una dirección de red o

una dirección de un enrutador. dirección La red destino a la que quiere enrutar. netmask masc Configura la máscara de red de la dirección dirección a masc. gw gatew Configura la dirección de enrutador para dirección a gatew. Normalmente se

usa como ruta por defecto. dev destino Envía todos los paquetes destinados a dirección a través de la red del

dispositivo destino según se configura con ifconfig.

Nota: La máquina gateway debe tener una dirección por cada red, debemos ejecutar el siguiente comando para poder intercambiar paquetes de una red a otra.

# echo 1 > /proc/sys/net/ipv4/ip_forward Para la Red-1 debemos agregarle una ruta por defecto por cada máquina:

# route add default gw 192.168.1.1 Y para la Red-2 debemos agregarle una ruta por defecto por cada máquina:

# route add default gw 192.168.2.1



Capítulo 8

Programación en la shell de Linux La programación en shell o también llamada shellscripting, se basa en el uso de las herramientas del sistema. GNU/Linux y UNIX son sistemas operativos que cuentan con bastantes herramientas de proceso, filtrado de textos y control de procesos. Por esta razón, los procesos repetitivos, que hechos a mano serían engorrosos y lentos, se pueden automatizar. Para programar scripts en shell hay que tener acceso a una shell compatible con la Bourne SHell (sh). También hay que tener cierta experiencia con sistemas GNU/Linux y UNIX (saber que son los permisos de archivos, conocer las órdenes básicas, etc.), y tener cierta idea de las cosas que ofrece la shell, como sustitución de caracteres especiales por nombres de archivos, redirecciones de las entradas y salidas, etc. ¿Que es la shell? Una shell es un intérprete de comandos, es la aplicación que permite al usuario comunicarse con el sistema operativo y darle órdenes. Podemos decir que es el intermediario entre el sistema operativo y el usuario. Existen varias shells, algunas son:

• Bourne SHell (sh) – La shell clásica que se encuentra en todos los sistemas UNIX. • Korn SHell (ksh). • C SHell (csh). • Bourne-Again SHell (bash) – La shell de GNU que se encuentra en todos los sistemas Linux y en

muchos otros UNIX. Es la que vamos a utilizar.

Nota: Para ver las shells que tenemos soportadas en nuestro sistema Linux, hacemos: # cat /etc/shells

¿Qué es un script? Un script es un archivo de texto ejecutable. Lo que contiene es uno o más comandos de Linux que son los mismos que ejecutamos en la shell o línea de comandos. Un script es de gran utilidad cuando tengo que ejecutar varios comandos seguidos. El único requisito es que ese archivo de texto tenga permiso de ejecución para la persona que intenta ejecutarlo. Si conoce DOS, puede pensar que la programación en shell es algo parecido a los archivos “.bat”, aunque la diferencia entre ellos es más o menos igual de grande que la existente entre los sistemas UNIX y el DOS (por versatilidad, potencia, diseño, etc.). Las instrucciones contenidas en el shellscript se procesarán por orden, como si alguien las escribiera en el mismo orden en la línea de comandos. Cuando se ejecuta un script de shell, se intenta ejecutar como un binario normal, pero al darse cuenta el sistema operativo de que no es un binario válido, pero que es un archivo de texto, ejecuta un shell hijo y empieza a interpretar el archivo de texto. Si fuera un archivo con un texto cualquiera, tarde o temprano (probablemente en la primera línea) habría un error de sintaxis (no reconocería el comando) y se abortaría la ejecución del programa. Los scripts de shell son muy útiles para ciertos tipos de tareas:

• Tareas administrativas: algunas partes de los sistemas UNIX son scripts de shell, para poder entenderlos y modificarlos es necesario tener alguna noción sobre la programación de scripts.

• Tareas tediosas que solo se van a ejecutar una o dos veces, no importa el rendimiento del programa resultante pero sí conviene que su programación sea rápida.

• Hacer que varios programas funcionen como un conjunto de una forma sencilla. • Pueden ser un buen método para desarrollar prototipos de aplicaciones más complejas que

posteriormente se implementarán en lenguaje más potentes. • Conocer a fondo la shell aumenta tremendamente la rapidez y productividad a la hora de usarla, incluso

fuera de los scripts.

Creación de scripts Como en todo aprendizaje de un lenguaje de programación, nuestro primer script será el famoso “Hello World!”. Abrimos nuestro editor de texto favorito, por ejemplo el vi.



# vi holamundo.sh

Nota: Debido a que en GNU/Linux-UNIX la ejecución de programas no depende de las extensiones sino de los permisos, no es obligatorio agregarle la extensión “.sh” a los scripts. Solo se ponen a modo de prolijidad.

Agregamos la sentencia “ echo “Hola Mundo” ”, grabamos el archivo, y le ponemos permiso de ejecución.

# chmod +x holamundo.sh Ahora lo ejecutamos, para lo cual hacemos

# ./holamundo.sh Esto nos mostrará un hermoso “Hola Mundo” en la pantalla.

Nota: echo es una orden simple para mostrar texto por pantalla, escribe la salida de un programa sobre la salida estándar. La opción -n nos mantiene el cursor en la misma línea, sin que pase al próximo renglón.

¿Qué se escribe en un script? Como ya explicamos antes, los scripts son simplemente sucesiones de comandos, tal y como si usted los estuviera escribiendo uno por uno. De esta forma podemos utilizar todos y cada uno de los comandos del sistema operativo. Esto es lo que hace tan poderosos a los scripts. Los programadores de scripts usan una técnica muy sencilla para especificar qué programa (en este caso la shell) debe interpretar el script. La técnica es colocar en la primera línea del script qué shell hay que invocar para su interpretación. Cuando el kernel abre el archivo para ejecutarlo, lee la primera línea y entonces le pasa el archivo a la shell (#!/bin/sh ó #!/bin/bash). Veamos un ejemplo de otro script:

#!/bin/sh clear echo "ahora estan en el sistema" who echo " y hoy que dia es?" date

Sintaxis de los scripts Comentarios Como en todo lenguaje de programación, hay un caracter o combinación especial de caracteres para escribir comentarios. Este texto es ignorado por la shell al interpretar el script, y sólo sirven para que una persona, cuando edite el script, pueda entender cómo funciona. Este carácter especial es el signo sharp (numeral) “#”, y denota que desde ahí hasta el final de la línea, el resto de los caracteres son un comentario del programador (como el “//” de C++). Ejemplo:

#!/bin/sh # Este script muestra usuarios del sistema y la facha actual clear echo "ahora estan en el sistema" who echo " y hoy que dia es?" date

Variables Digamos que diariamente un programa nos genera una cantidad de archivos temporales (cuyo nombre es “tmp-algo”) en el directorio “~/home” y entonces queremos borrar los que guardamos ayer, y guardar los de hoy en el directorio “~/home/tmp”. Veamos un ejemplo de otro script:

#!/bin/sh rm -r $HOME/tmp # borramos los de ayer mkdir $HOME/tmp # creamos el directorio mv $HOME/tmp-* $HOME/tmp # almacenamos los de hoy



echo “Actualización terminada.” Como explicamos anteriormente, todo lo que esté entre el “#” y el final de la línea es un comentario. Seguramente usted debe estar preguntándose que es eso de “$HOME”. La shell como todo buen lenguaje de programación permite utilizar variables. Para crear una variable solo tenemos que hacer:

VARIABLE="valor" Para ver el contenido de VARIABLE usamos:

echo $VARIABLE Es decir, creamos a VARIABLE cuando le asignamos un valor y utilizamos ese valor cuando le añadimos el caracter "$" (es decir, $VARIABLE). Las variables en el bash son todas cadenas de caracteres (strings). Hay dos tipos de variables, las variables de usuario y las variables especiales. Las variables de usuario son las que creamos en el script, y las variables especiales son aquellas que la shell (u otros programas) crea automáticamente al arrancar, también llamadas variables de entorno o de ambiente. En el siguiente ejemplo, mail es una variable creada por el usuario:

#!/bin/sh clear [email protected] echo "mi mail es $mail"

Algunas variables de entorno del sistema operativo son:

$HOME Especifica el directorio inicial del usuario. $PATH Es la ruta donde se buscarán los ejecutables. $SHELL Guarda la ubicación del shell que se está utilizando, usualmente /bin/bash. $PS1 Especifica el prompt que se está utilizando.

Algunas variables del ambiente de ejecución de la shell son:

$$ Contiene el número de proceso (PID) de la shell. $! Contiene el número de proceso (PID) del último proceso. $? Contiene el valor que regresó la última orden ejecutada. (0=Exitosa, 1=Falló)

Hay otras variables importantes que contienen los argumentos que recibe el script. Vea la siguiente sección. Pasaje de argumentos Como cualquier programa, los scripts pueden recibir parámetros en la línea de comandos, los parámetros recibidos se guardan en una serie de variables que el script puede consultar. Estas variables tienen los siguientes nombres:

$0 Contiene el nombre con el que se ha invocado al script. $1 - $20 Contiene los valores de los parámetros/argumentos recibidos con la invocación. $* Contiene todos los parámetros juntos en una única cadena. $# Contiene el número de parámetros que ha recibido el script. $? Devuelve 0 si la ejecución fue correcta.

Ejemplo: Crear un shell script llamado “argus.sh” (con vi argus.sh) conteniendo los siguientes comandos y establecerle permisos de ejecución (con chmod +x argus.sh)

#!/bin/sh echo “El nombre del script es : $0” echo “Cantidad de argumentos : $#” echo “El primer argumento es : $1” echo “El segundo argumento es : $2” echo “El tercer argumento es : $3” echo “Todos sus argumentos son : $*”

Ejecutarlo de la siguiente manera:

# ./argus.sh “Hola” “que tal” 99



La salida que vemos por pantalla es:

El nombre del script es : argus.sh Cantidad de argumentos : 3 El primer argumento es : Hola El segundo argumento es : que tal El tercer argumento es : 99 Todos sus argumentos son : Hola que tal 99

En el caso de usar más de 9 (nueve) parámetros, existen dos opciones para poder manejarlos:

• Usar las llaves (“{” y “}”) para encerrar el número de parámetro, por ejemplo “${10}”, ya que al usar simplemente “$10” se producen efectos inesperados en la manipulación de las variables.

• Usar el comando shift, que mueve todos los parámetros una posición a la izquierda, esto hace que el parámetro que haya en $1 desaparezca, y sea reemplazado por el que había en $2.

Redireccionamiento Igual que cualquier ejecutable, un script permite redireccionamientos de la entrada y de las salidas. Las redirecciones de la entrada, salida estándar, errores estándar, y todas las salidas se realizan con los caracteres “<”, “>” y “&>” como ya vimos en capítulos anteriores (depende de la shell, así son las de la bash). Algo que quizá no vimos es que existe un archivo-dispositivo, estándar a todos los UNIX y sus clones (Linux, etc.), que es el “/dev/null”. Cualquier cosa que se escriba en ese dispositivo virtual va a parar a un agujero negro, es decir, se ignora completamente. ¿Para qué sirve esto? Si queremos comprobar si un programa devuelve un error, pero no quiero que la salida estándar aparezca en pantalla (porque al usuario no le interesa, por ejemplo), entonces redirecciono la salida total (con “&>”) a “/dev/null”. Ejemplo del script secu.sh que usa redirección:

#!/bin/sh # este script muestra redirección a archivo # y también redirección desde un archivo a un comando find / -perm -4000 > secu.txt mail -s seguridad root < secu.txt

La orden read Permite insertar en la ejecución del script, lo que el usuario tipea en la línea de comandos. read sólo lee una línea de la entrada del usuario y la asigna a una o más variables de la shell. La orden read detiene la ejecución del script. Hasta que por línea de comandos no entre un valor, el programa estará detenido. La variable REPLY se utiliza por defecto si no se especifica ningún valor. Ejemplo del script nombre.sh:

#!/bin/sh echo “Ingrese su nombre : “ read nombre clear echo “Su nombre es : $nombre”

Ahora lo ejecutamos, para lo cual hacemos

# chmod +x nombre.sh # ./nombre.sh

Vemos que el script nos pide el nombre, y luego nos dice nuestro nombre. Podemos pedir varias entradas de datos con un solo read. Ejemplo del script datos_alumno.sh:

#!/bin/sh echo “Ingrese su nombre y su legajo : “ read nombre legajo clear echo “Su nombre es : $nombre y su numero de legajo es : $legajo”



Ahora lo ejecutamos, para lo cual hacemos # ./datos_alumno.sh

Estructuras de control Como todo buen lenguaje de programación la shell posee estructuras de control (if-then-else, case, etc.) y ciclos (for, while, etc.). La sintaxis de la sentencia if tiene la forma:

if comando1 then comandos2 else comandos3 fi

comando1 siempre se ejecuta (normalmente se ejecuta el comando test) comandos2 solamente se ejecutan si comando1 finaliza exitosamente (devuelve cero) comandos3 solamente se ejecutan si comando1 NO finaliza exitosamente (devuelve un valor distinto

de cero) El else es opcional, cuando no se encuentra nos queda así:

if comando1 then comando2 comando3 fi

Si comando1 se ejecuta exitosamente, se ejecutarán los comandos que se encuentran entre el then y el fi (comando2, comando3, etc.), Si comando1 no se ejecuta exitosamente, los comandos entre el then y el fi no se ejecutarán y la shell continuará con la ejecución de comandos que se encuentren después del fi.

Nota: El fi marca el final del if y no debe faltar. Pero el if de la shell solo puede evaluar comandos por lo que no podríamos evaluar los valores de las variables, para esto se usa el comando test (que pertenece a la shell). test devuelve 0 ,en caso verdadero ó 1 si es falso.

if test $HOME = "/home/agarcia" then echo "Hogar dulce hogar" else echo "¿Dónde estoy?, ¡Quiero ir a mi directorio home!" fi

Esta vez test revisa que el directorio $HOME del usuario sea "/home/agarcia" y escribe "Hogar dulce hogar" y sino escribe otro mensaje. Tenga en cuenta que la expresión que va a evaluar test debe estar separada por espacios ya que la expresión es, en realidad los argumentos con que se va a ejecutar test. Otra forma de escribir el if, abreviando la sintaxis de test, es poner entre corchetes la condición a evaluar, y la sintaxis sería igual a la mostrada anteriormente. Ahora si quisiera poner el then en la misma línea, después de la expresión del test debemos poner un “;”. Esto es muy común en los scripts (para ahorrar espacio), pero aun más común es esta forma de usar el comando test:

if [ "$PREFIJO" = "" ]; then PREFIJO="/usr/local/bin" fi

En este caso, cuando el bash encuentra los “[ ]” los reemplaza por el comando test sin que nosotros tengamos que pensar en ello siquiera.



Nota: Tenemos que dejar espacios entre el if, los “[ ]” y la condición.

Efectuando comparaciones Comprobaciones de cadenas

-z cadena Verdadero si la longitud de cadena es cero. -n cadena Verdadero si la longitud de cadena no es cero, es decir si existe cadena. cadena1 = cadena2 Verdadero si cadena1 y cadena2 son idénticos. cadena1 ¡= cadena2 Verdadero si cadena1 y cadena2 no son idénticos. cadena1 Verdadero si cadena1 no es la cadena nula.

Ejemplo con script primer_nombre.sh:

#!/bin/sh echo “Escriba su primer nombre : “ read nombre if [ -z $nombre ]; then echo “No ha ingresado su primer nombre” else echo “Su primer nombre es : $nombre” fi

Otro ejemplo: script cadena.sh

#!/bin/bash echo "ingrese la cadena 1" read cadena1 echo "Ingrese la cadena 2" read cadena2 if [ $cadena1 = $cadena2 ] then echo "las cadenas son iguales" else echo "las cadenas son distintas" fi

Comprobaciones de enteros

n1 -eq n2 Verdadero si los enteros n1 y n2 son iguales. n1 –ne n2 Verdadero si los enteros n1 y n2 no son iguales. n1 –gt n2 Verdadero si el entero n1 es mayor que el entero n2. n1 –ge n2 Verdadero si el entero n1 es mayor o igual que el entero n2. n1 –lt n2 Verdadero si el entero n1 es menor que el entero n2. n1 –le n2 Verdadero si el entero n1 es menor o igual que el entero n2.

Para recordar el significado de las comparaciones, es fácil si sabemos de donde viene la palabra a usar: eq de equal (igual); ne de not equal (no igual); gt de greater than (mayor que); ge de greater or equal (mayor o igual), lt de less than (menor que) y le de less or equal (menor o igual). Otro ejemplo: script numero.sh

#!/bin/sh clear var1=4 echo -n "Ingrese una variable : " read var2 if [ $var2 -ge $var1 ]; then echo $var2 else echo $var1 fi

Comprobaciones de archivos

-a archivo Verdadero si existe archivo. -r archivo Verdadero si existe archivo y puede leerse.



-w archivo Verdadero si existe archivo y puede escribirse. -x archivo Verdadero si existe archivo y es ejecutable. -f archivo Verdadero si existe archivo y es un archivo regular. -d archivo Verdadero si existe archivo y es un directorio. -h archivo Verdadero si existe archivo y es un enlace simbólico. -c archivo Verdadero si existe archivo y es un archivo de caracteres especiales. -b archivo Verdadero si existe archivo y es un archivo especial de bloque. -p archivo Verdadero si existe archivo y es un cauce con nombre. -s archivo Verdadero si existe archivo y tiene un tamaño mayor que cero.

Ejemplo con script verificar_archivo.sh:

#!/bin/sh echo –n “Escriba el archivo que desea verificar : “ read archivo if [ -a $archivo ]; then echo “Existe el archivo.” if [ -r $archivo ]; then echo “el archivo se puede leer” fi if [ -w $archivo ]; then echo “El archivo se puede escribir” fi if [ -x $archivo ]; then echo “El archivo se puede ejecutar” fi if [ -d $archivo ]; then echo “El archivo es un directorio” fi else echo “No existe el archivo : $archivo” fi

La sentencia case La sentencia case se utiliza cuando tenemos que usar varios if para hacer una misma comparación. Un uso típico es para comparar (usando comodines del shell como “*” y “?”) una cadena dada con varias posibilidades. La estructura es la siguiente:

case $variable in valor1 ) comandos1;; valor2 ) comandos2;; *) comandos3;; esac

La variable a evaluar ingresa en case $variable in Si cumple valor1, se ejecutan comandos1 Si cumple valor2, se ejecutan comandos2 Si ninguna opción se cumple, la shell toma como por valor por default a “*” y ejecutará comandos3. Ejemplo con script verificar_archivo.sh:

#!/bin/sh # Ejemplo de case echo –n “Escriba un valor : “ read valor case $valor in 1) echo “La variable es 1”;; 2) echo “La variable es 2”;; 3) echo “La variable es 3”;; *)echo “Fin”;; esac

Nota: El case es la herramienta que utilizaremos a menudo para crear menúes personalizados, que el usuario cuando se loguee, solo pueda acceder a él. Esta es una línea del archivo /etc/passwd:



genio:x:506:509::/home/genio:/usr/bin/menu.sh La sentencia for El bucle for toma una lista de cadenas y las asigna a una variable. Es una estructura que permite dos sintaxis: La primera, la del for más o menos tradicional, dar el nombre de una variable y los valores por los que tiene que "pasar", es la siguiente:

for variable in expreg1 expreg2 ... do comandos done

Hay una pequeña diferencia respecto a los bucles normales for de otros lenguajes, como C y Pascal, y ésta es que los valores por los que pasa la variable variable tenemos que especificarlos uno a uno (mediante expresiones regulares). Las expresiones regulares se intentarán hacer coincidir con los nombres de los archivos del directorio actual.

Nota: Las expresiones regulares, también pueden considerarse lista de valores. Ejemplo con script archivos.sh:

#!/bin/sh for i in `ls *.sh`; do # “`” son las comillas simples de ejecución. if [ -x $i ]; then echo “el fichero $i es ejecutable.” fi done

La segunda sintaxis que permite el bucle for es una sintaxis sin lista. Si utilizamos esta sintaxis, el shell interpretará que la lista que queremos es la de todos los parámetros dados al script desde la línea de comandos (u otro script o programa). La sintaxis queda:

for variable do comandos done

La sentencia while El bucle while se ejecutará mientras la condición que evaluamos sea verdadera. Se puede usar la palabra clave break para abandonar el bucle en cualquier punto de la ejecución. Con la palabra clave continue el bucle continúa con la siguiente iteración y se salta el resto del cuerpo del bucle. Para escapar de este bucle sin utilizar los breaks, la sentencia while deberá dejar de ser cierta. La estructura es la siguiente: while [ condicion ] do comandos done Ejemplo con script variable.sh:

#!/bin/sh clear i=0 var1=4 echo -n "Ingrese una variable : " read var2 while [ $var2 -ge $var1 ]; do echo $var2 i=`expr $i + 1` if [ $i -eq 4 ]; then break fi done



Depuración La shell también tiene un modo de depuración real o debugger. Si hay un error en nuestro script se puede depurar de la siguiente forma:

# sh –x nombre_de_script Esto ejecutará el script y mostrará todas la sentencias que se ejecutan con las variables y comodines ya expandidos. La shell también tiene un modo para comprobar errores de sintaxis sin ejecutar el shellscript. Se utiliza de la siguiente forma:

# sh –n nombre_de_script Si no retorna nada entonces su programa no tiene errores de sintaxis.



Capítulo 9

El demonio xinetd xinetd es el “Demonio de Servicios Extendidos de Internet” . Eso es lo que quiere decir sus siglas en inglés, es un superdemonio, maneja varios servicios simultáneamente, por eso es llamado un superdemonio o superserver. Su función es ayudar a controlar las conexiones de red en un sistema. Cuando llega una petición al puerto administrado por xinetd, éste verifica su configuración controlando una lista de control de accesos y si es autorizado el tráfico, se levanta el demonio que realmente tiene que escuchar la petición. xinetd ofrece más capacidades de control de acceso similares a las proporcionadas por tcp_wrapper, algunas son:

• control de acceso para los servicios TCP, UDP y RPC • control de acceso basado en intervalos de tiempo • prevención efectiva contra ataques del tipo Negación de Servicios (DoS) que bloquean una máquina

saturando sus recursos: o limitación del número de servidores del mismo tipo ejecutándose en forma simultánea. o limitación del número total de servidores o limitación del tamaño de los archivos log.

• anexión de un servicio a una interface determinada permitiendo, por ejemplo, hacer accesibles los servicios en una red privada pero no en el entorno ajena a ella.

• puede oficiar de proxy para otros sistemas lo cual resulta muy práctico en el caso del ip_masquerading (o NAT) a fin de acceder a máquinas situadas en una red interna.

El principal inconveniente, como ya se mencionó, está relacionado con la administración de las llamadas RPC que aún no se encuentran bien soportadas. Sin embargo, portmap y xinetd se complementan perfectamente. Toda esta primera parte dio una introducción a los usos de xinetd. Ahora nos dedicaremos a la configuración general de este demonio y algunos servicios dependientes de él. A partir del kernel 2.4 tenemos xinetd, anteriormente, en kernel 2.2 se usaba inetd. Así era inetd, para ver algunas diferencias con el actual, xinetd.

#vi /etc/inetd.conf #finger stream tcp nowait nobody /usr/sbin/tcpd in.fingerd -w #systat stream tcp nowait nobody /usr/sbin/tcpd /bin/ps -auwwx #netstat stream tcp nowait root /usr/sbin/tcpd #telnet stream tcp nowait root /usr/sbin/tcpd in.telnetd

tftp dgram udp wait nobody /usr/sbin/tcpd in.tftpd /tftpboot

Veamos que significa cada columna de este archivo:

- Nombre del servicio, (tftp, telnet, etc) - Tipo de socket. (stream, dgram, etc) - Protocolo. (tcp, udp) - wait/nowait - usuario con el que se ejecutará el servicio. (root, nobody, etc) - programa que brindará el servicio. (/usr/sbin/tcpd /usr/sbin/in.telnetd)

Nota: la última columna, la que contiene al programa que brindará el servicio, siempre es de la forma: /usr/sbin/tcpd y el path del programa correspondiente al servicio.

Vamos a ver que xinetd ofrece más controles sobre los puertos, tiene más opciones de configuración, por lo tanto asumimos, que es más seguro también.



Nota: Antes de iniciar xinetd no es necesario deshabilitar inetd. No obstante si no se toma en cuenta esta precaución puede originarse un comportamiento bastante impredecible de ambos demonios.

¿Cómo instalar el xinetd?

Fácil, como ya vimos apt-get es amigable para este tipo de cosas. Solo hace falta hacer:

apt-get install xinetd

y el apt-get hará su magia. Al finalizar el proceso de instalación nos va a aclarar que va a migrar la configuración de inetd al nuevo formato de xinetd. Si quisiéramos hacer este proceso a mano, podemos realizarlo de la siguiente forma.

# /usr/local/sbin/xconv.pl < /etc/inetd.conf > /etc/xinetd.conf

Luego, debemos agregarlo al runlevel correspondiente para que se ejecute cada vez que reiniciemos nuestro sistema. También debemos deshabilitar inetd, para que no cargue al arrancar. Si lo dejamos, el inetd en realidad no va a arrancar, porque en el proceso de instalación del xinetd, el script de arranque de inetd que está ubicado en /etc/init.d fue renombrado a inetd.real.

Configuración Los archivos de configuración para xinetd son los siguientes:

• /etc/xinetd.conf El archivo de configuración global de xinetd. • /etc/xinetd.d/directory El directorio que contiene todos los archivos específicos al

servicio. El archivo /etc/xinetd.conf es el archivo de configuración por defecto del demonio xinetd. Si bien la configuración de xinetd no es muy complicada, es bastante extensa y su sintaxis difiere de la empleada por su predecesor inetd. El archivo de configuración comienza con una sección por defecto cuyos atributos utilizarán todos los servicios administrados por xinetd. A continuación, se encuentran tantas secciones como servicios existan. En cada una de ellas se pueden redefinir las opciones específicas que vienen por defecto. Los valores por defecto de cada sección se escriben de la siguiente manera:

defaults {

atributo operador valor [ valor1 ] atributo2 operador valor2 ... atributoN operador valorN

} Ejemplo:

defaults {

instances = 60 log_type = SYSLOG authpriv log_on_success = HOST PID log_on_failure = HOST cps = 25 30

} includedir /etc/xinetd.d

Estas líneas controlan varios aspectos de xinetd:



• instantes Configura el máximo número de peticiones que xinetd puede manejar simultáneamente.

• log_type Configura xinetd para usar la facilidad de registro authpriv, el cual escribe las entradas de registro al archivo /var/log/secure. Al agregar una directiva tal como FILE /var/log/xinetdlog aquí, creará un archivo de registro personalizado llamado xinetdlog en el directorio /var/log/.

• log_on_success Configura xinetd para registrar si la conexión es exitosa. Por defecto, la dirección IP del host remoto y el PID del servidor procesando la petición son grabados.

• log_on_failure Configura xinetd para registrar si hay una falla de conexión o si la conexión no está permitida.

• cps Configura xinetd para no permitir más de 25 conexiones por segundo a cualquier servicio dado. Si se alcanza este límite, el servicio es retirado por 30 segundos. Esto es en el caso del ejemplo, de forma genérica, limita el número de conexiones entrantes. El primer argumento es precisamente este número. Cuando se supera este límite, se desactiva el servicio con un retraso (expresado en segundos) proporcionado por el segundo argumento.

• includedir /etc/xinetd.d/ Incluye las opciones declaradas en los archivos de configuración específicos del servicio localizados en el directorio /etc/xinetd.d/.

Configurando un servicio El directorio /etc/xinetd.d/ Los archivos en el directorio /etc/xinetd.d/ contienen los archivos de configuración para cada servicio manejado por xinetd y los nombres de los archivos que se correlacionan con el servicio. Como sucede con xinetd.conf, este archivo es de sólo lectura cuando el servicio xinetd es arrancado. Para que los cambios tengan efecto, el administrador debe reiniciar el servicio xinetd.

Nota: Recuerde como se reinicia un demonio o servicio. #/etc/rc.d/init.d/xinetd restart

El formato de los archivos en el directorio /etc/xinetd.d/ usan las mismas convenciones que /etc/xinetd.conf. La configuración para cada servicio se almacena en archivos separados para hacer más fácil la personalización y que sea menos probable afectar otros servicios. Veamos como es la estructura de estos archivos:

service nombre_del_servicio {

atributo operador valor(es) ...

} Existen tres operadores: '=', '+=' y '-='. La mayoría de los atributos sólo soportan el operador '=' que fija un valor a un determinado atributo. El operador '+=' agrega un elemento a una lista de valores en tanto que el operador '-=' lo elimina. Ejemplo:

service telnet {

flags = REUSE socket_type = stream wait = no user = root server = /usr/sbin/in.telnetd log_on_failure += USERID disable = yes

} Estas líneas controlan varios aspectos del servicio telnet:

• service Define el nombre del servicio, usualmente coincide con un servicio listado en el archivo /etc/services.



• flags Configura cualquier número de atributos para la conexión. REUSE instruye xinetd a reutilizar el socket para una conexión Telnet.

• socket_type Configura el tipo de socket. Puede ser stream (TCP), dgram (UDP), raw (acceso directo a IP) o seqpacket.

• wait Define si el servicio es de un sólo hilo (yes) o de múltiples hilos (no). Si es de múltiples hilos o multithread, por cada servicio nuevo solicitado, xinetd arranca un nuevo servidor de acuerdo al límite máximo definido.

Nota: Por defecto este límite es infinito. • user Define bajo qué ID de usuario se ejecutará el proceso. • server Define el binario ejecutable a lanzar. • server_args Argumentos que se deben pasar al servidor. • log_on_failure Define los parámetros de registro para log_on_failure además de aquellos

ya definidos en xinetd.conf. USERID — Registra el usuario remoto que está usando el método definido en RFC 1413 para todos los servicios de multiprocesos (log_on_failure y log_on_success).

• disable Define si el servicio está activo o no. • port Define el puerto asociado al servicio. También está definido en el archivo /etc/services. • redirect permite enviar la solicitud de un servicio hacia un determinado puerto de otra

máquina. Aquí tenemos algunos atributos más. Para ampliar la lista, vea la página man de xinetd.conf. Atributo Valores y descripción

flags

Estos son los valores más comunes. Ver la documentación para descubrir los restantes.

• IDONLY: únicamente acepta conexiones de clientes que tengan un servidor de identificación.

• NORETRY: en caso de fracasar evita que se desdoble el proceso. • NAMEINARGS: para pasar argumentos al servidor. Esto permite usar tcpd

poniéndolo en el atributo del server. Se escribe el nombre del servidor y sus argumentos tal como server_args, al igual que se haría con inetd.

log_type

xinetd usa por defecto syslogd y el selector daemon.info. • SYSLOG selector [nivel]: permite elegir entre daemon, auth, user ó

local0-7 de syslogd. • FILE [tamaño_max [tamaño_max_absoluto]]: el archivo especificado

recibe la información. Las dos opciones fijan los límites del tamaño del archivo. Cuando se alcanza el primero, se envía un mensaje a syslogd; en tanto cuando se alcanza el segundo, se interrumpe el registro de los logs del servicio (si se trata de un archivo compartido o fijo por defecto pueden verse afectados diversos servicios).

no_access Lista los clientes que no tienen acceso al servicio.

only_from Lista a los clientes autorizados. Si este atributo carece de valor, se deniega el servicio.

protocol El protocolo especificado debe existe en el archivo /etc/protocols. Si no se proporciona un protocolo se emplea el asociado por defecto.

type

xinetd puede administrar 3 tipos de servicios: • RPC: para aquellos definidos en el archivo /etc/rpc. • INTERNAL: para los servicios directamente administrados por xinetd (echo,

time, daytime, chargen y discard). • UNLISTED: para los servicios que no están definidos en el archivo /etc/rpc ni

en el /etc/services. Nota: Es posible combinar distintos valores como lo veremos con los servicios internos servers, services y xadmin.

max_load Define la carga máxima del servidor (por ejemplo, 2 ó 2.5). Más allá de este límite las solicitudes que se realizan al servidor se rechazan.



per_source Restringe el número de conexiones al servidor que tienen un mismo origen. Es un entero o bien UNLIMITED.

nice Cambia la prioridad del servidor, como lo hace el comando nice. rpc_version Todos los servicios RPC. rpc_number Todos los servicios RPC que no se encuentran en /etc/rpc. Los atributos max_load, per_source, instances y cps permiten controlar los recursos que dependen de un servidor. Esto es de gran utilidad para protegernos de manera eficaz de ataques del tipo Negación de Servicios (DoS) cuyo objetivo consiste en colgar una máquina usando todos sus recursos. Este ejemplo muestra cómo se definen los servicios:

service ntalk {

socket_type = dgram wait = yes user = nobody server = /usr/sbin/in.ntalkd only_from = 192.168.1.0/24

} service ftp {

socket_type = stream wait = no user = root server = /usr/sbin/in.ftpd server_args = -l instances = 4 access_times = 7:00-12:30 13:30-21:00 nice = 10 only_from = 192.168.1.0/24

} Note que estos servicios están únicamente autorizados en la red local (192.168.1.0/24). En cuanto al FTP, debe prever restricciones suplementarias: el número de instancias se limita a 4 y sólo será posible su uso en ciertos intervalos de tiempo. Otro Ejemplo:

service telnet {

disable = no flags = REUSE socket_type = stream wait = no user = root server = /usr/sbin/in.telnetd log_on_failure += USERID no_access = 10.0.1.0/24 log_on_success += PID HOST EXIT access_times = 09:45-16:15

} En este ejemplo, cuando un sistema cliente desde la red 10.0.1.0/24, tal como 10.0.1.2, intenta accesar el servicio telnet, recibirá un mensaje indicando lo siguiente:

Connection closed by foreign host. Además, su intento de conexión es registrado en /var/log/secure como sigue:

Jul 2 17:38:49 boo xinetd[16252]: START: telnet pid=16256 from=10.0.1.2 Jul 2 17:38:49 boo xinetd[16256]: FAIL: telnet address from=10.0.1.2 Jul 2 17:38:49 boo xinetd[16252]: EXIT: telnet status=0 pid=16256



Capítulo 10

Introducción a Samba Samba es una herramienta que permite a los equipos GNU-Linux/UNIX interactuar con sistemas Windows. Utiliza el protocolo SMB (Session Message Block, Bloque de Mensajes de Sesión) para permitir a aquellos sistemas compartir archivos. Para un administrador esto significa que puede instalar un servidor GNU-Linux/UNIX sin tener que instalar NFS en todos los clientes Windows, porque estos van a utilizar su protocolo nativo SMB. Samba es soportado por la mayoría de las variantes UNIX, por GNU-Linux y por algunos sistemas no UNIX. Es gratuito, está ampliamente documentado y por sus características facilita la administración de los servidores de archivos. Todo esto lo hace muy popular. Aunque nació como tal en 1995, su historia arranca realmente en 1992, cuando Andrew Tridgell se vio en la necesidad de acceder a archivos en una máquina Unix desde un PC. El cliente NFS (Network File System, Sistema de Archivos de Red es el protocolo nativo de compartición de archivos Unix-Linux) que utilizaba, trabajaba perfectamente, pero necesitaba también una aplicación que usaba la API de NetBIOS. Dada la problemática de usar protocolos múltiples bajo DOS, decidió adoptar un enfoque alternativo y utilizar la ingeniería inversa. Mediante un sniffer monitoreó los paquetes transmitidos mediante SMB, desentrañó el protocolo y lo implementó en su sistema Unix, capaz de manejar sin problemas varios protocolos de forma simultánea. Y eso fue el comienzo. Una vez depurado el código, dado que el objetivo se había alcanzado, su desarrollo se detuvo. Este paréntesis duró hasta unos años después, cuando pensó en conectar el PC con Windows de su esposa con su propia máquina Linux. Dado que lo tenía a mano, probó su propio código que, para su gran sorpresa, funcionó perfectamente. Desde entonces, la esposa de Andrew se ha convertido en el primer test al que se someten las nuevas versiones de Samba, que es el nombre que se adoptó para el paquete, buscando en un diccionario palabras con la combinación de letras smb.

Servidor Samba Samba es una emulación de NetBIOS, corriendo sobre Linux. Como tal, es un servicio que queda a la escucha sobre el puerto TCP/IP, 139. Para realizar el camino inverso, es decir que Linux vea archivos compartidos por los servidores Windows, se utiliza la utilidad smbclient que forma parte del paquete Samba.

Instalación de Samba Para tener samba funcionando, estos son los paquetes que debemos instalar: apt-get install samba smbfs smbclient samba-common

Nos van a aparecer algunas pantallas de configuración, recordemos que apt-get install nos deja el paquete instalado, listo para ejecutarlo. Por ejemplo, nos va a preguntar si queremos ejecutar samba como demonio independiente o dentro del superdemonio inetd. En este caso, por razones de rendimiento, elegimos la opción demonios

Nota: inetd y xinetd se tratan en otro capítulo.



También nos puede preguntar, si no lo encontró, el nombre del workgroup o dominio donde se encuentra el servidor. En otra pantalla nos puede preguntar si somos clientes de un servidor DHCP. Otra opción a configurar tiene que ver con el tema de las claves y la encriptación. Vamos a configurar un servidor que realiza validación de usuarios en diferentes sistemas operativos. Podemos tener usuarios windows que impriman en impresoras conectadas a un Linux, o compartan recursos en un servidor Linux. Por lo tanto los usuarios deberán poder loguearse tanto en sistemas windows como Linux. Estos sistemas utilizan diferentes formas de administración de usuarios y passwords. Por tal motivo nos pregunta si queremos utilizar cifrado de contraseñas.

Al contestar afirmativamente la pantalla anterior, debemos contestar que sí a la próxima, para crear un archivo /var/lib/samba/passdb.tdb, que es donde se almacenarán las contraseñas encriptadas.



Configuración de Samba El archivo principal de configuración es /etc/samba/smb.conf. Según las distribuciones puede cambiar la ubicación de este archivo. Este archivo está dividido en secciones, cada sección está separada de la siguiente por una cadena de caracteres encerrada entre corchetes. Esa cadena es el nombre del recurso a compartir. A continuación explicaremos los contenidos del archivo.

Nota: Recuerde que, en un archivo de configuración, los comentarios pueden comenzar con el signo numeral (#), o con punto y coma (;).

Globales En la primera sección, como en todo archivo de configuración, lo primero a setear es el entorno global o general. Por ejemplo, nombres, seguridad, logueos, protocolos de impresión. Luego seguiremos con opciones particulares en las próximas secciones.

# ================== G l o b a l S e t t i n g s ========================= [global] workgroup = centraltech

Esta variable workgroup, es el nombre de grupo de trabajo. Aquí debemos poner el nombre de workgroup o dominio que estemos utilizando. La siguiente línea será comentario de nuestro servidor, en éste lugar podemos poner lo que queramos.

# server string is the equivalent of the NT Description field server string = h% server (Samba %v) En esta línea %h será reemplazado por el nombre de host y %v será reemplazado por la versión de Samba. Podemos dejarlo así o ponemos la descripción deseada server string = mi h% server (Samba %v)

Si la red utiliza WINS

# Windows Internet Name Serving Support Section: # WINS Support - Tells the NMBD component of Samba to enable its WINS Server ; wins support = no Puede habilitar convertirse en servidor WINS o bien utilizar un servidor WINS ya existente. Se puede ser un servidor WINS o un cliente WINS, pero no ambas cosas a al vez.

Configuro la IP del servidor WINS

# WINS Server - Tells the NMBD components of Samba to be a WINS Client # Note: Samba can be either a WINS Server, or a WINS Client, but NOT both ; wins server = w.x.y.z

Si tengo un proxy.

# WINS Proxy - Tells Samba to answer name resolution queries on # behalf of a non WINS capable client, for this to work there must be # at least one WINS Server on the network. The default is NO. ; wins proxy = yes # DNS Proxy - tells Samba whether or not to try to resolve NetBIOS names # via DNS nslookups. The built-in default for versions 1.9.17 is yes, # this has been changed in version 1.9.18 to no. dns proxy = no

Le decimos como debe resolver los nombres, si debe buscar en el archivo lmhost (mapea IPs con nombres NETBIOS), en el archivo hosts o servidor de nombres, en wins o por broadcast. # what naming service and in what order should we use to resolve host names # to IP addresses ; name resolve order = lmhosts host wins bcast La siguiente línea permite indicar el rango de direcciones IP de clientes autorizados a conectarse con el servidor, pero como esta comentado por defecto, compartirá toda la red.

; hosts allow = 192.168.1. 192.168.2. 127.



Ahora vamos a ver como definir archivos de log, como generarlos. En el caso que necesitemos tener un archivo de logueo distinto por cada máquina que se conecte, podemos usar “%m” para incluir la máquina en el nombre del archivo de log.

#### Debugging/Accounting #### # this tells Samba to use a separate log file for each machine # that connects log file = /var/log/samba/log.%m

Se le puede especificar el tamaño máximo de cada uno de esos archivos (es recomendable dejar la configuración por default)

# Put a capping on the size of the log files (in Kb). max log size = 1000 # If you want Samba to only log through syslog then set the following # parameter to `yes`. ;syslog only = no

Nota: Los archivo de log son los que guardan un registro de actividades.

# We want Samba to log a minimum amount of information to syslog. Everything # should go to /var/log/samba/log.{smbd,nmbd} instead. If you want to log # through syslog you should set the following parameter to something higher. syslog = 0 # Do something sensible when Samba crashes: mail the admin a backtrace panic action = /usr/share/samba/panic-action %d

Seguridad Samba permite cuatro tipos de seguridad: share, user, server y domain. La autentificación de nivel de recurso compartido (share) requiere que cada usuario tenga una cuenta de SMB en el servidor de Samba o que se defina ese recurso compartido concreto de forma que permita el acceso de usuarios anónimos. Estos requisitos son las únicas restricciones de nivel de recurso compartido para acceder a los recursos compartidos; si los usuarios tienen cuentas de SMB, Samba, en la seguridad de nivel de recurso compartido, no podrá restringir el acceso de esos usuarios a los recursos compartidos. Estas restricciones limitadas difieren del acceso de nivel de recurso compartido de Windows 9x, que permite asignar contraseñas a los recursos compartidos. El acceso de nivel de usuario (user) es más potente y más seguro, y permite que los administradores especifiquen una lista de usuarios o grupos de usuarios que pueden acceder a un recurso compartido (la seguridad de nivel de recurso compartido otorga acceso al servidor, mientras que la seguridad de nivel de usuario otorga acceso a los recursos compartidos). Para la autorización de usuarios, Samba subdivide el acceso de nivel de usuario en dos: user (usuario) y domain (dominio). Si se especifica el acceso de nivel de usuario user, para autorizar al usuario Samba lo buscará en su base de datos de cuentas de usuario. Si se especifica domain, Samba autorizará a los usuarios dependiendo del PDC del dominio. Los administradores que usan Windows NT preferirán sin duda la seguridad de nivel de usuario para poder utilizar las infraestructuras de dominios de Windows NT ya existentes. Así y todo, configurar el acceso de nivel de usuario con Samba es más complicado que configurar el acceso de nivel de recurso compartido. Resumiendo share Comparación con cuenta guest. Todos pueden compartir. Indica que no se exige por parte del

servidor ningún tipo de autenticación por lo que se mostrarán todos los recursos compartidos. user Comparación a nivel grupo. Solo comparten usuarios válidos. Es el tipo de seguridad por defecto e

indica la necesidad de autenticar el usuario para acceder al servidor. La autenticación se hace en el servidor Samba.

server permite la autenticación en otro servidor, en caso de que esta falle se hará en el servidor Samba. domain permite la autenticación en un PDC siempre y cuando haya sido añadido el servidor Samba a este

dominio (más adelante se indica como hacer esto). Como utilizaremos la seguridad a nivel workgroup, cuenta guest, lo dejaremos así. ####### Authentication #######



# "security = user" is always a good idea. This will require a Unix account # in this server for every user accessing the server. See # /usr/share/doc/samba-doc/htmldocs/ServerType.html in the samba-doc # package for details. security = user Si quisiéramos tener la seguridad del tipo server deberíamos poner aquí el nombre del Dominio (Controlador de Dominio) que queramos usar para las autenticaciones. # Use password server option only with security = server ; password server = <NT-Server-Name> # Password Level allows matching of _n_ characters password for # all combinations of upper and lower case. ; password level = 8 ; username level = 8 Este es un punto muy importante del archivo de configuración. A partir de Windows 95 OSR2, los passwords están encriptados. Anteriormente, esto no era así. Así que ahora, lo que debemos hacer es descomentar esto. Más información encontramos en la ayuda del paquete Samba. # You may wish to use password encryption. See the section on # 'encrypt passwords' in the smb.conf(5) manpage before enabling. encrypt passwords = true # If you are using encrypted passwords, Samba will need to know what # password database type you are using. passdb backend = tdbsam guest # This parameter control whether or not Samba should obey PAM's # account and session management directives. The default # behavior is to use PAM for clear text authentication only and # to ignore any account or session management. Note that Samba # always ignores PAM for authentication in the case of # encrypt passwords = yes. obey pam restrictions = yes

Si queremos tener que evitar el registro de Windows® en todas las máquinas de la red local, debemos des-comentar las siguientes líneas de arriba

# This is a username which will be used for access to services which # are specified as "guest ok" guest account = guest # This is a list of users that should not be allowed to login to this service. invalid users = root

# This boolean parameter controls whether Samba attempts to sync the Unix # password with the SMB password when the encrypted SMB password in the # passdb is changed. unix password sync = yes # For Unix password sync to work on a Debian GNU/Linux system, the # following parameters must be set (thanks to Augustin Luton # <[email protected]> for sending the correct chat script for the # passwd program in Debian Potato). ; passwd program = /usr/bin/passwd %u passwd program = /usr/local/sbin/smbldap-passwd -o %u passwd chat = *Enter\snew\sUNIX\spassword:* %n\n *Retype\snew\sUNIX\ \spassword:* %n\n . # This boolean controls whether PAM will be used for password changes # when requested by an SMB client instead of the program listed in # 'passwd program'. The default is 'no'. pam password change = no La directiva include, indica que puedo llamar a otro archivo desde este archivo principal de configuración.



# Using the following line enables you to customise your configuration # on a per machine basis. The %m gets replaced with the netbios name # of the machine that is connecting ; include = /etc/samba/smb.conf.%m

# Configure Samba to use multiple interfaces # If you have multiple network interfaces then you must list them # here. See the man page for details. ; interfaces = 192.168.12.2/24 192.168.13.2/24

A continuación estableceremos cierto nivel de seguridad. Primero especificando por cuales interfaces del sistema se escucharan peticiones. Cualquier interfaz omitida significará que Samba no responderá a peticiones provenientes de esa interfaz. Esto es útil cuando Samba se ejecuta en un servidor que sirve también de puerta de enlace para la red local, impidiendo se establezcan conexiones desde fuera de la red local.

# Configure remote browse list synchronisation here # request announcement to, or browse list sync from: # a specific host or from / to a whole subnet (see below) ; remote browse sync = 192.168.3.25 192.168.5.255

Podemos hacer transmisión (Broadcast) hacia la red local, y hacer un anuncio remoto, con el siguiente parámetro: # Cause this host to announce itself to local subnets here ; remote announce = 192.168.1.255 192.168.2.44

Podemos indicarle a Samba que utilice las impresoras definidas en el archivo /etc/printcap. En ese archivo están definidas las impresoras y módulos. ########## Printing ########## # if you want to automatically load your printer list rather # than setting them up individually then you'll need this load printers = yes

Linux usa el sistema de impresión bsd, o también puede ser lprng. Debemos descomentar la siguiente línea. # lpr(ng) printing. You may wish to override the location of the # printcap file ; printing = bsd ; printcap name = /etc/printcap # CUPS printing. See also the cupsaddsmb(8) manpage in the # cupsys-client package. printing = cups printcap name = cups # When using [print$, root is implicitly a 'printer admin, but you can # also give this right to other users to add drivers and set printer # properties printer admin = @ntadmin ######## File sharing ######## # Name mangling options ; preserve case = yes ; short preserve case = yes ############ Misc ############ # Using the following line enables you to customise your configuration # on a per machine basis. The %m gets replaced with the netbios name # of the machine that is connecting ; include = /home/samba/etc/smb.conf.%m



# Most people will find that this option gives better performance. # See smb.conf(5) and /usr/share/doc/samba-doc/htmldocs/speed.html # for details # You may want to add the following on a Linux system: # SO_RCVBUF=8192 SO_SNDBUF=8192 socket options = TCP_NODELAY SO_RCVBUF=8192 SO_SNDBUF=8192 # The following parameter is useful only if you have the linpopup # package installed. The samba maintainer and the linpopup maintainer # are working to ease installation and configuration of linpopup and # samba. ; message command = /bin/sh -c '/usr/bin/linpopup "%f" "%m" %s; rm %s' & #### Domain Controller ####### En esta sección le decimos si el servidor va a ser el master browser o master domain. # This integer value controls what level Samba advertises itself as # for browse elections. The value of this parameter determines whether # nmbd(8) has a chance of becoming a local master browser for the # WORKGROUP in the local broadcast area. os level = 80 Por default, este parámetro acepta todos los sistemas operativos de Microsoft. # This boolean parameter controls if nmbd(8) is a preferred master browser for its workgroup. preferred master = yes Lo que sigue tiene que ver con el dominio principal, puede especificar que el servidor sea el Maestro del dominio, y también sobreponerse a cualquier otro en la red. # Domain Master specifies Samba to be the Domain Master Browser. If # this machine will be configured as a BDC (a secondary logon server), # you must set this to 'no'; otherwise, the default behavior is # recommended. domain master = yes # This option allows nmbd(8) to try and become a local master browser # on a subnet. local master = yes En el caso que Samba deba autenticar dominios, hay que configurar lo siguiente: # If set to yes, the Samba server will act as a Primary Domain # Controller (PDC) for the workgroup it is in. domain logons = yes # This parameter specifies the home directory where roaming profiles # (NTuser.dat etc files for Windows NT) are stored. logon path = \\%L\profiles\%u # This parameter specifies the local path to which the home directory # will be connected and is only used by NT Workstations. logon drive = H: # This parameter specifies the home directory location when a # Win95/98 or NT Workstation logs into a Samba PDC. logon home = \\%L\%u\.profile # This parameter specifies the batch file (.bat) or NT command file # (.cmd) to be downloaded and run on a machine when a user # successfully logs in. ; logon script = logon.cmd logon script =



# Be very careful with case sensitivity - it can break things! ; case sensitive = no # Users and groups allowed to be 'Domain Admins' ; domain admin group = @domainadmins # Some defaults for winbind (make sure you're not using the ranges # for something else.) idmap uid = 10000-20000 idmap gid = 10000-20000 Aquí comienza otra sección. El recurso compartido se llama homes, y son los directorios home de los usuarios #=====================Share Definitions ============================== [homes] comment = Home Directories browseable = no # By default, the home directories are exported read-only. Change next # parameter to 'yes' if you want to be able to write to them. writable = yes # File creation mask is set to 0700 for security reasons.If you want # to create files with group=rw permissions,set next parameter to0775. create mask = 0700 # Dir creation mask is set to 0700 for security reasons.If you want to # create dirs with group=rw permissions, set next parameter to 0775. directory mask = 0700 Lo anterior define que cada usuario mantiene su profile en el home que indique su entrada en el archivo /etc/passwd. También hay que especificar si el recurso compartido es de escritura o sólo de lectura. De forma predeterminada, Samba configura todos los recursos compartidos de disco como sólo de lectura. Para que los usuarios puedan escribir en los recursos compartidos habrá que utilizar el parámetro writeable (de escritura) para reemplazar el valor predeterminado. Se puede dejar que Samba aplique el valor predeterminado de sólo lectura (para recursos compartidos de disco que guarden controladores u otros archivos que no deban modificar los usuarios, por ejemplo) asignando a este parámetro el valor no o, simplemente, no definiéndolo. Sigue otra sección, la de impresoras

# NOTE: If you have a BSD-style print system there is no need to # specifically define each individual printer [printers] comment = All Printers path = /tmp browseable = no # Set public = yes to allow user 'guest account' to print guest ok = no writable = no printable = yes use client driver = no printer admin = root, @domainprintoperators ; create mask = 0700

Con esto le hemos dicho a Samba que queremos compartir las impresoras, pero que no le permita el acceso a las mismas al usuario guest. El parámetro guest ok, dice si admiten invitados. Se utiliza para permitir el acceso anónimo a un recurso compartido. Si no se permite el acceso anónimo, los usuarios que se conecten al recurso compartido necesitarán tener una cuenta de SMB en la base de datos local de contraseñas de Samba. Si se permite el acceso anónimo, (esto es para el caso de seguridad=share.), también habrá que especificar la cuenta de usuario de Linux con la que los usuarios accederán a los archivos del recurso compartido de disco (esta cuenta de usuario también puede especificarse en la sección global. En tal caso, esta sería la configuración predeterminada, que podría modificarse dependiendo del recurso compartido). Este paso es necesario, porque todos los accesos tienen que cumplir con los requisitos de autorización tanto de Samba como de Linux. Utilice la



cuenta de invitado para especificar la cuenta de usuario nobody (la cuenta originalmente propietaria del directorio):

guest ok = yes guest account = nobody

# Windows clients look for this share name as a source of downloadable # printer drivers [print$] comment = Printer Drivers path = /var/lib/samba/printers browseable = yes guest ok = no read only = yes write list = root, @domainprintoperators ;[cdrom] ; comment = Samba server's CD-ROM ; writable = no ; locking = no ; path = /cdrom ; guest ok = yes Llegó el momento de definir nosotros un recurso compartido. Lo llamaremos compartir. [compartir] # este es el nombre con el cual visualizaremos el recurso por NetBIOS comment = esta es la carpeta creada de ejemplo # Ubicación física del directorio compartido path = /home/samba/ # Control de accesos al share valid users = agarcia, gddlab, acarna Con lo anterior compartimos el directorio local /home/samba, con el nombre de compartir, al que tendrán acceso los usuarios agarcia, gddlab y acarna. Si quisiéramos permitir que el grupo Profesores acceda al recurso, lo haríamos de la siguiente manera:

valid users = @Profesores Por ultimo, decimos que no sea un directorio público.

public = no El archivo de configuración del servidor Samba está listo. Hacemos algunos ajustes adicionales. La primer tarea será crear en el servidor Linux el directorio que utilizará Samba para compartir archivos. Tanto en Linux como en Windows, el proceso es el mismo: crear el directorio y confirmar que su propietario es el usuario o el grupo adecuado. Entonces, como usuario root, hacemos en el sistema de archivos de Linux:

# mkdir /home/samba Observe que el directorio se crea en el directorio inicial de Samba. Linux asigna a casi todos los servicios una cuenta de usuario y un directorio inicial. Una práctica habitual en Linux es que los directorios de los recursos compartidos de disco estén en el directorio inicial de Samba, aunque el recurso compartido puede ponerse en otro disco e incluso en un dispositivo de almacenamiento de red montado. La ubicación del directorio es irrelevante si el soporte de almacenamiento es fiable. Vamos a configurar como propietario de este directorio de Linux a nobody (una cuenta que Linux crea automáticamente durante la instalación). Los administradores de Linux normalmente asignan la cuenta de usuario utilizada para acceder de forma anónima a "nobody" (nadie).

# chown nobody /home/samba Después de guardar el archivo y salir del editor debemos ejecutar el programa testparm de Samba, para que haga una comprobación de la sintaxis, por ejemplo que no hayamos ingresado cadenas que no sean reconocidas por Samba (por Ej.: suers en lugar de users)



Además, para determinar la causa de un problema puede utilizar los dos archivos de registro de Samba, log.smb y log.nmb, que se encuentra en /var/log/samba. El archivo log.smb registra la actividad de compartimiento de archivos e impresión. El archivo log.nmb registra la activación de servidores de nombres, como el registro del servidor WINS.

# testparm Load smb config files from /etc/samba/smb.conf Processing section "[homes]" Processing section "[printers]" Processing section "[print$]" Processing section "[compartir]" Loaded services file OK. Press enter to see a dump of your service definitions

Si existen errores de sintaxis nos lo irá diciendo, van a aparecer acá. Presionamos Enter y nos mostrará el archivo listo para ejecutar, sin ningún comentario. Ya configuramos el archivo, pero Samba no esta corriendo todavía. Para hacer funcionar el servicio debemos hacer lo siguiente:

# /etc/rc.d/init.d/smb start StartingSMBservices: smbd nmbd

Para asegurarnos que el servicio está funcionando podemos ejecutar lo siguiente. Recordar que Samba escucha en el puerto 139.

# telnet localhost 139 Trying 127.0.0.1... Connected to localhost.

Nota: Cuando el servidor esté en producción no es conveniente reiniciar Samba; durante el proceso de reinicio se pierde la conexión con el cliente, lo que puede provocar que el archivo se corrompa. Parar Samba cuando se está alojando un recurso compartido de disco es equivalente desde el punto de vista del cliente a desconectar el cable de red del servidor.

Recién configuramos el servidor, ahora necesitamos conectarnos como clientes, para ver si ha quedado bien. Para ver nuestro servidor, utilizamos la herramienta smbclient dragon:~# smbclient –L dragon

Nos pide un password, presionamos Enter para ejecutar un login anónimo, y muestra:



Como vemos, la configuración es correcta, vemos el servidor y a que workgroup pertenece. También vemos los recursos compartidos del servidor. Asegúrese de que puede acceder al recurso compartido de disco archivos a través de la red. Para ver los archivos del recurso compartido en \\<nombreservidorsamba> puede hacer la prueba siguiente:

C:\> net view \\<nombreservidorsamba> La salida del mandato debería ser parecida a esta:

Recursos compartidos en \\<nombreservidorsamba> Samba 3.0.14 Recurso Tipo Uso Comentario ----------------------------------------------------------- Archivos Disco Archivos de red El comando se ha completado correctamente.

Si el mandato se ejecuta correctamente, significa que es posible acceder al nuevo recurso compartido de disco. Para ver el servidor también puede utilizarse el Entorno de red.

Nota: Si el mandato no se ejecuta correctamente, es probable que tenga un problema de acceso al servidor. Intente verlo con el mandato net view y la dirección IP del servidor. Si el mandato con la dirección IP funciona y con el nombre de NetBIOS no, verifique que los parámetros correspondientes al servidor WINS y al grupo de trabajo son correctos. Si utilizando el mandato con la dirección IP tampoco funciona, vuelva a comprobar que Samba esté funcionando y que Linux esté configurado correctamente.

También, hay que determinar si es posible conectarse al recurso compartido y si se tiene acceso de escritura. Utilice el mandato net use para verificar que se tiene acceso y, a continuación, realice una operación de escritura en el recurso compartido para comprobar el acceso de escritura. En el ejemplo siguiente se comprueba el acceso creando un directorio:

C:\> net use Z: \\<nombreservidorsamba> La salida del mandato nos devuelve:

El comando se ha completado correctamente. Para crear el directorio utilice estos mandatos:

C:\> Z: Z:\> mkdir prueba Z:\> dir



Como resultado de estos mandatos verá la salida siguiente:

El volumen de la unidad Z es Archivos El número de serie del volumen es 2DE3-053C Directorio de Z:\ 13/06/06 11:02 <DIR> . 13/06/06 11:02 <DIR> .. 13/06/06 11:02 <DIR> prueba

Usuarios válidos para Samba Para validar los usuarios, Samba necesita además de que existan como usuarios de sistema. Debemos sincronizar las cuentas entre el servidor Linux y las estaciones Windows. Ejemplo: si en una máquina Windows ingresa como usuario agarcia con contraseña venus, en el servidor Linux debe existir también dicha cuenta con ese mismo login y esa misma contraseña. Para agregar las cuentas se pueden usar los comandos adduser y passwd, también smbadduser y smbpasswd. Veamos, si el usuario agarcia no existe en el sistema, lo podemos crear con useradd. Luego, para crear la cuenta de usuario agarcia en Samba, lo puedo hacer con smbadduser, como dije antes, o sino directamente con smbpasswd. Vea el ejemplo.

# smbadduser unixid:winid Donde primero coloco el nombre de usuario Linux y luego el nombre del usuario Windows. Otra forma es:

# useradd -m agarcia # smbpasswd -a agarcia NewSMBpassword: Retype newSMBpassword: Added user agarcia. Password changed for user agarcia

Acceso a los recursos compartidos El programa cliente que vamos a usar se llama smbclient. Este permite acceder hacia cualquier servidor Samba o Windows como si fuese el comando ftp en modo texto.

# smbclient -U agarcia -L dragon Veremos lo siguiente en pantalla:

Anonymous login successful Domain=[CENTRALTECH] OS=[Unix] Server=[ Samba 3.0.14a-Debian]

Sharename Type Comment --------- ----- ------- print$ Disk Printer Drivers compartir Disk esta es la carpeta creada de ejemplo IPC$ IPC IPC Service ( mi dragon (Samba 3.0.14a-Debian)) Server Comment --------- ------- DRAGON mi dragon(Samba 3.0.14a-Debian) Workgroup Master --------- ------- CENTRALTECH DRAGON En general, el comando es :

smbclient -L host -U usuario donde host es la maquina Windows o el servidor Samba y usuario es el usuario de la máquina o el dominio, y va a pedir la password del usuario del dominio Windows NT.



Si no quiero que pida la password: smbclient -L host -N

donde -N significa que no pida password para ver los recursos. Para navegar los recursos compartidos por una máquina Windows o el servidor Samba:

smbclient //DRAGON/compartir -U agarcia Al ejecutar esto, el sistema pedirá que se proporcione la contraseña del usuario agarcia en el equipo denominado DRAGON.

smbclient //DRAGON/compartir -U agarcia Password: Domain=[DRAGON] OS=[Unix] Server=[Samba 3.0.14a-Debian] smb: \>

En este prompt que nos aparece, pueden utilizarse los mismos comandos que en la consola del comando ftp, como serían get, mget, put, del, etc.

Acceso a los recursos compartidos: montaje En el ejemplo anterior hay un recurso de disco compartido que se llama compartir. Si queremos montarlo, para verlo, usarlo, etc, debemos crear un punto de montaje. Éste puede crearse en cualquier directorio sobre el que tengamos permisos de escritura. Luego, para montarlo, utilizamos la siguiente línea de comando:

smbmount //dragon/compartir /mnt/cdrom

Nota: El directorio para montar, recuerde que debe cumplir la condición de ser un directorio vacío. Conviene crear un directorio particular para montar Samba.

También puede utilizar el siguiente comando: En este caso creamos un directorio /samba para montar allí nuestros recursos compartidos. mount -t smbfs -o username=agarcia,password=agarcia //dragon/compartir /samba

Nota: Puede ser que necesite realizar algunos pasos adicionales para utilizar el comando smbmount. Por default, y por motivos de seguridad, solo root puede utilizar los comandos smbmount y smbumount. Entonces debemos establecer permisos de SUID a dichos comandos. Lo hacemos ejecutando, como root:

chmod 4755 /usr/bin/smbmount chmod 4755 /usr/bin/smbumount

Para poder imprimir un archivo, lo mandamos la impresora remota. No debemos olvidar volver a iniciar el demonio lpd de impresión para que reconozca a la nueva impresora.

lpr -P Sambaprinter oraconnpool.jsp

Nota: Para que Sambaprinter sea la impresora utilizada por defecto, recuerde sustituir en el archivo /etc/printcap donde diga impreSamba:\ por lp|impreSamba:\

Samba-SWAT A partir de la versión 2 del kernel de Linux se incorporó SWAT (Samba Web Administration Tool), que es una herramienta de administración de Samba vía Web. Este programa consta de una interfase GUI (Graphic User Interface) donde la configuración del servidor Samba la podemos hacer editando directamente el archivo smb.conf. Es una herramienta para configurar Samba utilizando el entorno gráfico. Al instalar el paquete samba, este incluye la aplicación SWAT, que podrá acceder desde cualquier navegador Web desde cualquier máquina de su red local.



Otra forma de habilitar samba-swat es editando /etc/xinetd.d/ y habilitar el servicio swat. Recuerde reiniciar el demonio xinetd.

Nota: Por las dudas, conviene guardar una copia del archivo de configuración original, ya que SWAT va a eliminar las líneas que no son necesarias en el archivo smb.conf, dejando solo aquellas requeridas para la configuración

Para poder utilizar Samba-SWAT debemos abrir nuestro navegador web y en la barra de URL ingresar la siguiente dirección (para acceder al servidor Samba instalado en el servidor local, si lo hacemos desde la red, debemos utilizar la URL correspondiente para ubicar al servidor desde la red): http://localhost.localdomain:901 Nos va a aparecer una ventana pidiendo nombre de usuario y contraseña. Ingresamos los de root, Y veremos una pantalla como la de la figura 23:

Figura 23

Como vemos, aquí tenemos las mismas opciones que nos aparecían en el archivo de configuración, y algunas más, como por ejemplo, la administración de usuarios, impresoras y demás secciones que vimos antes en el archivo.

Figura 24

Hasta dónde se puede llegar a partir de este sencillo servicio de archivos depende de cuanto quiera ahondar en su investigación sobre Samba y Linux. Samba se puede integrar en el dominio de Windows NT para ofrecer



seguridad a los usuarios, por ejemplo. Otra potente característica de Samba es que puede hacer funciones de PDC de dominios. También puede servir para habilitar el servidor Linux (u otro Sistema Operativo UNIX) como servidor de impresión para los clientes Windows. Samba permite que los usuarios controlen totalmente los trabajos de impresión (pueden cancelar y supervisar los trabajos de impresión, cambiar de impresora, etc), y puede configurar Samba para que ejecute programas externos para supervisar y registrar el uso de las impresoras o incluso para enviar faxes. Las posibilidades de uso de Samba son muchas. A medida que vaya explorando la aplicación, irá descubriendo toda su potencia y flexibilidad.

Nota: Bibliografia relacionada:

• Usando Samba, Robert Eckstein, David Collier-Brown, Peter Kelly. Links relacionados para buscar en la Web:

• http://www.samba.org • http://www.insflug.org/COMOs/Samba-Como/Samba-Como-6.html



Capítulo 11

Servidor DHCP DHCP es un protocolo de configuración dinámica de nodos (en ingles: Dynamic Host Configuration Protocol). Hemos visto en capítulos anteriores como asignar direcciones IP a los hosts de nuestra red, usando el comando ifconfig. Esta forma es útil y muy fácil mientras nuestra red esté compuesta de unos pocos servidores y/o terminales. Imagine que tiene que configurar una empresa de varios pisos (o varios edificios/sucursales), sería una tarea complicada asignar las direcciones IP manualmente a cada máquina. Así vemos la utilidad del protocolo de configuración dinámica. Configuramos un servidor que será el que asigne automáticamente las direcciones IP a los hosts que lo soliciten. Los pedidos incluyen máquinas temporales y portátiles. El protocolo DHCP es una ampliación del protocolo BOOTP, su predecesor, que arrancaba las máquinas que se conectaban a él porque no tenían disco rígido.

Nota: DHCP es un protocolo estándar. Cualquier sistema operativo que se conecte al servidor será configurado con una dirección IP.

El servidor DHCP permite asignación dinámica de IPs por ciertos períodos de tiempo. En realidad, hay tres tipos de asignación de direcciones:

• Estática • Dinámica por tiempo limitado • Dinámica por tiempo ilimitado.

La asignación de IPs se configurará de una forma u otra, según el tipo. Puede ser que nos interese un direccionamiento estático para clientes sin disco o para máquinas que brindan algún servicio específico (es más fácil para el administrador configurar un servidor, que cada cliente). El direccionamiento dinámico por tiempo ilimitado se usa cuando la cantidad de clientes no varía demasiado. El direccionamiento dinámico por tiempo limitado, o arrendamiento de direcciones es útil para racionar las IPs, minimizando el costo administrativo. Según sea la frecuencia de levantar o bajar hosts y de la cantidad de direcciones IPs disponibles se concederá un mayor o menor tiempo de arrendamiento. El tiempo será bajo, por ejemplo 15 minutos si los clientes se conectan y desconectan muy seguido y nos interesa que esté disponible la máxima cantidad de IPs. Cada vez que arranca un cliente, vuelve a solicitar una dirección. El servidor recuerda si el cliente ya tenía una IP asignada para reasignársela. Para instalar el servicio de DHCP, en Debian, hacemos: apt-get install dhcp El DHCP se ejecuta en el puerto 67, con protocolo UDP, porque las cantidades de datos involucradas son pequeñas, y la rapidez en la respuesta es crítica. Esto es para el servidor, en el cliente, el puerto es el 68. Para configurar este servicio debemos editar el archivo /etc/dhcpd.conf:

server-identifier 192.168.1.207; option subnet-mask 255.255.255.0; default-lease-time 600; max-lease-time 7200; option broadcast-address 192.168.1.255; option domain-name "dragonale.com.ar"; option domain-name-servers 192.168.1.10; option netbios-name-servers 192.168.1.10; option routers 192.168.1.1; subnet 192.168.1.0 netmask 255.255.255.0 { range 192.168.1.200 192.168.1.225; option routers 192.168.1.1; option domain-name “centraltech.com.ar”; }

server-identifier especifica la dirección IP del servidor. Parte de la respuesta del servidor DHCP es esta dirección IP. En sistemas que tengan varias placas, el servidor DHCP concede la IP a traves de la primera interfaz. Pero, esta interfaz no puede ser alcanzada por todos los clientes a veces.



Entonces, en estos casos, server-identifier se usa para enviar la IP de la interfaz apropiada para que el cliente se comunique con el servidor.

option subnet-mask indica la máscara de la red, en este caso es una clase C.

default-lease-time y max-lease-time son los tiempos de contrato, arrendamiento o de asignación de la dirección IP. Se expresan en segundos.

option broadcast-address indica la dirección de broadcast.

option domain-name indica el dominio que se usará en las búsquedas DNS.

option domain-name-servers indica el servidor DNS que usarán los clientes DHCP. Podría ser que el propio servidor Linux también trabaje como servidor DNS.

option netbios-name-servers indica el servidor WINS. Si, por ejemplo, tengo la necesidad que las máquinas Windows consulten un servidor WINS (para hacer la traducción NetBIOS-Name a IP) indico aquí su dirección IP.

Nota: Recuerde que incluso un servidor Samba puede actuar de servidor WINS, con solo agregar las siguientes líneas al smb.conf:

wins support = yes domain master = yes

si tuviera Samba y quiero que las máquinas Windows consulten el servidor Linux para hacer la traducción NetBIOS-Name a IP.

option routers indica cuál es la dirección IP del gateway que nos permite salir al exterior de nuestra subnet.

Hasta aquí, vimos todo el primer párrafo, que especifica la configuración global del servidor DHCP. Lo que sigue son configuraciones particulares, para cada red o subred.

subnet X.Y.Z.A netmask M.N.P.Q define la red que vamos a configurar.

range X.Y.Z.B X.Y.Z.C Especifica el rango de direcciones que brindará el servidor, por supuesto deben estar dentro de la subred indicada.

Ejemplo: si yo especifico como rango: 192.168.1.200 192.168.1.225, una máquina cliente que pida una IP se le podrá dar 192.168.1.220, pero no 192.168.1.100.

Una vez hecho esto nos queda reiniciar el dhcpd y configurar los clientes para que usen el servidor. Para esto tenemos dos opciones. En primera instancia podríamos probarlo de la siguiente forma: dragon:~# dhclient eth0 Internet Software Consortium DHCP Client 2.0pl5 Copyright 1995-2002 Internet Software Consortium. All rights reserved. For info, please visit http://www.isc.org/dhcp-contrib.html Listening on LPF/eth0/00:0c:6e:39:44:4e Sending on LPF/eth0/00:0c:6e:39:44:4e Sending on Socket/fallback DHCPREQUEST on eth0 255.255.255.0 port 67 interval 3 DHCPNAK from 192.168.1.107 DHCPDISCOVER on eth0 to 255.255.255.255 port 67 interval 3 DHCPOFFER from 192.168.1.107 DHCPREQUEST on eth0 to 255.255.255.255 port 67 DHCPACK from 192.168.1.107 bound to 192.168.1.201 -- renewal in 300 seconds. dragon:~#



Como se puede ver, el equipo consultó y le contestó nuestro servidor, que le asignó la IP 192.168.1.201. De esta forma, comprobamos que el servidor DHCP está funcionando OK y asignando IPs como corresponde. Ahora lo que tendríamos que hacer es fijar la configuración para que en el próximo inicio vuelva a configurar la placa vía DHCP. Para esto tenemos que configurar el archivo /etc/network/interfaces dragon:~# cat /etc/network/interfaces # /etc/network/interfaces -- configuration file for ifup(8), ifdown(8) # The loopback interface auto lo iface lo inet loopback iface eth0 inet dhcp Si por algún motivo es necesario que una de las máquinas de la red/subred tuviera una IP fija, es posible hacerlo. En este caso voy a configurar una IP estática. La única forma de diferenciar una máquina de otra, antes de asignar direcciones IP, es por la dirección física, por la placa de red, más conocida como MAC-ADDRESS. Esta dirección está grabada en el dispositivo, y es única para cada placa de red. Las siguientes son las líneas que debemos agregar al archivo de configuración:

host www { hardware ethernet 00:e0:7d:ad:2d:80; fixed-address 192.168.1.20; option domain-name "otrocentraltech.com.ar"; option host-name "www"; }

Soporte para IPV6 Debe instalarse un paquete llamado radvd. Su configuración es muy simple. Veamos el siguiente archivo /etc/radvd.conf Interface eth0 { AdvSendAdvert on; Prefix 0:470:1f00:296::/64 { }; }; Luego debemos levantar el demonio radvd dragon:~# /etc/init.d/radvd restart



Capítulo 12 (Parte de lo expuesto en la introducción de este capítulo fue extraído de www.tldp.org)

Firewalls Introducción Internet puede ser un ambiente muy hostil. Conectados a la gran red hay gente que puede estar interesada en la información que usted tiene almacenada (personal, financiera, empresarial). Aunque usted suponga que, por no guardar información comprometedora (números de tarjetas de crédito ó los secretos de su éxito), su computadora no es interesante para los hackers; esto no es completamente cierto. Uno de los objetivos de los hackers son las computadoras en si. En efecto, si el hacker quiere realizar ataques manteniendo oculta su propia identidad, puede poner las computadoras de otras personas a trabajar para él. Se puede dar el caso de que su PC este atacando el sitio Web de algún organismo sin que usted lo sepa. Se han dado casos de redes que estaban siendo utilizadas por extraños como depósitos de software ilegal, por supuesto, sin el consentimiento de los legítimos propietarios de la red.

Un firewall es un sistema de seguridad que actúa como una frontera de protección entre una red (o PC) y el mundo exterior.

Los Firewalls pueden ser por hardware o por software y son el equivalente a un guardia de seguridad, sólo que en este caso está apostado en la entrada/salida de su red. Existen cuatro tipos básicos de firewalls, y estos son:

• Packet filtering (Filtrado de paquetes) Un Firewall de este tipo acepta o deniega el paso del tráfico basado en los encabezados (headers) TCP/IP. Son los más baratos y también los que menos protección brindan. Operan en la capa de red, capa 3 del modelo OSI, no realizan chequeo del contenido de los paquetes y, como ventaja, casi no afectan la performance de la red.

• Circuit-level gateway (Gateway a nivel de circuito) Estos Firewalls operan en la capa de sesión (dos niveles más arriba que los Packet-filtering). En éste tipo, todas las conexiones (sesiones) son monitoreadas y solo a las que son consideradas válidas, por configuración se les permite el paso. Esto generalmente quiere decir que un cliente Circuit-level gateway detrás del Firewall podrá iniciar cualquier tipo de sesión, pero los clientes externos no podrán conectarse a la máquina protegida.

• Application-level Proxy (Proxy a nivel de aplicación) Un Proxy es un representante, intermediario en la operación de comunicación. Estos Firewalls fuerzan a todas las aplicaciones de las estaciones de trabajo protegidas a que usen el Firewall como un Proxy. Para el cliente su servidor es el Proxy y el servidor ve al Proxy como su cliente. Entonces el Firewall puede autorizar cada paquete de cada protocolo en forma independiente. Sus desventajas son una pérdida considerable en la performance de la red, y que aquellas aplicaciones que no puedan ser configuradas para utilizar un Proxy server, no funcionarán. La ventaja es el alto grado de seguridad que brinda.

• Stateful Firewall (completo) Estos Firewalls proveen un seguimiento y control del flujo de datos (entradas y salidas) de cada sesión. La información relativa a cada conexión se almacena en memoria y, a medida que cada paquete llega al filtro, el Firewall toma la decisión de pasarlo o bloquearlo usando la información “histórica” almacenada y una serie de reglas simples. El siguiente ejemplo del programa iptables causará que se bloquee el paso a cualquier paquete del protocolo ICMP que sea recibido desde la interface loopback:

iptables -A INPUT -s 127.0.0.1 -p icmp –j DROP

Nota: más adelante, en este mismo capítulo hablaremos de iptables Fundamentos sobre el Filtrado de Paquetes Todo el tráfico a través de una red se envía en la forma de paquetes. Por ejemplo, al descargar un archivo de internet, que dice 50k de tamaño, podría suceder que reciba algo como 36 paquetes de 1460 bytes cada uno (por poner números al azar). En el comienzo de cada paquete dice donde va, de donde viene, el tipo del paquete, y otros detalles administrativos. Esta parte del paquete se llama encabezado o header. El resto del paquete, contiene los datos reales que se están transmitiendo, lo que normalmente es llamado cuerpo.



Algunos protocolos, como TCP, que se usa para tráfico de la web, correo y logins remotos, usan el concepto de conexión. Esto significa que antes de que cualquier paquete de datos reales se envíe, varios paquetes de configuración (con encabezados especiales) son intercambiados diciendo “Quiero conectarme”, “OK” y “Gracias”. Luego, se intercambian paquetes normales. El filtrado de paquetes es una porción de software, del sistema operativo, que analiza el encabezado de los paquetes cuando ellos lo atraviesan, y decide el destino del paquete entero, basándose en un conjunto de reglas. Si permite pasar al paquete, se lo envía a la aplicación. Si no permite pasar al paquete, puede lanzar una respuesta de fallo al remitente o, simplemente lo tira como si nunca hubiera llegado. Bajo Linux, el filtrado de paquetes está implementado en el kernel, y hay unas cosas más complicadas que podemos hacer con paquetes, pero el principio general es el de mirar los encabezados y decidir el destino del paquete. ¿Y para que necesito un Firewall? Control. Seguridad. Vigilancia.

• Control: Cuando conecta una máquina Linux de su red interna a otra red (digamos, Internet) usted tiene la oportunidad de permitir ciertos tipos de tráfico, y desaprobar otros. Por ejemplo, el encabezado de un paquete contiene la dirección del destino del paquete, así que usted puede prevenir paquetes que van a una cierta parte de la red externa. Como otro ejemplo, uso Mozilla para acceder a los archivos de Dilbert. Hay anuncios de doubleclick.net en la página, y Mozilla alegremente pierde mi tiempo descargándolos. Diciendo al filtro de paquetes que no se permita ningún paquete hacia o desde las direcciones propiedad de doubleclick.net ese problema se resuelve (aunque hay maneras mejores de hacerlo).

• Seguridad: Cuando su máquina Linux es la única barrera entre el caos de Internet y su red, es bueno conocer que puede restringir lo que viene a su puerta. Por ejemplo, usted podría permitir que algo salga de su red, pero podría preocuparse por el muy conocido 'Ping de la Muerte' que llega desde los intrusos malvados. Como otro ejemplo, usted podría no querer que los intrusos hagan ssh a su máquina Linux, simplemente no permitiendo a nadie conectarse. Esto se hace configurando al filtro de paquetes para que rechace los paquetes entrantes que levantan las conexiones.

• Vigilancia: A veces una máquina mal configurada en la red local decidirá arrojar paquetes al mundo externo. Es bueno decirle al filtro de paquetes que le permita saber si algo anormal ocurre, quizás pueda hacer algo, o simplemente quizás, usted es curioso por naturaleza.

Netfilter/Iptables (CentralTech ha contribuido a wikipedia.org con la traducción del material que sigue). Netfilter es el conjunto de “hooks” (ganchos) dentro del Kernel Linux diseñados para interceptar y manipular los paquetes de red. El componente más conocido construido encima de netfilter es el “firewall” que filtra paquetes. Pero los hooks son también usados por un componente que realiza NAT (Network Address Translation) y por cualquier otro que provea compatibilidad con ipchains. Estos componentes son llamados “kernel modules” (módulos del kernel). Iptables es el nombre de la herramienta del “user space” (espacio de usuario) por medio de la cual el administrador crea reglas para módulos de filtrado de paquetes y NAT. Mientras que técnicamente iptables es solamente la herramienta que controla estos componentes dentro del kernel, el nombre “iptables” se utiliza muchas veces para referirse a toda la infraestructura, incluyendo a netfilter, connection tracking y NAT, como también a la herramienta propiamente dicha. iptables es una parte standard de todas las distribuciones Linux actuales. Historia El proyecto “netfilter/iptables” fue comenzado en 1998 por Rusty Russel, también autor del proyecto que precedió: ipchains. A medida que el proyecto creció, fundó el “Netfilter Core Team” (o simplemente el “coreteam”) en 1999. El software que ellos produjeron (lo llamaremos netfilter desde aquí en adelante) está licenciado bajo la licencia GPL (GNU General Public License), y fue incorporado al kernel Linux 2.3 en Marzo del 2000. En agosto del 2003 Harald Welte fue designado chairman del Coreteam. En abril del 2004, se produjo una ruptura del proyecto por aquellos que lo usaban embedded en routers sin ajustarse a GPL.



Antes de iptables los paquetes más usados para crear firewalls en Linux eran “ipchains” en Linux 2.2 e ipfwadm en Linux 2.0 que se basaba en el ipfw de BSD. Tanto ipchains como ipfwadm alteran el código de networking de modo de poder manipular los paquetes, ya que no existía un entorno general para el manejo de paquetes hasta la aparición de netfilter. iptables mantiene la idea básica introducida en Linux con ipfwadm: lista de reglas con “qué matchear dentro de un paquete” y “qué hacer con el paquete”. Ipchains agregó el concepto de “cadenas de reglas” (chains) e iptables extendió ésto a la idea de tablas: una tabla era consultada cuando se decidía NAT-ear un paquete, y otra cuando se debía decidir si filtrar el paquete. Adicionalmente, los tres puntos en los que se realiza el filtrado en el viaje de un paquete fue modificado, de modo que un paquete sólo pasa por un punto de filtrado. Mientras que ipchains e ipfwadm combinan filtrado de paquetes y NAT (especificamente tres tipos de NAT, llamado masquerading, port forwarding y redirection), netfilter hace posible separar las operaciones sobre los paquetes en tres partes: packet filtering, connection tracking, y Network Address Translation. Cada parte se conecta a los hooks netfilter en diferentes puntos para acceder a los paquetes. Los subsistemas de connection tracking y NAT son más generales y poderosos que los que realizaban ipchains e ipfwadm. Esta división permite a iptables, en su momento, usar la información que la capa de connection tracking ha determinado acerca del paquete: esta información estaba antes asociada a NAT. Ésto hace a iptables superior a ipchains ya que tiene la habilidad de monitorear el estado de una conexión y redirigir, modificar o detener los paquetes de datos basados en el estado de la conexión y no solamente por la fuente, destino o contenido del paquete. Un firewall que utilice iptables de este modo se llama “firewall statefull” contrario a ipchains que sólo puede realizar “firewalls stateless” (con excepción en muy pocas ocaciones). Es posible decir que ipchains no está al tanto del contexto completo del cual un paquete surge, mientras que iptables sí. Por tanto iptables puede hacer mejores decisiones sobre el futuro de los paquetes y las conexiones. Iptables, el subsistema NAT y el subsistema de connection tracking son también extensibles, y muchas extensiones están incluidas en el paquete básico de iptables, tal como la extensión ya mencionada que permite la consulta del estado de la conexión. Extensiones adicionales se distribuyen junto a la utilidad iptables, como patches al código fuente del kernel junto con una herramienta llamada patch-o-matic. Una versión de iptables para IPv6 ya fue escrita, llamada ip6tables al igual que la herramienta de administración.

¿Cómo? - ipchains Esta herramienta reemplaza a ipfwadm usado en el antiguo código de Ip firewall. A partir del kernel 2.2.x podemos correr ipchains. Y a partir de kernel 2.4.x tenemos ipchains e iptables. El paquete ipchains también contiene un shell script llamado ipfwadm-wrapper el cual le permitirá hacer filtrado tal como se hacía antes. No debe usar este script a menos que desee una manera rápida de actualizar un sistema que use ipfwadm (es más lento, y no verifica argumentos, etc).

Nota: ipchains también se usa para controlar enmascaramiento (masquerading) y proxy transparente, a pesar de que son dos conceptos del filtrado de paquetes totalmente separados (la implementación actual de Linux los opaca, dando la impresión de que se relacionan estrechamente).

Lo primero es ver si tenemos cargado el módulo de ipchains. Si tiene un kernel 2.2.x, no necesita cargarlo. Para ver los módulos que están levantados use el comando lsmod. Si no está ipchains, debemos cargarlo; para ello:

# modprobe ipchains Esto cargará el programa que nos permitirá editar las cadenas de filtrado. Hacemos:

# ping -c 1 127.0.0.1 PING 127.0.0.1 (127.0.0.1): 56 data bytes 64 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.2 ms --- 127.0.0.1 ping statistics --- 1 packets transmitted, 1 packets received, 0% packet loss round-trip min/avg/max = 0.2/0.2/0.2 ms



Esto quiere decir que la interface de loopback está respondiendo. 127.0.0.1 es la interface de retorno (loopback) que tendrá aun cuando no tenga ninguna conexión real de red. Usted puede usar el programa ping para generar tales paquetes (envía un ICMP de tipo 8 (echo request) al que todos los host deben obligatoriamente responder con un paquete ICMP de tipo 0 (echo reply)). Esto es útil para probar. Este comando déjelo corriendo y vayamos a otra consola. Aquí escribimos la siguiente regla de filtrado:

# ipchains -A input -p icmp -s 0/0 -d 127.0.0.1 –j DENY

Nota: ipchains es case-sensitive (sensible a mayúsculas y minúsculas). Nota: haciendo man ipchains tenemos acceso al manual de ipchains.

Si lo ejecuta (activa una regla en el Firewall), verá que los ping al localhost no serán respondidos. Vaya a la consola anterior, donde dejó corriendo el ping y verá que se frenó

PING 127.0.0.1 (127.0.0.1): 56 data bytes --- 127.0.0.1 ping statistics --- 1 packets transmitted, 0 packets received, 100% packet loss

¿Qué significa todo lo que escribimos en la regla de filtrado? Lo primero que tenemos que saber es que hay diferentes tipos de cadenas a ser reconocidas por el kernel. Los tres tipos de cadenas son llamadas entrada (input), salida (output) y traspaso (forward). Cuando un paquete entra (digamos, a través de la tarjeta Ethernet) el kernel usa la cadena input para decidir su destino. Si sobrevive este paso, entonces el kernel decide dónde enviar el paquete (esto se llama enrutamiento -routing-). Si el destino es otra máquina, consulta la cadena forward. Finalmente, justo antes de que el paquete salga, el kernel consulta la cadena output. Una cadena es una lista (de chequeo - checklist) de reglas. Cada regla dice “si el encabezado del paquete se ve como esto, entonces esto es lo que deseo hacer con el paquete”. Si la regla no concuerda con el paquete, entonces se consulta la próxima regla en la cadena. Finalmente, si no hay ninguna regla más por consultar, entonces el kernel mira la política de la cadena para decidir qué hacer. En un sistema de seguridad consciente, esta política normalmente le dice al kernel que rechace o deniegue el paquete. Ahora veamos que podemos hacer con las cadenas. En la tabla siguiente tenemos las acciones.

-A Add, agregar nuevas reglas -D Delete, borrar reglas -N New, nueva regla definidas por el usuario -X Delete user Rule, borra regla definida por el usuario. Debe estar vacía. -L List, lista reglas -I Insert, inserta una regla -P Policies, setea Políticas -F Flush, borra todas las reglas

-p indica el protocolo cuyos paquetes serán analizados por ésta regla. En el ejemplo el protocolo es

icmp (Internet Control Messages Protocol). Puede ver los protocolos en el archivo /etc/protocols.

-s establece la dirección de origen (source) de los paquetes a ser filtrados. 0/0 usado en el ejemplo indica TODAS las direcciones. Esta dirección de origen puede ser, el nombre o la IP. Para IP, puede ser la de un único host, por ejemplo: -s 192.168.4.2 o la de una red o subred, y sería así: -s 192.168.4.0/24, formato IP/Mask. Note que la máscara se escribe en forma CIDR, es decir que 24 es lo mismo que decir 255.255.255.0. También se puede dar la máscara completa, es decir 192.168.4.0/255.255.255.0.

-d establece el destino (destination) que debe tener un paquete para ser analizado bajo esta regla. En nuestro ejemplo 127.0.0.1, es la dirección de la interface de loopback. Las mismas consideraciones que para el caso anterior (-s).

-j establece la acción a ejecutar sobre los paquetes que cumplan con la regla. DENY indica que el Firewall NO dejará pasar los paquetes que cumplan con los requisitos establecidos en la regla. Otras acciones posibles son: ACCEPT, REJECT y MASQ. La opción MASQ es sólo válido para la cadena forward. REJECT es parecido a DENY, también rechaza paquetes, pero lo hace de una



forma más amable, envía un mensaje ICMP al remitente. En cambio DENY rechaza el paquete sin aviso.

Otras opciones que se pueden agregar al comando ipchains son:

--source-port especificar el puerto o rango de puertos sin tener que especificar una dirección IP. --destination-port igual que el caso anterior pero para el puerto de destino.

Enmascaramiento (masquerading o NAT) El Firewall también puede enmascarar las direcciones IP de los clientes dentro de nuestra red, de esa manera todos los hosts de su red exhibirán una única dirección pública, aunque dentro de la intranet mantengan sus direcciones privadas, esto esconde su red, esto también se llama NAT (Network Address Translation-Traducción de direcciones de red). El comando es

# ipchains -A forward -s 192.168.1.0/24 -j MASQ Esto indica que los paquetes provenientes de la red 192.168.1.0 con máscara de subred 255.255.255.0 (obviamente dentro de su red por tratarse de direcciones privadas) serán enviados a Internet mostrando cómo dirección de origen la dirección del servidor que provee el acceso a la Web.

Nota: Cuando use esta regla le aparecerá un mensaje que le recuerda habilitar el forwardeo de paquetes. Si no lo hizo debe hacerlo de esta forma:

# echo 1 > /proc/sys/net/ipv4/ip_forward Cerrando servicios Puertos y servicios: En el archivo /etc/services, encontraremos los puertos más comunes que utiliza TCP por ejemplo:

ftp-data 20 ftp 21 ssh 22 telnet 23 http 80 pop 110

Nota: Es bueno recorrer este archivo para tener presente que puertos utilizan nuestro servicios.

Si se quisiera cerrar el acceso a un servicio determinado, pero no a todo el protocolo, lo que se debe hacer es cerrar el acceso al PUERTO que ese servicio utiliza:

# ipchains -A input -p tcp -s superhackers.com -d 200.200.200.200 21 -j DENY

Donde superhackers.com es el origen a bloquear, 200.200.200.200 es la dirección del servidor a proteger y 21 es el puerto a controlar. 21 es el puerto por defecto de ftp. Lo que se conseguirá con este comando, es evitar que desde la dirección superhackers.com se obtenga acceso por ftp a 200.200.200.200.

También se puede cerrar un conjunto de puertos, determinando un rango en la regla. Así # ipchains -A input -p tcp -s superhackers.com -d 200.200.200.200 21:80 -j DENY

Establecería la regla para los puertos desde el 21 hasta el 80. Negación El puerto especificado o rango de puertos puede estar precedido por “!” para indicar lo contrario. Así, para especificar todos los paquetes TCP excepto los WWW, lo indicará así:

-p tcp -d 0.0.0.0/0 ! www -p tcp –d 0.0.0.0/0 ! 80

Es importante comprender que la especificación

-p tcp -d ! 192.168.1.1 www es muy diferente de

-p tcp -d 192.168.1.1 ! www



La primera especifica cualquier paquete de TCP al puerto de WWW en cualquier máquina excepto 192.168.1.1. El segundo especifica alguna conexión de TCP a cualquier puerto en 192.168.1.1 excepto el puerto de WWW. Finalmente, este caso significa que no a los de puerto WWW y no a los de dirección 192.168.1.1:

-p TCP -d ! 192.168.1.1 ! www

Nota: también puede negar interfaces y protocolos. Consultando las reglas Para listar las reglas que tenemos aplicadas en nuestro Firewall, el comando es simple:

# ipchains –L El resultado de este comando puede parecerse a lo siguiente:

Chain input (policy ACCEPT): Target prot opt source destination ports DENY icmp ------ anywhere localhost any -> any Chain forward (policy ACCEPT): Target prot opt source destination ports MASQ all ------ 192.168.1.0/24 anywhere n/a Chain output (policy ACCEPT):

Borrando reglas Hay tres formas de borrar reglas. Una forma de borrar reglas es cambiar la acción –A por –D en la regla original. Por ejemplo:

# ipchains -D input -p icmp -s 0/0 -d 127.0.0.1 -j DENY Este comando borrará la primera regla que estableció en este tutorial (aquella que denegaba la recepción de paquetes dirigidos a localhost), es decir que a partir de este momento, si hace ping localhost o ping 127.0.0.1, tendrá respuesta. Otra forma de borrar reglas, es especificando el número de regla:

# ipchains –D input 1 Esta borrará la primera regla de input que tenga en la lista de reglas. Y una tercer forma de borrar reglas es con la opción –F, pero en este caso borraría todas las reglas, flush, vacío la lista.

# ipchains -F Estableciendo políticas Establecer las políticas del firewall es indicar de qué modo se comportará por defecto frente a los diferentes tipos de tráfico. Por ejemplo:

# ipchains –P input DENY Le dirá al Firewall que deniegue TODO el tráfico entrante, menos lo explícitamente establecido (por otras reglas). Guardando información de eventos Hacer que el Firewall guarde un Log (registro de eventos) de lo que está ocurriendo es útil para saber que están accediendo o tratando de acceder los usuarios. Puede ser que se descubra que un usuario que tiene algún acceso denegado está tratando de usarlo (siendo rechazado por el Firewall), o que hay recursos que están siendo accedidos y que se ha olvidado de proteger. Los logs serán almacenados en /var/log/messages. La forma de iniciar el logueo es, por ejemplo:

# ipchains –A input –j DENY –l # ipchains –A output –j ACCEPT –l # ipchains –A forward –j DENY -l

Esto causará que desde éste momento se comiencen a loguear los paquetes recibidos que fueron bloqueados, los salientes que fueron autorizados y aquellos a los que se les negó el forward. Especificando una interface La opción -i especifica el nombre de una interface para comparar. Una interface es el dispositivo físico por el cual un paquete llega o sale. Puede usar el comando ifconfig para listar las interfaces activas. La interface para los paquetes entrantes (paquetes que atraviesan la cadena input) es considerada la interface por donde



ellos entran. Lógicamente, la interface para los paquetes salientes (paquetes que atraviesan la cadena output) es la interface por donde ellos saldrán. La interface para que los paquetes atraviesen la cadena forward es también la interface por donde ellos saldrán. Es absolutamente legal especificar una interface que actualmente no existe; la regla no emparejará nada hasta la interface sea activada. Esto es sumamente útil para enlaces telefónicos ppp (normalmente interface ppp0) y similares. El nombre de la interface puede ir precedido por un signo de admiración “!” para indicar un paquete que no empareja con la(s) interface(s) especificada(s). Guardando y recuperando las reglas Todo lo que se ha hecho fue trabajo en memoria, si ahora apago la PC, todo esto se elimina, es decir que al arrancar la máquina nuevamente no tendré ninguna regla. Si se desea contar con las reglas en sucesivos inicios del servidor, se deben guardar las reglas en un archivo y esto se logra con:

# ipchains-save > /sbin/firewall.myrules Lo cual guardará la configuración del Firewall en el archivo /sbin/firewall.myrules. La forma de recuperar esta configuración es:

# ipchains-restore < /sbin/firewall.myrules A continuación se muestra un Firewall sencillo implementado en un script usando ipchains: echo 1 > /proc/sys/net/ipv4/ip_forward MAXI="192.168.0.201" IPCHAINS="/sbin/ipchains" $IPCHAINS -F input $IPCHAINS -F output $IPCHAINS -F forward $IPCHAINS -A output -p tcp -d 0/0 www -t 0x01 0x10 $IPCHAINS -A output -p tcp -d 0/0 telnet -t 0x01 0x10 $IPCHAINS -A output -p tcp -d 0/0 ftp -t 0x01 0x10 $IPCHAINS -A output -p tcp -d 0/0 ftp-data -t 0x01 0x08 $IPCHAINS -A input -p tcp -s 0/0 -d 0/0 1023:65535 –j ACCEPT $IPCHAINS -A input -p udp -s 0/0 -d 0/0 1023:65535 -j ACCEPT $IPCHAINS -A input -p tcp -s $MAXI -d 0/0 20 –j ACCEPT $IPCHAINS -A input -p tcp -s 192.168.0.231 -d 0/0 20 -j ACCEPT $IPCHAINS -A input -p tcp -s $MAXI -d 0/0 21 –j ACCEPT $IPCHAINS -A input -p tcp -s 192.168.0.231 -d 0/0 21 -j ACCEPT $IPCHAINS -A input -p tcp -s $MAXI -d 0/0 23 –j ACCEPT $IPCHAINS -A input -p tcp -s $MAXI -d 0/0 25 –j ACCEPT # Reglas ICMP $IPCHAINS -A output -i eth0 -p icmp -s 0/0 -d 0/0 –j ACCEPT $IPCHAINS -A input -i eth0 -p icmp -s 0/0 -d 0/0 –j ACCEPT $IPCHAINS -A input -j DENY $IPCHAINS -A output -j ACCEPT $IPCHAINS -A forward -j DENY Como ven aquí, es mas sencillo utilizar variables, por si nos cambia una IP, no debería afectar a todo el firewall.

Algunas consideraciones Manipulando el Tipo de servicio (Type Of Service) Hay cuatro bits en el encabezado IP, llamados bits del Tipo de Servicio (TOS). Afectan a la forma como son tratados los paquetes. Los cuatro bits son "Retraso mínimo", "Máximo Throughput", "Fiabilidad Máxima" y "Costo Mínimo". Solo es permitido setear uno de estos bits. Rob van Nieuwkerk, autor del código TOS-mangling, dice:

Especialmente el "Retraso Mínimo" es importante para mí. Lo cambio a "interactivo" en mi router (Linux). Estoy tras un enlace de modem de 33kb. Linux prioriza paquetes en 3 colas. De esta forma obtengo un rendimiento interactivo aceptable mientras se hace descargas pesadas al mismo tiempo. (Incluso podría ser mejor si no hubiese semejante cola en el driver serial, excepto que la latencia se mantiene por debajo de 1.5 segundos).

El uso más común es poner las conexiones telnet a "Retraso Mínimo" y los datos FTP a "Máximo Throughput." Esto se haría como sigue:

ipchains -A output -p tcp -d 0.0.0.0/0 telnet -t 0x01 0x10



ipchains -A output -p tcp -d 0.0.0.0/0 ftp -t 0x01 0x10 ipchains -A output -p tcp -s 0.0.0.0/0 ftp-data -t 0x01 0x08

La marca “-t”' toma dos parámetros extras, ambos en hexadecimal. Éstos permiten un juego completo de los bits de TOS: la primera máscara es con AND con el TOS actual de los paquetes, y luego la segunda máscara es XOR. Si esto lo confunde, simplemente use la siguiente tabla:

Nombre del TOS Valor Usos típicos Minimum Delay 0x01 0x10 ftp, telnet Maximum Throughput 0x01 0x08 ftp-data Maximum Reliability 0x01 0x04 snmp Minimum Cost 0x01 0x02 nntp

Filtrando el Ping de la Muerte Las máquinas Linux ahora son inmunes al famoso Ping de la Muerte. Pero puede que se encuentre con algún sistema un tanto viejo, entonces debe protegerse. El Ping de la Muerte se produce enviando un paquete de ICMP ilegalmente grande que causa desbordamiento en los buffers en la pila TCP en el receptor y causa estragos. Si está protegiendo máquinas que podrían ser vulnerables, podría simplemente bloquear fragmentos de ICMP. Los paquetes de ICMP normales no son tan grandes como para requerir fragmentación, así que usted no interrumpirá nada excepto los pings grandes. La invocación para hacer esto es:

# ipchains –A input –p icmp –j DENY –f Hand Shaking Se usa para conexiones preestablecidas. A veces es útil permitir conexiones de TCP en un sentido, pero no en el otro. Por ejemplo, podría permitir conexiones hacia un servidor de WWW externo, pero no las que provienen desde él. El acercamiento ingenuo sería bloquear paquetes de TCP que vienen del servidor. Desafortunadamente, para que trabajen las conexiones de TCP requieren paquetes que van en ambos sentidos. La solución es bloquear sólo los paquetes de petición de conexión. A estos paquetes se les llama paquetes SYN -técnicamente son aquellos paquetes con la marca SYN activada (SYN flag) y las marcas FIN y ACK limpias, pero nosotros los llamaremos paquetes SYN. Impidiendo sólo estos paquetes, podemos detener los intentos de conexión. La marca “-y” se usa para esto: es sólo válida para reglas que especifican TCP como su protocolo. Por ejemplo, especificar intentos de conexión TCP desde 192.168.1.1:

-p TCP -s 192.168.1.1 -y Ej.: testeo de un paquete TCP-SYN desde 192.168.1.1 puerto 60000 al puerto www de 192.168.1.2, entrando la cadena input (Esta es una clásica iniciación de conexión WWW):

# ipchains -C input -p tcp -y -s 192.168.1.1 60000 -d 192.168.1.2 www packet accepted

Observe que esta regla tiene la opción -C y aparte no tiene qué acción tomar frente a esta regla. Este modificador se usa para testear un paquete TCP-SYN, usando exactamente las mismas rutinas que el kernel usa para diagnosticar paquetes reales. Luego del modificador -C, debe especificar qué cadena probará el paquete. Considerando que el kernel siempre empieza atravesando las cadenas input, output y forward, le permite atravesar cualquier cadena para estos propósitos. La opción –y se usa con los paquetes que tengan activado el bit SYN, pero no el bit ACK o FIN. El bit SYN de la cabecera TCP se usa para iniciar conexiones. Normalmente esta opción se usa para bloquear conexiones entrantes, pero permite conexiones salientes. Puede preceder esta opción con “!” para invertirlo, así todos los paquetes coincidentes con el bit SYN activo no se envíen y se envíen sólo los que tengan activos los bits ACK o FIN.

¿Cómo? - iptables Como dijimos al principio de este capítulo, a partir de kernel 2.4.x tenemos ipchains e iptables. iptables (también llamado netfilter), es similar a ipchains pero expande enormemente el ámbito y el control disponible para el filtrado de paquetes de red. Para ver si tenemos cargado el módulo de iptables ejecutamos el comando lsmod. Si no está, debemos cargarlo; para ello:

# modprobe iptables



Esto cargará el programa que nos permitirá editar las cadenas de filtrado. Hacemos:

# ping -c 1 127.0.0.1 PING 127.0.0.1 (127.0.0.1): 56 data bytes 64 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.2 ms --- 127.0.0.1 ping statistics --- 1 packets transmitted, 1 packets received, 0% packet loss round-trip min/avg/max = 0.2/0.2/0.2 ms

Esto quiere decir que la interface de loopback está respondiendo. 127.0.0.1 es la interface de retorno (loopback) que tendrá aun cuando no tenga ninguna conexión real de red. Usted puede usar el programa ping para generar tales paquetes (envía un ICMP de tipo 8 (echo request) al que todos los host deben obligatoriamente responder con un paquete ICMP de tipo 0 (echo reply)). Esto es útil para pruebas. Este comando déjelo corriendo y vayamos a otra consola. Aquí escribimos la siguiente regla de filtrado:

# iptables -A INPUT -p ICMP -s 0/0 -d 127.0.0.1 –j DROP

Nota: iptables es case-sensitive (sensible a mayúsculas y minúsculas). Nota: haciendo man iptables tenemos acceso al manual de iptables.

Si lo ejecuta (activa una regla en el Firewall), verá que los ping a localhost no serán respondidos. Vaya a la consola anterior, donde dejó corriendo el ping y verá que se frenó

PING 127.0.0.1 (127.0.0.1): 56 data bytes --- 127.0.0.1 ping statistics --- 1 packets transmitted, 0 packets received, 100% packet loss

¿Qué significa todo lo que escribimos en la regla de filtrado? Lo primero que tenemos que saber es que hay diferentes tipos de cadenas a ser reconocidas por el kernel. Los tres tipos de cadenas son llamadas entrada (input), salida (output) y traspaso (forward). Cuando un paquete entra (digamos, a través de la tarjeta Ethernet) el kernel usa la cadena INPUT para decidir su destino. Si sobrevive este paso, entonces el kernel decide dónde enviar el paquete (esto se llama enrutamiento -routing-). Si el destino es otra máquina, consulta la cadena FORWARD. Finalmente, justo antes de que el paquete salga, el kernel consulta la cadena OUTPUT. Una cadena es una lista (de chequeo - checklist) de reglas. Cada regla dice “si el encabezado del paquete se ve como esto, entonces esto es lo que deseo hacer con el paquete”. Si la regla no concuerda con el paquete, entonces se consulta la próxima regla en la cadena. Finalmente, si no hay ninguna regla más por consultar, entonces el kernel mira la política de la cadena para decidir qué hacer. En un sistema de seguridad consciente, esta política normalmente le dice al kernel que rechace o deniegue el paquete. Conclusión, las reglas se van verificando una a una de arriba hacia abajo

Nota: A diferencia de ipchains, en iptables no todos los paquetes atraviesan INPUT Ahora veamos las acciones, qué podemos hacer con las cadenas:

-A Add, agregar nuevas reglas. La agrega al final. -D Delete, borrar reglas -C Verifica una regla en particular antes de añadirla en la cadena especificada por el usuario. -N New, nueva regla definidas por el usuario -E Renombra una cadena definida por el usuario. Esto no afecta la estructura de la tabla. -X Delete user Rule, borra regla definida por el usuario. Debe estar vacía. -L List, lista reglas -I Insert, inserta una regla -P Policies, setea Políticas -F Flush, borra todas las reglas -Z Inicializa en cero los contadores de byte y de paquete en todas las cadenas de una tabla en

particular.



Veamos opciones de parámetros: -p Indica el protocolo cuyos paquetes serán analizados por ésta regla. En el ejemplo el protocolo es

ICMP (Internet Control Messages Protocol). Puede ver los protocolos en el archivo /etc/protocols.

-s Establece la dirección de origen (source) de los paquetes a ser filtrados. 0/0 usado en el ejemplo indica TODAS las direcciones. Esta dirección de origen puede ser, el nombre o la IP. Para IP, puede ser la de un único host, por ejemplo: -s 192.168.4.2 o la de una red o subred, y sería así: -s 192.168.4.0/24, formato IP/Mask. Note que la máscara se escribe en forma CIDR, es decir que 24 es lo mismo que decir 255.255.255.0. También se puede dar la máscara completa, es decir 192.168.4.0/255.255.255.0.

--source-port especifica el puerto o rango de puertos sin tener que especificar una dirección IP.

Es lo mismo que --sport -d Establece el destino (destination) que debe tener un paquete para ser analizado bajo esta regla. En

nuestro ejemplo 127.0.0.1, es la dirección de la interface de loopback. Las mismas consideraciones que para el caso anterior (-s).

--destination-port igual al anterior pero para el puerto de destino. Es lo mismo que –sport -i Configura la interfaz de red entrante, ejemplo eth0 o ppp0.

Nota: El signo de exclamación ! invierte la orden, es decir, se excluye de esta regla cualquier interfaz especificada. Si aparece un signo suma +, significa que aplico la orden a todas las interfaces que coincidan con la cadena especificada. Por ejemplo, el parámetro -i eth+ aplicará esta regla a cualquier interfaz Ethernet pero excluirá cualquier otra interfaz, tal como, ppp0.

-o Configura la interfaz de red de salida para una regla. Las mismas consideraciones que para el caso anterior (-i).

-j establece la acción a ejecutar sobre los paquetes que cumplan con la regla. Es el target, el objetivo

particular cuando un paquete coincide con una regla particular. Los target pueden ser: ACCEPT, DROP, QUEUE y RETURN y opciones extras, como LOG, MARK y REJECT, entre otros.

-ACCEPT Acepta el paquete, deja que se mueva hacia su destino (o hacia otra cadena, si no ha sido configurado ningún destino para seguir a esta cadena). -DROP Rechaza el paquete sin responder al solicitante. -QUEUE El paquete se pone en una cola para ser manejado por una aplicación en el espacio de usuario. -RETURN Se utiliza en caso de verificación del paquete contra las reglas de la cadena actual. Si el paquete con un destino RETURN cumple alguna regla de una cadena llamada desde otra cadena, el paquete es devuelto a la primera cadena para retomar la verificación de la regla allí donde se dejó. Si la regla RETURN se utiliza en una cadena predefinida, y el paquete no puede moverse hacia la cadena anterior, se define con la cadena actual el objetivo a llevar a cabo. -LOG Genera un log de todos los paquetes que coinciden con esta regla. Como el kernel registra los paquetes, debe configurarse el archivo /etc/syslog.conf para decirle donde debe escribir. Por defecto, escribe en el archivo /var/log/messages. Opciones adicionales para el objetivo LOG:

--log-level Para configura el nivel de prioridad del log. --log-ip-options Guarda todas las opciones de encabezado de paquetes IP. --log-prefix Coloca un prefijo, un string de hasta 29 caracteres antes de escribir la línea de log. --log-tcp-options Guarda todas las opciones de encabezado de paquetes TCP. --log-tcp-sequence Escribe el número de secuencia TCP del paquete en el log.

-REJECT Rechaza el paquete y envía un paquete de error al sistema remoto solicitante. -MASQUERADE Para hacer NAT.

-f Aplica esta regla sólo a los paquetes fragmentados, o sea a partir del segundo paquete. Si lleva

adelante un signo de exclamación !, se refiere al primer paquete, que está sin fragmentar --syn Provoca que todos los paquetes de TCP, llamados paquetes SYN, cumplan esta

regla. Cualquier paquete que esté llevando un payload de datos no será tocado,



solo los syn. Si aparece un signo de exclamación ! tras la opción --syn especifica que todos los paquetes no-SYN sean seleccionados.

--tcp-flags Chequea bits específicos o banderas de los paquetes TCP que coincidan con la regla. Esta opción acepta dos parámetros. Usando el signo de exclamación ! después de --tcp-flags invierte el efecto de la opción de coincidencia.

--tcp-option Selecciona opciones específicas de TCP que pueden estar activas en el paquete. Esta opción se puede revertir con el signo de exclamación !.

--icmp-type Selecciona el nombre o el número del tipo ICMP que coincida con la regla.

Nota: puede obtener una lista de nombres válidos ICMP con el comando iptables -p icmp –h

Como se hace el filtrado de paquetes Para filtrar paquetes el kernel puede ejecutar varias acciones, aceptar algunos de ellos, interceptar y analizar o modificar o rechazar. Para ello, netfilter tiene tres tablas o listas de reglas incorporadas. Estas son: filter se encarga del filtrado y es la tabla por defecto para el manejo de paquetes de red. nat se usa para alterar encabezados de paquetes, también se utiliza para NAT. mangle aquí se pueden cambiar otros campos específicos de los paquetes

Nota: cada tabla contiene sus propias cadenas. Ya vimos en apartados anteriores, generalidades sobre cadenas, ahora veremos qué tipo de cadenas soporta cada tabla en particular.

Tabla filter INPUT paquetes que llegan para nuestro sistema. FORWARD paquetes enrutados a través de nuestro sistema. OUTPUT paquetes generados en nuestro sistema y que son enviados.

Tabla nat PREROUTING se utiliza para alterar paquetes según entren. OUTPUT para alterar paquetes generados localmente antes de enrutar POSTROUTING para alterar paquetes a salir.

Tabla mangle PREROUTING altera paquetes recibidos por una interfaz de red antes de que sean dirigidos. POSTROUTING altera los paquetes de red cuando estos son enviados.

Nota: Las tablas no se verifican en orden. El orden depende del origen y destino de cada paquete en particular.

Sintaxis completa del comando iptables Como ya conocemos todas las tablas, opciones, parámetros y objetivos, les presento la sintaxis iptables [-t nombre_tabla] accion cadena <parametro-1> <opcion-1> <parametro-n> <opcion-n>

Ejemplos:

# iptables -A INPUT -i ippp0 -p ICMP -j ACCEPT

En este caso dejamos pasar los paquetes ICMP que llegan por la interfaz ippp0. Aquí no aparece ninguna tabla, por lo tanto, es la tabla por defecto, filter.

# iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE Aquí habilito el NAT, en la tabla correspondiente, para los paquetes que salen. Nota: Recordemos que para hacer forwardeo de paquetes, tenemos que tener activada esta opción en el kernel. Si no lo hizo debe hacerlo de esta forma: # echo 1 > /proc/sys/net/ipv4/ip_forward

# iptables -A INPUT -i ippp0 -p TCP --dport 22 -m state --state NEW -j ACCEPT Permito conexiones al puerto 22, SSH y las acepto a las conexiones nuevas. Un poco más adelante hablaremos de la opción –m, que es un módulo extra.



Consultando las reglas Para listar las reglas que tenemos aplicadas en nuestro Firewall, el comando es simple:

# iptables –L El resultado de éste comando puede parecerse a lo siguiente:

Chain INPUT (policy ACCEPT): Target prot opt source destination DROP icmp -- anywhere anywhere ACCEPT tcp -- anywhere anywhere tcp dpt:ssh state NEW Chain FORWARD (policy ACCEPT): Target prot opt source destination Chain OUTPUT (policy ACCEPT): Target prot opt source destination

# iptables –L -v

Muestra la salida por pantalla en modo verbose, con detalles, como el número de paquetes y bytes que cada cadena ha visto, ha encontrado y qué interfaces se aplican a una regla en particular.

# iptables –L -x Expande los números o contadores en sus valores exactos. En un sistema ocupado, el número de paquetes y bytes vistos por una cadena en concreto o por una regla.

# iptables –L -n Muestra las direcciones IP y los números de puertos en formato numérico, en lugar de utilizar el nombre del servidor y la red tal y como se hace por defecto.

# iptables –L –-line-numbers Proporciona una lista de cada cadena junto con su orden numérico en la cadena. Esta opción puede ser útil cuando esté intentando borrar una regla específica en una cadena o localizar dónde insertar una regla en una cadena.

# iptables –L -t Especifica un nombre de tabla. Si ejecuto # iptables –L –t nat –n veré lo siguiente:

Chain PREROUTING (policy ACCEPT): Target prot opt source destination Chain POSTROUTING (policy ACCEPT): Target prot opt source destination MASQUERADE all –- 192.168.1.0/24 0.0.0.0/0 Chain OUTPUT (policy ACCEPT): Target prot opt source destination

Borrando reglas Hay tres formas de borrar reglas. Una forma de borrar reglas es cambiar la acción –A por –D en la regla original. Por ejemplo:

# iptables -D INPUT -p icmp -s 0/0 -d 127.0.0.1 -j DROP Este comando borrará la primera regla que estableció en este manual (aquella que denegaba la recepción de paquetes dirigidos a localhost), es decir que a partir de este momento, si hace ping localhost o ping 127.0.0.1, tendrá respuesta. Otra forma de borrar reglas, es especificando el número de regla:

# iptables –D INPUT 1 Esta borrará la primera regla de INPUT que tenga en la lista de reglas. Y una tercer forma de borrar reglas es con la opción –F, pero en este caso borraría todas las reglas, flush, vacío la lista.

# iptables -F



Guardando y recuperando las reglas Todo lo que se ha hecho fue trabajo en memoria, si ahora apago la PC, todo esto se elimina, es decir que al arrancar la máquina nuevamente no tendré ninguna regla. Si se desea contar con las reglas en sucesivos inicios del servidor, se deben guardar las reglas en un archivo y esto se logra con:

# ipctables-save > /sbin/firewall.myrules Lo cual guardará la configuración del Firewall en el archivo /sbin/firewall.myrules. La forma de recuperar esta configuración es:

# iptables-restore < /sbin/firewall.myrules

Nota: como vimos en ipchains, con iptables también podemos utilizar variables, por si nos cambia una IP, por ejemplo, no afectar a todo el firewall.

Módulos con opciones de coincidencias adicionales Estas opciones adicionales se usan con la opción -m, como vimos en el ejemplo anterior

# iptables -A INPUT -i ippp0 -p TCP --dport 22 -m state --state NEW -j ACCEPT

Veamos una lista de los módulos usados más comúnmente:

Módulo limit Permite colocar un límite a la cantidad de paquetes que coinciden con una regla particular. Esto es útil cuando se usa en conjunto con el objetivo LOG, pues puede prevenir que una inundación de paquetes coincidentes sobrecarguen el registro del sistema con mensajes repetitivos o usen los recursos del sistema. El módulo limit habilita las opciones siguientes:

--limit Configura el máximo número de coincidencias en un intervalo de tiempo, por ejemplo, si usamos --limit 5/hour sólo dejaremos que una regla sea efectiva cinco veces a la hora. Valor por defecto: 3/hour. --limit-burst Configura un límite en el número de paquetes capaces de cumplir una regla en un determinado tiempo. Esta opción deberá ser usada junto con la opción --limit, y acepta un número para configurar el intervalo de tiempo. Si no se especifica ningún número, tan sólo cinco paquetes serán capaces inicialmente de cumplir la regla.

Módulo state Habilita la coincidencia de estado. Tiene las siguientes opciones:

--state tiene que ver con los estados de conexión: ESTABLISHED El paquete seleccionado se asocia con otros paquetes en una conexión establecida. INVALID El paquete seleccionado no puede ser asociado a una conexión conocida. NEW El paquete seleccionado o bien está creando una nueva conexión o bien forma parte de una conexión de dos caminos que antes no había sido vista. RELATED El paquete seleccionado está iniciando una nueva conexión en algún punto de la conexión existente.

Nota: Estos estados de conexión se pueden utilizar combinados separándolos mediante comas.

Módulo mac Habilita la coincidencia de direcciones MAC de hardware. El módulo mac activa la siguiente opción:

--mac-source Busca la coincidencia de una dirección MAC a la tarjeta de red que envió el paquete. Para excluir una dirección MAC de la regla, coloque un signo de exclamación ! después de la opción --mac-source.

Nota: para buscar otras opciones disponibles a través de los módulos, consulte la página man de iptables.



Capítulo 13

DNS Introducción El archivo hosts, está formado por columnas donde se relaciona la dirección IP con el nombre de dominio y con el nombre de máquina. Este archivo es una base de datos primitiva para resolver nombres. El concepto de su funcionamiento es centralizado. Este archivo debe actualizarse a mano cada vez que se agrega un nuevo dominio/máquina a la red. Con el crecimiento de internet, esta metodología se hace imposible de mantener. Nace entonces un nuevo sistema de resolución de nombres a direcciones IP, el BIND (Berkeley Internet Name Domain-Dominio de Nombres de Internet de Berkeley), para reemplazar el método anterior. El DNS (Domain Name System-Sistema de Nombres de Dominio), constituye la base de datos que proporciona a sus clientes la información acerca de las direcciones y los nombres de las máquinas de la red. El DNS tiene una orientación cliente servidor y todas las máquinas que queden bajo él pueden ser consideradas como archivos en una estructura de árbol de directorio. El DNS es un sistema jerárquico. La raíz o root es el punto (.). Debajo hay cierto número de TLDs (Top Level Domains-Dominios de Nivel Superior), los más conocidos son org, com, edu, gov y net, pero hay muchos más. El servicio de nombres en Linux, es manejado por un demonio llamado named o bind, según las distribuciones, y está ubicado en el directorio /usr/sbin. Este capítulo se ha desarrollado empleando la versión 9 de BIND. Para saber qué versión tiene instalada alcanza con hacer # named -v y la salida va a ser la versión de bind. Sino lo tuviera instalado, hacemos: # apt-get install bind9 dnsutils bind9-doc bind9-host Clasificación de Servidores Existen tres tipos de servidores DNS: primarios, secundarios y de caché. Los servidores primarios son los únicos que están considerados como autorizados para un dominio en particular. Un servidor autorizado es el único en el que residen los archivos de configuración del dominio. Cada vez que ocurra una actualización de tablas de dominio de DNS, se hará en este servidor. Los servidores secundarios actúan como respaldo y como distribuidores de carga de los servidores de nombres primarios. Los servidores primarios conocen la existencia de los secundarios y les envían constantemente actualizaciones de sus tablas. Cuando un cliente busca en un servidor de nombres secundario, el secundario responde con autoridad. Sin embargo, debido a que es posible que el secundario devuelva su búsqueda antes de que el primario le haya avisado de sus últimos cambios, algunas personas se refieren a los servidores secundarios como “no autorizados lo suficiente”. En realidad, puede confiar en que los secundarios tienen la información correcta (además, a menos que sepa cual es cual, no podrá distinguir la diferencia entre una respuesta a una búsqueda, hecha por un primario ó por uno secundario).

Nota: Un servidor DNS puede configurarse para actúe con un nivel determinado de autoridad. Por ejemplo, puede ser primario para un dominio y secundario para otro.

Los servidores de caché no contienen archivos de configuración de ningún dominio. En su lugar, cuando una máquina cliente realiza un pedido a un servidor de caché para que resuelva un nombre, este servidor comprueba su propia caché local primero. Si no la encuentra, buscará un servidor primario y le preguntará. Su respuesta pasará a caché. En la práctica, los servidores de caché trabajan bastante bien debido a la naturaleza temporal de las peticiones DNS. Por ejemplo, si pregunta por la dirección IP de yahoo.com es probable que la pida de nuevo en un futuro próximo. Los clientes pueden diferenciar entre una respuesta de un servidor de caché y uno primario o secundario. Cuando responde un servidor de caché, la respuesta es “no autorizada”.



Nota: Todos los servidores DNS actúan como servidores de caché, aunque sean primarios o secundarios de otros dominios.

Servidor de solo caché Por defecto, la configuración de bind es como un servidor de solo caché, el cual es muy útil para los usuarios de conexiones telefónicas. Este servidor obtendrá las respuestas a solicitudes de nombre provenientes de su red preguntando a servidores externos, recordando la respuesta para la próxima vez que lo necesite. Un servidor de nombres de este tipo es útil porque disminuye el tráfico de peticiones de resolución de nombres en la red. Tipos de Resolución Resolución de Nombres de Host a Direcciones IP Este tipo de resolución, también llamada Resolución Directa, es la más conocida, ya que permite, mediante una estructura jerárquica (como la que vemos reflejada mas abajo), poder encontrar la dirección IP específica de un host de la red (o de internet).

. (root)

com. net. org. […] ar. (TLDs)

yahoo.com. com.ar. net.ar. […]

ns1.yahoo.com. (66.218.71.198) yahoo.com.ar.

www.yahoo.com. (138.109.118.70) ns2.yahoo.com.ar.

(138.136.232.195)

mail.yahoo.com. (138.109.127.60) www.yahoo.com.ar.

(138.136.232.196)

Mail.yahoo.com.ar. (138.136.232.197)

Resolución de Direcciones IP a Nombres de Host Este tipo de resolución, también llamada Resolución Reversa, tiene la misma estructura jerárquica que la resolución directa, y nos permite determinar el FQDN de un host, del cual solamente conocemos su dirección IP.

arpa.

in-addr.arpa.

66.in-addr.arpa. 136.138.in-addr.arpa.

218.66.in-addr.arpa. 232.136.138.in-addr.arpa. […]

71.218.66.in-addr.arpa. 196.232.136.138.in-addr.arpa. (www.yahoo.com.ar)

198.71.218.66.in-addr.arpa. (ns.yahoo.com) 197.232.136.138.in-addr.arpa.

(mail.yahoo.com.ar)

223.71.218.66.in-addr.arpa.

(smtp.otraempresa.com)

Para lograr esta tarea, los servidores se acomodan en la estructura jerárquica siguiendo el orden de preponderancia de los octetos de una dirección IP. Como vemos en el gráfico, los octetos de las direcciones IP están escritos en orden inverso.



Configuración del servidor named.conf Este es el archivo principal de configuración de un servidor de nombres, que es leído por el demonio bind cuando inicia para saber a qué dominios va a servir y dónde encuentra las tablas de máquinas y direcciones IP, entre otras cosas. Este archivo está ubicado en /etc/bind/named.conf. Un ejemplo típico de este archivo, configurado como un servidor de sólo caché, es el siguiente: // This is the primary configuration file for the BIND DNS server named. // // Please read /usr/share/doc/bind9/README.Debian.gz for information on the // structure of BIND configuration files in Debian, *BEFORE* you customize // this configuration file. // // If you are just adding zones, please do that in /etc/bind/named.conf.local include "/etc/bind/named.conf.options"; // prime the server with knowledge of the root servers zone "." { type hint; file "/etc/bind/db.root"; }; // be authoritative for the localhost forward and reverse zones, and for // broadcast zones as per RFC 1912 zone "localhost" { type master; file "/etc/bind/db.local"; }; zone "127.in-addr.arpa" { type master; file "/etc/bind/db.127"; }; zone "0.in-addr.arpa" { type master; file "/etc/bind/db.0"; }; zone "255.in-addr.arpa" { type master; file "/etc/bind/db.255"; }; zone "com" { type delegation-only; }; zone "net" { type delegation-only; }; // From the release notes: // Because many of our users are uncomfortable receiving undelegated answers // from root or top level domains, other than a few for whom that behaviour // has been trusted and expected for quite some length of time, we have now // introduced the "root-delegations-only" feature which applies delegation-only// logic to all top level domains, and to the root domain. An exception list // should be specified, including "MUSEUM" and "DE", and any other top level // domains from whom undelegated responses are expected and trusted. // root-delegation-only exclude { "DE"; "MUSEUM"; }; include "/etc/bind/named.conf.local"; }; zone "4.168.192.in-addr.arpa" {

type master; file "db.4.168.192.in-addr.arpa";



}; zone "centraltech.com.ar" {

type master; file "db.centraltech.com.ar";

}; Cada línea significa:

zone corresponde a la definición de un dominio conocido. Más adelante veremos como se configura cada dominio. El valor encerrado entre comillas le indica a bind donde encontrar las definiciones de dominios y hosts para esa zona.

zone "." es la raíz de todas las búsquedas. Se va a fijar en el archivo etc/bind/db.root. zone "0.0.127.in-addr.arpa" resuelve reversa para localhost. La resolución inversa se usa para

encontrar el nombre de la máquina a partir de su dirección IP. zone "4.168.192.in-addr.arpa" se usa para efectuar la resolución inversa de direcciones IP a

nombres dentro de la red 192.168.4.0. La zona “centraltech.com.ar” la utilizamos en este ejemplo para mostrar como agregar un dominio propio.

file indica el nombre del archivo que contiene las definiciones particulares de la zona.

include se utiliza para llamar a otro archivo. En este caso /etc/bind/named.conf.options

Servidores Raiz /etc/bind/db.root El archivo db.root describe los servidores de nombre raíz en el mundo y cambiará a lo largo del tiempo por lo que tiene que ser mantenido y actualizado con cierta regularidad. Básicamente su contenido es el siguiente: ; This file holds the information on root name servers needed to ; initialize cache of Internet domain name servers ; (e.g. reference this file in the "cache . <file>" ; configuration file of BIND domain name servers). ; ; This file is made available by InterNIC ; on server FTP.INTERNIC.NET ; -OR- RS.INTERNIC.NET ; ; last update: Jan 29, 2004 ; related version of root zone: 2004012900 ; ; ; formerly NS.INTERNIC.NET ; . 3600000 IN NS A.ROOT-SERVERS.NET. A.ROOT-SERVERS.NET. 3600000 A 198.41.0.4 ; ; formerly NS1.ISI.EDU ; . 3600000 NS B.ROOT-SERVERS.NET. B.ROOT-SERVERS.NET. 3600000 A 192.228.79.201 ; ; formerly C.PSI.NET ; . 3600000 NS C.ROOT-SERVERS.NET. C.ROOT-SERVERS.NET. 3600000 A 192.33.4.12 ; ; formerly TERP.UMD.EDU ; . 3600000 NS D.ROOT-SERVERS.NET. D.ROOT-SERVERS.NET. 3600000 A 128.8.10.90 ; ; formerly NS.NASA.GOV ; . 3600000 NS E.ROOT-SERVERS.NET.



E.ROOT-SERVERS.NET. 3600000 A 192.203.230.10 ; ; formerly NS.ISC.ORG ; . 3600000 NS F.ROOT-SERVERS.NET. F.ROOT-SERVERS.NET. 3600000 A 192.5.5.241 ; ; formerly NS.NIC.DDN.MIL ; . 3600000 NS G.ROOT-SERVERS.NET. G.ROOT-SERVERS.NET. 3600000 A 192.112.36.4 ; ; formerly AOS.ARL.ARMY.MIL ; . 3600000 NS H.ROOT-SERVERS.NET. H.ROOT-SERVERS.NET. 3600000 A 128.63.2.53 ; ; formerly NIC.NORDU.NET ; . 3600000 NS I.ROOT-SERVERS.NET. I.ROOT-SERVERS.NET. 3600000 A 192.36.148.17 ; ; operated by VeriSign, Inc. ; . 3600000 NS J.ROOT-SERVERS.NET. J.ROOT-SERVERS.NET. 3600000 A 192.58.128.30 ; ; operated by RIPE NCC ; . 3600000 NS K.ROOT-SERVERS.NET. K.ROOT-SERVERS.NET. 3600000 A 193.0.14.129 ; ; operated by ICANN ; . 3600000 NS L.ROOT-SERVERS.NET. L.ROOT-SERVERS.NET. 3600000 A 198.32.64.12 ; ; operated by WIDE ; . 3600000 NS M.ROOT-SERVERS.NET. M.ROOT-SERVERS.NET. 3600000 A 202.12.27.33 ; End of File

Archivos de zona Aquí vamos a ver como se crean los archivos para cada zona o dominio. Una zona no es lo mismo que un dominio, pero para explicar como armar el archivo de zona, no hay diferencias. Aquí disponemos de un servidor de nombres secundario de seguridad y están enunciadas las diferentes máquinas dentro de la red. Ejemplos /etc/bind/db.centraltech.com.ar

$TTL 86400 @ IN SOA alexa.centraltech.com.ar. root.centraltech.com.ar. ( 2006060901 ; serial 10800 ; refresh 3600 ; retry 86400 ; expire 3600) ; default IN NS alexa.centraltech.com.ar. IN MX 0 alexa.centraltech.com.ar.



alexa.centraltech.com.ar. IN A 192.168.4.30 dragon.centraltech.com.ar. IN A 192.168.4.3 pumita.centraltech.com.ar. IN A 192.168.4.12 viktor.centraltech.com.ar. IN A 192.168.4.11 ojeda.centraltech.com.ar. IN A 192.168.4.16 www.centraltech.com.ar. IN CNAME alexa.centraltech.com.ar. mail.centraltech.com.ar. IN CNAME alexa.centraltech.com.ar.

/etc/bind/db.4.168.192.in-addr.arpa Este es el archivo de resolución inversa de nuestro ejemplo.

$TTL 86400 @ IN SOA alexa.centraltech.com.ar. root.centraltech.com.ar. ( 2006060901 ;serial 10800 ; refresh 3600 ; retry 86400 ; expire 3600) ; default IN NS alexa.centraltech.com.ar. 30 IN PTR alexa.centraltech.com.ar. 3 IN PTR dragon.centraltech.com.ar. 12 IN PTR pumita.centraltech.com.ar. 11 IN PTR viktor.centraltech.com.ar. 16 IN PTR ojeda.centraltech.com.ar.

$TTL 86400 es una directiva obligatoria a partir de la versión 9 de BIND (RFC1035 y RFC2308), indica el

TTL (Time To Live-Tiempo de Vida) de la información contenida en el archivo. Es decir, el tiempo máximo de validez, tras el cual deberá refrescarse o actualizarse, para comprobar que no haya cambiado. Por defecto se usan segundos, pero pueden usarse también semanas ($TTL 1w), días ($TTL 7d), horas ($TTL 168h) y minutos ($TTL 10080m). Un TTL pequeño permitirá que la información sea consistente casi siempre, pues los datos expirarán rápidamente obligando a descargarlos del caché y a obtener los nuevos valores de los servidores autorizados.

Estos tipos de archivo se llaman archivos de zona y a su dominio asociado, origen. Cada nombre de dominio o de máquina que aparezca en estos archivos es considerado relativo a este origen a menos que termine con un punto. Esta regla no debe ser tomada a la ligera: todos los nombres en un archivo de zona son expandidos agregándoles el origen a menos que terminen en un punto. Para hacer referencia al origen en sí es necesario usar el símbolo "@''. Los archivos de zonas están hechos con registros (Resource Records) que tienen un tipo asociado. Por ejemplo, un registro para asociar un nombre de máquina con una dirección IP tiene el tipo A, y uno para asociar un nombre corto o alias a una máquina a la que ya se le asoció un IP es de tipo CNAME. En general, los registros o RRs tienen la forma siguiente:

[dominio] [ttl] [clase] tipo datos Cada campo del registro se separa mediante espacios o tabuladores. Los campos entre corchetes son opcionales. Un campo puede ocupar más de una línea siempre y cuando aparezca un paréntesis antes del primer salto de línea y otro paréntesis de cierre después del último campo del registro en la última línea. Al igual que en el archivo principal, en el named.conf, es posible introducir comentarios en un archivo de zona mediante un punto y coma: todo lo que aparece después de este signo es ignorado. El registro SOA SOA (Start Of Authority-Comienzo de Autoridad) indica que todos los registros de recursos que le siguen están autorizados a dicha zona. Es la máquina que contiene la información de la zona, la que tiene alojado el DNS. Los datos asociados con un registro SOA son los siguientes:

• origin Es el nombre canónico del servidor de nombres primario para este dominio, y generalmente se da como absoluto, es decir, con un punto al final.

• contact Es el nombre de la persona responsable para este dominio. Es parecido a una dirección de correo electrónico normal, a excepción que la arroba se remplaza con un punto. También termina con un punto.



• serial Es un número que indica la versión del archivo de zona, y debe ser incrementado cada vez que el archivo se modifique. Es importante porque los servidores secundarios solicitan el registro SOA en ciertos intervalos (ver refresh, más abajo), para verificar el serial. Si éste ha cambiado, entonces transfieren el archivo completo para actualizarse. Una práctica muy común es utilizar la fecha en el formato aaaammdd y agregarle dos dígitos más para los cambios que se hacen al archivo en el mismo día. De tal manera, un serial típico podría ser 2006062201.

• refresh Es el intervalo, en segundos, para las revisiones que hacen los servidores secundarios del registro SOA, con el fin de verificar si la información del dominio ha cambiado.

• retry Es el tiempo que un servidor secundario debe esperar para reintentar una conexión por refresh que ha fallado.

• expire Si un servidor secundario no ha podido comunicarse con su servidor primario para verificar que no haya habido cambios a la zona (mediante su registro SOA), descartará la información que tiene después de este período.

• minimum o default Este es el tiempo empleado en los registros del archivo que no especifican su campo TTL.

El registro A Este registro sirve para asociar un nombre de máquina con una dirección IP. El único dato para este tipo de registro es la dirección IP en su forma estándar, por ejemplo 192.168.4.3. Debe haber sólo un registro A por cada dirección IP en el archivo, aunque es posible asignarle a una máquina más de una dirección mediante varios registros A. El registro NS Mediante un registro NS es posible designar un servidor que deberá responder para todas las peticiones que involucren un determinado subdominio. Esto es importante porque permite delegar la asignación de nombres y facilita el manejo de dominios complejos. Designar un servidor de nombres, sin embargo, no basta. Se necesita definir en alguna parte del archivo la dirección de este servidor (mediante un registro A por supuesto). A este registro se le llama en inglés glue record. El registro PTR Un registro PTR se utiliza para relacionar una dirección IP con un nombre de máquina, exactamente al revés que un registro tipo A. Estos registros aparecen en los archivos de zonas para la resolución inversa, los que en named.conf aparecen en una línea zone con el dominio “in-addr.arpa.”. Nótese que en cada registro sólo aparece una fracción de la dirección IP: la dirección se completa porque, como explicamos antes, a cada nombre que no termina en un punto se le agrega el origen. Los nombres de máquinas aparecen siempre en los registros PTR en su forma canónica, es decir, con el dominio completo. El punto es necesario porque de no aparecer se le agregaría erróneamente el origen. El registro MX Los registros MX sirven para anunciar a los programas de intercambio de correo (sendmail, por ejemplo), una máquina que se encarga de administrar el correo de un determinado dominio. El registro CNAME Los registros CNAME (Canonical Name-Nombre Canónico) es una forma de dar a cada máquina nombres alternativos o aliases adicionales. Por tanto www y mail son alias para alexa, el nombre del servidor. Es importante observar que los registros A, MX, CNAME y SOA nunca deben hacer referencia a registro CNAME, sólo pueden referirse a registros A. Luego de configurar los archivos del servidor o cada vez que cambie el archivo named.conf, se debe reiniciar el demonio bind. Recuerde, se hace con el siguiente comando:

# /etc/init.d/bind9 restart

Configuración del cliente En el directorio /etc se encuentran dos archivos, los cuales se emplean para configurar la biblioteca del resolvedor de la máquina.



/etc/host.conf Probablemente contiene varias líneas, una de ellas debe comenzar con order, indicando el orden en que se prueban los distintos mecanismos de resolución de nombres. Por ejemplo:

order hosts,bind En este caso indica a las rutinas de resolución de nombres que busquen primero en /etc/hosts y pregunte luego al servidor de nombres. /etc/resolv.conf Este archivo le dice al cliente como utilizar DNS para resolver nombres de servidor. Indica los servidores de nombre DNS que deben contactarse y el orden en que se debe contactarlos. Por ejemplo:

search centraltech.com.ar nameserver 192.168.4.30

La línea search especifica en qué dominios se buscaría para cualquier nombre de máquina a la que se quiera conectar. La línea nameserver especifica la dirección del servidor de nombres. Si se quiere una lista de varios servidores se debe poner una línea nameserver para cada uno. Es importante saber que bind nunca lee este archivo, lo hace el cliente que usa bind.

Verificaciones Para probar si nuestro servidor de nombres está funcionando correctamente haremos uso de la utilidad nslookup. Este programa se utiliza comúnmente para verificar la instalación de un servidor de nombres. Puede utilizarse interactivamente o como un comando cualquiera. Esto último se hace de la siguiente manera:

# nslookup maquina nslookup consultará al servidor de nombres especificado en el archivo /etc/resolv.conf acerca de la máquina que se desea encontrar y devolverá su dirección IP. En modo interactivo, nslookup puede hacer mucho más que sólo encontrar direcciones IP, puede preguntarle al servidor de nombres por cualquier clase de registros (no sólo A) e incluso puede mostrar la información referente a una zona entera. Para entrar en el modo interactivo tipee:

# nslookup El programa contestará con un prompt “>” indicando que está listo para ejecutar comandos. Entonces puede indicarle cualquier nombre de dominio y nslookup buscará por registros de tipo A. Para cambiar el tipo de registro que queremos encontrar es posible indicar set type=tipo, donde tipo puede ser cualquiera de los que ya mencionamos o incluso any, que indica cualquier tipo de registro. Si se usa nslookup para indagar por la máquina dragon, el programa entrega lo siguiente:

Server: alexa.centraltech.com.ar Address: 192.168.4.30 #53 >dragon .centraltech.com.ar Name dragon.centraltech.com.ar Address: 192.168.4.3

En algunas ocasiones aparece la línea "Non-authoritative answer"; esto significa que bind no sale de la red para preguntar por un equipo, en su lugar mira en su caché y lo encuentra allí. El número 53 que aparece en al dirección IP del servidor es el puerto que usa por protocolo TCP/IP.

Ejemplo de búsqueda Cuando se busca una máquina, la pregunta procede recursivamente en la jerarquía comenzando desde arriba. Si quiere localizar la dirección de prep.ai.mit.edu, su servidor de nombres ha de encontrar primero un servidor de nombres que sirva a edu. Pregunta al servidor (ya conoce los servidores, es para lo que se utiliza el archivo db.root), y el servidor proporcionará una lista de servidores edu:

$ nslookup Default Server: localhost Address: 127.0.0.1



Comienza preguntando a un servidor raíz.

> server c.root-servers.net. Default Server: c.root-servers.net Address: 192.33.4.12

Pone el tipo de petición (Query) a tipo de registro NS

set q=ns Pregunta por edu.

edu. El punto (".") final aquí es significativo, indica al servidor que le pedimos un edu que está justo debajo de ".", y esto reduce la búsqueda un poco.

edu nameserver = A.ROOT-SERVERS.NET edu nameserver = H.ROOT-SERVERS.NET edu nameserver = B.ROOT-SERVERS.NET edu nameserver = C.ROOT-SERVERS.NET edu nameserver = D.ROOT-SERVERS.NET edu nameserver = E.ROOT-SERVERS.NET edu nameserver = I.ROOT-SERVERS.NET edu nameserver = F.ROOT-SERVERS.NET edu nameserver = G.ROOT-SERVERS.NET A.ROOT-SERVERS.NET internet address = 198.41.0.4 H.ROOT-SERVERS.NET internet address = 128.63.2.53

B.ROOT-SERVERS.NET internet address = 192.228.79.201 C.ROOT-SERVERS.NET internet address = 192.33.4.12 D.ROOT-SERVERS.NET internet address = 128.8.10.90 E.ROOT-SERVERS.NET internet address = 192.203.230.10 I.ROOT-SERVERS.NET internet address = 192.36.148.17 F.ROOT-SERVERS.NET internet address = 192.5.5.241 G.ROOT-SERVERS.NET internet address = 192.112.36.4

Esto nos dice que *.root-servers.net sirve a edu., y así podemos seguir preguntando por ejemplo a C. Ahora queremos saber quién sirve el siguiente nivel del nombre de dominio: mit.edu.

> mit.edu. Server: c.root-servers.net Address: 192.33.4.12 Non-authoritative answer: mit.edu nameserver = strawb.mit.edu mit.edu nameserver = w20ns.mit.edu mit.edu nameserver = bitsy.mit.edu Authoritative answers can be found from: strawb.mit.edu internet address = 18.71.0.151 w20ns.mit.edu internet address = 18.70.0.160 bitsy.mit.edu internet address = 18.72.0.3

strawb, w20ns y bitsy sirven a mit.edu., selecciona uno y pregunta por ai.mit.edu.

server W20NS.mit.edu. Los nombres de máquina no son sensibles a mayúsculas/minúsculas, pero como podemos usar el mouse para cortar y pegar, obtengo una copia tal y como aparece en la pantalla.

Server: W20NS.mit.edu Address: 18.70.0.160 > ai.mit.edu. Server: W20NS.mit.edu Address: 18.70.0.160 Non-authoritative answer:



ai.mit.edu nameserver = WHEATIES.AI.MIT.EDU ai.mit.edu nameserver = TRIX.AI.MIT.EDU Authoritative answers can be found from: AI.MIT.EDU nameserver = WHEATIES.AI.MIT.EDU AI.MIT.EDU nameserver = TRIX.AI.MIT.EDU WHEATIES.AI.MIT.EDU internet address = 128.52.32.13 WHEATIES.AI.MIT.EDU internet address = 128.52.35.13 TRIX.AI.MIT.EDU internet address = 128.52.32.6 TRIX.AI.MIT.EDU internet address = 128.52.38.6

Entonces wheaties.ai.mit.edu es un servidor de nombres para ai.mit.edu.

> server WHEATIES.AI.MIT.EDU. Default Server: WHEATIES.AI.MIT.EDU Addresses: 128.52.32.13, 128.52.35.13

Ahora cambia el tipo de solicitud; ha encontrado el servidor de nombres y va a preguntar todo lo que queremos saber sobre prep.ai.mit.edu.

> set q=any > prep.ai.mit.edu. Server: WHEATIES.AI.MIT.EDU Addresses: 128.52.32.13, 128.52.35.13 prep.ai.mit.edu CPU = dec/decstation-5000.25 OS = unix prep.ai.mit.edu inet address = 18.159.0.42, protocol = tcp #21 #23 #25 #79 prep.ai.mit.edu preference = 1, mail exchanger =life.ai.mit.edu prep.ai.mit.edu internet address = 18.159.0.42 ai.mit.edu nameserver = wheaties.ai.mit.edu ai.mit.edu nameserver = mini-wheats.ai.mit.edu ai.mit.edu nameserver = trix.ai.mit.edu ai.mit.edu nameserver = count-chocula.ai.mit.edu ai.mit.edu nameserver = life.ai.mit.edu ai.mit.edu nameserver = mintaka.lcs.mit.edu life.ai.mit.edu internet address = 128.52.32.80 wheaties.ai.mit.edu internet address = 128.52.35.13 wheaties.ai.mit.edu internet address = 128.52.32.13 mini-wheats.ai.mit.edu internet address = 128.52.32.11 mini-wheats.ai.mit.edu internet address = 128.52.54.11 mintaka.lcs.mit.edu internet address = 18.26.0.36

De esta forma comenzando en “.” ha encontrado los sucesivos servidores de nombre para el siguiente nivel en el nombre de dominio. Si ha usado su propio servidor DNS en lugar de usar todos esos otros servidores, su bind, desde luego, habrá almacenado en el caché toda la información que haya encontrado mientras profundizaba en la búsqueda, y en consecuencia no tendrá que preguntar de nuevo durante un tiempo.



Capítulo 14

Apache Introducción Apache comenzó siendo un demonio servidor de HTTP, el NCSA httpd. Posteriormente, algunos usuarios de este programa formaron un grupo para desarrollar un servidor GNU a partir del trabajo que había realizado Rob McCool. Así, en abril de 1995 nace la primera versión de Apache, la 0.6.2. Apache es un software de libre distribución bajo la GPL de GNU, y es el servidor web más utilizado. Según estadísticas de NetCraft Ltd. Apache tiene más del 60% del mercado de servidores de Internet. Esto se debe a las siguientes ventajas: • El programa completo y módulos relacionados son open source. • Es estable y muy versátil. • Es multiplataforma. Aparte de funcionar con Linux, funciona sobre Unix y también sobre Microsoft.

Instalación de Apache2 Por defecto, al instalar apache2 bajo Debian se instalará el módulo apache2-mpm-worker Este módulo provee un modelo de ejecución por hilos para Apache2. Es considerablemente más rápido que el modelo tradicional sin hilos de MPM. Pero en vez de este módulo, nos conviene instalar apache2-mpm-prefork Este Módulo de Multi-Procesamiento (MPM) implementa un modelo sin hilos, que realiza pre-forking. Maneja los pedidos de manera similar a Apache 1.3. Es el apropiado para sitios que deben implementar librerías con problemas de compatibilidad con threads (hilos), o que podrían llevar a problemas de seguridad, por desbordamiento de pila. Entonces hacemos: #apt-get instal install apache2 #apt-get install apache2-mpm-prefork Esto nos instalará varios paquetes dependientes, entre ellos: openssl y ssl-cert Luego, debemos correr el script apache2-ssl-certificate # apache2-ssl-certificate que nos pedirá la siguiente información, y generará el certificado con el que va a firmar las comunicaciones seguras entre el cliente y el servidor: Creating self-signed certificate replace it with one signed by a certification authority (CA) enter your ServerName at the Common Name prompt If you want your certificate to expire after x days call this programm with -days x Generating a 1024 bit RSA private key ..........................................++++++..........++++++ writing new private key to '/etc/apache2/ssl/apache.pem' ----- You are about to be asked to enter information that will be incorporated into your certificate request. What you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank For some fields there will be a default value, If you enter '.', the field will be left blank. ----- Country Name (2 letter code) [GB]: State or Province Name (full name) [Some-State]: Locality Name (eg, city) []: Organization Name (eg, company; recommended) []: Organizational Unit Name (eg, section) []: server name (eg. ssl.domain.tld; required!!!) []: Email Address []:



Luego, debemos correr el script a2enmod ssl # a2enmod ssl Este script automáticamente genera un link simbólico entre los directorios mods- available y mods – enabled, correspondiente al archivo ssl.load. Dentro de este archivo podremos encontrar información sobre qué módulo debe cargar Apache, y dónde buscarlo, esto es lo que hay en el archivo: LoadModule ssl_module /usr/lib/apache2/modules/mod_ssl.so

Luego, debemos generar la configuración para el sitio seguro. Para esto, hacemos una copia del archivo /etc/apache2/sites-available/default a /etc/apache2/sites-available/ssl. Dentro del directorio /etc/apache2/sites-available se guardan archivos de configuración, en general uno para cada sitio que se quiera habilitar. La ventaja de esta configuración es que nos permite servir o dejar de servir un sitio sin reiniciar Apache2. # cp /etc/apache2/sites-available/default /etc/apache2/sites-available/ssl

Como en el caso de los módulos, mediante un script generamos un link simbólico al archivo disponible en /etc/apache2/sites-available/ssl y lo colocamos en el directorio /etc/apache2/sites-enabled: #a2ensite ssl Ahora vamos a editar parámetros del servidor en el archivo principal de configuración.

Configuración Para cambiar cualquier parámetro básico del funcionamiento del servidor web, debemos editar el archivo /etc/apache2/apache2.conf. Como en los archivos de configuración ya vistos, recuerde que las líneas que comienzan con uno o más caracteres "#" son comentarios, es decir, que no se ejecutan. Si se desea cambiar el directorio en el cual se almacenan los archivos del sitio (por defecto es /var/www), debemos editar el parámetro DocumentRoot en /etc/apache2/sites-available/default y reiniciar el servidor. DocumentRoot: Esta directiva especifica el directorio donde se alojarán las páginas que están en el servidor, es decir que cuando un cliente conecte con nuestro servidor, este mostrará por defecto los archivos de este directorio, así, los directorios que cuelguen de este serán accedidos especificando en el cliente la ruta relativa desde este punto, también son válidos los enlaces simbólicos y los alias. Ejemplo: DocumentRoot "/var/www/html". Ahora debemos agregar el puerto 443 a los puertos en los que queremos que escuche Apache2, editando /etc/apache2/ports.conf. Por defecto, Apache2 escucha en el puerto 80 pero ya que además estamos instalando soporte SSL debemos agregar el puerto 443 Listen 443

Ahora debemos editar el archivo /etc/apache2/sites-available/ssl y cambiar el puerto 80 en el nombre del sitio a 443. Debemos agregar las dos líneas siguientes al archivo /etc/apache2/sites-available/ssl SSLEngine On SSLCertificateFile /etc/apache2/ssl/apache.pem

Debemos cambiar el parámetro SSLCertificateFile /etc/apache2/ssl/apache.pem por la ruta al archivo de certificado generado al principio. Este parámetro, junto a la firma digital, controla cómo se genera el túnel seguro entre un cliente y el servidor, y además la forma en la que el cliente autentica la identidad del servidor:



SSLCertificateFile /etc/apache2/ssl/online.test.net. SSLCertificateKeyFile /etc/apache2/ssl/online.test.net.key

Debemos colocar ServerSignature con valor off, para evitar revelar información sobre nuestro servidor. Poniendo ServerTokens a ProductOnly limitaremos la cantidad de información que se revela en cada conexión: ServerSignature Off ServerTokens ProductOnly

Si además se quiere habilitar el soporte para CGI y PHP, se deben instalar los siguientes paquetes: libapache2-mod-php4,php4-cli,php4-common,php4-cgi

# apt-get install libapache2-mod-php4 php4-cli php4-common php4-cgi Debemos editar entonces el archivo /etc/apache2/apache2.conf y cambiar la línea DirectoryIndex index.html index.pl index.xhtml index.shtml a DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.shtml Para que el servidor busque esos archivos y los sirva de manera automática cuando se le pide una ruta que incluya sólo un directorio, por ejemplo, www.centraltech.com.ar/alumni/. Hay que tener cuidado, porque el orden en el que se buscan esos archivos es el que se utiliza para buscarlos, por lo que si se tienen dos archivos, uno index.php y otro index.html, se entregará al cliente el segundo, ya que se lo listó primero en la directiva DirectoryIndex. Luego, debemos reiniciar el servidor, para que los cambios tengan efecto: /etc/init.d/apache2 restart Veamos otras variables de configuración • ServerType: hay dos formas de correr el servidor web, solo (standalone) o como parte del superdemonio

xinetd. En el primero de los casos, el que se encuentra configurado por defecto, el servicio se lanza mediante un script en forma independiente, mientras que con la segunda opción, el demonio es lanzado desde el xinetd.

• ServerRoot: le decimos a apache2 cual es el directorio donde están todos los archivos de configuración, de logs, errores, etc. Ejemplo: ServerRoot /etc/apache2

• LockFile: esta línea debe descomentarse si corremos el servidor desde una unidad montada mediante NFS (network file system), y especifica donde se alojará el archivo de bloqueo, ya que este debe encontrarse siempre en una unidad local. Ej:LockFile /var/lock/apache2/accept.lock

• PidFile: indica en que archivo se almacena el PID (número de identificación del proceso) del servidor. Por ejemplo: PidFile /var/run/apache2.pid

• Timeout: es el tiempo en segundos que esperará entre pedidos y respuestas. Por defecto: Timeout 300 • KeepAlive: si está en On, permite más de una petición por conexión, por defecto: KeepAlive On. • MaxKeepAliveRequests: es el número máximo de peticiones durante una conexión Se aconseja tener un

número alto para aumentar la performance del servidor. El valor recomendado es: MaxKeepAliveRequests 100. Si está en 0, quiere decir que es ilimitado.

• KeepAliveTimeout: es el tiempo máximo en segundos que va a esperar la siguiente petición de un mismo cliente en una misma conexión, por defecto: KeepAliveTimeout 15

<IfModule prefork.c> StartServers 5 MinSpareServers 5 MaxSpareServers 10 MaxClients 20 MaxRequestsPerChild 0 </IfModule>



<IfModule worker.c> StartServers 2 MaxClients 150 MinSpareThreads 25 MaxSpareThreads 75 MaxRequestsPerChild 0 </IfModule> <IfModule perchild.c> NumServers 5 StartThreads 5 MinSpareThreads 5 MaxSpareThreads 10 MaxThreadsPerChild 20 MaxRequestsPerChild 0 AcceptMutex fcntl </IfModule> • MinSpareServers y MaxSpareServers: es la cantidad mínima y máxima de procesos de Apache en

espera de peticiones, los valores por defecto son adecuados en la mayoría de los casos. • MinSpareThreads y MaxSpareThreads, igual al anterior, pero en vez de procesos, es la cantidad de

hilos. • StartServers: es la cantidad de servidores que arrancan inicialmente, debe estar entre la cantidad máxima

y mínima definida en el ítem anterior. • MaxClients: es la cantidad de peticiones o conexiones que atiende simultáneamente. Esta opción ayuda a

prevenir algunos tipos de ataques. Está OK dejarlo en un valor no mayor a 250. • MaxRequestsPerChild: es la cantidad máxima de peticiones que un proceso hijo puede atender. No es

necesario en los sistemas Linux, se recomienda usarlo en Solaris. • User/Group: Nombre o número del usuario y del grupo que ejecutará el demonio apache2, normalmente:

User www-data Group www-data. Otra forma: user apache y group apache

• LogFormat: como es el formato de escritura de archivos de log. • ErrorLog: Se usa para asignar la ubicación y nombre del archivo donde se registrarán los errores que se

produzcan durante la operación del servidor. En el caso de los hosts virtuales, en caso de no asignarles archivos de log de errores serán almacenados en este. El archivo y ruta por defecto son: ErrorLog /var/log/apache2/error_log.

• LogLevel: La cantidad y nivel de los mensajes de error que nos interesa registrar se especifican con esta directiva, los valores posibles son: debug, info, notice, warn, error, crit, alert, emerg. Y el valor por defecto es: LogLevel warn.

• Include /etc/apache2/mods-enabled/*.load • Include /etc/apache2/mods-enabled/*.conf • Include /etc/apache2/httpd.conf • Include /etc/apache2/ports.conf • Include /etc/apache2/conf.d/[ ^.#]* • Alias /icons/ “/usr/share/apache2/icons/” <Directory “/usr/share/apache2/icons”> Options Indexes Multiviews AllowOverride None Order allow,deny Allow from all </Directory>

• Customizable Error Response: se refieren a la configuración de respuestas de error de Apache,

tenemos tres opciones: o Texto: Se visualiza en texto plano, ejemplo: ErrorDocument 404 "No se encontró el

archivo".



o Redireccionamiento local: Se visualiza un documento en el mismo servidor, ejemplo: ErrorDocument 404 /missing.html.

o Redireccionamiento externo: Se visualiza un archivo en otro servidor, ejemplo: ErrorDocument 404 http://otro.server.com.ar/missing.html.

Luego aparecen todos los códigos de error, dentro del módulo mod-negotiate.c • DirectoryIndex: Con esta directiva se fija el o los nombres de los archivos que Apache intentará

servir en primera instancia, por defecto se asigna index.html, pero es bueno especificar otras opciones, esta línea podría quedar de la siguiente manera:

DirectoryIndex index.html index.htm index.cgi principal.html principal.htm • UserDir: Con esto se fija el nombre del directorio que es agregado dentro del directorio home de los

usuarios si se recibe un requerimiento de este tipo del usuario. • AccessFileName: Este es el nombre del archivo donde se definirán las características de acceso a los

directorios protegidos con claves, dejar como está: AccessFileName .htaccess. • UseCanonicalName: Esta es una característica incorporada a partir de las versiones 1.3.x en adelante,

cuando está activada (On) el servidor usa el nombre "canónico" en el caso de que tenga que hacer un auto-referencia a si mismo, son las referencias a los DNS que vimos en el capítulo anterior. Cuando está deshabilitada, Apache usa la configuración hostname:port que el cliente proveyó con la petición de su navegador. Esta opción también afecta SERVER_NAME y SERVER_PORT en los scripts CGI.

• TypesConfig: especificamos con esta directiva donde se encuentra el archivo mime.types o su equivalente. Por defecto es: TypesConfig /etc/httpd/conf/mime.types

• DefaultType: En caso de que el servidor no pueda determinar el tipo MIME de algún archivo, Apache asignará lo que acá definamos, si la mayoría de sus documentos son binarios la opción adecuada sería, application/octet-stream, sino dejamos la línea como está: DefaultType text/plain.

• HostnameLookups: Esta directiva se usa para que Apache resuelva los nombres para loguear los accesos o solo almacene los números de IP, por defecto su conducta es esta última: HostnameLookups Off.

• IndexOptions: Directiva usada para optar por el sistema de visualización de los directorios con Apache, puede ser normal o indexado, la configuración clásica es: IndexOptions FancyIndexing VersionSort.

• AddIcon*: Las directivas de este tipo asignan un icono para cada tipo de archivo que será visualizado, solo son usados en el caso de que IndexOptions esté seteado como FancyIndexing.

• DefaultIcon: Esto determina el icono que será usado por defecto en el caso de los archivos que no tengan un tipo definido. Por defecto es: DefaultIcon /icons/unknown.gif.

• ReadmeName: Nombre del archivo "Leeme" que el servidor visualizará por defecto con el listado del directorio. Valor: ReadmeName README.

• HeaderName: Nombre del archivo "Cabecera" que el servidor visualizará por defecto con el listado del directorio. Valor: HeaderName HEADER.

• IndexIgnore: Máscaras de nombres de archivos y nombres de archivos que serán ignorados por el listado de directorios servido por apache. Valor por defecto: IndexIgnore .??* *~ *# HEADER* README* RCS CVS *.v *.t

• AddEncoding: Usando esta directiva, algunos navegadores descomprimen la información en tiempo de servicio, es decir, que se sirve al navegador en forma descomprimida, esto es útil solo en caso de cliente UNIX. Las opciones por defecto son: AddEncoding x-compress Z y AddEncoding x-gzip gz.

• AddLanguage: Algunos navegadores pueden negociar con el servidor el lenguaje en el que los documentos serán servidos. En el caso de disponer de traducciones, en este caso, debemos agregar la línea: AddLanguage es .es para los archivos en castellano. Para que esto funciones los archivos en castellano tienen que tener como ultima extensión ".es".

• LanguagePriority: Prioridad de lenguajes, usando dos caracteres especificamos cual será el primero, segundo y tercera opción para servir los documentos, por defecto es: LanguagePriority en fr de, pero podría ponerlo en: LanguagePriority es en fr.

• AddDescription: esta directiva es muy útil para que en los listados de directorios servidos por Apache, se agregue al final de la línea una descripción del formato del archivo. Esta opción es solo válida para el caso de que IndexOptions esté seteado como FancyIndexing. El formato de esta directiva es: AddDescription "descripción" extensión_archivo. Un ejemplo es: AddDescription "Documento comprimido con GZIP" .gz.

• AddType: Asigna tipos sin necesidad de editar el archivo mime.types.



• AddHandler: Directiva usada para asignar determinada extensiones de archivos a manejadores del servidor, por ejemplo la extensión .cgi como un Script, AddHandler cgi-script .cgi.

• BrowserMatch: Permite especificar comportamientos según el navegador que solicite servicios, por ejemplo: BrowserMatch "Mozilla/2" nokeepalive o BrowserMatch "MSIE 5\.0b2;" nokeepalive downgrade-1.0 force-response-1.0.

• BindAddress: también para dar soporte de hosts virtuales. Puede poner una IP, ó un nombre de dominio.

Dejar comentado. • ServerAdmin: Dirección de correo del administrador del servidor. En caso de problemas el servidor usará

esta dirección para contactar con el administrador, coloque aquí su dirección de correo. Ejemplo: ServerAdmin [email protected].

• Directory: Los Servicios y características que serán permitidas y negadas a cada directorio a los que Apache dé acceso se habilitan y deshabilitan desde acá, por defecto la configuración es muy restrictiva con estos permisos, se debe dejar como está:

<Directory /> Options FollowSymLinks AllowOverride None </Directory>

Luego de denegar todo en la secuencia anterior se habilitan los directorios con las características que se desean asignar a cada uno. Observe el ejemplo de abajo:

<Directory "/var/www/html"> Options Indexes FollowSymLinks AllowOverride None Order allow,deny Allow from all </Directory>

• CacheNegotiatedDocs: Esta opción es necesaria si queremos acceder al servidor con proxys, en cuyo

caso no es necesario que el mismo guarde en cache los documentos. Si queremos deshabilitar esta característica debemos descomentar la línea, por defecto está comentada.

• Aliases: Directiva usada para poner alias a los recursos del servidor. El formato es: Alias nombre_alias nombre_verdadero. Ejemplo: Alias /icons/ "/var/www/icons/"

• ScriptAlias: Usando esta directiva, asignamos un alias al directorio que contiene los scripts CGI, el valor por defecto es: ScriptAlias /cgi-bin/ "/var/www/cgi-bin/".

Virtual Hosts Esta opción de Apache un muy útil en el caso de que tengamos más de un dominio en nuestro host, es decir hosts virtuales.

NameVirtualHost: Es necesario definir un número de IP y puerto para el host virtual, para eso usamos esta directiva, ejemplo: NameVirtualHost 12.34.56.78:80

A continuación daremos un ejemplo sobre como configurar un host virtual:

<VirtualHost www.centraltech.com.ar> ServerAdmin [email protected] ServerName www.cortech.com.ar DocumentRoot /www/docs/hostvirtual ErrorLog logs/host_virtual.log CustomLog logs/host_virtual_access.log common </VirtualHost> <VirtualHost _default_:*> </VirtualHost>

Prueba de Apache Para probar el servidor de web debemos lanzar el demonio: # /etc/init.d/apache2 restart



Abrimos nuestro navegador preferido. Le pedimos en la barra de URL la dirección de nuestra máquina. (http://localhost). Si todo quedó bien configurado, nos tiene que aparecer la página de Bienvenida de Apache. Para nuestra próxima prueba, debemos crear una página web simple en HTML y guardarla en el directorio que especificamos en DocumentRoot del VirtualHost. Luego iniciamos nuestro servidor DNS (si no esta iniciado aún) y repetimos la prueba desde el navegador, pero esta vez utilizamos el nombre canónico que especificamos en VirtualHost (http://www.centraltech.com.ar)

Páginas protegidas En algunas ocasiones es necesario restringir algunas páginas a los usuarios, de manera de permitir el acceso sólo a usuarios autorizados. Las razones para esto pueden ser varias, por ejemplo, que la información o servicio ofrecido sea pago, o que sea de carácter privado o confidencial. Cualquiera sea el caso, veremos como se hace con Apache para proteger directorios, no confundir esto con páginas seguras por encriptación (https). Para limitar el acceso a una página HTML o directorio, solo a las personas que estén registradas por el webmaster, debemos crear un nuevo directorio, debajo del directorio de documentos de Apache (en nuestro ejemplo: /var/www/html), en el cual alojaremos las páginas que estarán protegidas por clave. Dentro del directorio deberá crear un archivo llamado .htaccess, el punto antes del nombre sirve para que este archivo sea oculto. El contenido de este archivo es el siguiente:

<Directory> AuthUserFile /var/www/html/privado/.htpasswd AuthGroupFile /var/www/html/privado/.htgroups AuthName Pagina de acceso restringido AuthType Basic <limit GET POST> require group nombregrupo require user usuario1 require user usuario2 require valid-user </limit> </Directory>

En el archivo /var/www/html/privado/.htpasswd se encuentran los nombres de usuarios y las claves o passwords de los clientes con acceso permitido. Junto con apache se provee una aplicación con la que se podrá crear su propio archivo de passwords. Hay otro archivo llamado .htgroups en el mismo directorio (/var/www/html/privado/) o en la ruta que se indique en AuthGroupFile, que sirve para relacionar los login de los usuarios a un determinado grupo, y que va a ser el que se use en require group nombregrupo para limitar el acceso a ese grupo únicamente. Para limitar el acceso por usuarios lo indica esta línea: require user usuario1. De esta forma solo los usuarios indicados tendrán acceso a la página. Si indica require valid-user, sólo los usuarios que aparezcan en el archivo .htpasswd, podrán tener acceso. Se puede indicar por separado o de forma conjunta cada una de estas opciones.

Nota: Es importante indicar siempre la ruta completa al archivo de claves .htpasswd y de grupos .htgroups.

Podemos crear la cantidad de grupos que queramos, siempre teniendo en cuenta que el nombre del grupo debe ser el mismo que el usado para dar acceso a su página (require group nombregrupo). Puede utilizar el archivo de claves que mostrado antes indicando AuthUserFile, o bien crear su propio archivo de claves, donde podrá crear las cuentas y claves que desee. Para hacer esto, disponemos de la aplicación htpasswd. Este comando se genera junto con los otros ejecutables del servidor durante la compilación (y la instalación). Para usarlo por primera vez es necesario invocarlo con el parámetro -c, ejemplo:

# htpasswd -c .htpasswd cuenta El programa inmediatamente solicita que ingresemos la clave dos veces, luego encripta la clave y la almacena en el archivo creado. Si desea añadir nuevos usuarios deberá hacer lo siguiente:

# htpasswd .htpasswd cuenta



Nota: Observe que en esta ocasión no se usa el parámetro -c que indica que se cree un nuevo archivo. Si crea su propio archivo de passwords, estos login serán los que se usen para el archivo de grupos.

Ejemplo: Veamos ahora paso a paso un ejemplo de como crear un directorio privado. Nos ubicamos en el directorio raíz que contiene los documentos del servidor apache.

1. Creamos el directorio que tendrá acceso limitado. mkdir secret 2. Ingresamos al nuevo directorio. cd secret 3. Creamos y editamos el archivo .htacess vi .htpasswd 4. Agregamos el siguiente contenido al archivo httpd.conf:

AuthUserFile /var/www/html/secret/.htpasswd AuthGroupFile /var/www/html/secret/.htgroups AuthName Acceso Restringido a Miembros AuthType Basic <limit GET POST> require valid-user </limit>

5. Creamos y editamos el archivo .htgroups vi .htgroups 6. Agregamos el siguiente contenido a .htgroups

pub: publico 7. Creamos el archivo de claves con la primera cuenta htpasswd -c .htpasswd alexa 8. Agregan las demás cuentas htpasswd .htpasswd agarcia

Nota: el programa htpasswd lo ejecuto del directorio a proteger.

9. Finalmente modificar la configuración de apache httpd.conf en la línea AllowOverride colocar el valor "All"

Con esto terminamos de configurar nuestro directorio protegido secret. Con nuestro navegador pedimos por la dirección http:/127.0.0.1/secret y si todo funciona correctamente, al hacer este pedido, el servidor nos va a solicitar ingresar el nombre de usuario y la clave para acceder al directorio y sus documentos.

Nota: La línea AuthName Acceso Restringido a Miembros del archivo httpd.conf especifica la frase que aparecerá al pedir el password.



Capítulo 15

Programando tareas con at y cron Introducción Los demonios (daemons) son, programas que se encargan de gestionar y administrar el sistema. Son varios y permiten automatizar muchas tareas del sistema operativo Linux. Estos programas son llamados así porque se ejecutan (o corren) en segundo plano, y una vez configurados no necesitan la intervención del usuario para hacer tal o cual operación, esto incrementa la velocidad del sistema. Uso de at El comando at se utiliza para planificar la ejecución (en el futuro y por una vez) de ciertas tareas. Por ejemplo, dejar para el horario nocturno los trabajos que, por su empleo de recursos o su duración, representen una gran carga para el sistema. En el momento deseado, at se encargará de ejecutar esas tareas. Su sintaxis es:

at [-V] [-q queue] [-f file] [-m] fecha_y_hora at -c tarea [tarea...]

Podemos especificar varios formatos para especificar la fecha y hora en que at debe activarse. El tiempo puede especificarse en formato HHMM o HH:MM de 24 hs, o colocar el sufijo am o pm, si uso 12 hs. También se puede especificar midnight (medianoche), noon (mediodía) o teatime (4 de la tarde). Si las tareas deben ejecutarse otro día distinto al que me encuentro, hay que especificarle la fecha en la forma “mes día”, por ejemplo, May 27, e incluso, de ser necesario, también puede especificarse el año, en la forma MM/DD/AA o MM.DD.AA. Otra manera de que at sepa el momento en que tiene que actuar es darle la fecha y hora en forma de un signo '+' seguido de un número de unidades de tiempo, ya sean weeks (semanas), days (días), hours (horas) o minutes (minutos). Por ejemplo

6pm+4 days dentro de 4 días a las 6 de la tarde 8pm tomorrow mañana a las 8 de la tarde

at devuelve un número, un identificador de tarea, al ser invocado. Este identificador lo usaremos más tarde si necesitara información acerca de la tarea concreta, se hace con la opción -c.

Nota: No se puede utilizar at cuando los usuarios compiten por los recursos. Uso de cron Este demonio también se utiliza para automatizar tareas y es una de las mejores armas de Linux para agendar, contra fecha y hora, la realización de una actividad repetitiva. Su uso es un poco más complicado que at, ya que permite realizar tareas especificando hora, día, semana, mes y con cierto intervalo de días, según como esté configurado, siempre y cuando éste se encuentre en modo multiusuario. Para esto, debe leer los archivos llamados crontab, que se localizan en /etc. El nombre de los archivos y/o su ubicación puede ser diferente, dependiendo de que distribución de Linux esté manejando. La estructura es de esta forma:

SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=root HOME=/ # # check scripts in cron.hourly, cron.daily, cron.weekly, and cron.monthly # # run-parts 01 * * * * root run-parts /etc/cron.hourly 02 4 * * * root run-parts /etc/cron.daily 22 4 * * 0 root run-parts /etc/cron.weekly 42 4 1 * * root run-parts /etc/cron.monthly

Las primeras cuatro líneas son las variables de entorno que utiliza. La variable MAILTO lleva el nombre de usuario a quien se le manda el correo de notificación de lo realizado (la salida estandar y la salida de error del programa ejecutado); puede ser root o algún otro usuario, o también podría dejarlo en blanco para que no envíe



ningún mail. Los siguientes renglones muestran como se deben configurar las acciones para que crontab las realice periódicamente. El formato para programar las acciones es:

Minuto Hora Dia_del_Mes Mes Dia_de_Semana [programa o comando] Donde

Minuto Minuto en que se ejecuta el proceso. (0-59) Hora Hora en que se ejecuta el proceso. (0-23) Dia_del_Mes Día del mes en que se ejecuta el proceso. (0-31) Mes Mes en que se ejecuta el proceso. (1-12, ó los nombres) Dia_de_Semana Día de la semana, va del 0 (domingo) al 6 (sábado) [programa o comando] Aquello que va a ejecutarse al llegar el momento especificado.

Nota: si en vez de especificar un programa en particular, especificamos run-parts directorio, cron ejecutara todos los scripts contenidos en directorio.

Para los valores de tiempo (Minuto, Hora, Dia_del_Mes, Mes y Dia_de_Semana) puedo especificar valores puntuales o conjuntos de valores, para reiterar la ejecución en secuencias regulares. En este último caso, puedo hacer una lista de valores separados por coma (1,3,6,11) o un rango de valores separados por un guión (4-12). Otro valor de tiempo que puede tomar es el asterisco (*). El asterisco, es como un comodín, se usa para especificar todos los valores posibles. Veamos algunos ejemplos:

Para ejecutar el programa randsig a las 12:30 (del mediodía), todos los días (cualquier día de la semana, cualquier día del mes y cualquier mes):

30 12 * * * /usr/bin/randsig El mismo caso anterior, pero ejecutando a las 12:30 (de la medianoche)

30 0 * * * /usr/bin/randsig

Nota: Para disponer del PATH estándar para la ejecución de los comandos (y no tener que añadirlo en todos, debe incluirse la variable de entorno en el archivo: PATH=/usr/local/bin:/usr/bin:/bin:(etc...)

Nota: si quisieramos evitar el mail con la salida estándar y/o la salida de error de nuestro comando, podemos usar 1>/dev/null y/o 2>/dev/null, o ambos combinados en >/dev/null 2>&1. Por ejemplo: 30 12 * * * /usr/bin/randsig >/dev/null 2>&1

Otra forma de administrar tareas con cron es guardar directamente las tareas a realizar en los directorios /etc/cron.daily, /etc/cron.weekly y /etc/cron.monthly. Esto es válido si tiene una tarea para ejecutar diaria, semanal o mensualmente y quiere independizarla de un usuario en particular (serán ejecutados con permisos de root). Los scripts contenidos en estos directorios se llaman desde /etc/crontab, y se ejecutarán en orden alfabético. Opciones de crontab Veamos algunos parámetros que pueden acompañar al comando crontab:

crontab –l lista el archivo crontab. crontab –e permite editar el crontab, utilizando el editor seteado por defecto (vi) crontab –r borra el archivo crontab. crontab -u usuario permite modificar el crontab del usuario

Los parámetros pueden usarse combinados, por ejemplo:

crontab -u carlos -e editará directamente el crontab del usuario carlos

Nota: Para mayor información, vea las páginas man.



Crontab para los usuarios Si los demás usuarios del sistema necesitan ejecutar acciones, bajo el esquema de tareas programadas, también podrán utilizar crontab. Dada la estructura de permisos de Linux, la posibilidad de que el usuario realice una acción dañina es baja, ya que los comandos invocados por cron identificarán quién (que usuario) los está invocando y Linux delimitará el acceso siguiendo la politica de permisos establecida para ese usuario. Entonces, como usuario ejecutamos:

$ crontab -e Esto busca si tenemos un archivo de crontab, en caso de existir lo abre, y si no, lo crea. Editamos sus contenidos y guardamos los cambios realizados, los cambios surten efecto inmediatamente. De acuerdo a la distribución que Linux que tengamos, el archivo se guarda en diferentes ubicaciones, en el caso de RedHat se ubica en /tmp.

Nota: Sólo el superusuario (root) puede ver y editar los archivos de cron de todos los usuarios, el resto tiene acceso exclusivamente al que le pertenece.

Contol de accesos y uso de crontab Mediante los archivos /etc/cron.allow y /etc/cron.deny, el administrador puede decidir qué usuarios tendrán acceso a crontab. Si no existe un archivo cron.deny, todos los usuarios lo pueden utilizar. Una forma muy sencilla de editarlo es directamente desde la línea de comandos, recordando que esto lo debe realizar root.

# echo ALL >> /etc/cron.deny Esto limita el acceso a TODOS los usuarios, es decir que ningún usuario podrá utilizar crontab. Si un usuario cualquiera tipea:

$ crontab -l Verá como respuesta:

You (usuario) are not allowed to use this program (crontab) See crontab(1) for more information

Nota: Esto es extensivo incluso a root.

Para otorgar permisos, ejecutamos lo siguiente:

# echo usuario >> /etc/cron.allow



Apéndice A

Utilizando vi Introducción En Linux podemos configurar un servidor editando los correspondientes archivos de configuración. Entonces, necesitamos una herramienta para modificarlos; por tal razón vamos a estudiar como funciona el vi, uno de los editores de texto más potentes y más importantes tanto en Linux como en UNIX. Invocando a vi Para abrir el archivo que desea corregir o editar, debemos llamar al programa así:

# vi ejemplo.txt Si el archivo no existiera, de esta forma lo creamos, es decir, se crea un archivo vacío de nombre ejemplo.txt que se encuentra en el directorio donde estoy ubicado.

Nota: si el archivo que nos interesa editar no se encuentra en el directorio donde estamos ubicados, tenga la precaución de nombrar el archivo con su pathname completo.

Si el archivo ejemplo.txt es nuevo, vi nos muestra uno de los mensajes siguientes en la línea de estado (que aparece en la parte inferior de la pantalla) de la terminal (o sesión) para indicar que se está creando y editando un archivo nuevo.

• ejemplo.txt New File • ejemplo.txt No such file or directory. • ejemplo.txt ERROR

Cuando se edita un archivo existente, vi despliega las primeras líneas del archivo y da información del estado de éste en la línea de estado.

Nota: Cuando se le da vi un mandato, es importante distinguir entre letras mayúsculas o minúsculas.

Cómo funciona vi Antes de comenzar a escribir, debemos saber que vi tiene 2 modos de operación: modo comando y modo edición. Para entender el porqué de estos dos modos, veamos un poco de historia. Cuando aparecieron los UNIX, allá por los años ´70, los teclados que tenían las máquinas y/o terminales que se conectaban a servidores no eran como los que utilizamos actualmente, eran más pobres en la cantidad de teclas. No tenían, por ejemplo el teclado medio donde aparecen las teclas Insert, Supr, Inicio, Fin, RePag, etc. Esta situación obligó a utilizar una misma tecla para hacer cosas diferentes y, para hacer la diferencia se pensó en tener modos de operación distintos. Veamos un ejemplo para entenderlo mejor. Si estoy en modo edición, la letra w tiene su significado implícito del alfabeto, cada vez que la tipeo, aparece en el texto que estoy editando. Si estoy en modo comando la letra w adopta el significado de “word” (palabra), me permite realizar acciones referidas a palabras completas y no caracteres individuales, por ejemplo avanzar hasta la siguiente palabra a lo largo del texto. Y si estoy trabajando con comandos globales w también significa “write” (escribir), para guardar los cambios realizados.

Modo comando permite aplicar acciones o comandos sobre el texto. Cuando estamos ubicados en este modo cada pulsación de una tecla (o combinación de teclas) se toma como comando. Algunos comandos nos permiten pasar al modo edición y otros comandos nos permiten navegar (o desplazarnos) por el documento.

Modo edición permite modificar los contenidos el archivo. Para volver al modo edición, utilizamos la tecla Esc.

En ambos modos se trata de interpretar las pulsaciones de teclas, pero en el primero como órdenes y en el segundo como datos de entrada.

Nota: luego de pulsar alguna de las teclas que lo llevan a modo edición vi no emite ninguna señal notoria para indicar que se encuentra en modo edición (salvo las versiones nuevas que muestran “INSERT” en la base de la



pantalla). Si no está seguro de encontrarse en modo edición o comando, pulse un par de veces la tecla Esc y escuchará un aviso (un sonido agudo o “campanita”), esto le confirmará que se encuentra en modo comando.

Desplazarse por el archivo Mientras vi está en modo de comando, puede colocar el cursor encima de cualquier caracter de la pantalla. Nos podemos mover por el archivo que estemos editando de diferentes y prácticas maneras. Dependiendo de la precisión o el rango de desplazamiento deseado, podemos pulsar:

h un carácter a la izquierda j un renglón hacia abajo k un renglón hacia arriba l (ele minúscula) un carácter hacia la derecha 0 (cero) para ir al comienzo de la linea donde estoy ubicado $ ir al final de la linea donde estoy ubicado ctrl.+B una pantalla hacia arriba ctrl.+F una pantalla hacia abajo b una palabra hacia la izquierda B una palabra hacia la izquierda (delimitada por blancos) w una palabra hacia la derecha W una palabra hacia la derecha (delimitada por blancos) Enter principio de siguiente línea ( principio de frase ) fin de frase { principio de párrafo } fin de párrafo }} fin de archivo

Introducir texto Desde el modo comando de vi podemos usar una serie de teclas, para introducir texto en un archivo, dependiendo de donde deseamos ingresarlo, podemos pulsar:

i (de insert) para insertar texto, los caracteres que se encontraban en la posición del cursor se desplazaran hacia la derecha (en las versiones tambien se puede pulsar la tecla Insert)

I igual que i pero desde el principio de la línea a (de append) para insertar texto detrás de la carácter que está en la posición del cursor. A para insertar texto detrás del último carácter de la línea o (de open) abre una nueva línea en blanco debajo de la línea actual e inserta texto en ella O abre una nueva línea en blanco arriba de la línea actual e inserta texto en ellla

Mientras vi se encuentra en modo inserción, puedo utilizar las teclas @, #, ctrl.+H, ctrl.+W y BackSpace para corregir el texto que estoy ingresando. Al terminar de introducir el texto, se oprime la tecla Esc para devolver vi al modo de comando. Borrar texto Para borrar texto, hay que salir del modo edición y ubicarse en modo comando, dependiendo de la cantidad de texto que deseemos borrar, podemos pulsar:

x (equis) para borrar el carácter que se encuentra en la posición del cursos, (los caracteres que se encuentren a la derecha de este, se desplazarán hacia la izquierda)

X para borrar el carácter que se encuentra a la izquierda del cursor. d para borrar más de un carácter, debo indicar con una segunda letra hasta donde deseo

borrar, la segunda letra puede ser una de las siguientes: w desde el cursor hasta el fin de la palabra (inclusive el blanco que la divide de la

próxima palabra) d toda la línea 0 (cero) desde el principio de la línea hasta el cursor $ desde el cursor hasta el fin de la línea G desde el cursor hasta el fin del archivo



Reemplazar texto En caso de necesitar reemplazar texto escrito (para no hacer las acciones de borrar y luego las de insertar), podemos utilizar, desde el modo comando, las siguientes teclas:

r (de replace) reemplaza el carácter donde está ubicado el cursor por el siguiente que tipeemos (y regresa automáticamente al modo comando)

s (de substitute) reemplaza el carácter donde esta ubicado el cursor por los siguientes caracteres que tipeemos (hasta que apretemos Esc para volver al modo comando)

~ cambia de mayúscula a minúscula (y viceversa) la letra sobre la que estemos situados Copiar, Cortar y Pegar texto El mandato yy guarda en el buffer la línea que voy a copiar. Luego me posiciono en el lugar donde deseo hacer la copia y presiono p para pegarla (de paste). Y ahí aparece la línea que guardó en el buffer. Estos mismos pasos se pueden hacer con el comando dd, si lo que deseo hacer es cortar y pegar. Deshacer y Repetir El mandato u (de undo), deshace lo que acaba de hacerse. Ya sea restaurar texto insertado, borrado o cambiado por error. El mandato u sólo arregla el último comando. Si se borra una línea y después se cambia una palabra, el mandato u sólo restaura la palabra cambiada, no la línea borrada. El mandato U restaura la línea actual a la forma en la que estaba antes de empezar a cambiarla, aunque se hayan realizado muchos cambios. El mandato . (punto) vuelve a hacer el último comando realizado. Es más, este último comando se repetirá tantas veces como pulsemos el . (punto). Factor de repetición Para los comandos de borrar, reemplazar, copiar, cortar y pegar texto, podemos especificar la cantidad de veces que deseemos hacer dichos comandos. Esto simplemente se logra anteponiendo un número al comando que deseemos repetir. Por ejemplo: En modo comando, tipear “4x” (primero el ”4“ y después la ”x”) equivale a pulsar 4 veces la letra “x” Búsqueda de una cadena vi buscará por el buffer de trabajo una cadena de texto específica. Para encontrar la siguiente ocurrencia de una cadena (hacia adelante), oprima la tecla barra diagonal (/), digite el texto que se desea localizar (llamado cadena de búsqueda) y presione Enter. Al oprimir la tecla /, se despliega una barra diagonal en la línea de estado y al introducir la cadena de texto, también esta aparecerá desplegada en la línea de estado. Cuando se oprime Enter, vi busca la cadena desde la posición del cursor hacia abajo, hasta el final del archivo; si la encuentra, coloca el cursor sobre el primer caracter de la cadena. Si se utiliza un signo de interrogación (?) en lugar de /, vi busca la existencia de una cadena desde la posición del cursor hacia arriba, hasta el principio del archivo. Las teclas N y n repiten la última búsqueda sin tener que introducir de nuevo la cadena de búsqueda. La tecla n repite de manera exacta la búsqueda original, mientras que N la repite en dirección opuesta. El menú “:” Para acceder al menú de acciones globales, pulsamos el símbolo “:”. Aparecerá un símbolo “:”, seguido del cursor, en la esquina inferior izquierda de la pantalla (la línea de estado), y desde este lugar podremos realizar acciones como:

• Guardar los cambios en el archivo actual w • Guardar los cambios en un nuevo archivo w nuevo_nombre.ext • Salir de vi q • Salir de vi sin guardar los cambios q! • Salir de vi y guardar los cambios en el archivo actual x (equivale a wq!) • Editar un nuevo archivo e otro_archivo.ext • Insertar los contenidos de otro archivo r otro_archivo_mas.ext • Ejecutar un comando en la shell ! comando • Insertar los resultados de un comando r! comando

Nota: Existe un shortcut (comando rápido) para abreviar la salida de vi guardando los cambios realizados, equivalente a tipear “:x” o “:wq!”. Si estamos en modo comando, simplemente tipeamos “ZZ” (sin las comillas y sin necesidad de acceder al menú del símbolo “:”)



Apéndice B

Propuesta de Laboratorio Con los conocimientos adquiridos durante las clases LX3, armar el siguiente escenario:

• una PC alumno con Firewall (iptables) • una PC alumno con WebServer (Apache) • una PC alumno con Samba • una PC alumno con DNS • una PC alumno con DHCP Server • una PC alumno con IP Dinámica • una PC alumno desde windows consulta al servidor Samba

Se desea lograr lo siguiente:

• la PC alumno con IP Dinámica, obtiene su configuracion TCP/IP del Servidor DHCP • la misma PC alumno consulta la pagina web del Web Server (www.corpruebas.com.ar) • el WebServer obtiene los HTML a mostrar de un directorio compartido por el servidor Samba. • entre el WebServer y el Samba debe haber un FireWall que además actua como gateway • armar los HTML desde la máquina Windows y ubicarlos en el Share compartido por Samba • el FireWall no debe admitir paquetes ICMP y solo debe aceptar trafico desde el WebServer



Apéndice C

Preguntas Exámen LPI 1. ¿Qué dos comandos mostrarán el status de procesos en un sistema Linux?

Seleccione uno. a. ls y df b. ps y top c. ps y df d. df y top e. du y df

2. ¿Qué representa el archivo del dispositivo /dev/hdb6?

Seleccione uno. a. Una partición extendida en un SCSI disk drive b. Una partición lógica en un SCSI disk drive c. Una partición extendida en un IDE disk drive d. Una partición primaria en un IDE disk drive e. Una partición lógica en un IDE disk drive

3. ¿Qué comando mostrará las últimas líneas del documento de texto file1?

Seleccione uno. a. head -b file1 b. head --bottom file1 c. head -v file1 d. tail file1 e. tail –n 1 file1

4. Nombre el comando que muestra las páginas del manual on-line del usuario y referencias de comandos 5. En respuesta al comando df, el sistema reporta un uso del 98% para el sistema de archivo montado en

/home. ¿Cuál de los siguientes describe mejor el significado de ésta información?

a. Los archivos en /home están consumiendo 98% del espacio físico del disco b. El archivo read/write activity on /home están consumiendo 98% de la capacidad del sistema I/O c. Los archivos en /home están consumiendo el 98% del sistema de archivos /home d. Inodes on /home are nearly exhausted e. Inodes on /home 98% libre



6. De los siguientes directorios ¿A cuál es más importante realizarle un back up en la base rutinaria?

a. /var b. /tmp c. /usr d. /root e. /etc

7. Carolina tiene un archivo de texto llamado guest_list que contiene 12 líneas. Ella ejecuta el siguiente

comando. $ split -4 guest_list gl ¿Cuál es el resultado? Seleccione uno

a. Las primeras cuatro columnas en el texto son escritas a archivos nuevos glaa, glab, glac and glad

b. Las primeras cuatro columnas en el texto son escritas a archivos nuevos aagl, abgl, acgl and adgl

c. Las líneas guest_list están igualmente divididas entre archivos nuevos glaa, glab, glac and glad

d. Las líneas de guest_list están igualmente divididas entre archivos nuevos glaa, glab and glac

e. Las líneas de guest_list están igualmente divididas entre archivos nuevos aagl, abgl, and acgl

8. ¿Cuál de los siguientes comandos sería el mejor para montar un CD-ROM conteniendo una distribución

Linux, sin depender de ningún archivo de configuración? a. mount /dev/cdrom/dev/hdc b. mount -f linux /dev/hdc/mnt/cdrom c. mount -t iso9660 /dev/cdrom /mnt/cdrom d. mount -t linux /dev/cdrom /mnt/cdrom e. mount -t iso9660 /mnt/cdrom /dev/cdrom

9. El usuario jdoe, un miembro del grupo "finanzas", posee un un archivo de texto con el dueño del grupo

finanzas y modo 0077. ¿Qué declaraciones son verdaderas con respecto al acceso para ver los contenidos del archivo, asumiendo que el directorio que lo contiene tiene el modo 0777? Seleccione las que se apliquen

a. jdoe puede ver los contenidos del archivo b. jdoe puede primero cambiar el modo de protección del archivo y entonces ver los contenidos del

archivo c. root no puede ver los contenidos del archivo d. Todos en el grupo finanzas pueden ver los contenidos del archivo excepto jdoe e. Todos en el grupo finanzas pueden ver los contenidos del archivo incluso jdoe



10. Indique la sintaxis para dirigir la salida estándar de comando1 directamente en la entrada estándar de

comando2. 11. ¿Cuál de las siguientes respuestas crea una variable de ambiente VAR1 presente en el ambiente del proceso

hijo bash? a. VAR1="fail" ; export VAR1 b. VAR1="fail" \ export VAR1 c. VAR1="fail" d. set VAR1= "fail" ; enable VAR1 e. export VAR1 \ VAR1="fail"

12. Nombre la ruta y nombre completos del archivo que contiene la mayoría de la información en el sistema de

grupos de usuarios. 13. ¿Cuál de los siguientes directorios deben ser parte de la raíz del sistema de archivos?

Seleccione todas las que apliquen a. /etc b. /home c. /lib d. /usr e. /root

14. Nombre el servicio que ejecuta comandos independientemente en una base periódica para usuarios múltiples 15. Alex está trabajando actualmnte en un directorio que contiene solo un archivo: Afile1.

¿Qué se muestra luego que los siguientes comandos han entrado en bash? # MYVAR=”ls” ; export MYVAR # echo $MYVAR "$MYVAR" '$MYVAR' `$MYVAR`

a. Afile1 Afile1 Afile1 Afile1 b. ls Afile1 Afile1 Afile1 c. ls ls Afile1 Afile1 d. ls ls $MYVAR Afile1 e. ls ls ls $MYVAR



16. ¿Qué hace el caracter & cuando se lo posiciona al final de un comando?

Seleccione uno a. Permite que otro comando sea incorporado en la misma línea b. Hace que el proceso sea parado c. Reinicia un proceso que ha sido parado d. Hace que el proceso sea puesto en el primero plano e. Hace que el proceso sea puesto en el fondo

17. ¿Qué es el PID (Process ID) de init? Seleccione uno

a. 0 b. 1 c. 2 d. indefinido e. desconocido

18. ¿Cuál de los siguientes comandos resultan del siguiente comando?

# chmod g+s /home/software a. El SUID bit será seteado para /home/software b. El SGID bit será seteado para /home/software, previniendo el acceso a aquellos que no son

miembro del grupo del software c. El SGID bit será seteado para /home/software, en orden de mantener la asociación del grupo del

directorio constante para todos los archivos creados d. El sticky bit será seteado para /home/software e. El sticky bit será aplicado a los archivos en home/software

19. ¿Cuál de los siguientes comandos es equivalente al siguiente comando para el usuario jdoe de quien su

directorio principal es /home/jdoe? # chmod 754 ~/file1

a. # chmod u=rwx,g=rx,o=r /home/jdoe/file1 b. # chmod ugo=rwx ~/file1 c. # chmod u=7, g=5, o=4 ~/file1 d. # chmod 754 \home\jdoe\file1 e. # chmod 754 /usr/jdoe/file1

20. ¿Qué comando y parámetro requerido crea un link simbólico en un sistema de archivo Linux ext2?



21. Un proceso con PID 4077 está causando problemas en su sistema. Como un superuser, usted ingresa el

siguiente comando: # kill 4077 Sin embargo el resultado nada cambia. ¿Qué puede hacer usted para terminar el proceso? Seleccione uno.

a. # kill -9 4077 b. # kill -15 4077 c. # kill +9 4077 d. # kill 4078 e. # kill --die 4077

22. ¿Cuál de las siguientes secuencias es utilizada para poner a un programa en modo de texto no interactivo

que es adjuntado a la terminal en el fondo para permitirle que continúe procesando? a. Ctrl-C b. Ctrl-B c. Ctrl-B y entonces ingresa el comando bg d. Ctrl-Z e. Ctrl-Z y entonces ingresa el comando bg

23. ¿Qué comando básico se usa para crear las particiones del disco duro? 24. ¿Cuál de los siguientes comandos extrae verbalmete los archivos de un archivo tar en un dispositivo de cinta

magnética? a. tar cvf /dev/st0 b. tar cvf /dev/ttys0 c. tar xvf /dev/st0 d. tar xvf /dev/tys0 e. tar rvf/dev/st0

25. ¿Cuál de los siguientes es una declaración exacta en ralación con ésta expresión regular? [^1-8A-Za-z]

a. Matchea todas las letras y números b. Matchea todas las letras y los números excepto el 9 c. Matchea todas las letras y números excepto 9 y 0, pero solamente en el comienzo de una línea d. Matchea los números 9, 0 y los caracteres que no sean letras y que no sean números e. Matchea todos los caracteres con excepción de letras o de números



26. Mónica consulta el achivo /etc/passwd esperando encontrar passwords encriptadas para todos los

usuarios de su sistema. Ella ve lo siguiente: jdoe:x:500:500::/home/jdoe/bin/bash bsmith:x:501:501::/home/bsmith:/bin/cts ¿Cuál de los siguientes es verdadero? Seleccione uno

a. Las cuentas jdoe y bsmith no tienen contraseña b. La cuenta jdoe y bsmith están deshabilitadas c. Las contraseñas están en /etc/passwd- d. Las contraseñas están en /etc/shadow e. Las contraseñas están en /etc/shadow-

27. Nombre la forma más breve del comando para inicial un cambio a runlevel 5. 28. ¿Qué hace el "sticky bit"? Seleccione uno

a. Previene que los archivos sean eliminados por cualquier usuario b. Marca los archivos para ser eliminados c. Evita que los archivos sean eliminados por no-dueños excepto root d. Evita que los archivos sean eliminados por no-dueños incluyendo root e. Marca los archivos para archivar

29. ¿Qué variable contiene una lista de directorios buscados por la shell para encontrar programas

ejecutables? 30. Alex ejecuta el comando runlvel y obtine 3 5 como respuesta.

¿Qué le dice ésto a Alex? a. El sistema está en runlevel 3 y el default es en 5 b. El sistema está en runlevel 3 y después irá a runlevel 5 c. El sistema estaba en runlevel 3 y ahora está en runlevel 5 d. El sistema no tiene default runlevel e. El default runlevel está configurado incorrectamente



31. ¿Cuántos dispositivos IDE pueden ser instalados y usados simultáneamente en un sistema Intel-based

típico? Seleccione uno a. 1 b. 2 c. 3 d. 4 e. 5

32. Considerando las siguiente línea de salida de consola, extractado de otras líneas de salida.

/dev/hda8 1.9G 559M 1.2G 30% /home ¿Cuál de los comandos la produce?

a. du –s b. du –k c. df –h d. df –k e. df –m

33. ¿Cómo puede configurar su sistema al momento de apagarlo para suprimir fsck en el boot siguiente?

Seleccione uno a. init 6 b. init --suppress 6 c. shutdown –h d. shutdown –f e. shutdown –F

34. ¿Cuál de los siguientes es verdadero acerca de cargador boot LILO?

a. Puede iniciar el Windows NT Loader b. Es iniciado usando el comando lilo c. Es el único boot loader disponible para Linux d. Puede empezar múltiples Linux kernels, pero no sistemas operativos foráneos e. Reside entero en el Boot Sector

35. ¿Cuál de las siguientes declaraciones describe correctamente los símbolos > y >> en el contexto de el bash

shell? a. > añade una salida estándar a un archivo existente , y >> escribe una salida estándar a un archivo

nuevo b. > escribe una salida estándar a un nuevo archivo, y >> añade una salida estándar a un archivo

existente c. > escribe un error de estándar a un archivo nuevo, y >> añade un error estándar a un archivo

existente d. > dirige una salida estándar a un archivo nuevo, y >> dirige una salida estándar a un archivo

existente e. > dirige una salida estándar a un archivo existente y >> dirige un error de estándar a un archivo

nuevo



36. ¿Cuántos hosts pueden existir en una subred con máscara de 255.255.255.128?

Seleccione uno a. 512 b. 256 c. 128 d. 127 e. 126

37. Para una red de trabajo de Internet con una sola interface de red, ¿Qué rutas deben ser agregadas a la

interface eth0 después que es iniciada? Seleccine uno a. Ninguna b. Interface c. Interface y Default Gateway d. Interface, Local Network, y Default Gateway

38. En un servidor Linux, ¿qué servicio estará "escuchando" en el puerto 25?

Seleccione uno a. FTP b. SendMail c. Apache d. Samba

39. ¿Cuál de estos protocolos es usado como un servicio de entrega de datagramas por los tres restantes?

a. TCP b. UDP c. IP d. ICMP

40. ¿Qué comando mostrará información sobre la interface Ethernet eth0? Seleccione uno.

a. cat /proc/eth/0 b. ifconfig eth0 c. ipconfig eth0 d. ipconfig /dev/eth0 e. cat/ etc/eth0.conf



41. ¿Cuáles son las dos interrupciones usualmente asociadas a interface serial onboard de una PC? a. 3 b. 4 c. 5 d. 10 e. 12

42. ¿Cuáles de los siguientes comandos causará que módulo cargable sea incluido en el kernel que está

corriendo? a. modinsert b. modprobe c. insmod d. prbmod e. rmmod

43. ¿Cómo pude usted preguntar la base de datos RPM para una lista de todos los paquetes RPM instalados?

Seleccione uno. a. rpm –q b. rpm –qa c. rpm –a d. rpm –al

44. ¿Cuál de las siguientes e s una entrada válida en /etc/fstab para un NFS remoto montado desde un

servidor fs1? Selecciones uno a. fs1:/proc /mnt/fs1 nfs defaults 9 9 b. /mnt/fs1 fs1:/proc nfs defaults 0 0 c. fs1:/home /mnt/fs1 nfs defaults 0 0 d. /mnt/fs1 fs1: home nfs defaults 0 0 e. /home:fs1 /mnt/fs1 nfs defaults 0 0

45. ¿Qué protocolo de red es usado por Telnet y FTP? Seleccione uno

a. ICMP b. UDP c. TCP d. DHCP e. PPP



46. Desde el punto de vista del usuario, ¿Qué respuesta describe mejor la apariencia de un directorio NFS

montado? Seleccione uno a. Un nuevo dispositivo en /dev b. Un nuevo volumen local tuvo acceso con una letra del volumen, por ejemplo D: c. Un nuevo volumen local tuvo acceso con el nombre del servidor NFS d. Parte del sistema de archivos local, tuvo acceso usando pathnames ordinarios e. Parte del sistema de archivos de los servidores NFS, han tenido acceso usando el nombre del

servidor NFS 47. ¿Qué sucede cuando rpm es lanzado de la siguiente manera?

rpm -Uvh file a. El archivo RPM será verificado b. Un paquete instalado se puede mejorar con la versión en el archivo, con la salida detallada c. Un paquete instalado se puede mejorar con la versión en el archivo, con la salida detallada y

marcas índice indicando el progreso d. Un error ocurrirá porque un modo mayor no está especificado e. Un error ocurrirá porque no se especificó ningunas opciones del archivo

48. ¿Cómo se hacen los cambios a la BIOS? Seleccione uno.

a. Usando linuxconf. b. Editando manualmente archivos de texto c. Usando el comando LILO d. Durante el inicio de la PC, usando menús específicos del sistema e. Durante el inicio de la PC, usando comandos de LILO

49. ¿Qué demonio resuelve nombres de dominio a direcciones IP para peticiones de los hosts? 50. Considerando el siguiente extracto del archivo /etc/resolv.conf de una estación de trabajo Linux:

nameserver 127.0.0.1 nameserver 192.168.105 nameserver 192.168.250.2 ¿Qué se puede decir sobre ésta configuración? Seleccione uno

a. Dos servidores DNS en la red pública se están utilizando para la resolución de nombres. b. Un servidor DNS en la red local se está utilizando para la resolución de nombres. c. La configuración contiene los errores que evitarán que funcione la resolucion d. Un servidor de solo cache esta en ejecución e. La biblioteca del resolver consultará primero el nameserver 192.168.250.2



51. Nombre el archivo que contiene mappings simples entre la dirección IP y los nombres de sistemas. 52. Cuando se usa xdm, ¿Cuál de los siguientes archivos puede ser usado para empezar un administrador de

ventanas? a. Xservers b. Xaccess c. Xdm-config d. Xsession e. Xsetup_0

53. ¿Cuál de los siguientes representa una secuencia un comando válido para compilar e instalar un uevo

kernel? Seleccione uno a. make_modules install; make bzImage; make clean; make dep b. make dep; make clean; make bzImage; make config; make modules; make modules_install c. make config; make dep; make clean; make bzImage; make modules; make modules_install d. make config; make bzImage; make dep; make clean; make modules; make modules_install e. make dep; make clean; make bzimage; make modules; make modules_install; make config

54. ¿Qué programa mostrará una lista de cada salto a través de la red a un destino específico? Seleccione uno

a. tracert b. rttrace c. traceroute d. routetrace e. init

55. ¿Cuál de los siguientes no es el nombre de un archivo de configuración de Apache? Seleccione uno

a. httpd.conf b. html.conf c. srm.conf d. access.conf



Respuestas Exámen LPI 1. B. Los comandos ps y top, rinden estado de procesos. Ninguno de los otros comandos listados están

relacionados. 2. E. Las acciones del disco IDE son referidas a como /dev/hdx, donde x es a, b, c ó d. Las particiones

están numeradas del 1 al 4 para las particiones primarias y extendidas, y del 5 al 16 para particiones lógicas. 3. D. El comando tail es usado para chequear las últimas líneas del archivo de texto. Por defecto,

muestra diez líneas. 4. El comando man muestra páginas del manual on-line de usuario. 5. C. El comando df reporta información del disco, incluyendo porcentaje de los sistemas de archivos

usados. El comando df lista la información para las particiones. 6. E. /var y /tmp son principalmente transitorios, /usr es típicamente estático, /root es simplemente

un directorio home para root, pero /etc contiene información de sistema de configuración que frecuentemente cambia.

7. D. "split -n file outfile" separa un archivo en archivos de salidas múltiples, cada uno con n

líneas y los nombran outfileaa, outfileab, y asi. Como el archivo original tiene 12 líneas y Carolyn las dividió en sets de 4 líneas, el resultado es 3 archivos llamados glaa, glab y glac, cada uno conteniendo 4 líneas.

8. C. Los CD-ROM usan los sistemas de archivos iso9660, el cual es el defecto del montaje, pero

también indica el uso de -t. Sin la asistencia de una entrada en /etc/fstab, los dos dispositivos de montaje (/dev/cdrom) y el punto de montaje (/mnt/cdrom) deben ser proveídos.

9. B y D. Sin el privilegio del usuario al archivo, jdoe no puede ver los contenidos. Sin embargo, como

dueño del archivo, el modo puede ser cambiado para ganar acceso. A todos en finance se le da permiso, pero a jdoe como dueño se le es negado.

10. comando1 | comando2 11. A. La variable deben ser establecidas y exportadas. El punto y coma separa los dos comandos. 12. /etc/group 13. A y C. /etc, /lib, /sbin, y /dev deben estar en el sistema de archivos / (raiz). 14. cron 15. D. El primer argumento de echo no es citado y así retorna su contenido: ls.

El segundo es citado con comillas dobles, el cual no preserva el $, entonces éste también retorna: ls. El tercero es citado con comillas simples, las cuales no preservan el $, asi que retorna: $MYVAR. El último argumento es con comillas de ejecución, lo cual significa que retorna el resultado del comando almacenado en $MYVAR. El comando es ls, el cual muestra el único archivo en el directorio: Afile1.

16. E. Usando el carácter & pone al programa en ejecución en segundo plano (BackGround). 17. B. init, siempre tiene PID 1, ya que es el primer proceso que inicia después que el kernel es cargado

en memoria. 18. C. La g indica que estamos operando sobre los permisos de en un grupo, y la +s indica quedeberíamos

agregar el bit "set id", lo cual significa que la característica SGID será aplicada. 19. A. El modo 700 es el mismo que u=rwx, el modo 050 es el mismo que g=rx, y el modo 004 es el

mismo que o=r. La sintáxis “~/” implica el directorio home del usuario.



20. ls –s 21. A. 22. E. El Ctrl-Z para el trabajo y le devuelve el control a la terminal. Y bg reinicia el trabajo y lo ubica el

background. 23. fdisk 24. C. tar debe ser usada con la opción de extración: x y un dispositivo de cinta, como una cinta SCSI con

nombre de dispositivo /dev/st0. 25. Los corchetes se usan para agrupar caracteres que consisten en números del 1 al 8, y caracteres A-Z y a-

z. El ^ justo dentro de la corcheta que abre niega toda la secuencia, tales que la secuencia matchea los números 0, 9, y los símbolos

26. D. El sistema de password shadow ha sido implmentado, ubicando todas las contraseñas en

/etc/shadow como es denotado por la x siguiente al nombre de usuario. 27. init 1 28. C. El sticky bit es un modo que previene la eliminación por los no-dueños, pero root puede eliminarlo

de todas formas. 29. PATH 30. C. El comando runlevel produce el runlevel anterior y el presente 31. D. Las PCs tienen generalmente dos interfaces IDE, cada uno capaz de manejar dos dispositivos 32. C. el modificador –h produce una salida “human readable” 33. D. El modificador -f configura el sistema de archivo para saltearse el chequeo de fsck. La opción -F,

fuerza a realizar el chequeo 34. A. LILO puede iniciar el Boot-Loader de Windows NT y muchos otros sistemas operativos. 35. B. El caracter > crea y escribe a un archivo nuevo, mientras que >> agrega a un archive existente, a

menos que ese archivo no existe, en cuyo caso lo crea previamente. 36. E. Con el bit más alto del último byte puesto en la máscara de la subnet (.128), nos quedan 7 bits. 2**7

es 128, menos la dirección de la red y la dirección de propagación (BroadCast), dejando 126 direcciones para los hosts.

37. D. Las rutas a la interface y a la red requieren intercambir información en el LAN local. Para actuar

como como una red de trabajo de Internet (p.ej., usando Netscape) también es necesario un Default Gateway.

38. B. Como se define en /etc/services, el puerto 25 es el puerto SMTP, monitoreado frecuentemente

por sendmail o algún otro servidor de e-mail. 39. C. IP es el protocolo de datagrama subyacente 40. B. El comando ifconfig es usado para configurar y mostrar información de la interface. El comando

ipconfig es una utilidad de Windows. 41. A y B.



42. B y C. 43. B. El modo query (pregunta) es requerido, lo cual implica -q. La opción -a en modo query produce

todos los paquetes. 44. C. La respuesta A intenta montar el sistema de archivo /proc. Las respuestas B, D, y E tienen la sintaxis

incorrecta. 45. C. Telnet y FTP son ambas conexiones orientadas y usan TCP para conexiones confiables. 46. D. Los directorios NFS montados se funden al sistema de archivo local, si requerir una sintaxis especial

para acceder. 47. C. Suponiendo que ese archivo es un archivo RPM, -U indica que debería ocurrir upgrade. -h activa

marcas hash. 48. Linux no tiene control sobre los seteos de la BIOS 49. named. El demonio DNS es named. Está incluído en un paquete llamado BIND. 50. D. La presencia de la dirección de localhost 127.0.0.1 indica que named está corriendo. Como el

sistema es una red de trabajo, se puede asumir que no está serviendo DNS a una red más amplia. 51. /etc/hosts 52. D. Xsession es archivo de inicio de aplicaciones establecido por default para todo el sistema. 53. C. La respuesta A es incorrecta porque instala módulos antes de compilarlos. Las respuestas B y E son

equivocadas porque construyen el kernel después de configurar. La respuesta D está al revés 54. C. tracert es una utilidad del Windows con la misma función que traceroute. 55. B. Apache usa httpd.conf, srm.conf y access.conf. Algunas implementaciones pueden poner

todos estos archivos en un solo httpd.conf



Esta publicación no puede ser reproducida, ni en todo ni en parte, ni registrada en o transmitida por un sistema de recuperación de información, en ninguna forma ni por ningún medio, sea mecánico, fotoquímico, electrónico, magnético, electroóptico o cualquier otro, sin el permiso previo y por escrito de Premiere IT S.R.L.

Registro de Obras Publicadas (Derecho de Autor): Expediente Número: 278087

linux original courseware - lx1, lx2 y lx3

Documents

para archivos

archivos y directorios

para directorios

archivos filesystems

archivos normales files

atributo sgid

atributo suid