Manual de CRUX

Versión 2.0

Copyright (c) 2001, 2002, 2003, 2004 Per Liden

2004-06-01

Este manual cubre la instalación, configuración y administración de

CRUX.
Se debe tomar en cuenta que este documento sólo trata temas
específicos
referentes a la distribución CRUX. Se puede encontrar más información
sobre
Linux en el Proyecto de Documentación de Linux (Linux Documentation
Project).

En esta traducción al Español se han mantenido los conceptos

originales en
Inglés cuando se ha considerado que resultarían confusos si se
tradujeran.
Por lo demás, el vocabulario de uso cotidiano en la informática
aparece en
Español (instalar, actualizar, etc.)

-------------------------------------------------------------------------
--

Contenido

Prefacio

1. Introducción

1.1. ¿Qué es CRUX?

1.2. ¿Por qué usar CRUX?

1.3. Licencia

1.3.1. Paquetes

1.3.2. Scripts de Build

1.3.3. NINGUNA GARANTÍA

2. Instalando CRUX

2.1. Hardware soportado

2.2. Instalar desde CD-ROM

2.3. Actualizar desde CD-ROM

2.4. Métodos alternativos de Instalación

 2.4.1. Preparar una Imagen de Arranque propia

2.4.2. Instalación por medio de una Red

3. El Sistema de Paquetes

3.1. Introducción

3.2. Usando el Sistema de Paquetes

3.2.1. Instalar un Paquete

3.2.2. Actualizar un Paquete

3.2.3. Desinstalar un Paquete

3.2.4. Consultar la Base de Datos de Paquetes

3.3. Creando Paquetes

3.4. Reglas sobre Paquetes

3.4.1. Información General

3.4.2. Directorios

3.4.3. Removiendo Archivos innecesarios

3.4.4. Pkgfile

4. El Sistema de Puertos

4.1. Introducción

4.1.1. ¿Qué es un Puerto?

4.1.2. ¿Qué es el Sistema de Puertos?

4.2. Usando el Sistema de Puertos

4.2.1. Sincronizar la Estructura Local de Puertos

4.2.2. Presentar un Listado de los Puertos Locales

4.2.3. Presentar un Listado de las Diferencias de

Versiones

4.2.4. Construir e Instalar Paquetes

5. Configuración

5.1. Scripts de Inicio

5.1.1. Runlevels (Niveles de Inicio)

5.1.2. Organización de los Scripts

 5.1.3. Variables de Configuración en /etc/rc.conf

5.1.4. Configuración de la Red

5.2. Contraseñas

5.3. Actualizando el Kernel

6. Preguntas Frecuentes

6.1. Información General

6.2. Instalación

6.3. Configuración

Prefacio

Per Liden escribió originalmente este manual. Robert McMeekin lo

convirtió al
DocBook. Muchos otros han comentado sobre él y han sugerido mejoras.

Capítulo 1. Introducción

1.1. ¿Qué es CRUX?

CRUX es una distrubución ligera de Linux que ha sido optimizada para

la
arquitectura i686 y se ha creado especialmente para el usuario
experimentado.
El objetivo principal de esta distribución es "hacer todo más simple",
lo
cual se ve reflejado en un sistema sencillo de paquetes tar.gz,
Scripts de
inicio estilo BSD y una colección relativamente pequeña de paquetes
ordenados. Otro objetivo es la utilización de nuevas funciones de
Linux y
herramientas y librerías actuales. CRUX también cuenta con un sistema
de
puertos que facilita la instalación y actualización de aplicaciones.

1.2. ¿Por qué usar CRUX?

En estos días se encuentran muchas distrubuciones pequeñas de Linux,

entonces, ¿qué diferencia ésta de cualquier otra? Bueno, básicamente
se
trata de una cuestión de gustos. Yo le puedo dar mi punto de vista en
materia de gustos y es posible que compartamos los mismos o no. En
primer
lugar, yo deseaba crear una distribución en la que predominara la
búsqueda
de la simplicidad de principio a fin. Además deseaba tener programas
actualizados que fueran estables, no la última versión en etapa de
prueba.
Quería también que el instalar paquetes nuevos y actualizar antiguos
no
 fuera complicado (actualizar un paquete en CRUX se logra simplemente
con el
comando pkgmk -d -u). Los paquetes tenían que estar optimizados para
mi
procesador (como con -march=i686). Por otra parte, no quería tener el
sistema de archivos atiborrado de ficheros que nunca usaba (tal como
en
/usr/doc/*, etc.) Si necesito información sobre un programa
específico, más
allá de lo que se puede encontrar en las páginas man, lo busco en
Internet.
Por último, deseaba utilizar las nuevas posibilidades que ofrecen los
Kernels recientes de Linux (tales como devfs, reiserfs, ext3fs, etc.)

Si usted uno de esos usuarios experimentados de Linux que buscan una

distribución sólida y organizada para su sistema, prefieren trabajar
con los
archivos de configuración con un editor de consola en lugar de uno de
interfaz gráfica y no se quejan por tener que bajar y compilar los
programas
por sí mismos, puede ser entonces que esta distribución le resulte
interesante y llene sus expectativas.

1.3. Licencia

1.3.1. Paquetes

CRUX es una distribución de Linux, por tanto contiene software

desarrollado
por muchos programadores diversos. Cada paquete es regulado por la
licencia
escogida a gusto del autor o de los autores. Para saber qué licencia
trae un
programa en particular se puede revisar el código fuente.

1.3.2. Scripts de Build

Todos los scripts de build para los paquetes en CRUX (aquellos en las
categorías de paquetes base y opt) se encuentran bajo los derechos de
autor (c) 2000-2005 por Per Liden y se regulan por la licencia GNU
General
Public License.

1.3.3. NINGUNA GARANTÍA

CRUX se distribuye esperando que sea de utilidad, pero SIN GARANTÍAS

de
ningún tipo, sin siquiera las garantías de MERCADERÍA o APLICACIÓN
PARA UN
PROPÓSITO PARTICULAR. Úselo BAJO SU PROPIO RIESGO.

Capítulo 2. Instalando CRUX

2.1. Hardware soportado

 Los paquetes en la imagen ISO oficial se han compilado con
optimización para
procesadores i686 (Pentium-Pro/Celeron/Pentium-II o mayores). No
intente
instalarlos sobre la arquitectura i586 (Pentium, AMD K6/K6-II/K6-III)
o
procesadores menores porque no funcionaría. Para instalar CRUX sobre
un
sistema i586 necesita bajar la versión i586 de la imagen ISO de CRUX.

El Kernel que se usa durante la instalación, por ejemplo cuando se

corre
la imagen ISO de CRUX (El Torito), fue compilado con los siguientes
controladores de disco y soporte de USB:

+------------------------------------------------------------------------
+
| Subsistema| Controladores incluídos en el Kernel de arranque
|
|-----------
+------------------------------------------------------------|
| IDE | Chipset genérico PCI IDE
|
|-----------
+------------------------------------------------------------|
| SATA | ServerWorks Frodo/Apple K2, Intel PIIX/ICH, Promise,
|
| | Silicon Image, VIA, VITESSE VSC-7174
|
|-----------
+------------------------------------------------------------|
| | 7000FASST, ACARD, Adaptec AACRAID, Adaptec AIC7xxx,
|
| SCSI | Adaptec AIC79xx U320, AdvanSys, Always IN2000, AMI
|
| | MegaRAID, BusLogic, Compaq Fibre Channel,
NCR5380/53c400, |
| | IBM ServeRAID, SYM53C8XX, Tekram DC390(T) and
Am53/79C974 |
|-----------
+------------------------------------------------------------|
| | Sistema de archivos para dispositivos USB, soporte para
|
| | EHCI HCD (USB 2.0), soporte para UHCI (Intel PIIX4, VIA,
|
| USB | etc.), soporte para OHCI (Compaq, iMacs, OPTi, SiS, ALi,
|
| | etc.), soporte para dispositivos de Almacenamiento
Masivo |
| | USB, soporte para Dispositivos de Interfaz Humana (HID
|
| | completo), soporte para la capa de entrada (input layer)
|
| | de HID
|
+------------------------------------------------------------------------
+

Para poder instalar CRUX su controlador de disco debe aparecer en la

lista
de arriba. Si su hardware no es soportado o tiene otros problemas
instalando CRUX, puede encontrar ayuda en la sección 2.4 "Métodos
alternativos de Instalación".

2.2. Instalando desde CD-ROM

1. Descargue la imagen ISO de CRUX (crux-2.0.iso). Para asegurarse

que la
descarga se realizó de forma exitosa puede revisar el checksum
usando
md5sum.

$ md5sum crux-2.0.iso

Compare la salida con el archivo crux-2.0.md5sum, el cual puede

ser
encontrado en el mismo directorio que el de la imagen ISO el la
página
donde la bajó. Si los checksums coinciden, la descarga fue
satisfactoria y puede a continuación "quemar" la imagen en un CD.

2. La imagen ISO puede autoejecutarse (arrancar): sólo inserte el CD

que
acaba de crear y reinicie el equipo. Presione Enter (Entrar) en el
Símbolo del Sistema (boot prompt).

3. Inicie sesión como root (no requiere contraseña).

4. Si es necesario, cree y formatee la partición (o las particiones)

donde se instalará CRUX.

$ fdisk /dev/discs/disc?/disc
$ mkreiserfs /dev/discs/disc?/part?
$ mkswap /dev/discs/disc?/part?

La cantidad de espacio en disco dependerá de cuántos paquetes

desee
instalar. Le recomendaría dejar por lo menos 1GB para la partición
root (directorio raíz). CRUX necesita de 200MB a 500MB dependiendo
de su configuración.

Se le recomienda usar ReiserFS, aunque cuenta también con soporte

para
Ext2fs/Ext3fs, XFS y JFS. Además, sería bastante importante
separar los
datos del sistema de los datos de usuario, como al usar una
partición
para /home (y /var si así lo desea) ya que eso le facilitará las
tareas
de actualización, instalación y desinstalación del sistema.
 [Nota] Nota
Asegúrese que la opción de Antivirus del BIOS se encuentre
DESACTIVADA, de otro modo pueden surgir problemas al
intentar
crear las nuevas particiones en el disco mediante fdisk.

5. Monte la partición sobre la cual desea instalar esta distribución.

$ mount /dev/discs/disc?/part? /mnt

Si desea que la instalación abarque más de una partición, monte

también
esas particiones. Por ejemplo, si quisiera tener particiones
diferentes
para /home y para /var, digite entonces:

$ mkdir /mnt/var
$ mount /dev/discs/disc?/part? /mnt/var

6. Active su partición swap (archivo de intercambio)

$ swapon /dev/discs/disc?/part?

7. Introduzca setup para inicializar el script de instalación. El

Script
le preguntará dónde montó la nueva partición root y qué paquetes
desea
instalar. Sólo seleccione los paquetes que quisiera instalar; nada
más
se copiará al disco. Sin embargo le recomendaría que instale los
paquetes que aparecen marcados como base.

Una vez que se hayan instalado los paquetes que seleccionó, el

Script
de instalación mostrará un historial (log). Asegúrese que en la
última
línea aparezca "0 error(s)".

Si más adelante desea instalar paquetes adicionales puede montar

el CD
de CRUX y ejecutar pkgadd.

[Nota] Nota
Durante la instalación de paquetes no se realiza un chequeo
de
dependencias. Esto quiere decir que usted es el que decide
si,
por ejemplo, debe seleccionar el paquete db para poder
instalar
sendmail.

Pantallas de la instalación
 8. Ahora deberá compilar el Kernel y hacer algunas tareas básicas de
configuración. Para la complilación del Kernel necesita ejecutar
"chroot" en la nueva instalación de CRUX.

$ mount -t devfs devfs /mnt/dev

$ mount -t proc proc /mnt/proc
$ chroot /mnt /bin/bash

9. Establezca la contraseña del usuario root.

$ passwd

10. Edite /etc/fstab para configurar sus sistemas de archivos. Puede

utilizar los editores vim and pico.

11. Edite /etc/rc.conf para configurar las fuentes, el teclado, la

zona
horaria y los servicions. Consulte la sección 5.1.3 "Variables de
Configuración en /etc/rc.conf" para detalles sobre el archivo
/etc/rc.conf.

12. Edite /etc/rc.d/net, /etc/hosts y /etc/resolv.conf para la

configuración de la red (dirección ip/puerta de acceso/nombre de
host/
dominio/dns).

13. Diríjase a /usr/src/linux-2.6.6, configure y compile un Kernel

nuevo.

$ cd /usr/src/linux-2.6.6
$ make menuconfig
$ make all
$ make modules_install
$ cp arch/i386/boot/bzImage /vmlinuz
$ cp System.map /

Tome en cuenta que debe activar las siguientes opciones en el

Kernel:

Code maturity level options --->

[*] Prompt for development and/or incomplete code/drivers

File systems --->

Pseudo filesystems --->
[*] /dev file system support
[*] Automatically mount at boot

14. Edite /etc/lilo.conf para poder arrancar el Kernel que acaba de

compilar y ejecute lilo para que el nuevo sistema pueda arrancar.

15. Remueva el CD-ROM de CRUX de la unidad y reinicie desde el disco

duro.

2.3. Actualizar desde CD-ROM

Para versiones de CRUX 1.3 (o menores) no hay soporte para la

 actualización. Se recomienda especialmente instalar "desde cero" la
versión 2.0 del CRUX.

2.4. Métodos alternativos de Instalación

2.4.1. Preparar una Imagen de Arranque propia

Si no le es posible instalar CRUX desde CD-ROM porque su hardware no

es
soportado por el Kernel de Arranque, puede crear el propio y añadir
cualquier
soporte de hardware que desee. Para crear un Kernel de Arranque
necesita
un disquette (floppy) de 1.44MB, el acceso a otro sistema Linux y la
imagen
ISO de CRUX "quemada" en un CD. Además debe contar con conocimientos
básicos
acerca de cómo se configura y compila el Kernel de Linux.

1. Construya un nuevo Kernel con el soporte para su hardware. Utilice

la
configuración del Kernel provista por el Kernel de Arranque para
comenzar.
Si el Kernel llega a ocupar mucho espacio puede ser más seguro si
remueve
los controladores de SCSI y USB (a menos que los necesite, claro
está),
pero no debe deshabilitar las opciones para soporte de los
sistemas
de archivos.

2. Descargue las herramientas de creación del floppy de arranque y

"desempáquelas".

3. Diríjase al directorio mkbootfloppy y ejecute el Script

mkbootfloppy
(como usuario root). Este Script requiere un argumento: la imagen
de Kernel
que desee utilizar en lugar de la imagen del floppy. Antes de que
realice
esta operación, tome en cuenta que no debe tener nada montado sobre
/mnt, ya
que el Script mkbootfloppy lo usa como punto de montaje.

$ cd mkbootfloppy
$ ./mkbootfloppy /path/to/linux/kernel/arch/i386/boot/bzImage
1440+0 records in
1440+0 records out
mke2fs 1.27 (8-Mar-2002)
Added CRUX *

4. Guarde el archivo resultante boot.img en un disquette (floppy)

$ dd if=boot.img of=/dev/fd0
 5. Inserte tanto el disquette como el CD de CRUX en el sistema en el
que
desee instalar CRUX y reinicie el equipo.

6. Instale CRUX.

2.4.2. Instalación por medio de una Red

Si no tiene un quemador de CD a su disposición o si no le es posible

arrancar
el CD-ROM de CRUX o si por otra razón no puede instalar CRUX de la
manera
normal (Sección 2.2, "Instalar desde CD-ROM"), tal vez le interese
revisar la
guía de Martin Opel "CRUX Network Setup Guide" (Guía de Instalación de
CRUX
mediante una Red) o el "HOWTO install CRUX via NFS" (CÓMO instalar
CRUX por
medio de NFS) de Juergen Daubert.

Capítulo 3. El Sistema de Paquetes

3.1. Introducción

El sistema de paquetes se desarrolló enfocado en la simplicidad, en

cuanto
todos los paquetes son sencillos archivos tar.gz (por ejemplo sin
datos
ajenos a este tipo de archivos).
Los paquetes siguen esta convención (regla o norma) para nombres
<nombre>#<versión>-<sub-versión>.pkg.tar.gz, donde <nombre> es el
nombre del
programa, <versión> es su número de versión y <sub-versión> se refiere
al
número de versión del paquete. Se utiliza la extensión pkg.tar.gz (en
lugar
de tar.gz y nada más) para indicar que se no se está trabajando con
cualquier
archivo tar-gz, sino que se trata de un tar.gz que se debe instalar
usando
pkgadd. De este modo se pueden diferenciar los paquetes de otros
archivos
tar.gz.

pkgadd(8), pkgrm(8), pkginfo(8), y pkgmk(8) son las utilidades de

administración de paquetes. Con estas herramientas se puede instalar,
desinstalar, inspeccionar y producir paquetes, además de que se puede
consultar
la base de datos de paquetes.

Al instalar un paquete con pkgadd, se genera un nuevo registro que se

añade a la
base de datos de paquetes (ubicada en /var/lib/pkg/db). El sistema de
paquetes
no tiene ningún método para revisar las dependencias, así que no le
dará una
advertencia si requiere un cierto paquete para instalar otro.
 A continuación se presenta una descripción breve sobre el uso de las
utilidades
de paquetes. Se puede encontrar información adicional sobre las
herramientas en
las páginas man respectivas.

3.2. Usando el Sistema de Paquetes

3.2.1. Instalar un Paquete

Se puede instalar un paquete mediante el comando pkgadd. Esta utilidad

necesita
como mínimo un argumento: el paquete que desee instalar. Ejemplo:

$ pkgadd bash#2.05-1.pkg.tar.gz

Durante la instalación de un paquete la herramienta realizará un

chequeo para
corroborar que no se sobreescriban archivos. Si se presentan
conflictos aparecerá
un mensaje de error y pkgadd cancelará la instalación del paquete. Los
mensajes de
error incluyen los nombres de los archivos con los que se tiene
problemas.

$ pkgadd bash#2.05-1.pkg.tar.gz
bin/sh
usr/man/man1/sh.1.gz
pkgadd error: listed file(s) already installed (use -f to ignore and
overwrite)

Para forzar la instalación y sobreescribir el archivo que presenta

conflictos puede
utilizar la opción -f (o --force). Ejemplo:

$ pkgadd -f bash#2.05-1.pkg.tar.gz

En el sistema de paquetes un archivo únicamente puede encontrarse en

un sólo paquete.
Cuando se instala de forma forzada, el permiso de "propiedad" del
archivo que entre
en conflicto se traspasa al paquete que se esté instalando. Es posible
que varios
paquetes sean "dueños" de un directorio.

[Advertencia] Advertencia
No es una buena idea proceder con una instalación forzada
a menos que
sepa muy bien lo que está haciendo. Si se producen
conflictos entre
un paquete que se esté instalando y archivos ya
instalados, puede ser
una señal de que el paquete se encuentra dañado y copia
archivos de
 forma inesperada. Utilice esta opción com mucho cuidado:
es preferible
que no la use del todo.

Como se indicó anteriormente, los paquetes no incluyen datos extra

(información sobre
el paquete, por ejemplo). De hecho, el administrador de paquetes se
basa en el nombre
de archivo del paquete para determinar el nombre del paquete y la
versión. Así, si
está instalando un paquete llamado bash#2.05-1.pkg.tar.gz, el
administrador de
paquetes lo interpretará como un paquete llamado bash en versión 2.05-
1. Si pkgadd
falla en leer el nombre de archivo (en el caso, por ejemplo, que
faltara el signo #)
se mostrará un mensaje de error y pkgadd cancelará el proceso sin
instalar el paquete.

3.2.2. Actualizar un Paquete

Para actualizar un paquete se utiliza el pkgadd con la opción -u.

Ejemplo:

$ pkgadd -u bash#2.05-1.pkg.tar.gz

De este modo, se reemplazará el paquete de bash que se haya instalado

antes por el
nuevo. Si bash no había sido instalado en el pasado, pkgadd mostrará
un mensaje de
error. Por otra parte, el sistema de paquetes no presentará problemas
a causa de las
versiones, ya que puede "actualizar" la versión 2.05-1 con la versión
2.04-1 (incluso
con la misma versión 2.05-1). El paquete ya instalado será reemplazado
por el paquete
que se desee instalar.

Actualizar un paquete equivale a correr pkgrm y a continuación pkgadd

con una (gran)
excepción. Si se actualiza un paquete (usando pkgadd -u) puede evitar
que algunos de
los archivos ya instalados sean reemplazados. Este detalle muchas
veces resulta util
si desea conservar los archivos de configuración y los de registro
(log).

Al ejecutar pkgadd el archivo /etc/pkgadd.conf es leído. Este archivo

contiene las
reglas que describen de qué modo debe funcionar pkgadd cuando se
realizan
actualizaciones. Una regla consiste en 3 fragmentos: evento, patrón y
acción. El
evento se refiere a los tipos de situaciones en los que aplica la
regla. Por el
 momento sólo se puede utilizar un tipo de evento que es el de UPGRADE
(actualizar).
El patrón es un patrón de nombre de archivo que se presenta mediante
expresiones
regulares; la acción que se puede aplicar al evento UPGRADE puede ser
YES (sí) o NO
(no). Si se permite, es posible agregar más de una regla con el mismo
tipo de evento.
Es ese caso, la primera regla tendría la menor prioridad y la última
tendría la
mayor prioridad. Ejemplo:

#
# /etc/pkgadd.conf: pkgadd(8) configuration
#

UPGRADE ^etc/.*$ NO
UPGRADE ^var/log/.*$ NO
UPGRADE ^etc/X11/.*$ YES
UPGRADE ^etc/X11/XF86Config$ NO

# End of file

De acuerdo con el ejemplo, pkgadd nunca tendría que actualizar nada en

/etc on en
/var/log (inclusive en subdirectorios), a excepción de /etc/X11/ (y
subdirectorios),
a menos que se trate del archivo /etc/X11/XF86Config. La regla por
defecto implica
una actualización completa; las reglas en este archivo son excepciones
a esa norma.

[Nota] Nota
Un patrón nunca debe incluir "/" al principio, ya que se está
refiriendo a
los archivos en el paquete, no a los del disco duro.

En el caso en que pkgadd detecte que un determinado archivo no debe

ser actualizado,
se instalará en la carpeta /var/lib/pkg/rejected/. Los archivos en ese
directorio
no se agregan en ningún momento a la base de datos de paquetes. Así,
el usuario
tiene la libertad de examinar y de instalar o eliminar ese archivo de
forma manual.
Otra opción es la de utilizar rejmerge. La aplicación rejmerge puede
mostrar las
diferencias entre el archivo instalado y el que se encuentre
"rechazado" en
/var/lib/pkg/rejected/. De este modo, el usuario tiene la oportunidad
de elegir
entre dejar la versión del archivo instalado intacta, actualizar al
archivo
"rechazado" o una mezcla de esas opciones. Ejemplo (usando el archivo
/etc/pkgadd.conf del ejemplo anterior):
 $ pkgadd -u bash#2.05-1.pkg.tar.gz
pkgadd: rejecting etc/profile, keeping existing version
$ ls /var/lib/pkg/rejected/
etc/
$ ls /var/lib/pkg/rejected/etc/
profile

3.2.3. Desinstalar un paquete

Para desinstalar un paquete se usa la herramienta pkgrm. Esta utilidad

necesita
un argumento: el nombre del paquete que desee remover. Ejemplo:

$ pkgrm bash

[Advertencia] Advertencia
Este comando eliminará todos los archivos que
pertenezcan al paquete
sin ninguna petición de confirmación (sin preguntar
nada). Tenga mucho
cuidado al realizar este procedimiento y asegúrese de que
escribió
correctamente el nombre del paquete: puede presentarse el
caso de que
desinstale algo que no quería (por ejemplo, considere
sobre lo que
sucedería si digita glib en lugar de glibc).

3.2.4. Consultar la Base de Datos de Paquetes

Se puede consultar la base de datos de paquetes mediante el comando

pkginfo. Esta
utilidad utiliza algunas opciones para brindar información dependiendo
de la consulta.

+------------------------------------------------------------------------
---+
| Opción | Descripción
|
|----------------------------
+----------------------------------------------|
| -i, --installed | Proporciona un listado de los paquetes
|
| | instalados y sus versiones
|
|----------------------------
+----------------------------------------------|
| -l, --list paquete|archivo | Presenta una lista de los archivos que
|
| | pertenezcan al paquete que se indique o
los |
| | que contienen el archivo
|
|----------------------------
+----------------------------------------------|
 | -o, --owner archivo | Lista los propietarios del archivo
|

+------------------------------------------------------------------------
---+

Ejemplos:

$ pkginfo -i
audiofile 0.2.3-1
autoconf 2.52-1
automake 1.5-1
<...>
xmms 1.2.7-1
zip 2.3-1
zlib 1.1.4-1

$ pkginfo -l bash
bin/
bin/bash
bin/sh
etc/
etc/profile
usr/
usr/man/
usr/man/man1/
usr/man/man1/bash.1.gz
usr/man/man1/sh.1.gz

$ pkginfo -l grep#2.5-1.pkg.tar.gz
usr/
usr/bin/
usr/bin/egrep
usr/bin/fgrep
usr/bin/grep
usr/man/
usr/man/man1/
usr/man/man1/egrep.1.gz
usr/man/man1/fgrep.1.gz
usr/man/man1/grep.1.gz

$ pkginfo -o bin/ls
e2fsprogs usr/bin/lsattr
fileutils bin/ls
modutils sbin/lsmod

3.3. Crear paquetes

Para crear paquetes se usa la herramienta pkgmk. Esta aplicación

utiliza un
archivo llamado Pkgfile, en el cual está contenida la información
sobre el
paquete (tal como nombre, versión, etc.) y los comandos necesarios
para
compilar el paquete. De hecho, para ser más específicos, el archivo
Pkgfile
 es un Script de bash(1), el cual incluye una cantidad de variables
(nombre,
versión, sub-versión y fuente del paquete), además de una función
(build).
A continuación se presenta un ejemplo de cómo luce el archivo Pkgfile.
En
el ejemplo se muestra la forma de empaquetar el programa grep(1). Se
agregaron también comentarios para una mayor comprensión.

# Especificar el nombre del paquete.

name=grep

# Especificar la versión del paquete.

version=2.4.2

# Especificar la sub-versión del paquete.

release=1

# La fuente de donde proceden los archivos para producir el paquete.

source=(ftp://ftp.ibiblio.org/pub/gnu/$name/$name-$version.tar.gz)

# La función build() descrita más abajo se llamará pkgmk una vez que
los
# archivos de código fuente que se indican hayan sido desempacados.

build() {
# Lo primero que se hace es ir al directorio base.
cd $name-$version

# Se ejecuta el Script de configuración con los argumentos

deseados.
# En este caso grep se copiará a /usr/bin y el soporte para el
# lenguaje nacional será desabilitado.
./configure --prefix=/usr --disable-nls

# Compilar.
make

# Se instalarán los archivos, pero no se copiarán a /usr. Por el

# contrario, todos los archivos serán redirigidos a $PKG/usr según
como se
# definió la variable DESTDIR. La variable $PKG se refiere a un
directorio
# temporal que, en su momento, se convertirá en un archivo tar.gz.
Se debe
# tomar en cuenta que, por ejemplo, la variable DESTDIR no es
utilizada por
# todos los archivos Makefiles, algunos usan prefijo, otros usan
ROOT, etc.
# En este caso se debe inspeccionar el Makefile en cuestión para
averiguar
# más. Incluso algunos Makefile no permiten de ningún modo la
redirección.
# En estos casos es necesario crear el parche correspondiente.
make DESTDIR=$PKG install
 # Se eliminarán los archivos innecesarios: en este caso las páginas
de info.
rm -rf $PKG/usr/info
}

No es necesario incluir todos los comentarios, por lo que el Pkgfile

para
grep(1) se ve en realidad así:

# $Id: package.xml,v 1.4 2004/05/20 22:57:20 per Exp $

# Maintainer: Per Liden <per@fukt.bth.se>

name=grep
version=2.4.2
release=1
source=(ftp://ftp.ibiblio.org/pub/gnu/$name/$name-$version.tar.gz)

build() {
cd $name-$version
./configure --prefix=/usr --disable-nls
make
make DESTDIR=$PKG install
rm -rf $PKG/usr/info
}

[Nota] Nota
La función de build() que se acaba de explicar se utilizó
sólamente
como ejemplo de cómo se construye grep. Los comandos de esa
función
pueden variar en forma significativa dependiendo de la
aplicación que
desee instalar, ya que, por ejemplo, puede no utilizar autoconf.

Cuando se haya ejecutado la función build(), el directorio $PKG será

transformado al paquete llamado <nombre>#<versión>-<sub-
versión>.pkg.tar.gz.
Para que el paquete esté listo, pkgmk deberá comparar el contenido del
paquete con el archivo .footprint. Si el archivo no existe, se crea y
no se
realiza la prueba. En el archivo .footprint aparecerá la lista de
todos los
archivos que deberían estar integrados en el paquete si la instalación
se
cumplió satisfactoriamente o, de otro modo, la lista de todos los
archivos
que fueron instalados en $PKG (en el caso en que .footprint no
existiera de
antemano). Si se encuentra una diferencia entre el paquete y el
archivo, se
detiene la prueba y se muestra un mensaje de error. No se debe crear
el
archivo .footprint en forma manual. Por otra parte, si se ha
actualizado un
paquete y se debe actualizar el archivo .footprint, se utiliza
simplemente
el comando pkgmk -uf. De este modo, se comprueba que el proceso para
 construir el paquete de nuevo se llevó a cabo como estaba previsto.

Si el paquete se construyó sin errores, se puede instalar y probar. Es

muy
recomendable que se consulten los archivos Pkgfile de otros paquetes,
ya que
los ejemplos son una buena ayuda para aprender.

3.4. Reglas sobre Paquetes

3.4.1. Información General

o El nombre de un paquete siempre se debe escribir en minúscula (por

ejemplo name=eterm y no name=Eterm). En el caso en que el paquete
se
añada al sistema de puertos de CRUX, el nombre exacto debe ser
utilizado
para el nombre del directorio en la estructura de puertos, como en
/usr/ports/???/eterm.

o No se deben integrar varias aplicaciones o librerías en un sólo

paquete.
En ese caso se deben generar paquetes separados.

3.4.2. Directorios

o En general los paquetes deben instalarse en los siguientes

directorios.
Siempre se pueden aceptar excepciones bien justificadas. De otro
modo,
se debe seguir esta estructura lo más fielmente posible.

+--------------------------------------------------------------------+
| Directorio | Descripción
|
|--------------------
+-----------------------------------------------|
| /usr/bin/ | Archivos binarios de aplicaciones y
comandos |
|--------------------
+-----------------------------------------------|
| /usr/sbin/ | Archivos binarios del sistema (como
Daemons) |
|--------------------
+-----------------------------------------------|
| /usr/lib/ | Librerías
|
|--------------------
+-----------------------------------------------|
| /usr/include/ | Archivos Header
|
|--------------------
+-----------------------------------------------|
| /usr/lib/<prog>/ | Plug-ins, addons, etc
|
 |--------------------
+-----------------------------------------------|
| /usr/man/ | Páginas de manual (man)
|
|--------------------
+-----------------------------------------------|
| /usr/share/<prog>/ | Archivos de datos
|
|--------------------
+-----------------------------------------------|
| /usr/etc/<prog>/ | Archivos de configuración
|
|--------------------
+-----------------------------------------------|
| /etc/ | Archivos de configuración para programas
del |
| | sistema (por ejemplo Daemons, etc.)
|

+--------------------------------------------------------------------+

o Los directorios /usr/X11R6 y /usr/???/X11 quedan reservados

exclusivamente para X11. Los programas de X que no sean
distribuidos en
X11 deben ser instalados en /usr y no en /usr/X11R6 or
/usr/???/X11.

o El directorio /opt se utiliza para aplicaciones que se compilen o

instalen a mano. Los paquetes nunca deben copiar nada allí.

o CRUX no usa /usr/libexec/, así que los paquetes no deben instalar

nada
en esa carpeta. Se debe utilizar /usr/lib/<prog>/.

3.4.3. Removiendo Archivos innecesarios

o Los paquetes no debe incluir "archivos innecesarios". Entre ellos

se
encuentran las páginas de info y otro tipo de documentación, a
menos
que se trate de las páginas de man (por ejemplo usr/doc/*, README,
*.info, *.html, etc).

o En el caso de los archivos relacionados con el NLS (national

language
support; soporte para lenguages nacionales) se debe utilizar
--disable-nls si se encuentra disponible.

o No se debe incluir archivos binarios obsoletos (tales como

/usr/games/banner o /sbin/mkfs.minix).

3.4.4. Pkgfile

o No se debe agregar nuevas variables al archivo Pkgfile. Sólo en

muy pocos
casos pueden mejorar la comprensión o la calidad de los paquetes.
 Además, las únicas variables que se podrán utilizar en versiones
futuras
de pkgmk son name (nombre), version (versión), release (sub-
versión) y
source (fuente). Puede ocurrir que otras variables entren en
conflicto con
variables internas de pkgmk.

o Se debe utilizar las variables $name y $version para facilitar las

labores
de actualización y mantenimiento del paquete. Por ejemplo,
source=(http://xyz.org/$name-$version.tar.gz) se considera más
conveniente
que source=(http://xyz.org/myprog-1.0.3.tar.gz), ya que la
dirección URL
se actualizará automáticamente a modificar la variable $version.

o Se debe tomar en cuenta que la variable source es un array

(arreglo), así
que siempre se debe digitar source=(...) en lugar de source=...

Chapter 4. El Sistema de Puertos

4.1. Introducción

4.1.1. Qué es un Puerto?

El Puerto se refiere a un directorio que contiene los archivos que

sean
necesarios para construir un paquete utilizando pkgmk. De este modo,
en este
directorio se encuentran, por lo menos, los archivos Pkgfile (en los
cuales
se describe la forma de construir los paquetes) y .footprint (que se
usa
para corroborar versiones e incluye una lista de archivos que deberían
integrar el paquete después de que haya sido construido). Por otra
parte,
en un directorio de Puerto se pueden ofrecer parches u otros archivos
que
se requieran para construir el paquete. Se debe tomar en cuenta que el
código fuente de las aplicaciones de los paquetes no se encuentra
necesariamente en el directorio de Puertos. Por el contrario, los
archivos
Pkgfile incluyen las direcciones de Internet donde se puede descargar
el
código fuente.

El concepto de "Puerto" en este sentido se incorporó del sistema BSD,

en
cuanto un "Puerto" se refiere a los programas que hayan sido
reescritos
para que puedan correr bajo cierta arquitectura de procesador. El
vocablo
tiende a ser un tanto confuso, ya que la mayoría de aplicaciones no
deben
 ser reescritas, o sea que no se debe crear "Puertos", para que puedan
ser
ejecutadas en CRUX (o en Linux en general).

4.1.2. Qué es el Sistema de Puertos?

El sistema de Puertos está relacionado con un repositorio ("almacén")

CVS
que contiene los Puertos y un programa cliente que permita descargar
Puertos
de ese repositorio CVS. En CRUX se utiliza la herramienta ports(8)
para
"bajar" los Puertos y guardarlos en /usr/ports/. Otra utilidad,
CVSup(1), se
encarga de realizar la sincronización y descarga respectivas.

4.2. Usando el Sistema de Puertos

4.2.1. Sincronizar la Estructura Local de Puertos

Al instalar CRUX por primera vez, la estructura local de Puertos (que

se
localiza en /usr/ports/) se encuentra vacía. Se utiliza la herramienta
de
Puertos con la opción -u para actualizar la estructura local de
Puertos.
Ejemplo:

$ ports -u

El argumento -u quiere decir "actualizar", lo cual se logra al

contactar
el repositorio CVS de Puertos y descargar los Puertos más nuevos. La
respuesta del programa puede lucir como esto:

Connected to cvsup.fukt.bth.se
Updating collection base/cvs
...
Updating collection opt/cvs
...
Finished successfully

La salida del programa informa sobre los archivos que hayan sido
descargados,
actualizados y eliminados.

4.2.2. Presentar un listado de los Puertos Locales

Después de actualizar la estructura local de Puertos, el directorio

/usr/ports/
incluirá dos categorías, base y opt. Se pueden encontrar Puertos
dentro de esos
directorios. Es sólo cuestión de explorar la estructura de carpetas
para
determinar los Puertos que se encuentran disponibles.
 $ cd /usr/ports/base/
$ ls
autoconf/ filesystem/ man/ sh-utils/
automake/ fileutils/ man-pages/ shadow/
bash/ findutils/ modutils/ sysklogd/
bin86/ flex/ nasm/ sysvinit/
binutils/ gawk/ ncurses/ tar/
bison/ gcc/ net-tools/ tcp_wrappers/
bsdinit/ glibc/ netkit-base/ tcsh/
bzip2/ grep/ patch/ textutils/
cpio/ groff/ perl/ time/
db/ gzip/ pkgutils/ traceroute/
dcron/ kbd/ procps/ util-linux/
devfsd/ less/ psmisc/ vim/
diffutils/ libtool/ readline/ wget/
e2fsprogs/ lilo/ reiserfsprogs/ which/
ed/ m4/ sed/ zlib/
file/ make/ sendmail/

También es posible utilizar ports con el argumento -l para desplegar

una lista
de todos los Puertos locales. Ejemplo:

$ ports -l
base/autoconf
base/automake
base/bash
base/bin86
base/binutils
base/bison
...

Cuando se esté buscando un paquete específico, es recomendable

utilizar este
método (como por ejemplo ports -l | grep sendmail) para corroborar si
el
paquete se encuentra disponible, y, si es el caso, determinar a qué
categoría
pertenece.

4.2.3. Presentar un Listado de las Diferencias de Versiones

Para averiguar si hay una estructura de Puertos cuya versión

(probablemente
más nueva) difiera de la que ya se encuentra instalada en el sistema
se
puede utilizar la opción -d. En el caso en que las versiones no sean
las
mismas, se podría recibir una salida de este tipo por parte del
programa:

$ ports -d
Collection Name Port Installed
base glibc 2.3.2-2 2.3.3-1
opt gtk 2.2.0-1 2.4.0-1
 Si, por el contrario, no se encontraron diferencias entre las
versiones, como
por ejemplo cuando la estructura local de Puertos se encuentra
actualizada al
día, sólo se presentará una respuesta como la siguiente:

$ ports -d
No differences found

4.2.4. Construir e Instalar Paquetes

Una vez que se haya encontrado el Puerto por agregar al sistema, sólo
se tiene
que accesar el directorio que contiene el Puerto y ejecutar pkgmk para
construirlo. Ejemplo:

$ cd /usr/ports/base/sendmail
$ pkgmk -d

Con el argumento -d se le da la orden al programa para que baje los

archivos
fuente que se requieran, según lo que se haya definido en el archivo
Pkgfile
(si el código fuente se ha descargado por completo y no se necesita
otro
archivo, el sistema ignora esta opción). Al terminar de "bajar" el
archivo
se inicia la construcción del paquete. Si el paquete ha sido
construído de
forma exitosa es posible ejecutar pkgadd para instalarlo o
actualizarlo.
Ejemplo.

$ pkgadd sendmail#8.11.6-2.pkg.tar.gz

Para facilitar estas tareas de administración, se incluyen las

opciones -i
(para instalar) y -u (para actualizar), mediante las cuales se
fusionan los
comandos. Ejemplo:

$ pkgmk -d -i

or

$ pkgmk -d -u

De este modo se descargará el código fuente, se compilará y se

instalará o
actualizará de acuerdo con lo que se desee. Se debe prestar atención
al
hecho de que el paquete sólo se instalará o se actualizará si su
construcción se realiza de forma satisfactoria.

Capítulo 5. Configuración
5.1. Scripts de Inicio

5.1.1. (Runlevels) Niveles de Inicio

A continuación se presentan los niveles de inicio que se utilizan en

CRUX
(definidos en /etc/inittab).

+----------------------------+-------------------------+
| Runlevel (Nivel de inicio) | Descripción |
|----------------------------+-------------------------|
| 0 | Apagar |
|----------------------------+-------------------------|
| 1 (S) | Modo de un sólo usuario |
|----------------------------+-------------------------|
| 2 | Modo multiusuario |
|----------------------------+-------------------------|
| 3-5 | (No se usan) |
|----------------------------+-------------------------|
| 6 | Reiniciar |
+------------------------------------------------------+

5.1.2. Organización de los Scripts

Los Scripts de inicio en CRUX se basan en el estilo de BSD (en lugar

del
estilo SysV) y se organizaron de la forma que se describe a
continuación:

+-----------------------------------------------------------------------+
| Archivo | Descripción
|
|------------------
+----------------------------------------------------|
| /etc/rc | Script de arranque del sistema
|
|------------------
+----------------------------------------------------|
| /etc/rc.single | Script de inicio en modo de un sólo usuario
|
|------------------
+----------------------------------------------------|
| /etc/rc.modules | Script de inicialización de módulos
|
|------------------
+----------------------------------------------------|
| /etc/rc.multi | Script de inicio en modo multiusuario
|
|------------------
+----------------------------------------------------|
| /etc/rc.local | Script local de inicio en modo multiusuario
(vacío |
| | por defecto)
|
|------------------
+----------------------------------------------------|
 | /etc/rc.shutdown | Script para apagar el sistema
|
|------------------
+----------------------------------------------------|
| /etc/rc.conf | Configuración del sistema
|
|------------------
+----------------------------------------------------|
| /etc/rc.d/ | Script para iniciar o detener servicios
|

+-----------------------------------------------------------------------+

Se deben modificar los archivos /etc/rc.modules, /etc/rc.local y

/etc/rc.conf dependiendo de las necesidades.

5.1.3. Variables de configuración en /etc/rc.conf

En el archivo /etc/rc.conf se pueden encontrar las siguientes

variables de
configuración:

+------------------------------------------------------------------------
+
| Variable | Descripción
|
|----------
+-------------------------------------------------------------|
| | Especifica la fuente para la consola que debe ser cargada
|
| | al inicio. El valor de la variable se pasa como argumento
a |
| | setfont(1). Las fuentes disponibles se encuentran en
|
| FONT | /usr/share/kbd/consolefonts/.
|
| |
|
| | Ejemplo: FONT=default
|
|----------
+-------------------------------------------------------------|
| | Especifica la distribución para el teclado que debe ser
|
| | activada al inicio. El contenido de esta variable se usa
|
| KEYMAP | como argumento en loadkeys(1). Las distribuciones para el
|
| | teclado se encuentran en /usr/share/kbd/keymaps/.
|
| |
|
| | Ejemplo: KEYMAP=sv-latin1
|
 |----------
+-------------------------------------------------------------|
| | Especifica la zona horaria que el sistema utilizará. Los
|
| | archivos correspondientes a las zonas horarias
disponibles |
| TIMEZONE | se encuentran en /usr/share/zoneinfo/.
|
| |
|
| | Ejemplo: TIMEZONE=Europe/Stockholm
|
|----------
+-------------------------------------------------------------|
| | Especifica el hostname (nombre de la máquina).
|
| HOSTNAME |
|
| | Ejemplo: HOSTNAME=pluto
|
|----------
+-------------------------------------------------------------|
| | Especifica los servicios que se iniciarán con el sistema.
|
| | Los servicios que se agregen en este array (arreglo)
deben |
| | tener una contraparte como Scripts para iniciar o detener
|
| | en /etc/rc.d/. Al iniciar en modo multiusuario, los
Scripts |
| | que se especifiquen serán invocados en el orden en el que
|
| SERVICES | se hayan definido con el argumento start. Cuando el
sistema |
| | se cierra o cuando se pasa al modo de un sólo usuario,
|
| | estos Scripts se invocan en forma inversa con el argumento
|
| | stop.
|
| |
|
| | Ejemplo: SERVICES=(crond identd sshd sendmail)
|

+------------------------------------------------------------------------
+

5.1.4. Configuración de la Red

El archivo de configuración de la red se puede encontrar en el Script

de
servicio /etc/rc.d/net. Para activarlo, se debe agregar net al array
SERVICES en el archivo /etc/rc.conf. Por defecto sólo se configura el
dispositivo "lo", por lo que si se deseea configurar otros (como eth0,
eth1, etc) se debe ejecutar los comandos ifconfig(8) y route(8).
Ejemplo:

#!/bin/sh
#
# /etc/rc.d/net: start/stop network
#

case $1 in
start)
/sbin/ifconfig lo 127.0.0.1
/sbin/ifconfig eth0 195.38.1.140 netmask 255.255.255.224
/sbin/ifconfig eth1 192.168.0.1 netmask 255.255.255.0
/sbin/route add default gw 195.38.1.129
;;
stop)
/sbin/ifconfig eth1 down
/sbin/ifconfig eth0 down
/sbin/ifconfig lo down
;;
restart)
$0 stop
$0 start
;;
*)
echo "usage: $0 [start|stop|restart]"
;;
esac

# End of file

Si el sistema debe ser detectado como un cliente DHCP, se utiliza el

comando dhcpcd(8) (en lugar de ifconfig(8). Ejemplo

#!/bin/sh
#
# /etc/rc.d/net: start/stop network
#

case $1 in
start)
/sbin/ifconfig lo 127.0.0.1
/sbin/dhcpcd eth0 [add additional options if needed]
;;
stop)
killall -q /sbin/dhcpcd
/sbin/ifconfig lo down
;;
restart)
$0 stop
$0 start
;;
*)
echo "usage: $0 [start|stop|restart]"
;;
esac

# End of file
5.2. Contraseñas

CRUX, por defecto, utiliza contraseñas MD5SUM. Es posible, sin

embargo,
regresar al sistema tradicional de contraseñas DES. Debe tomarse en
consideración que las contraseñas DES son menos seguras. Para cambiar
la forma en que se manejan las claves en el sistema, o sea desactivar
MD5SUM, se debe cambiar la variable MD5_CRYPT_ENAB en /etc/login.defs
al
valor "no".

Además, al compilar programas que utilicen la función crypt(3) para

realizar el proceso de autentificación de los usuarios, se debe
corroborar que esas aplicaciones hayan pasado por link usando la
librería
libcrypt (por ejemplo, agregue -lcrypt cuando haga el linking). Esta
librería incluye la versión MD5SUM de la función crypt (esta versión
es
compatible con versiones anteriores y puede trabajar también con
contraseñas DES).

5.3. Actualizando el Kernel

El código fuente del Kernel que se encuentra en /usr/src/linux-2.6.6/

no
se instala por medio de pkgadd. En caso de que opte por actualizar el
Kernel, puede realizar el proceso de forma segura al reemplazar el
código fuente del Kernel con una nueva versión (o al guardarlo en otro
directorio). De ningún modo se producirá una inconsistencia en la base
de datos de los Paquetes (ya que el Kernel no se instala con pkgadd)
ni
tampoco se llegará a modificar los Headers del Kernel que se localizan
en
/usr/include/linux y /usr/include/asm porque no existen symlinks
(vínculos simbólicos) al código fuente del Kernel, aunque sí incluyen
copias de los Headers.

Capítulo 6. Preguntas Frecuentes

6.1. Información general

1. ¿Por qué se usó el nombre "CRUX"?

Lo siento, pero no detrás del nombre no hay ninguna historia en

especial.
Sencillamente lo escogí porque suena bien, es corto y contiene una
X, lo
cual lo hace un poco más sencillo de recordar, como en el estilo
de
UNIX/Linux ;)

2. ¿Cuándo lanzarán la nueva versión?

Se puede decir que la respuesta fácil es "cuando esté lista". Las

nuevas
 versiones aparecen cada 3 o 4 meses. Los paquetes actualizados se
agregan
al sistema de Puertos aún si no ha salido una nueva versión.

3. ¿Cómo se llama la distribución: Linux CRUX o GNU/Linux CRUX?

Ninguna de las anteriores. El nombre es, ni más ni menos que CRUX.

4. Oí rumores de que CRUX se basaba en Slackware, ¿es eso cierto?

Eso que dicen no es cierto. CRUX se creó partiendo desde cero y

nunca se
ha basado en otra distribución de Linux.

6.2. Instalación

1. ¿Puede funcionar CRUX en AMD K6/K6-II/K6-III?

Sí, y no. AMD K6, K6-II y K6-III tienen un conjunto de

instrucciones que
es compatible con i586 (Pentium). Los paquetes de la versión
oficial de
CRUX son compilados usando la opción -march=i686. Esto quiere
decir que
CRUX requiere una arquitectura de procesador con un conjunto de
instrucciones que sea compatible con i686 (tal como
Intel PPro/Celeron/PII/PIII/P4 or AMD K7/Athlon). Aún así, Juergen
Daubert se encarga de mantener una versión i586 de la imagen de
disco ISO
de CRUX, la cual se puede encontrar aquí. La versión i586 de la
imagen
de disco ISO de CRUX puede funcionar sobre AMD K6/K6-II/K6-III.

2. Al arrancar con el CD-ROM de CRUX aparece un mensaje de Kernel

Panic que
dice "VFS: Unable to mount root fs". ¿Qué pasó?

Esta situación puede presentarse si posee más de una unidad de CD-

ROM.
Asegúrese de que está arrancando desde la "primera" unidad, tal
como
/dev/cdroms/cdrom0. Es posible arrancar desde otra unidad (por
ejemplo
una que no sea la primera), pero para ello necesita digitar
CRUX root=/dev/cdroms/cdrom1 en el símbolo del sistema (Boot
Prompt) al
arrancar (cdrom1 se refiere a la segunda unidad, cdrom2 a la
tercera,
etc.)

3. Cuando arranco CRUX por primera vez aparece el error "Unable to

open
initial console". ¿Qué sucedió?
 Es muy probable que no se haya activado devfs o no se le haya
ordenado
al Kernel montat devfs cuando el sistema arranca. Las
instrucciones
de instalación (Sección 2.2, "Instalando desde CD-ROM") indican
cómo
se debe activar.

4. Al iniciar CRUX por primera vez, el sistema me pide una

contraseña,
aún cuando en las instrucciones de instalación aparece que el
inicio
de sesión como root no requiere clave. ¿Qué salió mal?

Puede ser que no se haya editado el archivo /mnt/etc/fstab antes

de
reiniciar el sistema o que se haya ingresado un nombre incorrecto
para la partición en el simbolo del sistema (Boot Prompt) al
arrancar.

6.3. Configuración

1. ¿Por qué no se guardan los cambios a los archivos en /dev para la

próxima vez que se inicia el sistema?

CRUX utiliza devfs, el cuales es un sistema de archivos virtual en

la memoria RAM. Las modificaciones realizadas a los archivos en
/dev
se pierden cuando se apaga el equipo. Sin embargo se pueden
recuperar
mediante devfsd(8) la próxima vez que se inicia el sistema. Es
necesario editar el archivo /etc/devfsd.conf de acuerdo a las
configuraciones que se requieran. En la página de manual devfsd(8)
se
describe la utilidad con más detenimiento. Ejemplo:

#
# /etc/devfsd.conf: devfsd(8) configuration
#

REGISTER .* MKOLDCOMPAT
UNREGISTER .* RMOLDCOMPAT

LOOKUP .* MODLOAD

REGISTER ^sound/.* PERMISSIONS root.users 660

REGISTER ^v4l/.* PERMISSIONS root.users 660

# End of file

2. ¿Cómo puedo hacer que sshd se ejecute?

Se debe editar /etc/hosts.deny y, en caso necesario,

/ets/hosts.allow,
para así indicar los Hosts que son aceptados y los que son
rechazados.
 Para permitir que cualquiera se conecte al sistema se puede
agregar
sshd: ALL al archivo /etc/hosts.allow. En la página de manual
hosts_access(5) se explica con más detalle el formato de archivo.
Una
vez que se haya realizado ese paso, se puede iniciar sshd al
ejecutar
/etc/rc.d/sshd start o al modificar /etc/rc.conf y agregar sshd al
Array (arreglo), tal como en SERVICES=(... sshd ...). Esto
significa
que sshd se activará la próxima vez que se inicie el sistema.

3. Mozilla colapsa o no puede ejecutarse. ¿Qué fue lo que pasó?

Mozilla tiende a ser muy "quisquilloso" cuando no encuentra

archivos
fonts.cache-1. Si Mozilla sencillamente no corre (ya sea a causa
de una
violación de segmentación o simplemente cuando termine sin mostrar
mensajes de error) se debe tomar en cuenta que pueden faltar
archivos
de caché de fuentes (font cache). Para crear o actualizar archivos
de
caché de fuentes, se ejecuta fc-cache (como root o superusuario).
Se
puede consultar más detalles sobre esta aplicación en la página de
manual fc-cache(1).

4. Aparece un error que dice: "ports: no driver(s) installed", al

intentar
actualizar los Puertos. ¿A qué se debe eso?

Es posible que no se haya instalado el paquete opt/cvsup. Este

paquete
se puede localizar en la imagen de disco ISO de CRUX (dentro del
directorio /crux/opt/).