Manual de Rembo 2.0 - ForPAS Sevilla

Traduccin al Espaol realizada por:
(en orden alfabtico)
Sergio Baos Calvo (elrothbaco@hotmail.com)

Gerardo Barea Prez (braxstorm@hotmail.com)
Esteban Reche Barea (e_reche@hotmail.com)
Macarena Titos Gonzlez (macatitos@hotmail.com)
Jos Antonio Toribio Daz (jatoribio@terra.es)
Jorge Torres Chacn (axelstone@hotmail.com)
Escuela Tcnica Superior de Ingenieros en Informtica

Universidad de Sevilla
Viernes, 15 de Febrero de 2002
NDICE
NDICE..........................................................................................................................2
MANUAL DE ADMINISTRACIN DEL SERVIDOR .....................................................9
CAPTULO 1: Instalacin del servidor REMBO .....................................................................10
1.1.- Conceptos y requisitos ..............................................................................................10
1.1.1.- Cmo funciona?..............................................................................................10
1.1.2.- Requisitos del Servidor .....................................................................................10
1.1.2.1.- Servidor DHCP .........................................................................................10
1.1.2.2.- Servidor REMBO ......................................................................................11
1.2.- Configuracin del servidor DHCP .............................................................................11
1.2.1.- Servidor DHCP y REMBO en equipos diferentes.............................................11
1.2.2.- Servidor DHCP y REMBO en el mismo equipo ................................................11
1.2.2.1.- Aadiendo la opcin 60 al servidor DHCP de WinNT 4 ...........................11
1.2.2.2.- Aadiendo la opcin 60 al servidor DHCP de Win2000 ...........................12
1.2.2.3.- Aadiendo la opcin 60 a un host con servidor ISC
DHCP ..........12
1.2.3.- Aadiendo REMBO a una infraestructura con Boot Discovery existente.........12
1.3.- Instalacin de REMBO en Windows NT / 2000 ........................................................12
1.3.1.- Instalacin .........................................................................................................13
1.3.2.- Configuracin mnima .......................................................................................13
1.3.3.- Comprobando la configuracin .........................................................................13
1.3.4.- Solucin de problemas con el servicio NT........................................................13
1.4.- Instalacin de REMBO en Unix.................................................................................14
1.4.1.- Instalacin .........................................................................................................14
1.4.3.- Instalando los ficheros del servidor...................................................................15
1.4.4.- Comprobando la configuracin .........................................................................15
1.4.5.- Opciones de lnea de comandos del servidor REMBO ....................................16
1.5.- Solucin de problemas..............................................................................................16
1.5.1.- Rom de arranque PXE no detectada ................................................................16
1.5.1.1.- Descripcin del problema .........................................................................16
1.5.1.2.- Resolucin del problema ..........................................................................16
1.5.2.- En el arranque aparece DHCP... y un mensaje de error ..................................17
1.5.3.- En el arranque aparece MTFTP... y un mensaje de error ................................18
CAPTULO 2: Configuracin del servidor REMBO ................................................................19
2.1.- Conceptos .................................................................................................................19
2.1.1.- Configuracin basada en ficheros vs basada en registro.................................19
2.1.2.- Organizacin de parmetros.............................................................................20
2.2.- Parmetros Globales ................................................................................................21

2.2.1.- Parmetros relativos al PXE .............................................................................21
2.2.2.- Parmetros especficos de REMBO .................................................................23
2.2.3.- Parmetros de configuracin relacionados con la tolerancia a fallos...............23
2.3.- Dominios de autentificacin ......................................................................................24
2.4.-Tneles TCP ..............................................................................................................25
2.5.- Grupos de servidor (Host groups).............................................................................26
2.5.1.- El grupo por defecto (default) ...........................................................................26
CAPTULO 3 : Herramientas administrativas del servidor REMBO .......................................28
3.1.- Netclnt .......................................................................................................................28
3.1.1.- NetClnt Interactivo............................................................................................28
3.1.1.1.- Primer paso: conexin con el servidor REMBO .......................................28
3.1.1.2.- Segundo paso: comprobacin de la conexin..........................................28
3.1.1.3.- Tercer paso: experimentando con la conexin.........................................28
3.1.2.- Usando NetClnt en modo batch........................................................................29
3.1.3.- Comandos de NetClnt.......................................................................................29
3.2.- Consola del servidor .................................................................................................31
3.2.1.- Introduccin.......................................................................................................31
3.2.2.- La interfaz .........................................................................................................31
3.2.3.- Aadir un servidor .............................................................................................31
3.2.3.1.- Servidor local ............................................................................................32
3.2.3.2.- Servidor remoto NT...................................................................................32
3.2.3.3.- Servidor remoto sin NT .............................................................................32
3.2.4.- Estado del servidor ...........................................................................................32
3.2.5.- Arrancando el servidor .....................................................................................32
3.2.6.- Parando el servidor ..........................................................................................33
3.2.7.- Recargando la configuracin del servidor .......................................................33
3.2.8.- Modificacin de los parmetros ........................................................................33
3.2.9.- Modificacin de las variables ............................................................................33
3.2.10.- Ver los ficheros de log ...................................................................................34
3.2.11.- Acceso a los ficheros del servidor ..................................................................34
3.2.12.- Preguntas ms frecuentes ..............................................................................34
CAPTULO 4 : Despliegue de REMBO en la empresa ..........................................................35
4.1.- Tolerancia a fallos .....................................................................................................35
4.1.1.- Tolerancia a fallos a nivel DHCP ......................................................................35
4.1.2.- Tolerancia a fallos a nivel REMBO ...................................................................36
4.2.- Front-end de la distribucin.......................................................................................37
MANUAL DE ADMINISTRACIN DEL CLIENTE ......................................................39

CAPTULO 1 : Conceptos sobre REMBO ..............................................................................40
1.1.- Qu es Rembo? ......................................................................................................40
1.2.- Cmo trabaja ?.......................................................................................................40
1.3.- Requisitos para el sistema cliente.............................................................................41
CAPTULO 2: Comenzando a usar REMBO ..........................................................................42

2.1.- Arrancando Rembo por primera vez .........................................................................42
2.1.1.- Cambiar la pgina de comienzo .......................................................................42
2.1.2.- Mostrar la consola Rembo ................................................................................42
2.2.- Experimentando con los scripts de Rembo ..............................................................43
2.2.1.- Arrancar el evaluador interactivo ......................................................................43
2.2.2.- Funciones bsicas ............................................................................................43
2.2.3.- Funciones de disco ...........................................................................................43
CPITULO 3 : Trabajando con REMBO ................................................................................44
3.1.- Acceso a ficheros mediante REMBO........................................................................44
3.2.- Protocolos de red ......................................................................................................44
3.2.1.- Protocolo NETfs ................................................................................................45
3.2.2.- Protocolo MCAST .............................................................................................45
3.2.3.- Protocolo Metacast ...........................................................................................46
3.2.4.- Protocolo FAST.................................................................................................46
3.3.- Uso de variables en REMBO ....................................................................................47
3.3.1.- Introduccin.......................................................................................................47
3.3.2.- Variables incorporadas (built-in) .......................................................................47
3.3.3.- Variables persistentes.......................................................................................47
3.4.- Creacin de imgenes de disco y restauracin ........................................................48
3.4.1.- Ms sobre la clonacin .....................................................................................48
3.4.1.1.- Clonacin basada en sectores .................................................................48
3.4.1.2.- Clonacin basada en estructura ...............................................................48
3.4.2.- Crear una imagen de disco...............................................................................49
3.4.3.- Cmo restaurar una imagen de disco...............................................................49
3.4.4.- Una restauracin inteligente: Sincronizacin....................................................50
3.4.4.1.- Sincronizacin: cmo trabaja....................................................................51
3.4.4.2.- Aplicaciones del metodo de Sincronizacin .............................................51
3.4.4.3.- Sintxis y uso del mtodo de Sincronizacin ...........................................51
3.5.- Conceptos avanzados de clonacin .........................................................................52
3.5.1.- Filtrando ficheros con Imgenes Virtuales........................................................52
3.5.2.- Imgenes incrementales ...................................................................................53
3.5.2.1- Imgenes incrementales bsicas ..............................................................53
3.5.2.2.- Imgenes incrementales avanzadas ........................................................53
3.5.2.3.- Cmo crear una imagen incremental........................................................54
3.5.3.- Fusin de imgenes usando imgenes virtuales..............................................55
3.5.3.1.- Cmo fusionar las imgenes? ................................................................55
3.5.4.- Conversin del tipo de particin........................................................................55
3.6.- Iniciando REMBO sin conexin a la red ...................................................................56
3.6.1.- Modo desconectado..........................................................................................56
3.6.1.1.- Configurando el modo desconectado .......................................................57
3.6.1.2.- Cmo de seguro es el modo desconectado? .........................................57
3.6.1.3.- REMBO como gestor de arranque ...........................................................57
3.6.1.4.- Imgenes del modo desconectado...........................................................57
3.6.2.- Arrancar desde un CD de autoarranque...........................................................57
3.6.2.1 Creando un CD de autoarranque................................................................57
3.6.3 Arrancando REMBO desde un disquete .............................................................58
3.6.4 Activacin PXE....................................................................................................58
3.7.- Uso de canales TCP para acceder a recursos remotos ...........................................59

3.7.1. Mandando correo electrnico con REMBO .......................................................59
3.7.2. Acceso a bases de datos con REMBO ..............................................................59
CAPTULO 4: INSTRUCCIONES ESPECFICAS PARA CADA

S.O. ......................................................................................................................................61
4.1.- Clonando MS-DOS....................................................................................................61
4.1.1.- Clonando un sistema MS-DOS.........................................................................61
4.1.2. Ajustando un sistema MS-DOS .........................................................................61
4.1.3. Instalando clientes Lan Manager para UNDI .....................................................62
4.2.- Clonando Windows 95/98 .........................................................................................63
4.2.1.- Creando una imagen base Windows 9x ...........................................................63
4.2.2.- Comprobando la imagen base del disco ..........................................................64
4.2.3.- Crear un script de restauracin.........................................................................64
4.2.4.- Sincronizando en lugar de RestoreDiskImage .................................................65
4.2.5.- Personalizando .................................................................................................66
4.2.6. Imgenes incrementales bsicas.......................................................................67
4.2.7. Imgenes incrementales avanzadas..................................................................68
4.2.7.1.- Restaurando una imagen incremental avanzada .....................................69
4.2.7.2.- Yendo mas all .........................................................................................70
4.3.- Clonando Windows NT / 2000 ..................................................................................71
4.3.1.- Creando una imagen base Windows NT ..........................................................71
4.3.2.- Comprobando la imagen de disco base ...........................................................71
4.3.3.- Crear un script de restauracin.........................................................................72
4.3.4.- Sincronizacin en lugar de restauracin de una imagen..................................73
4.3.5.- Personalizando .................................................................................................74
4.3.6.- Imgenes incrementales bsicas......................................................................74
4.3.7.- Imgenes incrementales avanzadas ................................................................75
4.3.7.1.- Restaurando una imagen incremental avanzada .....................................76
4.3.8.- Ficheros comprimidos .......................................................................................77
4.3.9.- Parcheando el SID de NT con REMBO ............................................................78
4.4.- Clonar Linux ..............................................................................................................79
4.4.1.- Creacin de una imagen base Linux ................................................................79
4.4.2.- Arrancar un kernel de Linux ..............................................................................79
4.4.3.- Probar la imagen base del disco.......................................................................80
4.4.4.- Creacin de un script de restauracin ..............................................................80
4.4.5.- Imgenes incrementales de Linux ....................................................................81
4.4.6.- Personalizar scripts de arranque de Linux .......................................................82
MANUAL DE REFERENCIA DE REMBO-C...............................................................84

CAPTULO 1 : El lenguaje de scripts de Rembo-C................................................................85
1.1.- Utilidad ......................................................................................................................85
1.2.- Aadiendo scripts a las pginas Web.......................................................................85
1.3.- Creacin de interfaces de usuario dinmicos ...........................................................85
1.4.- Creacin de plug-ins precompilados ( libreras ) ......................................................86
CAPTULO 2 : El lenguaje......................................................................................................87
2.1.- Estructura de un programa Rembo-C .......................................................................87
2.2.- Declaraciones de variables y tipos............................................................................87
2.3.- Declaracin de funciones ..........................................................................................88
2.4.- Expresiones...............................................................................................................88
2.5.- Sentencias de control................................................................................................89
2.6.- Hilos ( threads ) .........................................................................................................89
2.7.- Manejo de excepciones ............................................................................................89
2.8.- Programacin orientada a objetos ............................................................................90
2.9.- Directivas pragma .....................................................................................................90
2.10.- Palabras reservadas ...............................................................................................90
2.11.- Resumen de diferencias entre C y Rembo-C .........................................................91
CAPTULO 3 : Bibliotecas de funciones.................................................................................92
3.1.- Cadenas ....................................................................................................................92
3.2.- Objetos binarios ........................................................................................................93
3.3.- Tablas y estructuras ..................................................................................................93
3.4.- Directorios .................................................................................................................93
3.5.- Ficheros.....................................................................................................................94
3.6.- Contenido de un fichero ............................................................................................94
3.7.- Interfaz de usuario.....................................................................................................95
3.8.- Primitivas relacionadas con la evaluacin ................................................................95
3.9.- Variables persistentes ...............................................................................................96
3.10.- Primitivas relacionadas con la red ..........................................................................96
3.11.- Primitivas del sistema .............................................................................................97
ANEXO A : GUA RPIDA DE
INSTALACIN DE REMBO .................................99
GUA RPIDA DE INSTALACIN DE REMBO ...................................................................100

1.- Consideraciones previas ............................................................................................100
2.- Instalando REMBO.....................................................................................................100
3.- Instalando los Sistemas Operativos...........................................................................101
4.- Clonando Windows 2000 ...........................................................................................101

5.- Restaurando y arrancando Windows 2000 ................................................................101
6.- Clonando Windows 98 SE .........................................................................................102
7.- Restaurando y arrancando Windows 98 SE ..............................................................102
9.- Clonando Linux ..........................................................................................................103
10.- Restaurando y arrancando Linux .............................................................................103
ANEXO B : OTROS ASPECTOS DE REMBO .........................................................105

CAPTULO 1 : PERSONALIZANDO REMBO ......................................................................106
1.1.- Men personalizado ................................................................................................106
1.2.- Modificar el men raz .............................................................................................106
1.3.- Rembo en castellano ..............................................................................................107
1.4.- Cambio pantalla de autentificacin .........................................................................107
1.5.- Ejecucin de scripts ................................................................................................108
1.6.- Instalacin asistentes avanzados ...........................................................................108
CAPTULO 2 : ALGUNAS CUESTIONES DE SEGURIDAD ...............................................109
2.1.- Proceso de autentificacin ......................................................................................109
2.2.- Asegurar arranque en Rembo.................................................................................109
2.3.- Bloqueo de perifricos ............................................................................................110
ANEXO C : MEN DE EJEMPLO ............................................................................111

MEN DE EJEMPLO ...........................................................................................................112
MANUAL DE ADMINISTRACIN DEL

SERVIDOR
Manual de Administracin del Servidor
CAPTULO 1: Instalacin del servidor REMBO

En este captulo explicaremos cmo instalar el servidor Rembo. Siga cuidadosamente las
instrucciones de configuracin pues cualquier parmetro incorrecto u omitido impedir el
funcionamiento correcto del sistema.
1.1.- Conceptos y requisitos

El arranque remoto es el proceso de arrancar remotamente un ordenador usando recursos
remotos puestos a salvo en un servidor.
1.1.1.- Cmo funciona?

La secuencia tpica de arranque remoto es la siguiente:
1) Encendido: El ordenador remoto est encendido o esperando evento.
2) Descubrir direccin IP: Un servidor DHCP suministra direcciones IP a los clientes. El
servidor dar los parmetros de red necesarios para iniciar arranque remoto.
3) Descubrir servidor de arranque: El servidor de arranque remoto puede ser otra mquina
diferente al servidor DHCP. El servidor de arranque suministra un pequeo programa de
inicio de arranque en red al cliente usando un protocolo multicast (MTFTP).
4) Conexin NBP: REMBO utiliza una conexin segura mediante un servicio NBP. Permite
configurar parmetros de seguridad, el grupo de trabajo del cliente, bloquear puertos E/S...
5) Configuracin pre-arranque (Pre-OS): REMBO ejecutar las acciones definidas en la
pgina de arranque, definidas como scripts en lenguaje Rembo-C.
6) Arranque del S.O.: Cuando se inicia el arranque del cliente REMBO se borra de
memoria. Esto asegura plena compatibilidad con el S.O. y evita los problemas tradicionales
del arranque remoto sin disco.
1.1.2.- Requisitos del Servidor

Sern necesarios un servidor DHCP y un servidor REMBO, que pueden ser la misma mquina
si se desea.
1.1.2.1.- Servidor DHCP

No hay requisitos especiales para el servidor DHCP. Si el servidor Rembo va a estar en el
mismo equipo que el servidor DHCP hay que definir la opcin DHCP class identifier (opcin
60).
Prcticas de Empresa 2001/02 1er Turno
Pgina 10
1.1.2.2.- Servidor REMBO

El servidor REMBO puede funcionar sobre WinNT/2000, Linux(x86) y Solaris (Sparc). No hay
requisitos especiales. Sera recomendable usar un disco duro de gran tamao si se prevee
usar muchas imgenes y lgicamente una CPU rpida para minimizar el tiempo de creacin de
dichas imgenes (la mayora del trabajo de compresin se realiza en el servidor).
1.2.- Configuracin del servidor DHCP

Este documento asumir que usted ya ha configurado su red para usar DHCP. Esta seccin
explica como configurar su servidor DHCP para una de las tres situaciones siguientes:
El servidor DHCP y el servidor REMBO no estn en la misma mquina.

El servidor DHCP y el servidor REMBO estn en la misma mquina.
Usted ya tiene una infraestructura PXE 2.0 con "PXE Boot Server discovery" instalado
y quiere aadir REMBO a la lista de servidores disponibles.
1.2.1.- Servidor DHCP y REMBO en equipos diferentes

Las acciones que hay que realizar son :
Si las opciones DHCP 43 y 60 estn puestas, elimnelas.

Si los servidores DHCP y REMBO estn en diferentes mquinas, no hay nada que
cambiar en la configuracin DHCP. El servidor REMBO detectar los paquetes DHCP
enviados por la bios de arranque remoto de los clientes y ofrecer parmetro PXE sin
alterar la negociacin estndar DHCP (este comportamiento es llamado DHCPProxy).
1.2.2.- Servidor DHCP y REMBO en el mismo equipo

Las acciones que hay que realizar son :
Si la opcin 43 est puesta, elimnela;

Poner la opcin 60 (Class identifier) a "PXEClient".
1.2.2.1.- Aadiendo la opcin 60 al servidor DHCP de WinNT 4

Este proceso se realiza en dos pasos. Primero hay que crear una definicin para la opcin 60,
ya que esta no existe por defecto. Luego, habr que aadir esta opcin a un grupo de hosts o a
un solo host.
Paso 1. Aadir la opcin 60 al conjunto de opciones soportadas.
Vaya a Opciones DHCP/Por defecto y haga click en Nueva. Aada una opcin llamada
"Client Class", ponga tipo de dato "String" o "Cadena de texto" e identificador como 60.
Pgina 11
Paso 2. Aadir la opcin 60 al mbito DHCP.

Seleccione el mbito conteniendo los clientes PXE y vaya al men Opciones
DHCP/mbito. Aada la opcin 60 y ponga el valor a "PXEClient".
1.2.2.2.- Aadiendo la opcin 60 al servidor DHCP de Win2000

Por defecto la opcin 60 no est activada bajo Win2000. Si el servidor REMBO est
ejecutndose en la misma mquina que el servidor DHCP, tendr que aadir esta opcin y
poner su valor a PXEClient para decirle a los clientes PXE donde encontrar el servidor
REMBO.
Para aadir esta opcin siga los siguientes pasos:
1.
2.
3.
4.
5.
6.
Abra una ventana de smbolo del sistema.

Escriba netsh.
Escriba dhcp.
Escriba server \\nombre_servidor o server direccin_ip.
Debera ver un prompt indicando: dhcp server>
Escriba add optiondef 60 PXEClient STRING 0 comment=opcin aadida para
soporte PXE.
7. Escriba set optionvalue 60 STRING PXEClient.
8. Para confirmar que todo se ha hecho correctamente, escriba show optionvalue all.
1.2.2.3.- Aadiendo la opcin 60 a un host con servidor ISC
DHCP
Si est usando el servidor ISC DHCP 2.0, es posible aadir la opcin 60 a un grupo de hosts
o a un nico host aadiendo la sentencia option dhcp-class-identifier "PXEClient"; a una de las
secciones del fichero de configuracin. Si est usando la opcin 43 (vendor-encapsulatedoptions) para BPBatch, elimnela para servidores REMBO.
Las modificaciones a realizar para un servidor ISC DHCP 3.0 son las mismas, pero los
nombres varan:
Aada vendor-class-identifier "PXEClient"; para los hosts usando REMBO.

Elimine cualquier ocurrencia de option space PXE; si estaba usando BPBatch.
1.2.3.- Aadiendo REMBO a una infraestructura con Boot

Discovery existente
Si su red ya est configurada para PXE 2.0 Boot Server Discovery, todo lo que tiene que
hacer es aadir REMBO a su men de arranque. El identificador del servidor de arranque
REMBO es 15. Si quiere usar resolucin multicast, use la direccin IP multicast 232.1.0.1.
1.3.- Instalacin de REMBO en Windows NT / 2000

REMBO viene preconfigurado con un conjunto mnimo de opciones (opciones obligatorias).
Podr aadir nuevas opciones, nuevos grupos o hosts ms tarde.
Pgina 12
1.3.1.- Instalacin
Para instalar el servidor REMBO, ejecute el programa que recibi cuando compr REMBO.
Este ejecutable instalar REMBO en un directorio de su eleccin, y realizar tareas bsicas de
instalacin.
Una vez la instalacin haya acabado, usted debera tener los siguientes ficheros y directorios
en su directorio de instalacin REMBO:
rembo.exe : este es el servidor. Como el servidor es un servicio NT, usted no

necesitar ejecutar este fichero directamente, a menos que est intentando
ejecutar REMBO en modo depuracin.
files/ : este es el directorio usado por REMBO para almacenar los archivos del
servidor. Usted no necesita modificar ningn fichero almacenado en este directorio.
misc/ : este directorio contiene archivos variados. En particular, contiene
netclnt.exe, una herramienta para modificar ficheros del servidor desde la lnea de
comandos.
logs/ : este directorio es donde REMBO almacena sus archivos log. Usted puede
ver los ficheros en este directorio en cualquier momento para comprobar los
mensajes de error.
sconsole.exe : esta es la consola del servidor REMBO. Ver ms abajo para ms
detalles.
rconsole/ : este es la aplicacin de consola remota, usada para interactuar
remotamente con el cliente REMBO.
1.3.2.- Configuracin mnima

El proceso de instalacin debera haber creado un nuevo grupo llamado Rembo Server en su
men de inicio, con dos iconos:
La consola de servidor REMBO.

La aplicacin de consola remota.
1.3.3.- Comprobando la configuracin

Estando en la consola del servidor, haga click en su servidor local, entonces click en status.
La ventana derecha mostrar el estado de su servidor. Si el estado no es SERVER_RUNNING,
haga click con el botn derecho en el estado actual y seleccione start service. Esto debera
iniciar el servidor, y debera ver SERVER_RUNNING despus de unos segundos. Si an sigue
sin funcionar, vaya a la seccin 1.3.4.
Una vez su servidor est funcionando, puede mostrar los ficheros del servidor y ver los logs
desde la consola de REMBO. Experimente su instalacin ejecutando un cliente PXE. El
ordenador debera iniciar REMBO y mostrar un mensaje de bienvenida. Si no lo hace, mire los
logs en el servidor y asegrese que su servidor DHCP est configurado para contestar a su
mquina PXE. Ver seccin 1.5 si el cliente de arranque remoto no arranca.
1.3.4.- Solucin de problemas con el servicio NT

Si su servidor no se inicia, o usted sospecha que algo va mal, tiene varias opciones para
obtener informacin de depuracin desde el servidor:
Pgina 13
Mire en el visor de eventos de NT. El servidor REMBO registra los mensajes fatales de
error en el manejador de eventos de NT.
Si el servicio no comienza, ejecute rembo.exe desde la lnea de comandos con las
siguientes opciones: rembo -d -v 4. Esto ejecutar Rembo como una operacin de
consola, redireccionando todos los mensajes a la consola. Puede incrementar el nivel
de depuracin hasta 6.
Si el servicio funciona pero quiere informacin de depuracin, ponga la opcin
avanzada llamada GlobalDebugLevel a un valor entre 2 y 6 con la consola del
servidor.
1.4.- Instalacin de REMBO en Unix

Esta seccin describe como configurar su servidor REMBO bajo Unix (Linux o Solaris).
1.4.1.- Instalacin
Elija el directorio donde quiere instalar el servidor REMBO (por ejemplo /usr/local/rembo).
Extraiga el contenido del paquete de distribucin REMBO a este directorio. Entonces debera
ver:
Un programa llamado rembo (el servidor);
Un fichero de texto llamado rembo.conf (el fichero de configuracin del servidor);
Un fichero de texto llamado srvfiles.nc (el paquete de ficheros bsico del servidor);
Un subdirectorio llamado misc, con varios ficheros que puede necesitar mas tarde;

Usando su editor de texto favorito, abra rembo.conf. Su contenido debera ser algo como
esto:
# Basic Rembo Server config file
#
# BaseDir <string>
# Specifies the home dir for the server. All paths can then be
# specified as relative to this base directory
# e.g. Basedir "c:/bootrom/rembo"
BaseDir "/usr/local/rembo"
# NetPassword <string>
# This password is used by the Rembo server to protect its files
# against an illegal use through the NETfs client (netclnt).
# This option is mandatory.
NetPassword "please set a password here"
#
# Default group. Hosts will take their parameters from this group.
# Unless you create other groups with hosts in it.
#
GROUP Default {
StartPage "net://global/rembo.shtml"
}
Muchos componentes adicionales pueden ser especificados en el fichero de configuracin. Sin

embargo, todo lo que necesita configurar por ahora es la ruta donde instal el servidor REMBO
(BaseDir), y un password para acceder a los ficheros del servidor con la utilidad netclnt (Net
Password).
Ya esta listo para iniciar el servidor por primera vez.
Pgina 14
1.4.3.- Instalando los ficheros del servidor

El servidor REMBO necesita tener un conjunto mnimo de ficheros en su sistema de archivos
para que el cliente remoto arranque. Estos ficheros estn contenidos en el fichero de texto
srvfiles.nc, y el mtodo para instalar estos ficheros se describe en esta seccin.
Primero debe arrancar el servidor escribiendo rembo -d -v 4 en la lnea de comandos.
Durante la primera ejecucin, el servidor necesitar un tiempo extra para generar una clave
criptogrfica aleatoria.
Una vez el servidor este ejecutndose y esperando peticiones de conexin, edite el fichero
srvfiles.nc, y sustituya la lnea open 127.0.0.1 install con open 127.0.0.1 xxxx donde xxxx es el
password que usted puso en el fichero rembo.conf (parmetro NetPassword).
Ahora puede ejecutar el comando misc/netclnt srvfiles.nc en el directorio de instalacin del
servidor. Varios ficheros deberan ser transferidos al servidor, y NetClnt debera volver a la
lnea de comandos despus de que el ltimo archivo haya sido enviado al servidor.
Su servidor est ahora listo para recibir peticiones desde los clientes de arranque remoto.
1.4.4.- Comprobando la configuracin

Desde el directorio donde est el fichero de configuracin, escriba rembo -d -v 2 para
arrancar el servidor REMBO. Esto le indicar al servidor que informe de los errores en la salida
estndar.
REMBO debe ejecutarse como root, ya que necesita acceso a puertos UDP privilegiados.
Adems DHCP siempre debe ejecutarse antes que REMBO para que este ltimo lo detecte.
Cada uno de los hilos del servidor debera mostrar un mensaje en la salida estndar, y
entonces esperar que un cliente se conecte. Asegrese que no aparece ninguna advertencia ni
indicio de que un servicio haya sido desactivado. Algunos errores comunes son:
Arrancar el servidor sin privilegios de administrador (root), evitando la reserva de

algunos puertos;
Arrancar el servidor sin privilegios de escritura en el directorio base;
Tener otro servidor de arranque PXE ejecutndose en el mismo equipo, evitando que el
servidor REMBO reserve el puerto PXE BINL;
Tener un servidor TFTP configurado en el mismo equipo. Esto evita que REMBO entre
la secuencia de arranque a los clientes;
Ejecutar REMBO en un equipo sin capacidades multicast, como un equipo que solo
posee la interfaz loopback habilitada.
Ejecutar REMBO en un equipo con mltiples tarjetas de red sin especificar el
parmetro Interfaces.
Si obtiene alguna advertencia, detenga el servidor e intente arreglarlo. Una vez el servidor
est ejecutndose correctamente, conecte un cliente. Despus de unos segundos, REMBO
debera estar funcionando.
Pgina 15
1.4.5.- Opciones de lnea de comandos del servidor REMBO

El servidor REMBO puede ser ejecutado manualmente o a travs de un script init.d. No debe
ser ejecutado por inetd.
rembo [-d] [-v nivel_de_log] [-c fichero_configuracin]
-d : muestra informacin de depuracin a la salida estndar, no se ejecuta como

demonio.
-v : ajusta el nivel de detalle de la informacin mostrada (por defecto: 2).
-c : especifica el fichero de configuracin (por defecto: rembo.conf).
Los niveles de detalles de la informacin mostrada estn definidos como :
0 : sin salida.
1 : slo mensajes de error.
2 : slo mensajes de error y advertencias.
3 : mensajes de error, advertencias y mensajes de informacin.
4 : igual que 3, pero tambin mensajes de notificacin.
5 : igual que 4, con salida de depuracin.
6 : igual que 5, con trace de red.
1.5.- Solucin de problemas

1.5.1.- Rom de arranque PXE no detectada
1.5.1.1.- Descripcin del problema

Durante el proceso de arranque, no hay mensaje sobre la rom de arranque PXE, y el
ordenador arranca como es usual (desde floppy, disco duro o CD-ROM).
1.5.1.2.- Resolucin del problema

Primero compruebe que su tarjeta de red est correctamente instalada, y que el chip de
arranque remoto est instalado en dicha tarjeta. Para comprobar que la tarjeta de red funciona,
ejecute Windows o Linux, y configure el sistema operativo para que sea capaz de hacer ping a
otras mquinas (o para ser capaz de ver a otros equipos en el entorno de red).
En ciertas tarjetas de red, el chip de arranque remoto PXE puede no estar activado por
defecto. Lea la documentacin del producto para encontrar la combinacin de teclas que debe
presionar para entrar en el men de configuracin PXE en el momento del arranque. Algunas
tarjetas pueden no tener dicho men de configuracin.
Entonces, entre en la configuracin de la BIOS durante el arranque, y configure el proceso de
arranque para que la tarjeta de red sea la primera entrada en la lista de arranque. En algunas
BIOS, hay una opcin para activar el arranque en red. En otras BIOS, debe poner
manualmente la opcin de red como el primer dispositivos de arranque.
Pgina 16
Si todos estos pasos fallan, intente obtener una actualizacin para la memoria flash de su
tarjeta de red, y actualice la rom de la tarjeta de red con dicha actualizacin. Si el proceso de
flash falla, posiblemente no exista chip de arranque remoto en la tarjeta de red.
Si an as no ve los mensajes PXE, pregunte al fabricante de su tarjeta de red.
1.5.2.- En el arranque aparece DHCP... y un mensaje de error

El chip de arranque remoto no recibe suficiente informacin para continuar. El servidor DHCP
o el servidor REMBO no estn correctamente configurados.

Primero compruebe que su servidor DHCP esta correctamente configurado como se explica
en la seccin 1.2. En particular, compruebe que la opcin 60 esta puesta a PXEClient, slo si
est ejecutando el servidor DHCP y el servidor PXE en la misma maquina.
Si el servidor DHCP y el servidor REMBO estn en la misma mquina, intente detener ambos
servidores, y reiniciarlos en el siguiente orden: el servidor DHCP primero, y luego el servidor
REMBO.
Compruebe su configuracin DHCP: ejecute Windows o Linux en su cliente de arranque
remoto, y configure la red para usar configuracin dinmica en lugar de direccin IP fija. Si
funciona (ejecute winipcfg o ipconfig en Windows, o ifconfig en Linux), entonces el servidor
DHCP esta configurado correctamente para esa mquina. Si no funciona, compruebe la
configuracin del servidor DCHP.
Si su servidor est correctamente configurado (incluyendo opcin 60), y el cliente an muestra
DHCP... seguido por un error, compruebe la configuracin del servidor REMBO. Detenga el
servidor REMBO, ejecute rembo.exe -d -v 6, y arranque el cliente de arranque remoto. Cuando
comience, el servidor debera mostrar una lnea diciendo si est actuando como DHCP Proxy o
como BINL Proxy. Si el servidor DHCP y el servidor REMBO estn en la misma mquina, el
servidor REMBO debe actuar como BINL Proxy. Si estn en diferentes mquinas, el servidor
debe actuar como DHCP Proxy. Si el servidor muestra un mensaje diciendo que esta actuando
como BINL Proxy, pero los dos servidores no estn en la misma mquina, significa que hay un
servidor DHCP habilitado en la mquina donde est instalado el servidor REMBO.
Cuando un cliente arranca, y el DHCP est correctamente configurado, el servidor REMBO
(en modo depuracin) debe mostrar Valid discovery from ... seguido por Client ... found in group
... . Si el servidor muestra la primera lnea, pero muestra Client ... not found in any group en la
segunda lnea, significa que el fichero de configuracin no contiene un grupo de trabajo por
defecto, y el cliente de arranque remoto no est declarado en ningn grupo (el cliente debe
estar declarado con su direccin hardware, no con su direccin IP).
Si el servidor no muestra el mensaje Valid discovery request from ..., significa que la opcin
60 del servidor DHCP no est correctamente puesta (ver seccin 1.2), o el servidor REMBO y
el servidor DHCP no estn en la misma subred. Si tienes instalado REMBO en un host con
varias tarjetas de red, use la opcin Interfaces para especificar que tarjeta usar.
Pgina 17
1.5.3.- En el arranque aparece MTFTP... y un mensaje de error

El chip de arranque remoto es incapaz de recibir la secuencia de arranque desde el servidor.

Si el intervalo de tiempo entre el mensaje MTFTP... y el mensaje de error es muy corto, y el
mensaje dice que un fichero no ha sido encontrado, significa que el ordenador donde tiene
instalado REMBO ya ejecuta un servidor TFTP (y este servidor TFTP contesta a las peticiones
del servidor REMBO). Si est usando Windows NT/2000 en el servidor, verifique la lista de
servicios, y desactive los servicios relacionados con TFTP o protocolos de arranque (Intel LCM,
Microsoft PXE, ...). Si est usando Linux/Solaris, compruebe que no hay procesos tftp
ejecutndose, y que la lnea con tftp in el fichero /etc/inetd.conf est comentada.
Si el intervalo de tiempo es largo, significa que los datagramas multicast TFTP enviados por el
servidor REMBO no estn siendo recibidos por el cliente de arranque remoto. Compruebe que
multicast est activado en el kernel si est usando Linux/Solaris en el lado del servidor. Si est
usando REMBO en un servidor con varias tarjetas de red use el parmetro Interfaces para
especificar qu tarjeta de red desea usar para los paquetes multicast.
Pgina 18
CAPTULO 2: Configuracin del servidor REMBO

Este captulo contiene una descripcin exhaustiva sobre los parmetros de configuracin del
servidor.
2.1.- Conceptos
2.1.1.- Configuracin basada en ficheros vs basada en registro
En un servidor Windows 2000/NT todos los parmetros se almacenan en el registro de
sistema. En los servidores Unix se almacenar en ficheros. El siguiente ejemplo muestra un
archivo de configuracin. Estn incluidos todos los parmetros, pero aquellos que no
corresponden a la configuracin mnima han sido comentados:
----------------- rembo.conf -----------------# Ejemplo de configuracin de servidor Rembo
################################
### PARMETROS GLOBALES
###
################################
#
- PARMETROS COMUNES -
Basedir "/usr/local/rembo"
NetPassword "Por favor, introduzca aqu una clave"
# Nota: la opcin Interfaces es parte de la configuracin mnima si usa
# mltiples servidores o conexiones a servidores.
Interfaces 192.168.1.4
#
#
#
#
#
- PARMETROS PXE - #
DisableDHCPProxy
BootNoMulticastDiscovery
BootDiscoveryAddress 232.2.0.1
BootDiscoveryPort 4011
#
#
#
#
MTFTPPort 4015
MTFTPClients 231.1.0.1:8500
MTFTPStartDelay 2
MTFTPMCastTTL 1
- PARMETROS DE REMBO -
# NBPServerPort 4012
#
#
#
#
#
#
#
#
DataDir "files"
FileServerPort 4013
FileMCastAddress 239.2.0.1:10000
FileMCastTTL 1
MCASTEncrypt
FASTEncrypt
FASTPort 4025
- PARMETROS DE TOLERANCIA A FALLOS -
# BootReplyDelay 1
# Backup 192.168.1.8
#####################################
### AUTENTIFICACIN DE DOMINIOS ###
#####################################
Pgina 19
- DOMINIO LOCAL -
# AuthLocalDomain lcltest {
# Usergroup "rembo"
# }
#
#
#
#
#
#
#
#
#
#
- DOMINIO NT -
AuthNTDomain ntatest {
AuthServerName "company-pdc"
Usergroup "rembo"
}
- DOMINIO RADIUS -
AuthRadiusDomain radtest {
AuthServerAddress 192.168.1.15
RadiusSecret "testing123"
}
###############################
### GRUPOS DE SERVIDORES
###
###############################
#
- Grupo por defecto -
Group Default {
Options admin
}
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
- Grupo de ejemplo -
Group TestGroup {
FileServer 192.168.10.10
Options admin
Lockout mouse
AuthDomain "lcltest"
StartPage "net://global/mypage.html"
RemoteConsole 192.168.1.10
Host
192.168.1.118
Host
192.168.1.119 {
StartPage "net://global/special.html"
}
Host
00:10:4b:12:12:12
HostRange 192.168.2.1 -> 192.168.2.254
HostRange 192.168.3.1 -> 192.168.3.254 {
AuthDomain "nttest"
}
}
2.1.2.- Organizacin de parmetros

Los parmetros se organizan en 3 grupos: Parmetros globales, dominios de autentificacin y
grupos de servidores.
Parmetros globales : opciones de configuracin del servidor a bajo nivel. Se dividen

en 4 partes: comunes a todos los servicios, relacionados con el arranque PXE,
servicios especficos de Rembo y tolerancia a fallos.
Dominios de autentificacin : grupos de trabajo.
Grupos de servidores : Para agrupar servidores con la misma informacin de

configuracin.
Nota: cualquier modificacin de los parmetros globales requiere reiniciar la mquina.
Pgina 20

Al instalar REMBO por primera vez viene con una serie de parmetros mnimos por defecto,
necesarios para arrancar el servidor REMBO. Si editas el fichero de configuracin rembo.conf
(en un servidor basado en ficheros) debers establecer 2 variables:
BaseDir: el directorio donde REMBO se ha instalado.

NetPassword: clave elegida para proteger los ficheros contra accesos ilegtimos.
2.2.- Parmetros Globales

Como se ha indicado previamente, el servidor REMBO necesita los parmetros globales para
funcionar. Normalmente no es necesario modificar ningn parmetro global salvo Basedir,
NetPassword o Interfaces.
En la configuracin basada en registros (lase Windows 2000/NT) los parmetros globales
necesarios se introducen durante la instalacin. Si trabajas con el sistema basado en ficheros
debers editarlos a mano. El formato de estos es:
Basedir "cadena" : Especifica el directorio base para el servidor. Todos los paths
incluidos en la configuracin son relativos a este directorio. Este parmetro es
obligatorio, y no tiene valor por defecto.
NetPassword "cadena" : REMBO utiliza este password para proteger sus archivos de
acceso remoto no autorizado. Si usas netclnt, tendrs que aadir este password como
opcin del comando open para poder acceder a los archivos del servidor remotamente.
Si usas la consola del servidor, tendrs que introducir el password solo si aades un
servidor en el modo de servidor remoto. Si el servidor es local, o un servidor Windows
NT remoto, la consola toma este password del registro (leer el manual para ms
informacin).
MaxLogSize nmero : Este parmetro se usa para limitar el tamao de los ficheros de
log que genera el servidor REMBO. El tamao mximo se especifica en bytes, y se
aplica a todos los ficheros de log generados por el servidor (file,nbp y boot). Si no se
especifica, o el lmite es 0, no hay lmite de tamao (leer el manual para ms
informacin).
Interfaces "cadena" : Este parmetro especifica la lista de interfaces de red usados por
el servidor cuando recibe y enva paquetes a los clientes REMBO. Si no se indica, el
servidor usar el interfaz de red correspondiente al hostname del servidor (leer el
manual para ms informacin).
El resto de parmetro globales se usan para definir parmetros avanzados, relacionados con
el comportamiento PXE del servidor REMBO, y parmetros especficos de REMBO.
2.2.1.- Parmetros relativos al PXE

El servidor REMBO implementa todos los servicios requeridos para un arranque PXE,
permitiendo deshabilitar los servicios no requeridos en tu entorno o cambiarlos para
acomodarlos a una infraestructura PXE ya existente. Existen 3 formas diferentes de detectar al
servidor PXE:
Pgina 21
La opcin 60 del DHCP est puesta a PXEClient.

Si el paquete respuesta que llega al cliente incluye dicha opcin iniciada a ese mismo
valor (PXEClient), el cliente sabr que el servidor PXE es el mismo que el DHCP. La
negociacin continuar enviando un paquete por el puerto UDP 4011 del servidor. Si
has
elegido
este
modo
puedes
deshabilitar
DisableDHCPProxy
y
BootNoMulticastDiscovery.
El servidor PXE enva una respuesta PXE para descubrir el DHCP (DHCP Proxy).K
Si el servidor DHCP y el PXE estn en diferentes mquinas, el servidor PXE puede ser
configurado para responder a una peticin DHCP (DHCPDISCOVER). De este modo el
cliente recibir 2 paquetes de respuesta: el primero enviado por el servidor DHCP
(DHCPOFFER) que contiene su direccin IP y los parmetros de red asociados al
arranque remoto, y el segundo enviado por el servidor PXE conteniendo las opciones
especficas PXE.
La respuesta DHCP informa al cliente que ejecute un descubrimiento multicast

Si no se puede usar ninguno de los mtodos anteriores el servidor DHCP se puede
configurar para incluir los parmetros PXE para un descubrimiento multicast. Estos
parmetros dirn al cliente como ejecutar un descubrimiento multicast PXE (que
direccin usar y qu servidor buscar). La especificacin PXE define qu parmetros
DHCP deben cambiarse para el descubrimiento multicast. La identificacin de arranque
(Boot ID) para servidores REMBO es 15. En este modo, BootNoMulticastDiscovery no
debe ser iniciada y BootDiscoveryAddress debe iniciarse a la direccin multicast de tu
infraestructura de descubrimiento. Si quieres puedes deshabilitar el DHCPProxy con
DisableDHCPProxy.
Nota: Si tienes mltiples servidores REMBO en una la misma subred puedes implementar
balance de carga y tolerancia a fallos habilitando DHCPProxy en todos los servidores y
definiendo los clientes en todos ellos.
Gua de referencia rpida de parmetros PXE
DisableDHCPProxy : Deshabilita el servicio DHCPProxy. El servidor no enviar

respuestas DHCP extendidas (respuestas PXE) a los paquetes DHCP enviados por el
cliente (leer el manual para ms informacin).
BootNoMulticastDiscovery : Se deshabilitar el descubrimiento PXE multicast. El
servidor no escuchar los paquetes PXE multicast de descubrimiento (leer el manual
para ms informacin).
BootDiscoveryAddress direccin_ip : Direccin IP multicast que los servidores
escuchan cuando se esperan paquetes PXE de descubrimiento multicast (leer el
BootDiscoveryPort puerto : El puerto que el servidor escucha para paquetes de
descubrimiento multicast y respuestas BINL (leer el manual para ms informacin).
Otra parte importante del soporte PXE implementado en REMBO es el servicio MTFTP
(Multicast Trivial File Transfer Protocol). Se utiliza para cargar la parte inicial de REMBO en el
cliente. Una vez hecho esto, los protocolos propietarios son usados para proporcionar un
servicio ms eficiente y seguro. El servicio MTFTP implementado en REMBO es una
implementacin parcial de la especificacin del protocolo, orientada al cliente. Los siguientes
parmetros permiten configurarlo, aunque sus valores por defecto funcionan habitualmente:
Pgina 22
MTFTPPort puerto : Puerto usado por el servidor para escuchar peticiones MTFTP
(leer el manual para ms informacin).
MTFTPClients puerto [:puerto-cliente] : Direccin IP destino y puerto usado por el
servidor para mandar datagramas MTFTP multicast a los clientes(leer el manual para
ms informacin).
MTFTPStartDelay segundos : Retraso en el cliente antes de mandar la primera
peticin MTFTP (leer el manual para ms informacin).
MTFTPMCastTTL ttl : Define el Time-To-Live (TTL) o etiqueta temporal asociado a los
paquetes multicast (leer el manual para ms informacin).
2.2.2.- Parmetros especficos de REMBO

Se utilizan para modificar el comportamiento de los servicios de ficheros y NBP en el servidor.
Probablemente no debers modificarlos a menos que requieras cambiar los puertos porque ya
estaban ocupados por otros servicios.
Gua de referencia rpida de parmetros especficos de Rembo
NBPServerPort puerto : puerto UDP por el que se reciben las peticiones NBP de los
clientes. Se recomienda no modificar su valor (leer el manual para ms informacin).
DataDir "ruta" : Directorio que contiene los ficheros internos del servidor (leer el
FileServerPort puerto : Puerto UDP usado por el servidor para recibir peticiones
NETfs, MCAST y FAST (leer el manual para ms informacin).
FileMCASTAddress direccin_ip:puerto
(y FileMCASTAddrCount) : Direccin
IP:puerto destino usados por el servidor REMBO cuando se envan datagramas
multicast para el protocolo MCAST (leer el manual para ms informacin).
FileMCASTTTL ttl : Time-To-Live asignado a los datagramas multicast enviados por el
servidor a los clientes cuando se usa el protocolo MCAST. (leer el manual para ms
informacin).
FileMCASTEncrypt : Encripta todos los datagramas enviados con el protocolo MCAST
FastEncrypt : Encripta todos los datagramas enviados con el protocolo FAST (leer el
FastPort puerto : Puerto usado por el servidor cuando los clientes usan el protocolo
FAST para enviar paquetes al servidor (leer el manual para ms informacin).
2.2.3.- Parmetros de configuracin relacionados con la

tolerancia a fallos
Un sistema de tolerancia a fallos es aquel capaz de continuar incluso cuando falla uno de sus
componentes. En el caso de los servidores REMBO puedes configurar un servidor para que no
responda a peticiones del cliente a menos que el servidor primario haya cado. Esto asegura
alta fiabilidad cuando el servidor primario falla o se estn llevando a cabo tareas de
mantenimiento que requieren el apagado del equipo.
Gua de referencia rpida de parmetros de tolerancia a fallos
Backup direccin_ip : Direccin IP de un servidor REMBO backup (leer el manual para

ms informacin).
BootReplyDelay segundos : Segundos que esperar el servidor antes de mandar
paquetes de respuesta a un paquete de descubrimiento multicast, a uno BINL o a uno
de descubrimiento DHCP (leer el manual para ms informacin).
Pgina 23
2.3.- Dominios de autentificacin

Un dominio de autentificacin es un grupo de parmetros relativos a la autentificacin de
usuarios por REMBO. El trmino dominio no tiene nada que ver con los dominios de Windows
NT o los dominios NIS+. Los parmetros contenidos en un dominio de autentificacin definen
cmo la informacin del usuario y clave introducida en el equipo de un cliente REMBO es
chequeada por el servidor. Por ejemplo, podra chequearse en una base de datos local al
servidor o a travs de un dispositivo de autentificacin remota (con Radius). Asimismo REMBO
puede restringir la bsqueda a grupos simples de usuarios en entornos NT o Unix para mayor
flexibilidad.
El servidor REMBO soporta varios protocolos de autentificacin dependiendo de la plataforma
del servidor:
En Windows NT un usuario puede identificarse con la base de datos local o con una
base de datos remota (tambin ubicada en un servidor NT).
En Unix el usuario se identifica con las funciones de la base de usuarios estndar, que
puede configurarse para usar ficheros locales, NIS o NIS+.
En ambas plataformas, el servidor REMBO puede usar la autentificacin estndar de
Radius con un dispositivo que soporte el protocolo Radius, o con una puerta de enlace
(gateway) Radius para Netware (NDS) por ejemplo.
Nota: bajo Windows NT la autentificacin solo puede hacerse si el usuario que ejecuta
REMBO tiene el permiso Actuar como parte del Sistema Operativo. Por defecto, la cuenta de
usuario utilizada para los servicios lo tiene (cuenta System).
Si ests usando una configuracin basada en ficheros (p.e. Unix), debe aadir los dominios
de autentificacin al fichero de configuracin. Cada dominio comienza con AuthLocalDomain,
AuthNTDomain (en Windows NT solamente), o AuthRadiusDomain, seguidos por el nombre
que quieres atribuir al dominio. El nombre del dominio puede ser usado en grupos y as unir
grupos de autentificacin y grupos de usuarios. Un ejemplo con las 3 formas de autentificacin:
AuthLocalDomain lcltest {
UserGroup "rembo"
}
AuthNTDomain ntatest {
AuthServerName "company-pdc"
Usergroup "rembo"
}
AuthRadiusDomain radtest {
AuthServerAddress 192.168.1.15
RadiusSecret "testing123"
}
Si utiliza una configuracin basada en registros puede aadir un nuevo dominio de

autentificacin con la consola del servidor pinchando en la subtecla Parmetros y eligiendo
Aadir Dominio de Autentificacin desde el men Aadir / Eliminar. Te aparecer un formulario
para definir los parmetros del dominio.
Gua de referencia rpida para dominios de autentificacin:
Local Domains usa la base de datos local de usuarios para la autentificacin. El

parmetro opcional UserGroup puede usarse para restringir la verificacin a un grupo
especfico de usuarios. Este dominio es soportado por ambas versiones de REMBO
(Windows NT y Unix).
Pgina 24
Remote NT Domains enva la peticin de autentificacin al servidor NT especificado

en el parmetro AuthServerName. El parmetro opcional UserGroup puede usarse
para restringir la verificacin a un grupo especfico de usuarios. Este dominio es
soportado solamente por la implementacin Windows NT del Rembo.
Radius Domain enva la peticin de autentificacin a un dispositivo Radius
especificado en AuthServerAddress. El valor del parmetro RadiusSecret es usado
como el secreto en la comunicacin por Radius y debe coincidir con la palabra secreta
almacenada en la configuracin del dispositivo Radius para que el protocolo funcione.
Nota: para los clientes puedes usar dominios de autentificacin con los asistentes (wizards) o
con las funciones LogonUser y Logon de REMBO-C.
2.4.-Tneles TCP
Un Tnel TCP es una forma de proveer conectividad TCP en clientes REMBO. Un tnel TCP
define un nombre de servidor y un puerto que se hace accesible para clientes REMBO a travs
de clientes especficos Rembo-C.
Los tneles TCP pueden usarse para proveer de un amplio rango de interesantes
aplicaciones por parte del cliente. Algunos ejemplos:
Acceder a un servidor SMTP para mandar correo a un administrador si se ha detectado

algn fallo en el REMBO.
Acceder a servidores de base de datos (a travs de una puerta de enlace TCP-toODBC) para obtener informacin o instrucciones de qu tipo de operacin ejecutar, o
almacenar informacin sobre el ordenador (inventario de hardware).
Acceder a un servidor HTTP (servidor web) para extraer informacin directamente de la
World Wide Web.
Acceder a herramientas de gestin o a un interface con mtodos de autentificacin
especficos.
Si trabajas en una configuracin basada en ficheros debes aadir los tneles TCP al principio
del fichero de configuracin, antes del primer grupo del servidor. La definicin del tnel TCP se
hace como sigue:
TCPTunnel Identificador (palabra que usarn los clientes para identificar el tnel).
Ejemplo: un tnel TCP llamado sendmail que permite el envo de correo electrnico a la World
Wide Web:
TCPTunnel sendmail {
RemoteHost mail.company.com
RemotePort 25
}
Si usa configuracin basada en registros puede crear los tneles TCP desde la consola del
servidor. Elija Aadir tnel en el men pinchando con el botn derecho en el rbol del servidor.
Introduzca su identificador, un nombre de servidor (o direccin IP) y un puerto.
Gua de referencia rpida para los tneles TCP:
RemoteHost es una cadena que representa el host remoto (nombre o direccin IP)
TCP con el cul contactar cuando el cliente Rembo abre este tnel TCP. Si trabajamos
en un servidor basado en ficheros, el nombre o IP del host debe ir entre comillas.
Pgina 25
RemotePort es el puerto al cul se conectar el cliente Rembo. Puedes obtener una

lista completa de puertos vlidos en el fichero /etc/services en una mquina Unix o en
el fichero /winnt/system32/drivers/etc/services en una mquina Windows NT.
Nota: El cliente accede a los tneles TCP mediante las funciones: TCPConnect, TCPRead
TCPWrite y TCPClose.
2.5.- Grupos de servidor (Host groups)

Los grupos de servidor se usan para organizar los ordenadores en pequeas unidades. Cada
unidad tiene sus propios parmetros. Un grupo de servidor en REMBO consta de 2 partes:
Parmetros, como la pgina HTML de inicio o el dominio de autentificacin que usar.

Una lista de servidores contenidos en ese grupo. Estos hosts usarn los parmetros
genricos definidos para el grupo o puede tener parmetros especficos al servidor.
Habitualmente solo se modificarn los parmetros StartPage y Options.
2.5.1.- El grupo por defecto (default)

Existe un grupo especial, conocido como default. No requiere lista de servidores y lo utiliza el
servidor cuando se conecta un ordenador que no pertenece a ningn grupo. Si no existe el
grupo default la conexin es rechazada. Este grupo resulta una opcin especialmente
interesante en cuestiones de seguridad ya que se puede borrar y dejar exclusivamente grupos
definidos por el administrador con parmetros determinados, rechazando conexiones de
clientes que no pertenezcan a ningn grupo.
Si trabaja en una configuracin basada en registros puede aadir nuevos grupos desde la
consola del servidor: pincha en Parmetro, elija Aadir Grupo en el men Aadir / Eliminar.
Aparecer un cuadro de dilogo solicitando los valores del grupo. Ningn campo es obligatorio
y pueden dejarse en blanco. Posteriormente puede borrarse un grupo si se desea.
En la configuracin basada en ficheros puede aadir nuevos grupos insertando la orden
Group nombre en el fichero de configuracin.
Gua rpida de referencia para los parmetros de grupos de servidor
Se pueden definir a nivel de grupo (antes de la lista de servidores en una configuracin
basada en ficheros) o a nivel de servidor (para cada entrada Host o HostRange).
Fileserver direccin_ip : Direccin IP del servidor que suministra los protocolos NTEfs,
FAST y MCAST (leer el manual para ms informacin).
RemoteConsole dir_ip:puerto : Direccin IP y puerto para la consola remota de
aplicacin, y ordena al Rembo que contacte con la consola remota al prximo arranque
Options [admin][, autoboot][, novesa][, unicast] : estos parmetros definen el modo de
operacin de REMBO (leer el manual para ms informacin).
Lockout [none][, poweroff][, reset][, mouse][, keys][, screen][, all] : pueden usarse para
bloquear algn perifrico determinado durante el tiempo que REMBO est activo en el
cliente (leer el manual para ms informacin).
AuthDomain dominio : Este es el dominio de autentificacin cuando uno de los
grupos de servidor necesita comprobar la identidad de un usuario (leer el manual para
ms informacin).
Pgina 26
StartPage ruta : Pgina de inicio del cliente (leer el manual para ms informacin).
Host direccin_ip y Host direccin_hardware : Valores de cada servidor en la lista de
servidores (leer el manual para ms informacin).
HostRange startip->endip : Rango de servidores (leer el manual para ms
informacin).
Pgina 27
CAPTULO 3 :
servidor REMBO
Herramientas
administrativas
del
Las dos herramientas utilizadas para administrar el servidor REMBO son : NetClnt, una
utilidad de lnea de comando para acceder a los ficheros del servidor, y la Consola del
Servidor, una aplicacin de Windows para administrar todos los aspectos del servidor REMBO
con Windows NT.
3.1.- Netclnt
NetClnt es una utilidad de lnea de comando disponible para Windows, Linux y Solaris. Se
usa para acceder remotamente a los ficheros del servidor REMBO.
Algunas de las caractersticas de NetClnt son:
Las comunicaciones entre NetClnt y el servidor estn protegidas con un password y

encriptado.
NetClnt puede ser usado de forma interactiva o en modo batch.
Los ficheros pueden ser borrados, renombrados, movidos, descargados y subidos. Los
directorios pueden ser slo borrados, renombrados y movidos.
Los ficheros son descargados con el protocolo NETfs y cargados con el protocolo
FAST.
3.1.1.- NetClnt Interactivo

Simplemente hay que ejecutar el fichero netclnt en el directorio misc que se encuentra dentro
del directorio de instalacin de REMBO. Vers el prompt NETFS>. Puedes utilizar los
comandos interactivos de NetClnt pero lo primero que tienes que hacer es abrir una conexin
con el servidor REMBO.
3.1.1.1.- Primer paso: conexin con el servidor REMBO

Para abrir una conexin con el servidor REMBO hay que usar el comando open seguido de la
direccin IP (o hostname) del servidor. A continuacin te pedir un password que es el mismo
que le pusimos en el fichero de configuracin (rembo.conf) en el parmetro global
NetPassword.
Usando el comando open no se generar trfico en la red.
3.1.1.2.- Segundo paso: comprobacin de la conexin

Para comprobar la conexin se utilizar el comando dir. Este comando descargar y mostrar
el contenido del directorio actual en el servidor remoto.
3.1.1.3.- Tercer paso: experimentando con la conexin

Ya se puede usar cualquier comando de NetClnt. Puedes enviar un nuevo fichero al servidor
(put), cambiar el directorio actual (cd) u obtener localmente un fichero del servidor (get). Hay
Pgina 28
que tener en cuenta que si quiere enviar un fichero al servidor ste debe existir en tu ordenador
local en el directorio actual (para cambiar el directorio actual local se utiliza lcd).
3.1.2.- Usando NetClnt en modo batch

Para usar NetClnt en modo batch crearemos un fichero de texto con la secuencia de
comandos que queremos que se ejecuten con NetClnt y ejecutar netclnt filename donde
filename es el nombre del fichero de texto que hemos creado con la lista de comandos. El
primer comando debe ser open con una direccin de IP vlida y un password vlido (el
password puede ser pasado como tercer parmetro del comando open).
Ejemplo del modo Batch :
open 192.168.1.10 rembopwd
mkdir /myfiles
cd /myfiles
put file1
put file2
put file3
exit
3.1.3.- Comandos de NetClnt
open host [password] / connect host [password]

Este comando es el primero que se deber utilizar porque es el que hace que comience
la conexin de informacin requerida para acceder remotamente al servidor REMBO.
Es recomendable poner el password en la lnea de comando porque si no lo
especificamos ahora nos ser pedido ms tarde.
dir [path] / ls [path]

Muestra el contenido de un directorio del servidor remoto. Si no se especifica ningn
parmetro el directorio que se muestra es el actual.
cd path / chdir path

Cambia el directorio actual remoto. Al comenzar NetClnt el directorio actual es el root
del sistema de ficheros del servidor. El path es el relativo al directorio actual remoto.
md path / mkdir path

Crea un nuevo directorio en el servidor.
rd path / rmdir path

Borra un directorio del servidor. El directorio debe estar vaco.
deltree path
Borra un directorio remoto y todos sus subdirectorios. Este directorio no tiene que
estar vaco pero USA ESTE COMANDO CON PRECAUCIN.
Pgina 29
pwd
Muestra el directorio remoto actual.
ren old-name new-name / move old-name new-name

Renombra o mueve un fichero del servidor. El nuevo fichero y el antiguo deben ser
especificados.
del path / rm path

Borra un fichero del servidor.
lcd path
Cambia el directorio actual del ordenador local. Este comando no tiene efectos sobre
el servidor. Slo modifica el directorio actual del ordenador que arranca NetClnt.
!localcommand
Ejecuta un comando en el ordenador local. Por ejemplo, !dir muestra el contenido del
directorio actual del ordenador local. !edit myfile edita el fichero myfile con el editor de
MS-DOS.
get remote-path [local-path] / mget pattern

Descarga el fichero remoto remote-path desde el directorio remoto actual en el fichero
local-path dentro del directorio local actual. Si el segundo parmetro es omitido el
fichero se cargar bajo el nombre de remote-path. Mget descarga todos los ficheros
remotos que se correspondan con el patrn pattern al directorio local.
put local-path [remote-path] / mput pattern

Carga el fichero local local-path desde el directorio actual local sobre el fichero remotepath en el directorio actual remoto. Si el segundo parmetro es omitido el fichero se
carga bajo el nombre de local-path en el servidor. Mput carga todos los ficheros que se
correspondan con el patrn pattern al directorio remoto.
wake hardware-address
Enva un paquete wake a la direccin hardware especificada. El ordenador al que se le
enva dicho paquete debe encontrarse en la misma red que el ordenador en el que se
est ejecutando NetClnt. Tambin, dicho ordenador debe permitir wake-on-lan desde
la tarjeta de red. La direccin hardware no debe tener ningn delimitador. Por ejemplo,
la direccin hardware 00:10:4B:12:34:56 debe ser puesta en el comando wake como
00104B123456.
Pgina 30
sleep sleeptime
Espera sleeptime segundos. No se ejecuta ningn comando durante este tiempo. Este
comando es utilizado en los batch scripts.
getlock lockname / releaselock lockname

Realiza un servidor de cierre. ste es identificado por un nombre (lockname).
3.2.- Consola del servidor

Esta seccin da instrucciones sobre el uso de la aplicacin de consola del servidor REMBO,
disponible para Windows NT.
3.2.1.- Introduccin
SConsole es una poderosa aplicacin para administrar el servidor REMBO. Puede ser usado
para:
control del estado operativo del servidor.

iniciar, parar y reiniciar el servidor.
modificar los parmetros de configuracin remotamente.
crear accesos a host y accesos a grupos.
cargar ficheros desde y al sistema de ficheros del servidor.
mirar los ficheros log del servidor.
editar variables constantes.
Todas estas operaciones pueden ser ejecutadas sobre un servidor REMBO local, o sobre un
servidor remoto.
La consola del servidor debe ser ejecutada como un administrador local o como un usuario
con suficientes privilegios para acceder al registro en modo lectura / escritura.
3.2.2.- La interfaz
La interfaz de la consola del REMBO es similar al explorador de Windows. A la izquierda
podrs ver a los servidores y temas de configuracin (parmetros, ficheros...) y a la derecha
vers todos los elementos correspondientes al tema activado en el panel de la izquierda. Cada
nivel de jerarqua tiene sus propios elementos y sus propias acciones. Puedes usar el botn
de la derecha para mostrar un men contextual basado en la localizacin actual que tiene en la
jerarqua.
3.2.3.- Aadir un servidor

Para aadir un nuevo servidor a la lista de servidores (en la parte izquierda de la ventana
principal), elija aadir servidor desde el men Add/Remove o click con el botn derecho del
ratn sobre el icono del servidor del REMBO en la parte de arriba de la lista mostrada a la
izquierda del panel: {bmct bmp/rembo.bmp}
Pgina 31
SConsole soporta tres tipos diferentes de servidores: servidor local, servidor remoto NT y
servidor remoto no-NT.
3.2.3.1.- Servidor local

Este tipo de servidor se usa cuando el servidor y la consola estn ejecutndose en el mismo
ordenador. La consola mirar en el registro local NT para buscar y editar los parmetros del
servidor. Por defecto, un icono para el servidor local es aadido cuando Sconsole comienza si
un servidor local ha sido detectado.
3.2.3.2.- Servidor remoto NT

Se usa cuando se utiliza un servidor REMBO remoto (no se encuentra en el mismo ordenador
que la consola). La consola usar Windows NT para abrir el sistema de registros sobre el host
remoto. Esto significa que debe tener suficientes privilegios para abrir y escribir en el registro
sobre el ordenador remoto.
3.2.3.3.- Servidor remoto sin NT

Si el servidor REMBO se ejecuta bajo Linux o Solaris, se usa este tipo de servidor para
acceder a los ficheros del servidor. La consola no puede leer o escribir la configuracin de un
servidor Linux/Solaris remotamente.
3.2.4.- Estado del servidor

Puedes ver el estado del servidor REMBO haciendo click sobre el icono de estado que se
encuentra debajo del icono del servidor en la parte izquierda del panel.
La primera lnea de la parte derecha del panel muestra el actual estado del servidor. Puede
mostrar uno de estos valores:
RUNNING: el servidor est operativo y ejecutndose.
STOPPED: el servidor no se est ejecutando.
START_PENDING: el servidor est intentando comenzar.
STOP_PENDING: el servidor est intentando parar.
3.2.5.- Arrancando el servidor

Si el estado del servidor es STOPPED, puedes arrancar el servidor REMBO haciendo click
con el botn derecho del ratn sobre la lnea del estado STOPPED en la parte derecha del
panel y eligiendo la opcin Start Server, o simplemente elegir la opcin Start Server desde el
men del servidor.
Pgina 32
3.2.6.- Parando el servidor

Si el estado del servidor es RUNNING, puedes parar el servidor REMBO haciendo click con el
botn derecho del ratn sobre la lnea del estado RUNNING en la parte derecha del panel y
eligiendo la opcin Stop Server, o simplemente elegir la opcin Stop Server desde el men del
servidor.
3.2.7.- Recargando la configuracin del servidor

Para ello solamente tenemos que hacer click con el botn derecho del ratn sobre la lnea de
estado en la parte derecha del panel y elegir la opcin Restart server o elegir Restart server en
el men del servidor.
Este comando fallar si el estado del servidor no es RUNNING.
3.2.8.- Modificacin de los parmetros

Puedes usar la consola del servidor para modificar los parmetros globales, autentificacin de
dominios y grupos de host. Para completar la descripcin de dichos parmetros vase captulo
2.
Los parmetros son accesibles slo si el servidor es un servidor local o un servidor remoto
NT. Por lo tanto, puedes acceder a todos los parmetros desde el icono Parameters :
Los parmetros bsicos son accesibles directamente desde la seccin Parameters.
Los parmetros globales se encuentran dentro de la seccin Parameters\Advanced.
Los dominios de autentificacin los podemos encontrar dentro de la seccin

Parameters\AuthDomains
Y por ltimo, los grupos de host se encuentran en la seccin Parameters\Groups
Podemos cambiar cualquiera de estos parmetros haciendo click sobre estos nombres con el
botn derecho del ratn sobre la ventana derecha y seleccionando Modify en el men
contextual.
3.2.9.- Modificacin de las variables

Puedes aadir, modificar o borrar las variables persistentes desde la consola del servidor.
Estas variables estn definidas en la seccin 3.3 del manual para clientes REMBO.
El acceso a estas variables esta limitado para el servidor local y servidor remoto NT.
Una variable persistente puede ser global, local a un grupo o local a un host. Las variables
globales se encuentran en la seccin Parameters\Variables. La ventana derecha muestra la
lista de variables ya definidas. Para aadir una nueva variable, hacemos click con el botn
derecho del ratn en la ventana derecha y seleccionamos New integer variable, New string
variable o New boolean variable en el men contextual. Puedes modificar stas en las
variables haciendo click con el botn derecho del ratn sobre ellas en la ventana derecha y
seleccionar Modify en el men contextual. Para borrar una variable tambin tenemos que hacer
click sobre el nombre de la variable con el botn derecho del ratn y elegimos Delete en el
men contextual.
Pgina 33
Para acceder a las variables locales a un grupo especfico de hosts, haz click en el icono
Variables debajo del icono de grupo que quieres modificar en el rbol de directorios. El resto es
como se ha indicado para las variables globales.
Las variables locales a un host son accesibles en el icono Variables bajo el icono de host de
la entrada de host que se quiera modificar.
3.2.10.- Ver los ficheros de log

La consola permite acceder a los ficheros log creados por el servidor durante su ejecucin.
Estos ficheros contienen informacin muy til cuando se tiene la sospecha de que algo va mal.
Hay tres ficheros log que pueden ser vistos desde la consola:
Boot Log, el cual contiene informacin acerca del servicio PXE Proxy, del servicio
PXE Boot Discovery y del servicio MTFTP.
NBP log, el cual contiene informacin acerca de los parmetros de grupo y host, de
autentificacin y del dominio NT.
File log, el cual contiene informacin acerca de todos los ficheros multicast y unicast
transferidos entre el REMBO y el servidor.
Para mirar un fichero log debemos hacer doble click sobre el nombre del fichero en el panel
derecho. El contenido del fichero ser mostrado con el editor Rembo Quick. Los ficheros log
son de slo lectura.
3.2.11.- Acceso a los ficheros del servidor

El explorador del sistema de ficheros de la consola trabaja como el explorador de Windows.
Los comandos esenciales (delete, copy, paste, makedir) estn disponibles en el men
contextual que aparece cuando hacemos click con el botn derecho del ratn sobre el objeto
que queramos en el panel derecho. Este panel se refresca con F5.
3.2.12.- Preguntas ms frecuentes
P : Quiero salvar mi fichero con el editor Rembo Quick y la consola me muestra un

tamao 0.
R : Presiona F5 para refrescar.
P: No puedo cargar ni descargar desde el explorador de la consola...
R: Algunas versiones de Windows NT parece que tienen problemas con la carga y

descarga. Usa download en el men del fichero.
P:Dnde est la funcin SaveAs en el editor Rembo Quick?
R: No existe. Copia el fichero con copy/paste antes de editarlo.
Pgina 34
CAPTULO 4 : Despliegue de REMBO en la empresa

Este capitulo describe las caractersticas necesarias en grandes corporaciones o instituciones.
La tolerancia a fallos aade robustez a su infraestructura de arranque remoto, mientras la
distribucin de ficheros es la manera ideal de distribuir imgenes de disco duro a mltiples
servidores REMBO. Tenga en cuenta que el modulo de distribucin de ficheros solo est
disponible en la edicin Enterprise de REMBO.
4.1.- Tolerancia a fallos

Un sistema es tolerante a fallos si es capaz de continuar trabajando cuando una de las partes
falla. En el caso de servidores REMBO, el sistema entero es tolerante a fallos si los servidores
REMBO estn respaldndose unos a otros. Cuando un servidor falla, otros servidores manejan
las peticiones enviadas al servidor que ha cado.
Tenga en cuenta que implementar tolerancia a fallos en el mbito de REMBO no significa que
su infraestructura de red sea tolerante a fallos. Usted est obligado a implementar tolerancia a
fallos a todos los niveles:
A nivel fsico, teniendo fuentes de alimentacin redundantes (si todos los servidores
REMBO se quedan sin energa elctrica a la vez, la tolerancia a fallos a nivel REMBO
es intil);
A nivel de red, teniendo enlaces de red de respaldo, y elementos activos de copia de
seguridad (el servidor de copias de seguridad debe ser capaz de alcanzar a los clientes
de arranque remoto);
A nivel de sistema operativo de red, teniendo mltiples dominios de red, o teniendo
servidores REMBO funcionando fuera de su arquitectura de dominios (p.e. los
servidores REMBO nunca deberan estar todos enlazados al mismo PDC NT, o al
mismo servidor NFS);
A nivel DHCP, teniendo mltiples servidores DHCP en la misma subred;
A nivel REMBO, implementando las instrucciones de tolerancia a fallos encontradas en
este captulo;
Finalmente, a nivel de sistema operativo. Si REMBO es capaz de sobrevivir a un
problema severo, pero el sistema operativo no es capaz de encontrar su servidor de
red, la tolerancia a fallos es intil.
Aqu veremos como implementar la tolerancia a fallos a niveles DHCP y REMBO. Los otros
niveles estn fuera del mbito de este documento.
4.1.1.- Tolerancia a fallos a nivel DHCP

El protocolo DHCP ha sido diseado de forma que permita implementar tolerancia a fallos y
balanceo de carga fcilmente. Si dos servidores DHCP estn conectados a la misma subred IP,
y ambos servidores estn configurados para entregar direcciones IP en la subred, el protocolo
manejar todos los conflictos entre los dos servidores.
Cuando un cliente remoto hace una peticin de direccin IP, la peticin es enviada a la
direccin broadcast local, es decir, a todos los hosts conectados a la misma subred IP que el
cliente remoto. Si uno o ms servidores DHCP estn conectados a la subred, ellos enviarn un
paquete de ofrecimiento DHCP al cliente remoto, conteniendo una direccin IP almacenada en
la lista de direcciones disponibles en el servidor, o asignadas por el administrador al cliente
remoto. Si ms de un paquete de ofrecimiento DHCP es recibido por el cliente remoto, slo el
"ms informativo" ser conservado por el cliente. Por "informativo", queremos decir que
ofrezcan suficiente informacin PXE para avanzar en la resolucin PXE.
Pgina 35
Cuando un cliente remoto ha seleccionado una oferta vlida, contesta al servidor desde donde
se origin el paquete broadcast. Este paquete es recibido por todos los hosts conectados a la
subred local, incluyendo los servidores DHCP. Este paquete es usado por los servidores DHCP
para saber si sus ofertas han sido aceptadas o rechazadas por el cliente remoto. Si la oferta ha
sido aceptada, la direccin IP es bloqueada en la base de datos del servidor DHCP, y el
proceso DHCP puede continuar en modo unicast entre el cliente remoto y el servidor DHCP. Si
la respuesta es para otra oferta, el servidor liberar la direccin IP que ofreci, y bloquear la
direccin IP enviada en la contestacin de la oferta, para marcar la direccin IP como usada en
la subred local.
Usted puede adems implementar tolerancia a fallos configurando mltiples servidores DHCP
para la misma subred. Si los servidores DHCP estn configurados de manera idntica,
entonces los clientes remotos siempre seleccionarn la primera oferta, o sea, la que venga del
servidor ms rpido. Esto puede ser usado para implementar balanceo de carga a la vez que
tolerancia a fallos: el servidor ms rpido siempre es seleccionado, y si el servidor ms rpido
se sobrecarga, ser otro el que enve las ofertas ms rpido, y llegar a ser el servidor ms
rpido.
4.1.2.- Tolerancia a fallos a nivel REMBO

La tolerancia a fallos a nivel REMBO est implementada con dos parmetros de
configuracin: Backup y BootReplyDelay.
Para comprender como est implementada la tolerancia a fallos a nivel REMBO, debe
recordar que el proceso de arranque es hecho en varias fases: resolucin DHCP, resolucin
PXE, descarga MTFTP y finalmente REMBO. La tolerancia a fallos a nivel DHCP es descrita en
la seccin previa. La tolerancia a fallos a nivel PXE puede conseguirse usando mltiples
servidores REMBO en modo Proxy DHCP (p.e. no hay servidor REMBO en la maquina servidor
DHCP, pero todos los servidores REMBO estn conectados a la subred). En modo Proxy
DHCP, los servidores REMBO enviarn paquetes de contestacin PXE al paquete de
resolucin DHCP inicialmente enviado por el cliente remoto. Como los paquetes de resolucin
DHCP son enviados a las direcciones broadcast, todos los servidores REMBO recibirn la
resolucin, y enviarn un paquete de contestacin, con las siguientes consideraciones:
El cliente remoto debe ser conocido por el servidor (siendo miembro de un grupo en la
configuracin del servidor, o si la configuracin contiene un grupo por defecto);
El servidor no contestar inmediatamente si el parmetro BootReplyDelay est puesto.
Puede usar BootReplyDelay para introducir preferencias de orden en la misma subred. El

servidor con el BootReplyDelay ms bajo (o sin BootReplyDelay puesto) ser el primero en
contestar a los paquetes de resolucin DHCP. Todos los clientes remotos sern
redireccionados a este servidor. Pero si el servidor falla, el servidor con el segundo valor de
BootReplyDelay ms bajo ser el primero en contestar, y as sucesivamente. La tolerancia a
fallos a nivel resolucin PXE est aqu.
Si varios servidores REMBO (o todos) tienen el mismo valor para el parmetro
BootReplyDelay, ellos enviarn la contestacin PXE a la vez, y el cliente remoto seleccionar el
primero, o el servidor ms rpido. Este entorno especfico puede ser usado para implementar
carga balanceada a nivel REMBO.
Una vez el cliente remoto ha seleccionado su servidor DHCP y PXE, la secuencia de inicio
REMBO puede ser descargada desde el servidor PXE (servidor REMBO), y el cliente REMBO
iniciado. Puede implementar tolerancia a fallos dentro de REMBO usando el parmetro Backup
para especificar un servidor de respaldo. Este valor ser enviado al cliente remoto durante el
arranque inicial del cliente REMBO, y ser usado como servidor de respaldo si el servidor
primario falla. El protocolo interno de red usado en REMBO ha sido diseado para permitir al
Pgina 36
cliente cambiar del servidor primario al de respaldo en mitad de una transferencia de ficheros.
Sin embargo, esto solo funciona bajo las siguientes consideraciones:
Los ficheros abiertos en modo escritura (subidos al servidor) no pueden ser cambiados
a un servidor de respaldo. Esto puede ocasionar corrupcin de datos en el servidor,
porque una parte del fichero puede ser escrito en el servidor primario, y la otra parte en
el servidor de respaldo;
La estructura del sistema de ficheros en los servidores primarios y de respaldo debe
ser estrictamente idntica (p.e. el mismo contenido bajo el directorio files del servidor).
Sugerimos usar servidores de respaldo a nivel REMBO (con el parmetro Backup) cuando
haya estabilizado su sistema (imgenes de disco duro realizadas, scripts listos). Una vez todo
est estabilizado en el servidor principal, copie el directorio files del servidor primario al servidor
de respaldo, y ajuste el parmetro Backup en el servidor principal.
4.2.- Front-end de la distribucin

El front-end de la distribucin solo est disponible para la edicin Enterprise de REMBO.
Pgina 37
MANUAL DE ADMINISTRACIN DEL

CLIENTE
Manual de Administracin del Cliente
CAPTULO 1 : Conceptos sobre REMBO

Si ya estas familiarizado con programas de arranque remoto, puedes saltarte este captulo y
saltar directamente al captulo 2.
1.1.- Qu es Rembo?
Rembo es un programa de arranque remoto PXE. Este tipo de programas se diferencia de
cualquier otro por varias razones:
Se le llama durante el arranque del ordenador, antes que a ningn sistema operativo o
administrador de arranque de disco.
Depende de la presencia de un chip especial en la tarjeta de red, la Boot Rom.
Es capaz de usar la red gracias a una interfaz facilitada por la boot rom. PXE es el
estndar de facto para este tipo de interfaz.
Se baja de un servidor especial de arranque, y no depende de ningn dispositivo de
almacenamiento local. Puede trabajar en ordenadores sin disco duro o sin unidad de
disquete. Si los tiene puede usarlos, pero el arranque no fallar si estos dispositivos s
lo hacen.
Consigue sus parmetros (direccin IP y otros parmetros de arranque) de un servidor
DHCP.
Una vez comenzado se comporta como un mini-Sistema Operativo. Puede ejecutar varias
operaciones, que pueden ser divididas en cuatro categoras: Operaciones de fichero, de red, de
interfaz de usuario y de sistema. Algunas de las operaciones ms tiles son:
Autentificacin de usuarios.
Acceso a ficheros independientemente del SO : Rembo puede acceder a sistema
de ficheros NTFS, FAT, EXT2.
Interfaz HTML.
Imgenes de disco : esta caracterstica se puede usar para clonar sistemas
operativos o para restaurar sistemas inestables.
Sistema de fichero de red : el servidor de Rembo es un poderoso software multitarea
con su propio sistema de archivos. Los ficheros del servidor pueden ser cargados por
el cliente ejecutando Rembo.
Agrupar ordenadores : los ordenadores se pueden agrupar en el fichero de
configuracin del servidor para compartir las mismas opciones de arranque. Cada
ordenador o grupo de ordenadores pueden tener sus propias opciones.
1.2.- Cmo trabaja ?

Una secuencia tpica de arranque remoto sigue las siguientes fases.
Encendido : el ordenador con arranque remoto se enciende, tanto por un usuario

como por un evento programado.
Obtencin de la direccin IP : el cliente remoto hace una peticin DHCP para
conseguir su IP. Cualquier servidor DHCP que conozca al cliente (es decir, reconozca
su direccin ethernet) o que tenga direcciones IP dinmicas libres le enva una
direccin IP.
Pgina 40
Descubrimiento del servidor de arranque : el servidor de arranque es el encargado

de servir el programa de arranque al cliente. No tiene que ser necesariamente la misma
mquina que el servidor DHCP. El cliente responder al primer servidor de arranque
que le conteste, y se bajar un pequeo programa de arranque usando un protocolo
multicast (MTFTP).
Conexin BNP : con este servicio el cliente obtiene la informacin de cmo tiene que
ser configurado.
Configuracin Pre-SO : Rembo, entonces, descargar un fichero del servidor de
arranque con todo lo que es necesario para llevar a cabo una configuracin especfica
del administrador del sistema.
Arranque del SO : Rembo se borra de la memoria y deja al ordenador iniciar el SO,
como si el ordenador estuviera arrancando normalmente del disco duro. Esto
asegurar una compatibilidad total con los sistemas operativos.
El servidor Rembo debe estar siempre disponible para el cliente, pero para el caso de graves
fallos en la red, los clientes Rembo se pueden configurar para trabajar en modo off-line, es
decir, sin acceso a la red.
1.3.- Requisitos para el sistema cliente

El cliente arranque remoto debe estar equipado con un bootrom PXE. Recomendamos
comprar tarjetas de red actualizables para poderlas actualizar con la ultima versin PXE
disponible. Actualmente la mejor implementacin de PXE est en las tarjetas de red de Intel.
3COM, IBM y RealTek tambin lo suministran.
Pgina 41
CAPTULO 2: Comenzando a usar REMBO

A lo largo de este captulo descubriremos como trabaja Rembo, qu tipo de tareas puede
ejecutar y cmo controlar el comportamiento de cada ordenador usando Rembo.
2.1.- Arrancando Rembo por primera vez

La pantalla de Rembo se divide en dos partes: el escritorio y la barra de herramientas. El
contenido del escritorio esta determinado por una pgina HTML almacenada en el servidor. Por
defecto este fichero se llama rembo.shtml, pero es posible configurar un fichero diferente para
uno o varios ordenadores. Puedes personalizar libremente el aspecto de Rembo editando este
fichero. La barra de herramientas tiene un men a la izquierda que tambin puedes
personalizar.
Atencin : Durante tu exploracin de Rembo, asegrate que lo ests ejecutando en modo
Administrador. La barra de men debera tener al menos 4 opciones, incluido una que se llama
Interact... Si no es el caso debes activar el modo administrador para esta mquina. Si ests
usando un servidor Linux, puedes hacerlo aadiendo una lnea como :
Options admin
al comienzo de la definicin de grupo en el fichero rembo.conf y manda una seal kill HUP al
servidor.
A menos que se configure de otra forma, Rembo comienza un asistente interactivo al
arrancar. Muestra la informacin del cliente en la parte superior derecha y un men emergente
que te permite experimentar las caractersticas bsicas de Rembo.
2.1.1.- Cambiar la pgina de comienzo

Tienes varias posibilidades para editar la pgina HTML del escritorio.
Editndola usando el editor de texto de Rembo, tecleando el siguiente comando en el

Evaluador interactivo: TextEdit(net//global/rembo.shtml);
Editndola en el servidor usando la consola de administracin del servidor (la consola
solo se ejecuta bajo Windows).
Editndola en cualquier ordenador y luego descargarla usando el programa netclnt.
2.1.2.- Mostrar la consola Rembo

Si cometes errores en tus scripts, por ejemplo, puedes querer comprobar la consola local para
un detallado informe de otros mensajes informativos. Para hacer esto, usa la opcin Show
console en la barra de men. Esto abrir una ventana con todos los sucesos de inters.
Tambin puedes leer ah si Rembo s esta ejecutando en modo Administrador o no.
Puedes probar a hacer que la ventana de la consola aparezca por s misma editando el
fichero rembo.shtml y reemplazando el HideConsole() por ShowConsole().
Pgina 42
2.2.- Experimentando con los scripts de Rembo

El modo interactivo de Rembo te permite evaluar expresiones simples una por una y ver los
resultados inmediatamente en la consola. Este modo es muy til para comprobar comandos
individuales que sern luego incluidos en los scripts.
2.2.1.- Arrancar el evaluador interactivo

El evaluador interactivo est disponible desde el men de inicio cuando el cliente esta
configurado en modo administrador.
2.2.2.- Funciones bsicas

Con la consola de REMBO visible, pruebe a evaluar los siguientes comandos :
Log(Hello <I>world<I>); Imprime en la consola el texto entrecomillado.

Keyb(es); Carga el mapa de teclado del pas seleccionado.
Log(GetPrimaryPartitions(0)); Muestra el contenido de la primera tabla de particiones
de tu primer disco duro
str part = Get PrimaryPartitions(0); esto hace lo mismo pero en lugar de mostrarlo
por la consola, lo guarda en la variable part.
PowerOff();
2.2.3.- Funciones de disco

Atencin : los comandos que se muestran a continuacin acceden al contenido de tu disco
duro. No usarlos en ordenadores con informacin til en los discos.
SetPrimaryPartitions(0,FAT16:200000);
Este comando cambiar la tabla de particiones, y crear una nica particin FAT16 de
200 MB. Solo cambia la tabla, no formatea.
HDClean(0.0);
Este comando limpia el master boot record (MBR) del primer disco duro.
HDClean(0,1);
Hace un formateo rpido de la primera particin del primer disco duro. En este caso
crear una particin vaca de 200MB con FAT16
CreateTextFile(disk://0:1/greetings.txt,From Rembo);
Este comando crea un fichero de texto llamado greetings.txt en el directorio raz de la
particin recin formateada. El nombre del fichero se da en formato URL.
CreateDir(disk://0:1/temp);
Crea un nuevo directorio llamado temp.
FloppyBoot();
Permite al ordenador arrancar desde un disquete, por ejemplo, para instalar un sistema
operativo manualmente o para verificar que Rembo ha hecho realmente lo que se
supone que hace.
Por supuesto, el objetivo de Rembo no es formatear los discos duros y/o reinstalar un sistema
operativo manualmente. En la seccin 3.4 aprenderemos a usar imgenes de disco para
automatizar la instalacin de sistemas operativos y cmo configurarlo automticamente.
Pgina 43
CPITULO 3 : Trabajando con REMBO

A lo largo de este tema vamos a tratar los siguientes temas :
Acceso a ficheros bajo REMBO (URLs).

Uso de la pseudo-particin cach de disco.
Imgenes de discos-floppy y discos-Ram.
Creacin y restauracin de imgenes de discos duros (clonacin).
Personalizacin del sistema destino (registros y parches)
Autentificacin de usuarios.
Escribir tus propios scripts de REMBO.
Arrancar REMBO sin conexin a red.
3.1.- Acceso a ficheros mediante REMBO

Todos los ficheros y directorios se identifican mediante una URL. Una URL es como un path,
excepto que aade dos campos junto al path. Estos dos campos permiten que el recurso sea
globalmente localizado.
Un URL Rembo tiene tres campos:
Tipo o prefijo: indica el mtodo usado para encontrar el recurso especificado.

disk
floppy
cdrom
ram
net
cache
reg
arch
link
display
loop
var
Disco duro local

Unidad de disco floppy local
Disco CD-Rom
Discos Ram de Rembo
Fichero remoto, accedido a travs de NETfs
Fichero remoto, accedido a travs de la particin
cach local
Registro Windows NT
Archivo de imagen de disco de Rembo (solo lectura)
Sistema de archivos virtual Rembo
Interfaz de usuario Rembo
Dispositivos Loopback
Ficheros de mapeado de memoria Rembo
Tabla 3-1. Tipos URL definidos en Rembo
Dispositivo raz : identifica el dispositivo, mquina o dominio en el cual est

almacenado el recurso.
Pathname : es la localizacin actual del fichero en el dispositivo raz especificado
anteriormente.
3.2.- Protocolos de red

Se usan varios protocolos de red para la comunicacin entre el cliente y el servidor Rembo :
Pgina 44
NETfs
UDP Protocolo de ficheros

Unicast
MCAST
UDP
Protocolo
para
transferencia
de
ficheros
Multicast
FAST
UDP
Protocolo
para
transferencia
de
ficheros
Unicast
Tabla 3-2. Protocolos de red usados por Rembo
Se usa para los ficheros

net:
Se usa para bajar los
ficheros cache:
Se usa para enviar los
ficheros cache:
3.2.1.- Protocolo NETfs

El protocolo NETfs se usa para todas las operaciones de ficheros realizadas por el cliente en
el servidor. Tales como borrar un fichero, renombrarlo, crear un directorio, buscar un fichero...
Tambin se usa para transferencias entre servidor y cliente (download) y entre cliente y
servidor (upload) cuando el path del fichero comienza por net:
La transferencia de ficheros podra ser menos eficiente que los otros dos protocolos debido a
su estructura de protocolo de peticin-respuesta.
3.2.2.- Protocolo MCAST

Se trata de un protocolo multicast que se usa para transferencia de ficheros desde el servidor
a los clientes REMBO. Se usa por defecto cuando el path del fichero comienza por cache: o se
le puede llamar con la funcin Download.
Nota : Si no hay particiones locales, se usa NETfs en lugar de MCAST para bajar los ficheros
cache:.
Por defecto la transferencia no est encriptada pero puedes encriptarla con el parmetro del
servidor MCASTEncrypt (es ligeramente ms lento).
No requiere ninguna sincronizacin entre las maquinas clientes, como ocurre con otros
protocolos multicast. Cuando un cliente quiere bajarse un fichero usando MCAST, le hace una
peticin al servidor del fichero y o bien se une a una sesin multicast ya existente o bien crea
una nueva. Si el cliente se une a una sesin que ya exista, puede que no reciba todos los
paquetes del fichero porque s uni a la sesin despus de que algunos paquetes ya fueran
enviados. En ese caso los paquetes perdidos se pedirn automticamente cuando el cliente se
convierta en la estacin primaria para la sesin multicast, es decir, se convierta en el master de
esa sesin.
MCAST es un protocolo con muy buen rendimiento. Puede saturar fcilmente una red de
10Mb/s con trafico Multicast. Si quieres limitar el ancho de bando usado por MCAST para
prevenir la congestin de la red, puedes configurar la variable Settings/MCASTSpeed a un
valor distinto de cero para hacer ir ms despacio las transferencias MCAST.
Si la variable Settings/UseMCAST esta puesta a false, REMBO usar NETfs en lugar de
MCAST para bajar los ficheros cache: a la particin cach local.
Nota : Por favor, lea la siguiente seccin si necesitas transferir varios ficheros con MCAST.
Pgina 45
3.2.3.- Protocolo Metacast

Mientras que slo se transfiera un fichero a la vez, el protocolo MCAST en su forma actual es
el ms eficiente para mandar dicho fichero a varios clientes. Sin embargo, si un grupo de
clientes pide varios ficheros en un corto periodo de tiempo, podras observar varias
transferencias MCAST a la vez, porque una vez que un cliente ha bajado un fichero, pedir el
siguiente, mientras que otros clientes pueden no haber completado la transferencia del primero.
La consecuencia de esto es que se realizan varias transferencias MCAST a la vez, lo que
llevara una congestin de la red y a timeouts.
Metacast es un conjunto de scripts de Rembo-C que aaden el concepto de sincronizacin al
protocolo MCAST. Metacast trabaja como sigue:
Todos los clientes participantes tienen una lista de ficheros para bajarse y el mismo
nombre de sesin metacast.
Todos los clientes de una misma sesin, acuerdan el nmero de clientes que tienen
que estar presentes antes de que comience a transferirse el primer fichero, o un
timeout global desde que el primer cliente se una a la sesin y el primer fichero sea
transferido (sincronizacin al comienzo de la transferencia).
Una vez que el nmero requerido de clientes han alcanzado el punto de sincronizacin
o ha terminado el tiempo de espera, el servidor enva el primer fichero. Todos los
clientes reciben el fichero y esperan a que el ltimo cliente lo termine de recibir
(sincronizacin al final de la transferencia).
Cuando todos los clientes han completado la transferencia, se programa el siguiente
fichero a transferir. Todos los clientes comienzan a descargarlo en el momento fijado
(transferencias programadas).
Estas restricciones de sincronizacin aseguran que slo se est transfiriendo un fichero a la

vez en la red, incluso si cada cliente tiene que recibir varios ficheros. Gracias a esto se anula la
congestin de la red que se provocaba por mltiples transferencias MCAST.
Metacast se recomienda para la transferencia programada de muchos ficheros. Dado que
metacast requiere algunas acciones administrativas antes de comenzar una transferencia
(elegir el numero de clientes o el timeout global, comenzar los ordenadores al mismo tiempo)
es la mejor recomendacin para transferencias de una nica vez, tales como la inicializacin de
cientos de ordenadores. Mcast es la opcin preferida para las operaciones del da a da, donde
la cantidad de datos a transmitir es mnima y la sincronizacin manual no es posible.
3.2.4.- Protocolo FAST

El protocolo FAST es un protocolo unicast usado para las transferencias desde el cliente al
servidor Rembo (upload). Se usa por defecto cuando el path del fichero comienza por cache: ,
incluso si no hay una particin cach local.
FAST se ha diseado para superar el funcionamiento limitado de NETfs cuando enviaba
grandes imgenes de disco al servidor. Esta basado en UDP, y usa timeouts adaptive y
ventana deslizante para obtener el mejor funcionamiento.
Por defecto no est encriptada la transferencia de ficheros, pero puedes hacerlo con el
parmetro del servidor FASTEncrypt.
FAST se ha diseado para usar el mximo de ancho de banda disponible. En algunos casos
podra ser deseable limitar el ancho de banda usado por FAST, para ello basta configurar la
variable Settings/FASTSpeed a un valor distinto de cero.
Pgina 46
3.3.- Uso de variables en REMBO

3.3.1.- Introduccin
Las variables de Rembo-C necesitan ser declaradas, pero pueden hacerse en cualquier parte
del programa. Hay varios tipos de variables en Rembo:
Variables incorporadas (built-in): Estas variables existen siempre. Obtienen un valor

por defecto al arrancar REMBO.
Variables globales: se crean en scripts de Rembo-C. Son accesibles desde cualquier
parte. Cuando se crea una nueva funcin Rembo, su contenido se almacena en una
variable global del mismo nombre de la funcin. A menos que la exportes como una
variable persistente, las variables globales se borran cuando REMBO arranca el
sistema operativo o reinicia.
Variables locales: Se crean dentro de funciones, o de forma ms general, dentro de
un bloque de cdigo. Las variables locales son accesibles solo en el mbito donde se
crean.
Variables persistentes : es un estado que se le aade al contenido de una variable
incorporada, global o local. Si el contenido de una variable se hace persistente con la
funcin Export, la variable ser automticamente recreada en el prximo arranque
durante la inicializacin de REMBO.
Estas variables pueden ser de tipo simple(escalar) o complejo, Se soportan los siguientes
tipos:
int varname: valor entero de 32 bits con signo

bool varname: booleano (valores vlidos: true o false);
str varname: cadena Rembo. Se pueden concatenar con el operador + y se puede
acceder a caracteres individuales usando la cadena como un array.
var varname: variable compleja Rembo, Este tipo de variable almacena una referencia
a una variable compleja, como un array, una estructura, buffer...
xxx varname[]: un array de elementos del tipo xxx.
3.3.2.- Variables incorporadas (built-in)

Para saber ms de las variables incorporadas ver la versin en ingls del manual.
3.3.3.- Variables persistentes

Cuando creamos una variable en uno de nuestros scripts, la variable slo existe durante la
sesin actual, ya que se almacena en la memoria del ordenador local. Cuando reiniciamos la
mquina y cargamos REMBO de nuevo perdemos el contenido de la variable.
Las variables persistentes son iguales que las variables normales, salvo que persisten
aunque se reinicie el ordenador. Una vez que una variable se declara como persistente
mantiene su valor durante la sesin actual y todas las siguientes. Esto es posible porque se
almacenan en el servidor y no en la memoria del ordenador local.
Cuando REMBO se inicia intenta cargar y ejecutar un fichero denominado autoload que se
encuentra en el servidor.
Pgina 47
3.4.- Creacin de imgenes de disco y restauracin

La creacin / restauracin de imgenes de disco es una caracterstica fundamental de
REMBO. Permite la clonacin de sistemas operativos de una forma muy eficiente. A la hora de
escribir este manual REMBO es capaz de clonar los siguientes sistemas operativos:
MS-DOS.
Windows 95 / 98.
Windows NT4 / 2000.
Linux.
3.4.1.- Ms sobre la clonacin

La clonacin es el proceso de duplicar e instalar un sistema operativo desde un ordenador de
referencia a uno o ms ordenadores destino. Esto se hace haciendo un backup de todos los
datos almacenados en las particiones del ordenador de referencia y restaurando esos datos en
los ordenadores destino.
En este documento a los datos extrados del ordenador de referencia lo llamamos imagen de
disco. Las imgenes de disco se almacenan normalmente en un fichero en el servidor, as
puede ser restaurado en los ordenadores destino sin necesidad de que el ordenador de
referencia est encendido.
Hay dos mtodos conocidos para la clonacin de particiones de disco, clonacin basada en
sectores (sector-based) o clonacin basada en estructura (structure-based). La clonacin
basada en sectores puedes ser dividida en otras dos categoras: blind analysis o allocationaware analysis. REMBO usa el mtodo de clonacin basado en estructura.
3.4.1.1.- Clonacin basada en sectores

Este es el mtodo ms simple de clonacin. Se hace un backup de todos los sectores del
disco y luego se almacenan en el ordenador destino. La herramienta de clonacin no conoce la
estructura del sistema de fichero. Este tipo de mtodo tiene la ventaja de soportar cualquier tipo
de sistema operativo. Como primera desventaja hay que sealar que la particin destino tiene
que tener el mismo tamao que la particin origen. La segunda desventaja es que tambin se
clona el espacio libre por lo que las imgenes tienen un tamao muy grande.
3.4.1.2.- Clonacin basada en estructura

La clonacin basada en estructura es lo opuesto a la clonacin basada en sectores, porque
requiere un amplio conocimiento del sistema de fichero que est instalado en el ordenador de
referencia y la capacidad de reconstruir un sistema de fichero completo en el ordenador
destino.
El mtodo de clonacin basado en estructura trabaja con ficheros y directorios ms que con
sectores, como una utilidad de backup/restore. Las ventajas que ofrece este mtodo son :
Es ms flexible que la clonacin basada en sectores. La herramienta puede seleccionar

qu ficheros salvar o restaurar ( o cuales no).
Puede restaurar ficheros en un sistema de ficheros existente, sin tener que borrar los
ficheros que ya existen.
Pgina 48
Las imgenes de disco se pueden editar para borrar ficheros o directorios que no se
quieran en el proceso de restauracin.
Puede sincronizar ms que clonar : los ficheros ya instalados en el ordenador destino
que sean idnticos al de referencia, no se copian.
3.4.2.- Crear una imagen de disco

El primer paso del proceso de clonacin es crear una imagen de una de las particiones del
disco del ordenador de referencia. Esta imagen se usar entonces para clonar este ordenador
de referencia a otro ordenadores.
La funcin implicada en el proceso de creacin de la imagen de disco es BuildDiskImage.
Los primeros dos parmetros de BuildDiskImage se usan para especificar la particin del
disco duro a copiar, mientras que el tercer parmetro es el nombre del fichero que usar
REMBO para almacenar la imagen de disco.
Nota : El nombre del fichero de la imagen de disco debe empezar con cache: o net: porque el
proceso de creacin del disco de imagen tiene una fase que se lleva a cabo en el servidor. Si
quieres almacenar la imagen en otro lugar, primero debes crearla en el servidor de REMBO, y
despus copiarla en donde quieras.
Ejemplo : Para crear una imagen de la primera particin almacenada en el primer disco duro,
y guardar el resultado en el fichero win98 en el servidor local, teclea:
BuildDiskImage(0,1,cache://global/win98);
Una vez creada la imagen, puedes bajrtela a la particin cach local y mirar su contenido
con la siguiente secuencia de comandos:
OpenArchive(testarch,cache://global/win98);
FileMan(arch://testarch/);
Usa CloseArchive para cerrar el archivo abierto y liberar recursos del sistema.
Nota : Si el tercer parmetro de la funcin BuildDiskImage es un fichero de disco existente,
REMBO actualizar esta imagen con el nuevo contenido de la particin a la que se hace
referencia en lugar de copiar la particin de forma ntegra. Esto es til si slo aades unos
pocos ficheros a tu particin de referencia y te gustara actualizar la imagen de disco para que
reflejara los cambios. Sin embargo, si quieres crear una imagen de disco nueva, entonces
debes borrarla antes de crearla de nuevo.
3.4.3.- Cmo restaurar una imagen de disco

La imagen de disco creada con REMBO puede ser restaurada posteriormente a uno o varios
clientes con la funcin RestoreDiskImage. Esta funcin toma tres parmetros: el disco duro y
el numero de particin a restaurar y el nombre del fichero que contiene la imagen de disco que
va a ser restaurada.
A continuacin se muestran algunas consideraciones que hay que tener en cuenta sobre la
restauracin de discos:
Cree particiones antes de restaurar la imagen de disco. Utilice un tipo de particin que
sea compatible con los datos almacenados en la imagen de disco.
Pgina 49
Configurar siempre particiones cach en los ordenadores destino y utilizar la referencia

URL cache para especificar el nombre del fichero que contiene la imagen de disco.
Esto mejorar enormemente las prestaciones.
Puedes configurar una particin cach dejando espacio de disco no particionado al final
de tu primer disco duro. REMBO detectar automticamente este espacio no
particionado y lo usar para cachear los ficheros de red accedidos con la especificacin
URL cache:.
Si la particin destino no est vaca, puedes usar la funcin HDClean para limpiar la
particin antes de restaurar los ficheros en ella. Si intentas restaurar una imagen de
disco en una particin que contiene datos, REMBO cambiar automticamente al modo
sincronizacin e intentar restaurar slo los ficheros modificados. Si estas seguro de
querer machacar todos los datos de la particin destino, use HDClean para hacerlo
ms rpido.
Ejemplo : este ejemplo muestra una secuencia de comandos REMBO necesarios para
preparar una particin destino y restaurar una imagen de disco creada con BuildDiskImage.
En este ejemplo, la imagen se restaurar en la primera particin del primer disco duro. El
tamao del disco duro es de 2 Gb, y se quiere mantener 500 Mb para la particin cach :
Primero creamos la particin con la funcin SetPrimaryPartitions. Queremos 1.5 Gb

para una particin FAT16 :
Observe que la particin cach no se especifica ya que esta es un espacio no

particionado al final del disco.
Finalmente, restauramos la imagen de disco con la funcin RestoreDiskImage :

RestoreDiskImage(0,1,cache://global/win98);
Observe que esta funcin realiza un formateo rpido de la particin antes de restaurar
la imagen.
En resumen:
RestoreDiskImage(0,1,cache://global/win98);
/* Para arrancar la imagen de disco resultante */
HDBoot(0,1);
Para comprobar que todo se ha escrito de forma adecuada, puedes aadir un

administrador de ficheros en la particin destino escribiendo: FileMan(disk://0:1/); o
puedes arrancar la particin recientemente creada con HDBoot(0,1);
3.4.4.- Una restauracin inteligente: Sincronizacin

La mayora de las tcnicas de clonacin disponibles hoy se usan para instalar un nuevo
sistema operativo en maquinas cliente vacas. REMBO va un paso ms all con su modo
Sincronizacin, donde la clonacin de disco no se limita ms a la utilizacin de SO.
Pgina 50
3.4.4.1.- Sincronizacin: cmo trabaja

En lugar de una realizar una restauracin ciega de la imagen de disco, destruyendo todos los
datos previamente almacenados en la particin destino, Rembo es capaz de restaurar los
ficheros selectivamente basndose en varias reglas:
En modo por defecto, el proceso de sincronizacin restaurar slo los ficheros en los
que el tamao, la fecha o los atributos del fichero hayan cambiado. Esto es similar a
una herramienta estndar de backup/restore.
En modo seguro, el proceso de sincronizacin restaurar todos los ficheros cuyo
contenido haya cambiado.
En modo compatible, el proceso de sincronizacin restaurar todos los ficheros,
emulando a una herramienta estndar de clonacin.
Adems, puede trabajar en uno de los siguientes tres modos a la hora de decidir qu hacer
con los ficheros nuevos (ficheros que estn en la imagen pero no en la particin destino) y con
los ficheros antiguos (ficheros que estn en la particin destino pero que no estn en la
imagen):
En modo comparacin : el proceso de sincronizacin no aadir nuevos ficheros a la

particin destino ni borraran ningn fichero de ella. REMBO slo actualizar los
ficheros que estn presentes tanto en la particin destino como en la imagen.
En modo aadir (add mode) : se aadirn los nuevos ficheros a la particin pero no se
borrarn los ficheros antiguos. Este modo es muy til para estaciones de trabajo.
En modo completo (full mode): se aaden los ficheros nuevos a la particin destino y
se borran los ficheros antiguos. La particin destino es una copia exacta de la imagen
al final del proceso de restauracin. Este es el modo por defecto.
3.4.4.2.- Aplicaciones del metodo de Sincronizacin

Aqu hay una lista de entornos dnde la sincronizacin podra ser ms til que una simple
herramienta de clonacin:
Escuelas y Universidades
Ciber-Cafs
Grandes compaas
3.4.4.3.- Sintxis y uso del mtodo de Sincronizacin

La sintxis completa de la funcin Synchronize se puede encontrar en la pgina del manual
de Synchronize.
Nota : Observe que BuildDiskImage y RestoreDiskImage son alias de Synchronize :
BuildDiskImage(0,1,cache://global/test);
es equivalente a
Synchronize (disk://0:1/,cache://global/test,);
y
RestoreDiskImage(0,1,cache://global/test);
es equivalente a
HDClean(0,1);
Synchronize(cache://global/test,disk://0:1/,b);
Pgina 51
3.5.- Conceptos avanzados de clonacin

3.5.1.- Filtrando ficheros con Imgenes Virtuales
En algunas circunstancias se podra requerir hacer una copia slo de un subconjunto de la
particin de referencia, o filtrar algunos ficheros que no se quieren, como el fichero de
paginacin de memoria (Windows 9x y Windows NT).
Nota : las imgenes virtuales no son soportadas en Rembo Classic Edition. Deberas usar en
su lugar RemoveFile y Synchronize en modo +
La imagen virtual te puede ayudar en esta tarea. Una imagen virtual es una copia de la
estructura de directorios (slo ficheros y directorios) de un sistema de ficheros existente. Esta
imagen virtual puede ser modificada aadindole otro sistema de ficheros (fusin) o borrando
ficheros o directorios.
Si quieres borrar slo unos pocos ficheros de tu particin de referencia antes de crear una
imagen, podras usar RemoveFile, y as no tener que configurar una imagen virtual. La
diferencia entre borrar ficheros con una imagen virtual o hacerlo con RemoveFile es que la
imagen virtual no modifica la particin de referencia mientras que RemoveFile borra
fsicamente el fichero de la particin.
El proceso de creacin de una imagen de disco apartir de una imagen virtual es muy simple:
Crear una imagen virtual de la particin de referencia.

Opcionalmente, aadir otras particiones como un subdirectorio de la imagen virtual.
Borrar los ficheros y directorios no deseados, tales como ficheros de paginacin o
temporales.
Usar Synchronize para construir una imagen de disco a partir de la imagen virtual.
Cerrar la imagen virtual para liberar recursos del sistema.
Veamos ahora cada uno de estos pasos.

1. Crear la imagen virtual: CreateVirtualImage.
El primer parmetro de la funcin es el nombre de la imagen virtual. El segundo
parmetro es el camino desde el que copiar la estructura de directorios. Puede ser el
directorio raz de una particin o un subdirectorio si slo quieres guardar parte de la
particin de referencia.
CreateVirtualImage(testimage,disk://0:1/);
FileMan(link://testimage/);
2. Aadir ficheros o directorios a una imagen virtual: LinkTree.

LinkTree(link://testimage/dir3, net//group/testf);
3. Borrar ficheros o directorios de una imagen virtual: UnLinkTree.

Por ejemplo, para borrar el fichero pagefile.sys de la raz de tu imagen virtual usamos
lo siguiente :
UnLinkTree(link://testimage/pagefile.sys);
4. Construir una imagen de disco a partir de una imagen virtual: Synchronize.

Utilizar el camino de la imagen virtual como primer parmetro. Por ejemplo, para crear
la imagen de disco de la imagen virtual previamente creada :
Pgina 52
Synchronize(link://testimage/,cache://global/ntimage,);
Ejemplo : a continuacin mostramos una secuencia tpica de comandos usados para crear
una imagen virtual desde una particin de referencia, usando imgenes virtuales para borrar
ficheros:
CreateVirtualImage(winimage,disk://0:1/);
UnLinkTree(link://winimage/windows/win386.swp);
Synchronize(link://winimage/,cache://global/winimage,);
FreeVirtualImage(winimage);
3.5.2.- Imgenes incrementales

Una imagen incremental es la diferencia entre dos sistemas de ficheros, en cuanto a
ficheros/directorios aadidos y ficheros/directorios borrados. Esta diferencia se puede
almacenar en una imagen de disco, creando una imagen de disco incremental.
Las imgenes incrementales son tiles para crear paquetes de instalacin software,
independientemente del hardware instalado. Por ejemplo podras crear una imagen de un
Windows 98 recin instalado, y llamarlo win98base. Entonces, podras crear una imagen
incremental de la misma particin de referencia despus de haber instalado MS Office en el
ordenador. La imagen incremental slo contendr los ficheros de Ms Office y estarn
separados de la imagen base. Si haces esto para otro software, tendrs una librera software
preparada para instalaciones. Ya que estas imgenes incrementales son independientes de la
imagen base, podra instalar MS Office en otra imagen base (es decir, win98base2, es una
imagen base para un hardware diferente) sin tener que recrear una nueva imagen.
3.5.2.1- Imgenes incrementales bsicas

Las imgenes incrementales bsicas son la forma ms simple de hacer una imagen
incremental. La diferencia entre el estado inicial y el nuevo estado, incluyendo ficheros de
configuracin, se almacenan en un nico fichero. En la restauracin, los ficheros de
configuracin se reemplazarn por la versin almacenada en la imagen incremental
te mtodo trabaja bien si estas fusionando una nica imagen incremental con la imagen base
a la vez. Si quieres fusionarla con ms de una imagen incremental debes usar imgenes
incrementales avanzadas.
3.5.2.2.- Imgenes incrementales avanzadas

Si quieres fusionar varias imgenes incrementales con una imagen base, debes manejar los
cambios de los ficheros de configuracin de forma separada. Dependiendo del SO que ests
clonando tendrs que ejecutar pasos adicionales a la creacin de imgenes incrementales.
En Windows 95/98 : los ficheros de registros se sacan de las imgenes incrementales,

y deben ser tratados de forma separada con un fichero patch de registro (.reg) para
cada imagen incremental.
En Windows NT : los ficheros de registros deben sacarse de las imgenes
incrementales y tratados individualmente con imgenes ficheros de registros
individuales para cada imagen incremental.
En Linux : los ficheros de registros que afecten a mas de una imagen incremental
debern ser sacados fuera y tratados de forma separada con ficheros de texto patch
diferenciales.
Pgina 53
REMBO proporciona poderosas herramientas para la fcil creacin de imgenes

incrementales limpias, especficamente para Windows NT/2000 para el que la operacin es la
ms complicada. Las tres operaciones bsicas para manejar esta operacin son TextDiff,
MakeDiffFromText y ApplyDiff. Ver las paginas del manual de estas funciones para detalles
de su uso.
3.5.2.3.- Cmo crear una imagen incremental

La funcin base para crear imgenes incrementales es Synchronize. Los dos primeros
parmetros son la fuente y el destino de la comparacin, y el tercer parmetro se usa para
decirle a Rembo dnde guardar la diferencia (la imagen incremental).
Ejemplo : para crear una imagen incremental hecha de la diferencia entre tu particin de
referencia y tu imagen de disco base, teclea:
Synchronize(disk://0:1/,cache://global/win98base,
>cache://global/msoffice);
En la mayora de los casos, necesitars filtrar registros fuera de la comparacin. Para hacer
esto, debes borrar los registros tanto en la particin de referencia como en la imagen base, de
tal forma que los registros no sean ni un fichero nuevo ni un fichero borrado. Las imgenes
virtuales se deben usar para conseguir esto:
// 1. Borrar loas registros backups
de la particin
RemoveFile(disk://0:1/windows/system.da0);
RemoveFile(disk://0:1/windows/user.da0);
//2. Filtrar los registros con una imagen virtual
CreateVirtualImage(source,disk://0:1/);
UnLinkTree(link://source/windows/system.dat);
UnLinkTree(link://source/windows/user.dat);
//3. Filtrar registros en la imagen de disco
OpenArchive(destarch,cache://global/win98base);
CreateVirtualImage(dest,arch://destarch/);
UnLinkTree(link://dest/windows/system.dat);
UnLinkTree(link://dest/windows/user.dat);
//4. Comparar imgenes virtuales para crear una imagen incremental
Synchronize(link://source/,link://dest/,>cache://global/msoffice);
//5. Liberar recursos
FreeVirtualImage(dest);
FreeVirtualImage(source);
CloseArchive(destarch);
Si utilizas TextDiff y MakeDiffFromText en lugar de Synchronize para crear tus imgenes

incrementales, los cambios en la imagen virtual las haces t implcitamente con estas
funciones. Adems, estas funciones te permite seleccionar especficamente que ficheros deben
o no ser parte de la imagen incremental. Es por tanto altamente recomendable usar estas
funciones para la creacin de imgenes incrementales, en lugar de crearlas directamente. Esto
es especialmente cierto para Windows NT/2000.
Pgina 54
3.5.3.- Fusin de imgenes usando imgenes virtuales

Si creaste imgenes incrementales como se describe en la seccin 3.5.2., probablemente
tengas que restaurar varias imgenes en una nica particin: una imagen base y una imagen
para cada aplicacin seleccionada por el usuario o por el archivo profile del ordenador. Cuando
restauras varias imgenes en una nica particin tienes dos opciones:
Ejecutar la funcin RestoreDiskImage para cada imagen.

Usar imgenes virtuales para fusionar las imgenes antes de la restauracin.
Nosotros recomendamos usar la segunda alternativa, porque ofrece mejores prestaciones que
la primera
3.5.3.1.- Cmo fusionar las imgenes?

Primero necesitas crear una imagen virtual con tu imagen base, y despus aadir las otras
imgenes con la funcin LinkTree. El siguiente ejemplo muestra una secuencia tpica de
comandos para una restauracin de varias imgenes:
Ejemplo : Restauracin de varias imgenes.
En este ejemplo vamos a restaurar una imagen base win98base y dos imgenes
incrementales msoffice y netscape en una nica particin, usando imgenes virtuales.
//1. Crear la imagen virtual
OpenArchive(base,cache://global/win98base);
CreateVirtualImage(virtual,arch://base/);
//2. Aadir la primera imagen incremental
OpenArchive(incr1,cache://global/msoffice/);
LinkTree(link://virtual/,arch://incr1/);
//3. Aadir la segunda imagen incremental
OpenArchive(incr2,cache://global/netscape/);
LinkTree(link://virtual/,arch://incr2/);
//4. Restaurar a la particin destino
Synchronize(link://virtual/,disk://0:1/,b);
FreeVirtualImage(virtual);
CloseArchive(incr2);
CloseArchive(incr1);
CloseArchive(base);
3.5.4.- Conversin del tipo de particin

Un archivo se suele restaurar en el mismo tipo de particin (FAT16, FAT32, NTFS) que en la
que fue creada. La particin donde se restaure no tiene por qu ser del mismo tamao que la
original, basta que sea lo suficientemente grande para almacenar el contenido del archivo. Sin
embargo, cuando un sistema operativo puede almacenarse en varios tipos de particin, no est
claro el hecho de restaurarlo en un tipo diferente al original..
Pgina 55
Los dos tipos de conversin de particiones que podras querer hacer cuando restauras un
archivo son:
Windows 95/98: en FAT16 o FAT32

Windows 2000/NT: en FAT16 (BIGDOS) o NTFS
Si intentas restaurar un archivo en una particin de un tipo diferente a la original, recibirs un

aviso en la consola advirtindote que el sector de arranque no es compatible y se salt. Esto
significa que la particin tendr todos los ficheros correctamente restaurados pero no tiene un
sector vlido de arranque y no ser botable.
Para conseguir restaurar un archivo que sea botable, debes proceder de la siguiente manera:
Limpiar la particin destino para asegurarte de tener un sector de arranque con los
parmetros de tamao correctos.
Restaurar un sector de arranque de cualquier archivo que tengas que coincida con el
tipo de la particin destino.
Restaurar todos los ficheros que quieres tener en la particin.
Ejemplo : cmo restaurar una imagen en una particin de otro tipo.

En la prctica, esto se puede hacer con un script como el siguiente. Aqu hacemos la
restauracin de una imagen en FAT32 a una particin BIGDOS. Para hacerlo, tienes
que tener en algn lugar un archivo de imagen BIGDOS (con cualquier cosa, no
importa), para ser capaz de obtener su sector de arranque.
// 1. Configurar el tipo de particin que se desee
SetPrimaryPartitions(0,BIGDOS:1000000);
// 2. Limpiarla.
HDClean(0,1);
// 3.Restaurar el sector de arranque apropiado de cualquier imagen
// BIGDOS. La restauracin en modo (b=) asegura que no se copiara ningn
// fichero.
Synchronize(cache://global/hdimages/win9x/bigdos.img,
disk://0:1,b=);
//4. Restaurar todos los ficheros de la imagen FAT32
Synchronize(cache://global/hdimages/win9x/fat32.img,disk://0:1,);
3.6.- Iniciando REMBO sin conexin a la red

Hay cuatro formas de arrancar REMBO sin conexin a red:
Modo Off-line (Desconectado).

Arrancar desde un CD de autoarranque.
Arrancar desde un disquete.
Mediante activacin PXE.
3.6.1.- Modo desconectado

Si accedemos a todos los archivos de la red mediante URLs del tipo: cache:// en vez de net://
REMBO podr acceder a los mismos directamente de la cach sin tener que recurrir a la red.
Pgina 56
3.6.1.1.- Configurando el modo desconectado

Antes que nada debemos asegurarnos que la BIOS permite arrancar del disco duro si el
arranque desde la red falla. A continuacin aadimos en el cliente una llamada a la funcin
SetOfflineMode, esto escribir un pequeo gestor de arranque en el MBR del disco duro,
esta lnea estar antes de cualquier comando que modifique las particiones, no se debe usar
tampoco la llamada a HDClean si no queremos echar a perder todo el trabajo hecho por
SetOfflineMode.
A continuacin arrancamos la mquina de la forma habitual y restauramos las imgenes de
los distintos sistemas operativos. Si ahora desconectamos el cable de red veremos como es
posible arrancar los sistemas operativos sin conexin a la red.
Podemos generar un script especial para este tipo de arranque y guardarlo como disk://0:1/autoload, esto har que se ejecute este script en vez de la pgina rembo.shtml.
Si no queremos escribir en el MBR podemos escribir el script en el sector de arranque de una
particin y marcar esta particin como de arranque.
3.6.1.2.- Cmo de seguro es el modo desconectado?

Se recomienda restaurar un sistema siempre desde la red, ya que los datos en el disco local
pueden estar corruptos y estn sujetos a mas peligros que el propio disco del servidor.
Los algoritmos de encriptacin utilizados para proteger la particin cach aseguran que los
datos contenidos en la misma no se volvern corruptos. Sin embargo, no protegen contra el
uso malintencionado y los intentos de desestabilizar el sistema.
Una alternativa al modo desconectado es la activacin PXE , la cual veremos ms adelante.
3.6.1.3.- REMBO como gestor de arranque

Segn todo lo visto REMBO puede ser usado como un efectivo y agradable gestor de
arranque, siendo una buena alternativa a LILO para aquellos usuarios de Linux.
3.6.1.4.- Imgenes del modo desconectado

Es recomendable guardar versiones de las imgenes de los sistemas operativos sin funcin
de red , as ser posible arrancar la mquina y trabajar con ella sin que nos est dando errores
constantemente de que no es capaz de conectar con el servidor principal.
3.6.2.- Arrancar desde un CD de autoarranque

Es deseable contar con copias de seguridad para restaurar un sistema en caso de un
desastre. Para ello REMBO es capaz de generar un CD de autoarranque capaz de restaurar el
sistema y arrancar sin conexin a la red.
3.6.2.1 Creando un CD de autoarranque

Crear un CD autoarrancable es tan sencillo como configurar un cliente : primero creamos las
imgenes y, a continuacin, activamos el modo desconectado como hemos visto en la seccin
Pgina 57
3.6.1.1, despus de probar todas las configuraciones y ver que el sistema puede arrancar bien
sin red. Es recomendable crear un script autoload que determinar el comportamiento al
arrancar.
Usaremos a continuacin la funcin CreateRemboCDRom para crear un CD ISO
autoarrancable con todas las imgenes y los scripts necesarios para arrancar.
Una vez hecho esto podremos copiar esta imagen ISO a un CD y utilizarlo para arrancar
cualquier mquina de la red.
3.6.3 Arrancando REMBO desde un disquete

Es posible generar un disquete de inicio para REMBO. Lgicamente en un disquete no caben
imgenes grandes, por eso debemos asegurarnos que las imgenes que estn en la particin
de cach quepan en un disquete o el proceso no funcionar.
Para crear el disquete utilizaremos la funcin CreateRemboFloppy. Recomendamos guardar
esta imagen en la direccin cache://global/fdmages para poder manejarla cmodamente con
los asistentes.
Podemos restaurar esta imagen utilizando los asistentes o bien con la funcin
RestoreFloppyImage. Una vez hecho esto podremos arrancar REMBO y acceder a los archivos
guardados en la imagen de disquete a travs de la direccin cache://global.
3.6.4 Activacin PXE

REMBO es capaz de utilizar un adaptador de red PXE incluso si el proceso de arranque no se
realiz como tal, este proceso se conoce como activacin PXE.
La activacin PXE aade otro nivel de seguridad a las mquinas pblicas de la red, de tal
forma que incluso si un usuario fue capaz de redirigir el arranque al disco duro REMBO seguir
arrancando y restaurando desde el servidor.
Esta caracterstica permite arrancar una configuracin REMBO en una red sin servidor
REMBO e incluso buscar en la red posibles servidores REMBO.
La activacin consta de dos pasos:
Primero cargamos la ROM PXE en la zona de memoria baja utilizando la funcin

LoadUNDI.
Por ltimo los parmetros IP son configurados mediante la funcin SetIPInfo.
Los parmetros IP pueden ser dados mediante un servidor DHCP o de forma directa. La
direccin del servidor REMBO primario estar especificada en la funcin SetIPInfo.
Estas llamadas se hacen desde el archivo autoload de la configuracin desconectada. As un
disquete de arranque REMBO podra conectarse automticamente a un servidor REMBO
predefinido.
Si es necesario podemos detectar si una mquina esta corriendo en modo desconectado o no
comprobando si tiene direccin IP de la siguiente forma:
If ((int)NetInfo.IPAddress = 0 ) {
//en linea
}
Pgina 58
3.7.- Uso de canales TCP para acceder a recursos

remotos
Es posible utilizar canales TCP para comunicar entre si distintas mquinas que corren
REMBO determinando el nombre de Host y el puerto de cada uno. Gracias a esta caracterstica
podemos implementar aplicaciones bastante interesantes :
Conectar con un servidor SMTP para mandar un correo al administrador e informar si

algo ha ido mal.
Conectar con un servidor de base de datos.
Acceder a un servidor HTTP para obtener informacin de Internet.
Acceder a suites de control o interactuar con mtodos de autentificacin.
3.7.1. Mandando correo electrnico con REMBO

demos utilizar la funcin SendMail para mandar correo a un administrador, para ello debemos
crear un canal TCP en la configuracin del servidor.
El identificador para el canal ser sendmail y el parmetro para RemotePort ser 25. El
parmetro para RemoteHost ser la IP del servidor SMTP.
Despus de configurar estos parmetros debemos reiniciar el servidor REMBO y en el cliente
debemos ejecutar join(Exec(cache://global/plugins/sendmail.rbx)); para acceder a SendMail,.
A partir de aqu ya podremos mandar mensajes con REMBO.
3.7.2. Acceso a bases de datos con REMBO

REMBO soporta ODBC, lo que le permite conectar con multitud de servidores de bases de
datos.
En un servidor Windows NT tendremos que instalar los drivers ODBC necesarios para
conectar con nuestra base de datos. En un sistema Solaris/Linux ser necesario instalar el
paquete UnixODBC que le permitir hacer lo mismo con multitud de bases de datos (incluidas
MySQL y PostgreSQL).
El proceso es el siguiente:
Abrimos un canal TCP que dirige las consultas del cliente a un enlace ODBC instalado
en la mquina que corre como servidor REMBO. Seguidamente este la manda al
manejador ODBC y este finalmente manda la consulta a la base de datos. La respuesta
sigue el mismo camino de vuelta hasta el cliente.
El enlace ODBC est en el directorio ODBC de la distribucin empresarial, para
instalarlo como un servicio WindowsNT ser necesario ejecutar dbgw i; para quitarlo
dbgw u.
El enlace entre TCP y la puerta de enlace solo contesta peticiones de localhost
(127.0.0.1). Esto se hace para prevenir que otras mquinas distintas del servidor
REMBO puedan acceder a la base de datos a travs del enlace. (RemoteHost
127.0.0.1 y RemotePort 2020).
Para configurar esta caracterstica hacemos lo siguiente:
Tener un servidor de base de datos listo.

Configurar en el servidor REMBO los drivers ODBC necesarios para acceder a la base
de datos.
Pgina 59
Instalar el enlace ODBC : en WindowsNT ejecutar dbgw inst ; en Unix ./dbgw.

Configurar el canal TCP en el servidor REMBO. (RemoteHost 127.0.0.1 y RemotePort
2020).
Para usar bases de datos en los scripts ejecutar lo siguiente :

join(Exec(cache://global/plugins/sql.rbx));
Las funciones de acceso a bases de datos son:
SQLOpen : Abre la sesin SQL.

SQLQuery : Ejecuta una consulta SQL.
SQLClose : Cierra la sesin.
SQLQuickQuery : Abre la sesin , consulta y cierra en un nico paso.
Pgina 60
CAPTULO 4: INSTRUCCIONES ESPECFICAS PARA CADA S.O.

Este captulo describe en detalles los procedimientos para clonar cada tipo de SO. Los
procedimientos difieren de uno a otro, no en el mecanismo de clonacin en s mismo, sino en la
reconfiguracin automtica post-clonacin que se quiera usar.
4.1.- Clonando MS-DOS

4.1.1.- Clonando un sistema MS-DOS
Prepare un puesto de trabajo de referencia con una instalacin tpica en la primera particin
del disco duro. Asegrese de no dejar archivos temporales en la particin de referencia.
Recomendamos que cree un fichero rembo.bat en el directorio raz de su particin de
referencia y aada la lnea call c:\rembo.bat en alguna parte del autoexec.bat. Esto har
posible ajustar su imagen MS-DOS en tiempo de ejecucin aadiendo comandos en el fichero
rembo.bat. En la particin de referencia, simplemente deje rembo.bat vaco.
Arranque el cliente con REMBO. Cree su imagen con BuildDiskImage como se describe en
la seccin 3.4.2. Llame a la imagen cache://global/images/dosimage.
Para restaurar la imagen en el ordenador destino, use RestoreDiskImage como se describe
en la seccin 3.4.3. No olvide crear una particin FAT vlida en el ordenador destino antes de
ejecutar RestoreDiskImage.
4.1.2. Ajustando un sistema MS-DOS

Puede que necesite modificar ficheros de sistema en tiempo de ejecucin, cuando la imagen
del disco haya sido restaurada en el ordenador destino. Dependiendo de sus necesidades,
necesitar modificar el autoexec.bat para aadir nuevos comandos o modificar un fichero de
sistema para reflejar la informacin que REMBO ha obtenido sobre su ordenador destino (p.e.
aadir variables de entorno conteniendo un nombre de usuario o una direccin IP).
Si cre un fichero rembo.bat durante la creacin de la imagen de disco, entonces ser capaz
de aadir comandos o variables de entorno modificando este fichero, ya que es llamado desde
el autoexec.bat. Para modificar su rembo.bat desde REMBO, cree un fichero plantilla en el
servidor y use el comando PatchFile para copiar la plantilla a disk://0:1/rembo.bat, con
sustitucin de expresiones automtica.
Ejemplo : Parcheo del archivo rembo.bat
Este ejemplo muestra el contenido de un fichero plantilla y el contenido de rembo.bat
despus de copiar la plantilla sobre el fichero destino con PatchFile.
Contenido del fichero plantilla:
ECHO "Installing environment variables"

SET IPADDRESS={$NetInfo.IPAddress$}
SET HOSTID={$NetInfo.MACAddress$}
SET USERNAME={$AuthInfo.UserName$}
SET FULLNAME={$AuthInfo.FullName$}
SET DOMAIN=COMPANY
Pgina 61
Contenido del fichero parcheado:
ECHO "Installing environment variables"

SET IPADDRESS=192.168.1.10
SET HOSTID=00 90 27 12 34 56
SET USERNAME=rembotest
SET FULLNAME=Rembo tester
SET DOMAIN=COMPANY
El comando usado para generar el archivo rembo.bat parcheado es :

PatchFile(NetFile("rembo.bat.tmpl"),"disk://0:1/rembo.bat");
Recomendamos que use la funcin NetFile para ajustar sus hosts. La funcin NetFile primero
comprueba si el fichero existe en el nivel net://host/, entonces intenta el nivel net://group/ y
finalmente usa net://global/ si el fichero no existe ni en el mbito de host ni de grupo. El uso de
NetFile hace posible aadir comportamientos definidos para un grupo de hosts o un solo host
simplemente aadiendo la rembo.bat.ref en el lugar apropiado del servidor.
PatchFile puede tambin ser usado para modificar un fichero de sistema, por ejemplo un
fichero de configuracin usada por su pila MS-DOS TCP/IP. Puede usar REMBO para insertar
la informacin de red apropiada (nombre de host, direccin IP, ...) en el fichero de
configuracin. Vea la seccion 3.3 para una lista de variables disponibles.
4.1.3. Instalando clientes Lan Manager para UNDI

Los clientes LanMan son clientes Microsoft Network para MS-DOS. Ellos pueden ser usados
para acceder a servidores Windows NT desde MS-DOS.
LanMan usa un driver de red NDIS para acceder al hardware de red. Este driver is
normalmente entregado por el fabricante de la tarjeta de red. Recientemente, Intel ha
desarrollado un driver NDIS universal que hace uso del chip de arranque remoto PXE (PXE
bootrom) para proporcionar acceso de red a LanMan. Si usa este driver, su instalacin LanMan
trabajar en todas las tarjetas de red PXE si arrancan a travs de REMBO.
Lea la pgina http://www.rembo.com/rembo/resources.html para obtener enlaces a diferentes
ficheros necesarios para LanMan. Tambin encontrar ejemplos de parches para ficheros de
configuracin LanMan.
Para instalar clientes LanMan, siga estos simples pasos:
Descargue los tres discos LanMan y el driver Intel NDIS;

Cree una particin MS-DOS vaca pero arrancable e instale los tres discos LanMan en
esta particin;
Copie el driver Intel NDIS y cambie los ficheros de configuracin LanMan para usar
este driver;
Haga una imagen de esta particin con REMBO;
Restaure la imagen y arranque con DeviceBoot(disk://0:1,false); en lugar de
HDBoot(0,1); para conservar el PXE bootrom cargado en memoria;
Compruebe que todo est funcionando correctamente;
Pgina 62
4.2.- Clonando Windows 95/98

Esta seccin describe cmo crear una imagen base para Windows 95/98, cmo crear
imgenes incrementales y como ajustar su ordenador destino despus de la restauracin (p.e.
cambiar el nombre de host).
La mayora de las operaciones descritas en esta seccin puede ser realizadas con los
asistentes. Esta seccin muestra como llevar a cabo estas operaciones con scripts Rembo-C.
4.2.1.- Creando una imagen base Windows 9x

Esta primera seccin describe como crear una imagen completa de disco duro Windows
95/98. Esta imagen es importante porque ser la base para las imgenes incrementales, y
tambin su copia de seguridad de emergencia si su disco duro se corrompe.
Configure un cliente tpico Windows 95/98, desde el principio, o arrancando desde el cliente
MS-DOS e instalando Windows sobre la red. Puede tambin usar una mquina con Windows
preinstalado. Para simplificar las instrucciones, asumiremos que ha instalado Windows en la
primera particin del disco duro.
Cree un fichero llamado rembo.bat en el directorio raz, y aada la lnea call c:\rembo.bat en
algn lugar del autoexec.bat. Esto har posible ajustar el proceso de arranque en tiempo de
ejecucin aadiendo comandos al fichero rembo.bat. En la particin de referencia, deje
rembo.bat vaco.
Ahora arranque REMBO, y ejecute FileMan(disk://0:1); para mostrar el contenido de su
particin Windows. Entonces, cierre el administrador de archivos y use el siguiente script para
crear la imagen base :
// 1. Crear una imagen virtual del disco
CreateVirtualImage("win9x","disk://0:1");
// 2. Eliminar el fichero de paginacin de la imagen virtual
RemoveFile("link://win9x/windows/win386.swp");
// 3. Eliminar cualquier versin previa de un archivo
if(FileExists("cache://global/hdimages/win9x/baseimage.img"))
RemoveFile("cache://global/hdimages/win9x/baseimage.img");
// 4. Crear un archivo de la imagen virtual
Synchronize("link://win9x","cache://global/hdimages/win9x/baseimage.img"
,"");
// 5. Liberar los recursos
FreeVirtualImage("win9x");
El script anterior almacena el contenido de su disco duro en un fichero

cache://global/hdimages/win9x/baseimage.img en el servidor. Puede eliminar otros ficheros o
directorios (p.e. ficheros temporales) para limpiar ficheros intiles de la imagen. Los ficheros o
directorios eliminados durante el paso 2 no son realmente eliminados del disco duro porque
usamos una imagen virtual (una imagen virtual es una copia de la estructura del disco usada
para editar directorios sin modificar el dispositivo subyacente).
Ahora tiene una copia de seguridad de su puesto de trabajo de referencia en el servidor. El
prximo paso es comprobar que la imagen es vlida.
Pgina 63
4.2.2.- Comprobando la imagen base del disco

Ahora debe verificar que la imagen base del disco funciona restaurando la imagen. Es
recomendable restaurar la imagen en un ordenador diferente del usado para crear la imagen de
referencia para prevenir la corrupcin del puesto de trabajo de referencia si algo fue mal.
Arranque REMBO, configure las particiones con los asistentes (no olvide dejar algo de
espacio al final del disco para el cach de particiones local). Entonces restaure su imagen
Windows 9x con el siguiente comando:
RestoreDiskimage(0,1,cache://global/hdimages/win9x/baseimage.img);
Una vez la descarga y restauracin se complete, ejecute FileMan(disk://0:1); para mostrar

los ficheros creados en su disco duro. Ejecute HDBoot(0,1); para arrancar en su particin
Windows 95/98.
En este punto, usted tiene una copia de seguridad completa de su ordenador de referencia en
caso de problemas durante los siguientes pasos de este tutorial. Puede volver en cualquier
momento a este estado inicial restaurando la imagen base de nuevo.
4.2.3.- Crear un script de restauracin

Esta seccin explica como automatizar el proceso de restauracin con un script. Si est
ejecutando REMBO Professional o Enterprise, puede obtener resultados similares definiendo
acciones de arranque automatizadas usando los asistentes.
Puede usar el siguiente script para restaurar su imagen base en el puesto de trabajo. Este
script realiza las siguientes acciones :
Configura particiones a un estado compatible con la imagen.

Restaura la imagen base.
Calcula un nombre nico para el equipo y crea un parche para el registro de Windows
que ser aplicado antes de que Windows comience.
Arranque.
// 1. Crear una particin de 1GB FAT16 (o BIGDOS)
SetPrimaryPartitions(0,"BIGDOS:1000000");
// 2. Restaurar la imagen
RestoreDiskImage(0,1,"cache://global/hdimages/win9x/baseimage.img");
// 3a. El nombre de la mquina est formado por los ltimos bytes de la
// direccin IP.
var ipa = StrParse(NetInfo.IPAddress,".");
str Hostname = "PC-"+ipa[2]+"-"+ipa[3];
// 3b. Crear un parche del registro para establecer el nombre de la
// mquina
CreateTextFile("disk://0:1/rembo.reg",
"REGEDIT4\n\n"
"[HKEY_LOCAL_MACHINE\\System\\CurrentControlSet"
"\\Services\\VxD\\VNETSUP]\n"
"\"ComputerName\"=\""+Hostname+"\"\n\n"
"\\Services\\VxD\\MSTCP]\n"
"\"HostName\"=\""+Hostname+"\"\n\n"
"\\control\\ComputerName\\ComputerName]\n"
"\"ComputerName\"=\""+Hostname+"\"\n");
Pgina 64
// 3c. Aadir una llamada al regedit en nuestro fichero .bat

CreateTextFile("disk://0:1/rembo.bat",
"c:\\windows\\regedit"
" /L:c:\\windows\\system.dat"
" /R:c:\\windows\\user.dat"
" c:\\rembo.reg");
// 4. Arrancar desde el disco
HDBoot(0,1);
Para usar el script anterior, gurdelo en un archivo aparte, copie el fichero en el servidor y
escriba Exec(net://global/scriptname); (sustituya scriptname con el nombre de su script).
Para ejecutar el script automticamente, cree una pgina HTML conteniendo un mensaje de
bienvenida y una seccin <SCRIPT>, como la que hay en el fichero rembo.shtml. Aada la
llamada a la funcin Exec en la seccin script de su pgina HTML, o simplemente copie y
pegue el contenido del script. Entonces, cambie el parmetro del servidor StartPage para sus
hosts de prueba al URL REMBO de pgina HTML que acaba de crear.
Puede ajustar el script a sus necesidades. Si quiere crear dos particiones, una para el sistema
y otra para los datos, simplemente aada una entrada BIGDOS:xxx en la cadena de
particiones, y no olvide hacer un formateo rpido a esta particin al menos una vez con
HDClean :
SetPrimaryPartitions(0,BIGDOS:500000 BIGDOS:500000);
HDClean(0,2);
Puede usar una variable persistente para determinar si es la primera vez que ejecuta este
script, y as ejecutar HDClean una sola vez.
Si quiere usar particiones FAT32 en lugar de FAT16, use entradas FAT32:xxx en la cadena de
particiones. Sin embargo, tenga cuidado de que FAT16 y FAT32 no usen el mismo sector de
arranque. Por consiguiente, si restaura una imagen FAT16 en una particin FAT32 (o
viceversa), el sector de arranque no ser restaurado y el disco no ser botable. Lea la seccin
3.5.4. para instrucciones de cmo restaurar una imagen en un tipo de particin diferente del
tipo para el que fue creado.
4.2.4.- Sincronizando en lugar de RestoreDiskImage

Puede mejorar notablemente la velocidad de restauracin de una imagen evitando el borrado
de todos los archivos. Si la particin contiene archivos REMBO intentar sincronizar el
contenido de la particin con la imagen de disco. Los ficheros que no hayan cambiado no sern
restaurados, acelerando mucho el proceso. Para usar la sincronizacin, reemplazar el paso 2
del script de restauracin visto en el punto anterior por el siguiente cdigo :
// 2. Sincronizacin elegante
Synchronize(cache://global/hdimages/win9x/baseimage.img,
disk://0:1,b);
Si la particin est corrupta debido a que Windows 9x no se cerr correctamente, el proceso

de sincronizacin puede fallar. En este caso puede usarse una restauracin a prueba de fallos
formateando el disco duro si la sincronizacin falla.
Ejemplo:
Var SyncErrorHandler (var exc)
{
Log(Restauracin fallida. Reiniciando<br>);
Pgina 65
// Limpiar particin
HDClean (0,1);
// Esperar 2 segundos
delay(200);
// Reiniciar equipo en modo seguro
Reboot();
}
// Sincronizar:
with (SyncErrorHandler) try {
Synchronice(cache://global/hdimages/win9x/baseimage.img,
disk://0:1,b);
}
Log(Restauracin exitosa<br>);
4.2.5.- Personalizando
El tratamiento personalizado del ordenador cliente es una fase importante en el proceso de
clonado. En esta fase se establecen parmetros especficos en los ficheros de configuracin de
Windows 9x para prevenir conflictos provocados por el hecho de que todos los ordenadores
clonados tengan el mismo nombre. Asimismo se hacen cambios especficos al host o
especficos al hardware.
Dado que Windows 9x est basado en MS-DOS, algunas configuraciones se almacenan en
ficheros, aunque la mayor parte de ella se almacena en registros. Las funciones de
modificacin de registro de REMBO Profesional y REMBO Enterprise funcionan solamente en
el registro de sistema de Windows 2000/NT. No obstante podemos usar el programa regedit
para parchear el registro antes de cargar Windows aadiendo la lnea correspondiente al
autoexec.bat. Basta con ejecutar un script con REMBO y configurar un parcheado automtico
del registro al arrancar (hecho en 4.2.3).
Si desea modificar alguna entrada especfica del registro use el siguiente procedimiento
genrico, que resulta ms elegante que escribir directamente sobre le registro como vimos en
la seccin anterior:
Bajo Windows 95/98 ejecutar regedit y localizar los parmetros que desea cambiar.
Los ajustes del equipo estn almacenados en HKLM/system/CurrentControl (o usar
bsqueda).
Seleccione el trozo que quiere parametrizar y use la funcin Exportar en el men para
salvarlo (con la extensin .reg).
Edite el fichero de texto resultante y reemplace los valores deseados.
Suba el fichero modificado al servidor usando netclnt en la consola del servidor.
Aada una lnea a su script de restauracin para generar un parche de registro
especfico del host en el disco, basada en el fichero genrico que ya habamos subido
al servidor.
Por ejemplo, podramos usar los siguientes valores:

REGEDIT4
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\VNETSUP]
ComputerName={$Hostname$}
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP]
Hostname={$Hostname$}
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\control\ComputerName\
ComputerName]
ComputerName={$Hostname$}
Pgina 66
Asumiendo que ha salvado este fichero en el servidor REMBO en hdimages/win9x/

baseimage.reg puede reemplazar el paso 3b de la seccin 4.2.3 por el siguiente comando:
// Paso 3b. Copiar y parchear los ajustes del registro especfico del
// host
PatchFile(cache://global/hdimages/win9x/baseimage.reg,
disk://0:1/rembo.reg);
4.2.6. Imgenes incrementales bsicas

Son imgenes que contienen la diferencia entre 2 estados del disco duro, sin tratar las
diferencias en los registros. Los registros son tratados como ficheros modificados y sern
incluidos en la imagen incremental, siendo restaurado a ciegas durante el proceso de
restauracin. Esto no causar problemas si trabaja con una nica imagen incremental a la vez.
Sin embargo, si quiere usar mltiples imgenes incrementales y unirlas para crear una nico
estado final, debe manejar los ficheros de registro explcitamente ya que tiene que unir los
cambios en el fichero de registros as como en los ficheros.
Lo primero que debe hacer antes de crear una imagen incremental es instalar un software o
driver adicional en la estacin de trabajo, para tener algo que almacenar en la imagen
incremental.
Para crear la imagen incremental simplemente ejecute Synchronize en modo incremental en
su disco duro. El siguiente ejemplo compara el contenido de la particin entre su imagen bsica
y la incremental en el servidor (3r parmetro):
Synchronize(disk://0:1,
cache://global/hdimages/win9x/baseimage.img,
>cache://global/hdimages/win9x/baseimage.diff);
No es necesario que la imagen incremental tenga un nombre similar a la bsica.

Para restaurar su imagen incremental sobre la imagen bsica, debe unir ambas. La forma
ms sencilla de hacerlo es usar una imagen virtual. Una vez que la imagen virtual se ha creado
uniendo las otras 2, puede restaurar esta imagen virtual en la particin de Windows en el modo
de restauracin completa. Aqu tenemos un script de ejemplo, similar al de restauracin bsica
pero con la imagen incremental aadida:
// 1. Abrir los 2 archivos de disco (base y diff)
OpenArchive(base,cache://global/hdimages/win9x/baseimage.img);
OpenArchive(diff,cache://global/hdimages/win9x/baseimage.diff);
// 2. Crear una imagen virtual en el archivo base
CreateVirtualImage(win9x,arch://base);
// 3. Aadir la imagen incremental a la imagen virtual
FileLink(link://win9x,arch://diff);
// 4. Sincronizar el contenido del disco con la imagen virtual
Synchronize(link://win9x,disk://0:1,b);
// 5. Liberar recursos usados
FreeVirtualImage(win9x);
CloseArchive(diff);
CloseArchive(base);
Nota: Si usa REMBO Classic o no quiere crear imgenes virtuales puede hacer la
sincronizacin en 2 pasos (ms lento):
// 1. Restaurar la imagen base, borrando todos los dems ficheros
Synchronize(cache://global/hdimages/win9x/baseimage.img,
disk://0:1,b);
Pgina 67
// 2. Restaurar la imagen incremental (no-destructiva)

Synchronize(cache://global/hdimages/win9x/baseimage.diff,
disk://0:1,b+);
4.2.7. Imgenes incrementales avanzadas

Necesitar imgenes incrementales avanzadas si quiere unir ms de una imagen incremental
con la imagen bsica. Las imgenes incrementales avanzadas son ms complejas de gestionar
que las bsicas, pero son ms flexibles. Con ellas puede crear una imagen incremental por
programa, y unirlas con la imagen bsica en funcin de lo que el usuario elija, para luego
restaurarlo al disco rpidamente.
Este es el procedimiento para crear una imagen incremental avanzada:
Restaurar la imagen base en la estacin de trabajo. Esto se llama estado original.

Desde este estado seguro, instalar el software requerido. Alcanzaremos el estado
final. El objetivo de la imagen incremental es contener las diferencias entre el estado
original y el final, de modo que es posible regenerar el estado final desde el original.
Crear una imagen incremental con los ficheros que han cambiado, excepto los de
configuracin del sistema (normalmente el registro, aunque tambin pueden aparecer
win.ini, system.ini, autoexec.bat y config.sys ...).
Crear parches de configuracin genricos y el script necesario para reproducir los
cambios en los ficheros de configuracin.
Aqu estn los detalles para la creacin de la imagen incremental para ficheros y registros:
Cuando su software est instalado (punto 2 del procedimiento), inicie REMBO y ejecute
el siguiente script. Este script usa una imagen virtual para cortar los ficheros de registro
segn la comparacin entre el contenido del disco y la imagen base. La imagen
incremental resultante no contendr los ficheros de registro :
CreateVirtualImage(win9x,disk://0:1);
// 2. Cortar los ficheros de registro
RemoveFile(link://win9x/windows/user.dat);
RemoveFile(link://win9x/windows/system.dat);
// 3. Crear la imagen incremental
Synchronize(link://win9x,
cache://global/hdimages/win9x/baseimage.img,
>cache://global/hdimages/win9x/mysoft.diff);
// 4. Liberar recursos
Este script crea la imagen incremental solo para ficheros. Para aplicar los correspondientes
cambios al registro debe crear manualmente un parche del registro comparando el registro de
la imagen base con el registro modificado. Se puede hacer siguiendo este procedimiento:
En un ordenador configurado en el estado original (imagen bsica solo) ejecutar

regedit y exportar la rama HKEY_LOCAL_MACHINE a un fichero de texto llamado
baseimage.reg.
En el ordenador donde instal el software, ejecute regedit y exporte la rama completa
HKEY_LOCAL_MACHINE al fichero de texto mysoft.reg.
Copiar ambos ficheros a un directorio temporal en el ordenador, abrir una ventana de
MS-DOS, y en este directorio, el siguiente comando buscar automticamente las
diferencias entre las 2 versiones del registro y las almacena en el siguiente fichero:
fc baseimage.reg mysoft.reg > mysoft.diffreg
Pgina 68
Abrir en un editor de texto los 3 ficheros simultneamente y editar las diferencias.

Asegrese de aadir la palabra REGEDIT4 al principio del fichero, seguido de una
lnea en blanco, y de tener todos los pares key/value prefijados por el selector
apropiado.
Subir el registro resultante al servidor en hdimages/win9x/mysoft.reg.
4.2.7.1.- Restaurando una imagen incremental avanzada

Se hace en 3 pasos:
Crear una imagen virtual para unir la imagen base con la incremental por ficheros.
Restaurar la imagen virtual.
Instalar el parche del registro.
Los pasos 1 y 3 pueden cambiarse para unir ms de una imagen incremental. Una vez ha
entendido cmo funciona para una imagen, puede copiar las sentencias de Rembo-C para
otras imgenes incrementales para crear un script ms complejo.
Aqu vemos un ejemplo completo de restauracin paso a paso:
// 1. Abrir los archivos de disco
OpenArchive(base,cache://global/hdimages/win9x/baseimage.img);
OpenArchive(diff1,cache://global/hdimages/win9x/mysoft.diff);
// 1b. Crear la imagen virtual en la imagen base
CreateVirtualImage(win9x,arch://base);
// 1c. Unir el archivo incremental con la imagen virtual
LinkTree(link://win9x,arch://diff1);
// 2. Restaurar los ficheros
// Esto restaurar los ficheros de registro de la imagen base en el
// estado inicial.
Synchronize(link://win9x,disk://0:1,b);
// 2b. Liberar recursos
CloseArchive(diff1);
CloseArchive(base);
// 3a. Configurar todos los parches de registro
str regcmd = c:\\windows\\regedit
/L:c:\\windows\\system.dat
/R:c:\\windows\\user.dat;
CreateTextFile(disk://0:1/rembo.bat,
regcmd + c:\\rembo.reg\n +
regcmd + c:\\mysoft.reg\n);
// 3b. Instalar el parche de registro del servidor
disk://0:1/rembo.reg);
// 3c. Instalar el parche de registro del software
disk://0:1/mysoft.reg);
Si necesita mezclar ms de una imagen incremental con la imagen base, debe hacer los
siguientes cambios al script anterior:
Extienda el paso 1 y repita el paso 1c para las otras imgenes incrementales (para
mezclar todas las imgenes incrementales en una imagen virtual). No olvide cerrar los
archivos abiertos despus de la sentencia Synchronize.
Extienda el paso 3 y repita el paso 3c para los otros parches de registro (para aplicar
secuencialmente todos los parches de registro).
Pgina 69
4.2.7.2.- Yendo mas all

Cuando empiece a usar restauracin incremental avanzada, debera considerar leer la
descripcin de todos los comandos relacionados con la restauracin de discos, imgenes
virtuales, registro NT y archivos para tener una mejor visin global de los mtodos avanzados
de clonacin descritos en esta seccin.
Hay muchas formas de combinar estos comandos para instalar o restaurar automticamente
un ordenador dependiendo del hardware, del perfil de usuario, del grupo, etc. Sin embargo,
tales procedimientos van ms all del mbito de este documento. Con alguna experiencia en
programacin y algo de imaginacin, usted debera ser capaz de hacer casi cualquier cosa con
REMBO. Si se enfrenta a un problema, puede intentar compartirlo con otros usuarios de
REMBO en el foro de soporte.
Puede tambin solicitar el REMBO Software Development Kit, el cual incluye mas de cien mil
lineas de cdigo fuente Rembo-C para realizar varias tareas de mantenimiento.
Pgina 70
4.3.- Clonando Windows NT / 2000

Esta seccin describe como crear una imagen base Windows NT, como crear imgenes
incrementales y como ajustar su ordenador destino despus de una restauracin (p.e. cambiar
el nombre del host).
Estas instrucciones estn basadas en Windows NT 4.0, pero pueden adaptarse para clonar
puestos de trabajo Windows 2000. La mayora de las operaciones descritas en esta seccin
pueden ser realizadas con los asistentes. Esta seccin muestra como llevar a cabo estas
operaciones con scripts Rembo-C.
4.3.1.- Creando una imagen base Windows NT

Esta primera seccin describe como crear una imagen completa de su disco duro Windows
NT. Esta imagen es importante ya que ser la base para las imgenes incrementales, y
tambin su copia de seguridad de emergencia si su disco duro se corrompe.
Instale Windows NT en un equipo limpio, sin ningn otro sistema operativo instalado. Durante
la instalacin, seleccione DHCP cuando se le pregunte por los parmetros de configuracin de
la interface de red. De un nombre a la estacin de trabajo, y nala a su dominio o grupo de
trabajo NT.
Arranque REMBO, y ejecute FileMan(disk://0:1); para mostrar el contenido de su particin
Windows NT. Entonces, cierre el administrador de archivos y use el siguiente script para crear
la imagen base :
CreateVirtualImage("nt","disk://0:1");
// 2. Eliminar el fichero de paginacin de la imagen virtual
RemoveFile("link://nt/pagefile.sys");
// 3. Eliminar versiones previas de los archivos
if(FileExists("cache://global/hdimages/winnt/baseimage.img"))
RemoveFile("cache://global/hdimages/winnt/baseimage.img");
// 4. Crear un archivo de la imagen virtual
Synchronize("link://nt","cache://global/hdimages/winnt/baseimage.img",
"");
FreeVirtualImage("nt");
El script anterior almacena el contenido de su disco duro en un fichero

cache://global/hdimages/winnt/baseimage.img en el servidor. Puede repetir el paso 2 para los
ficheros o directorios que quiera eliminar de la imagen. Los ficheros o directorios eliminados en
el paso 2 no son realmente eliminados del disco duro porque usamos una imagen virtual.
Ahora tiene una copia de seguridad del puesto de trabajo de referencia en el servidor. El
prximo paso es comprobar que la copia de seguridad es correcta.
4.3.2.- Comprobando la imagen de disco base

Ahora debe comprobar que su imagen de disco base funciona restaurando la imagen de
disco. Es recomendable restaurar la imagen en un ordenador diferente del usado para crear la
imagen base para evitar corromper la estacin de trabajo de referencia si algo fue mal.
Pgina 71
Arranque REMBO, configure las particiones con los asistentes (no olvide dejar algo de
espacio al final del disco duro para la particin cach). Entonces restaure su imagen Windows
NT con el siguiente comando:
RestoreDiskImage(0,1,cache://global/hdimages/winnt/baseimage.img);
Una vez la descarga y la restauracin se complete, ejecute FileMan(disk://0:1); para mostrar

los ficheros creados en su disco duro.
Escriba NTSetNetbiosName(NEWNAME); para cambiar el nombre de su recin creado
puesto de trabajo a NEWNAME y ejecute HDBoot(0,1); para arrancar en su particin Windows
NT.
En este punto, usted tiene una copia de seguridad completa de su ordenador de referencia en
caso de problemas durante las prximas etapas de este tutorial. Usted puede volver en
cualquier momento a este estado inicial restaurando la imagen base.
4.3.3.- Crear un script de restauracin

Esta seccin explica como automatizar el proceso de restauracin con un script. Si est
usando Rembo Professional o Enterprise, puede conseguir resultados similares definiendo
acciones de arranque automatizadas usando los asistentes.
Puede usar el siguiente script para restaurar su imagen base a una estacin de trabajo. Este
script lleva a cabo las siguientes acciones :
Configura las particiones a un estado conocido;

Restaura la imagen base;
Calcula un nombre nico para el ordenador y cambia el nombre de la estacin de
trabajo NT en el registro de Windows NT;
Arranca.
// 1. Creamos una particin NTFS de 1.5G
SetPrimaryPartitions(0,"NTFS:1500000");
// 2. Restauramos la imagen
RestoreDiskImage(0,1,"cache://global/hdimages/winnt/baseimage.img");
// 3. El nombre est formado por los ltimos bytes de la direccin MAC
var hwa = StrParse(NetInfo.MACAddress," ");
str name = "NTRBO-"+hwa[4]+hwa[5];
NTSetNetbiosName(name);
// 4. Arrancamos
HDBoot(0,1);
Para usar el script anterior, gurdelo en un archivo separado, cpielo en el servidor y ejecute
Exec(net://global/scriptname); (sustituya scriptname con el nombre de su script).
Para ejecutar el script automticamente, cree una pgina HTML conteniendo un mensaje de
bienvenida y una seccin <SCRIPT>, como la que hay en el fichero rembo.shtml. Aada la
llamada a la funcin Exec en la seccin script de su pgina HTML, o simplemente copie y
pegue el contenido del script. Entonces, cambie el parmetro del servidor StartPage para sus
hosts de prueba al URL REMBO de la pgina HTML que acaba de crear.
Puede ajustar el script a sus necesidades. Si quiere crear dos particiones NTFS, una para el
sistema y otra para los datos, simplemente aada una entrada NTFS:xxx en la cadena de
particiones, y no olvide hacer un formateo rpido a esta particin al menos una vez con
HDClean:
Pgina 72
SetPrimaryPartitions(0,"NTFS:1500000 NTFS:3500000");
HDClean(0,2);
...
Puede usar una variable persistente para determinar si es la primera vez que se ejecuta este
script, y as ejecutar HDClean una sola vez.
4.3.4.- Sincronizacin en lugar de restauracin de una imagen

Se puede mejorar la rapidez del proceso de restauracin trasladando todos los ficheros
anteriormente restaurados a un archivo. Si la particin contiene ficheros, REMBO intentar
sincronizar el contenido de la particin con la imagen del disco. Si muchos de los ficheros de
la particin no han sufrido cambios entre dos restauraciones, el modo de sincronizacin ser
ms rpido que el de restauracin.
Ejemplo :
// 1. Creamos una particin NTFS de 1.5GB
SetPrimaryPartitions (0,NTFS:1500000);
// 2.
Synchronize(cache://global/hdimages/winnt/baseimage.img,disd://0:1,
b);
// 3. El nombre est formado por los ltimos bytes de la direccin MAC
var hwa = StrParse(NetInfo.MACAddress, );
str name = NTRBO-+hwa[4]+hwa[5];
NTSetNetbiosName(name);
// 4. Arrancamos
HDBoot(0,1);
Ver la pgina de sincronizacin del manual para ms informacin acerca de los diferente
modos de sincronizacin.
Si la particin est corrupta porque Windows NT se ha apagado correctamente el modo de
sincronizacin del REMBO debe fallar porque los ficheros estn corruptos. Se puede
implementar una restauracin fail-safe formateando el disco duro si la sincronizacin falla al
restaurar la imagen.
Ejemplo :
Var SyncErrorHandler(var exc)
{
Log(Error en la restauracin. Reiniciando <br>);
// Limpiamos la particin
HDClean(0,1);
// Esperamos 2 seg
delay(200);
// Reiniciamos el ordenador para comenzar en un estado seguro
Reboot();
}
//Synchronize:
with (SyncErrorHandler) try {
Synchronize(cache://global/hdimages/winnt/baseimage.img,
disk://0:1,b);
Log(Restauracin correcta<br>);
Pgina 73
4.3.5.- Personalizando
El tratamiento personalizado del ordenador cliente es una fase muy importante en el proceso
clonado. Esta fase permite personalizar parmetros en la estacin de trabajo Windows NT para
prevenir conflictos provocados por el hecho de que todos los ordenadores clonados tengan el
mismo nombre o direccin IP.
En Windows NT, todos los parmetros residen en el registro de Windows NT. Prcticamente,
el registro est cargado en varios ficheros : SAM, SOFTWARE, SYSTEM, SECURITY y
DEFAULT. Estos ficheros se encuentran en el directorio /WINNT/system32/config.
Para cambiar el hostname al ordenador puedes usar una de las funciones de alto nivel del
Rembo-C como NTSetNetbiosName. Ver la seccin 5.4 en el manual de referencia de scripts
de Rembo-C para ms informacin.
Si quieres modificar una entrada especfica del registro usa el siguiente procedimiento:
Bajo Windows NT, ejecuta REGEDIT32 y localiza el parmetro que deseas cambiar. La
configuracin del ordenador est almacenada en HKLM/System/ControlSet001.
Determinar en que fichero est localizado el parmetro a modificar. Las entradas
HKLM/Software estn cargadas en SOFTWARE, las entradas HKLM/System estn
cargadas en SYSTEM, las entradas HKLM/Security estn cargadas en SECURITY, las
entradas HKLM/SAM estn cargadas en SAM y el perfil de usuario por defecto est
cargada en DEFAULT.
Crear un script que abra el fichero de registro, modificar el valor como se describe en el
reg:pgina del manual URL y cerramos el registro.
Un ejemplo para cambiar el nombre de usuario mostrado en el dilogo del Windows NT sera
el siguiente:
//
La
clave
winlogon
est
en
el
registro
de
software
OpenRegistry(soft,disk://0:1/winnt/system32/config/software);
// Almacena el valor ( cadena unicode ) en la clave DefaultUserName.
// La cadena se extiende por varias lneas debido a limitaciones de
// escritura.
// Puedes escribir el mismo commando en una nica lnea
CreateUnicodeFile(reg://soft/Microsoft/
Windows NT/CurrentVersion/
Winlogon/DefaultUserName,
Miusuario);
// Cerrar el registro para realizar los cambios
CloseRegistry(soft);
4.3.6.- Imgenes incrementales bsicas

Las imgenes incrementales bsicas son imgenes que contienen la deferencia entre dos
estados del disco duro, pero sin manejar la diferencia de los registros. Los registros se manejan
como ficheros modificados y sern incluidos en la imagen incremental y actualizados en la
restauracin. Esto no produce ningn problema si no trabajamos con ms de una imagen
incremental al mismo tiempo porque los registros sern restaurados en el estado de una
imagen incremental. Pero si quieres usar varias imgenes incrementales y combinarlas para
crear un nico estado final debemos manejar los ficheros de registro explcitamente porque hay
que combinar los cambios en el fichero de registros.
Lo primero que hay que hacer antes de crear una imagen incremental es instalar un driver
adicional y software sobre la estacin de trabajo.
Pgina 74
Crear la imagen incremental simplemente ejecutando Synchronize en el modo incremental

sobre tu disco duro. El siguiente ejemplo compara el contenido de la particin con la imagen
bsica y crea una imagen incremental sobre el servidor (tercer parmetro).
Synchronize(disk://0:1,
cache://global/hdimages/winnt/baseimage.img,
>cache://global/hdimages/winnt/baseimage.diff);
El nombre de tu imagen incremental no necesita ser similar al nombre de la imagen bsica.

Para restaurar tu imagen incremental sobre tu imagen bsica hay que combinarlas. Lo ms
sencillo es usar una imagen virtual. Una vez que la imagen virtual est creada combinando la
imagen incremental y la imagen bsica se puede restaurar esta imagen virtual sobre la
particin Windows NT en el modo de restauracin o en el modo de sincronizacin.
Un ejemplo de un script para imgenes incrementales sera:
// 1. Abrir dos archivos(base and diff)
OpenArchive(base,cache://global/hdimages/winnt/baseimage.img);
OpenArchive(diff,cache://global/hdimages/winnt/baseimage.diff);
// 2. Crear una imagen virtual
CreateVirtualImage(nt,arch://base);
// 3. Combinar la imagen incremental
FileLink(link://nt,arch://diff);
y la imagen virtual
// 4.Sincronizar el contenido del disco con la imagen virtual

Synchronize(link://nt,disk://0:1,b);
// 5.Liberar los recursos usados
FreeVirtualImage(nt);
CloseArchive(diff);
CloseArchive(base);
Si ests usando REMBO Classic, o si deseas usar imgenes virtuales, puedes conseguir un
resultado similar haciendo:
// 1. Restaurar la imagen bsica
Synchronize(cache://global/hdimages/winnt/baseimage.imag,
disk://0:1,b);
// 2. Restaurar la imagen incremental (non-destructive)
Synchronize(cache://global/hdimages/winnt/baseimage.deff,
disk://0:1,b+);
4.3.7.- Imgenes incrementales avanzadas

Necesitars usar imgenes incrementales avanzadas si deseas combinar ms de una imagen
incremental con la imagen bsica. Las imgenes incrementales avanzadas son ms complejas
de manejar que las imgenes incrementales bsicas pero permiten mas flexibilidad. Con las
imgenes incrementales avanzadas puedes crear una imagen incremental por programa, y
unirlas junto con la imagen bsica dependiendo de lo que elija el usuario, restaurndola al
disco rpidamente.
El proceso a seguir para crear una imagen incremental avanzada es el siguiente:
Restaurar la imagen bsica sobre la estacin de trabajo. Esto es el estado original.

Desde este estado, instalar el software requerido. El ordenador estar en el estado
final.
Crear una imagen incremental de todos los ficheros excepto los ficheros de registros.
Por cada fichero de registro, crear una imagen de registro incremental
El resultado son seis imgenes incrementales : una imagen incremental de todos los
ficheros y cinco por los ficheros del registro.
Pgina 75
Cuando tu programa est instalado, inicia REMBO y ejecuta el siguiente script.

// 1. Crea una imagen virtual del disco
CreateVirtualImage(nt,disk://0:1);
// 2. Corta el directorio de registro
DelTree(link://nt/winnt/system32/config);
// 3. Crea la imagen incremental
Synchronize(link://nt, cache://global/hdimages/winnt/baseimage.img,
>cache://global/hdimages/winnt/mysoft.diff);
// 4. Libera recursos
Este script crea la imagen incremetal para los ficheros. Si queremos crear las imgenes
incrementales para los ficheros de registro debe seguir las siguientes instrucciones para cada
una de los cinco ficheros de registros. Este script crea una imagen incremental entre el estado
original del fichero del registro y el estado actual (estado final). Remplaza la palabra SYSTEM
por SOFTWARE, SAM, SECURITY y DEFAULT para crear las otras cuatro imgenes
incrementales. No hay que olvidar que hay que cargar esas cinco imgenes en cinco ficheros
diferentes sobre el servidor (cambiar la extensin del tercer argumento en Synchronize).
//1. Abrir la imagen bsica para obtener el fichero de registro original
//2. Abrir el registro en la imagen bsica (estado inicial)
OpenRegistry(initial,arch://base/winnt/system32/config/SYSTEM);
//3. Abrir el registro sobre el disco(estado final)
OpenRegistry(final,disk://0:1/winnt/system32/config/SYSTEM);
//4. Crear la imagen incremental
Synchronize(reg://final,reg://initial,
?>cache://global/hdimages/winnt/mysoft.sys);
CloseRegistry(final);
CloseRegistry(initial);
CloseArchive(base);
4.3.7.1.- Restaurando una imagen incremental avanzada

Hay que seguir tres pasos:
Crear una imagen virtual para combinar la imagen bsica con la imagen incremental
para los ficheros.
Restaurar la imagen virtual.
Aplicar las imgenes incrementales de registros.
El primer paso puede combinar ms de una imagen incremental. El paso tercero es el ms

complejo de los tres. Las imgenes incrementales de registros contienen las diferencias entre
el estado inicial y el estado final para una registro. Para aplicar la imagen incremental debemos
ejecutar Synchronize en modo +-.
Ejemplo :
// 1a. Abrir los archivos baseimage.img y mysoft.diff
OpenArchive(diff1,cache://global/hdimages/winnt/mysoft.diff);
// 1b. Crear
una imagen virtual
Pgina 76
CreateVirtualImage(nt,arch://base);
// 1c.Combinar el archivo incremental en la imagen virtual.
LinkTree(link://nt,arch://diff1);
// 2a.Restaurar los ficheros.
// Esto restaurar los ficheros del registro desde la imagen bsica en
//el estado inicial
Synchronize(link://nt,disk://0:1,b);
// 2b.Liberar recursos
CloseArchive(diff1);
CloseArchive(base);
// 3a.Abrir el fichero del registro
OpenRegistry(openreg,disk://0:1/winnt/system32/config/SYSTEM);
// 3b.Aadir la imagen incremental del registro
Synchronize(cache://global/hdimages/winnt/mysoft.sys,reg://openret,
+-);
// 3c.Cierra el fichero del registro
CloseRegistry(openreg);
Como se puede observar el ejemplo est incompleto, los pasos 3a, 3b y 3c deben repetirse
para cada uno de los cinco ficheros del registro (remplazar SYSTEM y .sys).
Si deseas combinar ms de una imagen incremental debes realizar las siguientes
modificaciones en el script:
Ampliar el paso 1a y repetir el paso 1c para cada imagen incremental (combinar todas
las imgenes incrementales en una imagen virtual). No olvide cerrar los archivos
abiertos despus de Synchronize.
Repetir el paso 3b para las dems imgenes incrementales y para cada fichero del
registro.
4.3.8.- Ficheros comprimidos

REMBO no puede acceder a ficheros comprimidos sobre un volumen NTFS. Si
intentamos abrir un fichero comprimido el sistema de fichero lanzar una excepcin. Cuando
usamos Synchronize para regresar a la particin NTFS, los ficheros comprimidos saltarn con
un mensaje warning mostrado en la consola log.
Cuando creamos una imagen de la particin NTFS con REMBO, debera comprobar que no
hay ficheros comprimidos sobre la particin NTFS antes de que se ejecute Synchronize. Para
descomprimir un fichero en Windows NT hay que hacer click sobre el fichero y elegir Properties
desde el men contextual.
Hay dos situaciones en las que los ficheros comprimidos pueden crearse sobre la particin
NTFS:
Cuando instalas el Windows 2000 y la carpeta dllcache est comprimida por

defecto.Tendrs que descomprimir esta carpeta antes de la creacin de una imagen de
la particin NTFS con REMBO. La carpeta dllcache esta oculta por defecto.
Cuando instalas sobre la estacin de trabajo Windows NT un nuevo paquete de

servicio tienes la opcin de volver a los ficheros existentes si quieres desintalar dicho
paquete.
Pgina 77
4.3.9.- Parcheando el SID de NT con REMBO

Esta seccin explica paso a paso como remplazar el SID sobre un particin NTFS y en
ficheros del registro NT.
En este ejemplo mostramos como restaurar una imagen NTFS cargada en
cache://global/ntbase.img a la primera particin, usando el on-the-fly SID sustituyendo rutinas
de REMBO. Adems, mostramos como salvar el SID generado en un fichero host especfico
para usar este SID en posteriores restauraciones.
1. Extraer el SID original de la imagen del disco duro, y cargarla en la variable binaria
oldsid.
OpenArchive(nt,cache://global/ntbase.img);
var oldsid = GetSIDFromRegistry(arch://nt/winnt/system32/config/sam);
CloseArchive(nt);
2. Generar para este host un nico SID o usar el SID cargado en el fichero net://host/SID.
Cargar este nuevo fichero en la variable binaria newsid.
var newsid;
if (!FileExists(net://host/SID)) {
//no carga SID
newsid=GenerateSID(oldsid);
//generar
CreateHexFile(net://host/SID,newsid);
//carga
}else{
//usa el SID cargado
mewsid=LoadHexFile(net://host/SID);
3. Restaurar la imagen del disco

HDClean(0,1);
ApplySID(disk://0:1,oldsid,newsid);
Synchronize(cache://global/ntbase.img,disk://0:1,b);
4. Remplazar SID en los ficheros del registro

PatchSID(oldsid,newsid);
Pgina 78
4.4.- Clonar Linux

4.4.1.- Creacin de una imagen base Linux
El primer paso de la creacin de la imagen del disco es instalar el sistema Linux en la
mquina modelo, personalizndola segn las necesidades. Siempre que sea posible hay que
intentar instalar la distribucin en una nica particin. Si queremos utilizar distintas particiones,
deberemos crear una imagen para cada una.
A la hora de la creacin de la imagen tenemos dos posibilidades:
Crear una imagen de la distribucin completa. Hay que tener en cuenta que la
restauracin de la imagen toma su tiempo.
Copiar distintas partes de la distribucin ( p.e. /usr ) a un servidor NFS y quitar estas
partes de la particin principal. De esta forma creamos imgenes ms pequeas, pero
a costa de reducir el rendimiento de la mquina debido a que debe acceder al servidor
NFS en tiempo de ejecucin.
Cuando tu mquina modelo est lista ejecuta el siguiente script para crear la imagen. Si
tenemos varias particiones tendremos que ejecutarlo en cada particin.
// Creacin de una imagen de la particin 1 (/dev/hda1)
BuildDiskImage (0,1,cache://global/hdimages/linux/baseimage.base);
Si tenemos varias particiones y queremos crear una imagen que las contenga a todas
debemos utilizar una imagen virtual para fusionar todas las particiones en un sistema de
archivos virtual. El siguiente ejemplo asume que la particin raz es /dev/hda1, /usr es
/dev/hda5 y /home es /dev/hda6 :
// 1. Crear una imagen virtual con la particin raz (hda1)
CreateVirtualImage(linux,disk://0:1);
// 2. Aadir /usr a la imagen virtual (hda5)
LinkTree(link://linux/usr,disk://0:5);
// 3. Aadir /home a la imagen virtual (hda6)
LinkTree(link://linux/home,disk://0:6);
// 4. Crear una imagen en disco de la imagen virtual
Synchronize(link://linux,
cache://global/hdimages/linux/baseimage.base, );
No es necesario crear una imagen para la particin de intercambio, ya que no contiene datos
importantes y REMBO la crea automticamente al arrancar.
4.4.2.- Arrancar un kernel de Linux

El siguiente paso para la clonacin de un sistema Linux es probar tu imagen modelo en una
nueva estacin de trabajo.
Para arrancar un kernel de Linux utilizamos la funcin LXBoot. El primer parmetro es el
archivo que contiene el ncleo y el tercer parmetro contiene los parmetros del ncleo. La
imagen del ncleo debe estar en formato zImage o bzImage. Estos dos formatos son los
estndar que se utilizan en los makefiles para compilar los fuentes del ncleo. No es necesario
etiquetar los ncleos para usarlos con REMBO. El segundo parmetro de LXBoot, el disco de
arranque inicial, no es necesario en esta descripcin.
Pgina 79
Para poder utilizar LXBoot debemos extraer el kernel de nuestro disco duro. Para ello
podemos utilizar los asistentes o hacerlo manualmente copiando el archivo del ncleo al
servidor ( con CopyFile ). Las imgenes de los ncleos suelen estar guardadas en /boot. P.e.:
CopyFile(disk://0:1/boot/vmlinuz,
cache://global/hdimages/linux/basekernel.krn);
Para arrancar la imagen del ncleo desde el sistema de archivos raz instalado en /dev/hda1 :
LXBoot(cache://global/hdimages/linux/basekernel.krn,
,root=/dev/hda1);
4.4.3.- Probar la imagen base del disco

Recomendamos que pruebes la imagen base en una mquina diferente antes de instalarla en
otras mquinas o modificar la mquina de referencia. Cuando la imagen est correcta, puedes
usarla como copia de seguridad para la mquina de referencia si algo va mal en los pasos
siguientes de la clonacin.
Arranca REMBO en una nueva mquina, y crea las particiones que necesites. No olvides
crear una particin de intercambio. A continuacin restaura la imagen que creaste en la
seccin anterior con RestoreDiskImage. El siguiente script muestra como podemos llamar a
todas estas funciones :
// 1. Crea una particin linux de 800 Mb y una de intercambio de 128 Mb
SetPrimaryPartitions(0,EXT2:800000 EXT:128000);
SetLogicalPartitions(0,LINUX-SWAP:128000);
// 2. Restaura la imagen base
RestoreDiskImage(0,1,cache://global/hdimages/linux/baseimage.base);
// 3. Limpia la particin de intercambio
HDClean(0,5);
// 4. Lanza el kernel
LXBoot(cache://global/lxkernel, ,root=/dev/hda1);
Es importante comprender que la nica forma de arrancar la imagen de Linux es a travs de

una llamada a LXBoot. Si intentas ejecutar HDBoot(0,1) fallar porque los archivos que se
requieren para el gestor de arranque LILO se han cambiado durante la restauracin.
Puedes utilizar este script como el script de restauracin para las mquinas Linux colocando
el contenido dentro de una etiqueta SCRIPT en una pgina HTML, y mediante StartPage hacer
referencia a esta pgina.
4.4.4.- Creacin de un script de restauracin

Podemos utilizar el script creado en la seccin anterior para restaurar imgenes Linux en el
disco duro. Este script utiliza RestoreDiskImage para instalar la imagen en el disco. Esta
funcin siempre realiza una restauracin completa de la imagen del disco.
Podemos utilizar Synchronize para los mismos propsitos que BuildDiskImage, pero sin
tener que formatear la particin de destino. Cuando la particin ya contiene archivos
Synchronize construye una lista de diferencias entre la imagen base y los archivos que hay en
disco y copia nicamente los archivos que necesitan ser copiados y borra solo aquellos que
necesitan ser borrados. Este proceso es mucho ms rpido que BuildDiskImage si solo se
cambian unos cuantos archivos entre restauraciones consecutivas.
Pgina 80
Si hemos optado por la sincronizacin en vez de una restauracin completa, debemos tener
en cuenta que si la particin se corrompe Synchronize fallara al restaurar la imagen. Para
solventar esta situacin podemos utilizar un manejador de excepciones que capture los errores
generados por Synchronize. Si ocurre un error simplemente formatearamos la particin
destino y reiniciaramos. Esto devolver a REMBO a un estado seguro y Synchronize ser
capaz de restaurar todos los archivos.
A continuacin mostramos un ejemplo de script de sincronizacin a prueba de fallos :
// Manejador de excepciones
var SyncErrorHandler ( var exc )
{
Log( Se ha producido un error. Reiniciando ... <br>);
// Formatea la particin destino
HDClean(0,1);
// Espera 2 segundos
delay(200);
//Reinicia
Reboot();
}
// Sincronizacin
with(SyncErrorHandler) try {
Synchronize(cache://global/hdimages/linux/baseimage.base,
disk://0:1,b);
}
4.4.5.- Imgenes incrementales de Linux

Para crear una imagen incremental de Linux simplemente debemos ejecutar Synchronize en
modo incremental.
Ejemplo :
// Crea una imagen incremental entre el contenido actual del disco y la
// imagen base
Synchronize(disk://0:1,cache://global/hdimages/linux/baseimage.base,
>cache://global/hdimages/linux/mysoft.diff);
Para restaurar esta imagen incremental debemos utilizar una imagen virtual para fusionar la
imagen base con la imagen incremental.
Ejemplo :
// 1. Abrir los archivos del disco
OpenArchive(base,cache://global/hdimages/linux/baseimage.base);
OpenArchive(diff,cache://global/hdimages/linux/mysoft.diff);
// 2. Creacin de una imagen virtual sobre la imagen base
CreateVirtualImage(lx,arch://base);
// 3. Fusionar la imagen incremental en la imagen virtual
LinkTree(link://lx,arch://diff);
// 4. Sincronizar la imagen virtual al disco
Synchronize(link://lx,disk://0:1,b);
FreeVirtualImage(lx);
CloseArchive(diff);
CloseArchive(base);
Pgina 81
4.4.6.- Personalizar scripts de arranque de Linux

Generalmente las mquinas Linux no necesitan tanta personalizacin como las mquinas
Windows. Esto es as porque las mquina Linux estn mejor integradas dentro de una
infraestructura de red.
Para reducir las necesidades de personalizacin al mnimo configura tu imagen base con
configuracin automtica de red mediante DHCP y aade un comando en /etc/rc.d/rc.local
para ejecutar un script ubicado en el servidor. Este script puede realizar tareas basadas en la
direccin IP de la mquina local ( suponiendo que se ha guardado la direccin IP en una
variable de entorno ).
Si utilizamos las caractersticas de autentificacin de REMBO puedes utilizar la informacin
recogida durante la autentificacin ( normalmente usuario y password ) para manejar tus scripts
de arranque Linux. P.e.: podramos arrancar X automticamente mediante el comando
su l c startx $username. Utiliza la funcin PatchFile para crear un script que le de valor a la
variable $username.
Ejemplo :. Iniciar X segn el nombre de usuario
chown $username /dev/console /dev/fd0
chmod 622 /dev/console
su l c startx $username
Pgina 82
MANUAL DE REFERENCIA DE REMBO-C
Manual de referencia de Rembo-C
CAPTULO 1 : El lenguaje de scripts de Rembo-C

1.1.- Utilidad
Los scripts nos van a permitir realizar operaciones de mantenimiento automticas y una serie
de operaciones especiales que los asistentes proporcionados por el programa no pueden llevar
a cabo. Tambin permiten realizar imgenes de disco de forma automtica.
Los clientes cargan al iniciar Rembo una pgina de inicio ( por defecto, rembo.shtml ). El
cdigo del script se coloca entre las etiquetas <SCRIPT> de la pgina.
Atencin : No se recomienda modificar dicha pgina puesto que las actualizaciones del
programa escribirn sobre ellas. Si se quiere incluir cdigo personalizado se recomienda variar
la pgina de inicio de los clientes.
1.2.- Aadiendo scripts a las pginas Web

El cdigo de un script puede colocarse en dos lugares :
Entre dos etiquetas <SCRIPT>.

En llamadas a manejadores de eventos.
Para que un script sea ejecutado por REMBO es necesario declararlo de tipo text/rembo-c,
como sigue:
<script type=text/rembo-c>
cdigo del script
</script>
Si no se hace as REMBO ignorar el cdigo.

Las llamadas a manejadores de eventos son fragmentos de cdigo Rembo-C que se ejecutan
al producirse un evento ( ver ejemplos en manual de referencia ). Se definen con el atributo on
... .
1.3.- Creacin de interfaces de usuario dinmicos

La mayora de interfaces modernos cambian su aspecto de forma dinmica cuando el usuario
interacta con ellos.
Aunque el interfaz de usuario del REMBO est basado en HTML, se puede lograr este
comportamiento dinmico usando scripts.
Se puede cambiar el aspecto y el contenido de un elemento de dos formas: usando el sistema
de ficheros, que vuelca la jerarqua de pginas en un rbol de ficheros, o usando las pseudovariables correspondientes. Ambas son casi equivalentes, y cada una de ellas puede ser ms
til que la otra en determinadas circunstancias.
Cuando se accede a un elemento a travs del sistema de ficheros, cada directorio
corresponde a un elemento. En cada directorio aparecen dos archivos especiales: SELF y
Pgina 85

SELF-APPEND. Cuando sobreescribimos SELF el elemento es destruido y reconstruido a partir
del texto HTML escrito en el fichero.
Cuando sobreescribimos SELF-APPEND, el elemento intentar aadir el cdigo HTML escrito
en el fichero a su propia definicin ( esto no es soportado por todos los elementos ). Si leemos
SELF podemos obtener algo de informacin sobre el contenido del elemento, pero no se
garantiza devolver cdigo HTML que represente completamente el estado actual del mismo.
En los manejadores de eventos es ms conveniente acceder a los elementos mediante
variables, ya que cualquier hilo que maneje eventos est ligado a la ventana que provoc el
evento y puede acceder, por tanto, a sus elementos con nombre directamente, como cualquier
variable global.
Ver como ejemplo el cdigo fuente de los asistentes.
1.4.- Creacin de plug-ins precompilados ( libreras )

Se pueden precompilar los ficheros en mdulos .rbc en .rbx para no mostrar el cdigo fuente
de los mismos. Para ello se usa el compilador rbcc que incluye el kit opcional de desarrollo en
Rembo Profesional o en Rembo Empresa.
Los usuarios de Rembo Clsico solo pueden usar mdulos del fabricante o cdigo fuente
directamente.
Pgina 86
CAPTULO 2 : El lenguaje
2.1.- Estructura de un programa Rembo-C
La sintaxis del lenguaje Rembo-C es muy similar a la del lenguaje C. Destacamos las
siguientes caractersticas :
Es sensible a maysculas y minsculas.

Un programa est compuesto por un grupo de sentencias, que pueden ser :
1.
2.
3.
4.
5.
6.
Una sentencia compuesta.

Una declaracin de variable o un tipo estructurado.
Una declaracin de una funcin.
Una expresin ( tambin llamadas a una funcin ).
Una sentencia de control (if,while,do,for,switch,... ).
Una directiva pragma.
Los comentarios son del tipo /* ... */ o del tipo //.
2.2.- Declaraciones de variables y tipos

Los tipos bsicos del lenguaje Rembo-C son los siguientes:
int Enteros de 32 bits con signo.

bool
True o False.
str Cadenas.
var Variables.
Las variables tienen las siguientes caractersticas :
Son similares a las del lenguaje C.

Pueden tomar un valor inicial.
Mediante el modificador const se indica que es de slo-lectura.
Para que sean visibles solamente dentro de un mdulo se pueden declarar localmente
dentro de una sentencia compuesta.
Las tablas se caracterizan por:
Se definen igual que en C.

Si no se especifica en su declaracin un tamao son dinmicas.
La inicializacin se puede realizar incluyendo los elementos entre llaves. Los elementos no
inicializados se ponen a cero.
Las tablas multidimensionales no pueden declararse directamente. Hay que usar una tabla
de vars, siendo cada una de ellas una tabla en s misma.
Los tipos definidos por el usuario son dos: el tipo enumerado y las estructuras. Pueden
ligarse a un nombre para usarse posteriormente o declarar inmediatamente una o ms
variables.
La sintaxis del tipo enumerado es la siguiente :
enum [nombre]{
elementos
} [lista de variables];
Pgina 87

No es como en C: puede usarse donde se necesite una variable numrica, pero tambin
donde se requiera una variable cadena.
La sintaxis de una estructura es la siguiente :
struct [nombre]{
declaracin de campos
} [lista de variables];
La inicializacin de una estructura es como la de una tabla. Pueden anidarse libremente.
2.3.- Declaracin de funciones

Son como las del lenguaje C. En la cabecera de una funcin slo pueden aparecer tipos
bsicos y el tipo void. En los argumentos var o en los valores de retorno puede devolverse
cualquier objeto ( incluso funciones ! ).
Los tipos int, bool y str se pasan por valor. El tipo var se pasa por referencia.
No es necesario prototipar las funciones, ya que el tipo de los argumentos y de los valores de
retorno se comprueba en tiempo de ejecucin.
Al contrario que en el lenguaje C, Rembo-C puede devolver variables localizadas
automticamente ( p.e.: tablas ), puesto que incluye un recolector de basura automtico que
elimina el objeto en cuanto no sea necesario.
Para declarar funciones locales se hace igual que las variables locales.
2.4.- Expresiones
Las tenemos de cuatro tipos : numricas, booleanas, cadena y variable.
La comprobacin de tipos para las 3 primeras es rgida. La de las variables se realiza en
tiempo de ejecucin, permitiendo un cierto grado de polimorfismo.
Rembo-C le asigna mayor prioridad a las operaciones a nivel de bit que a las de comparacin.
En Rembo-C no se permite la evaluacin en cortocircuito de expresiones booleanas ni
condicionales : se comprueba la expresin completa aunque la evaluacin de la primera ya
resuelva el valor de la expresin entera.
Los constructores de tablas son los siguientes:
Tablas sin inicializar: tipo_bsico[tam] siendo tam opcional.

Tablas inicializadas: {elem1, elem2, ... , elemn} donde elemi puede ser cualquier expresin.
La comprobacin de rangos es automtica. Si se accede a una tabla dinmica con un ndice

mayor que el tamao de la misma, no aparece un error, sino que se aumenta su tamao hasta
que dicho elemento pueda existir.
Las cadenas pueden accederse de la misma forma que las tablas. A menos que hayan sido
declaradas como const crecen automticamente al acceder a una posicin mayor que su
longitud. Las posiciones intermedias se rellenan con espacios.
Pgina 88
2.5.- Sentencias de control

Son las mismas que el C:
if ( ... ) ... [else ... ]

while ( ... ) ...
do ... while ( ... );
for ( ... ; ... ; ... ) ...
switch ( ... ) { case ... : ... [ default : ... ] }
break;
continue;
goto ...;
return [ ... ];
Las condiciones del if y del while han de ser de tipo bool.
Las expresiones de la sentencia case pueden ser expresiones de cualquier tipo compatible
con la expresin del switch correspondiente.
2.6.- Hilos ( threads )

La mquina virtual REMBO (MV) es multihilo. La ejecucin es multitarea de tipo preemptive
en tiempo real. Cada tarea tiene una porcin del tiempo total de procesador. Las primitivas son
atmicas y pueden superar su porcin.
Se crea un nuevo hilo para el manejador de eventos HTML, las excepciones o cuando se
produce una llamada a las primitivas exec o eval. Estas primitivas devuelven un IDThread que
se puede usar para interactuar con dicho hilo.
La primitiva SELF devuelve el IDThread del hilo actual.
Mediante la orden join( IDThread ) hacemos que el hilo actual espere a que termine el hilo
indicado por IDThread. El hilo actual no usa su porcin de tiempo y cuando le toca pasa el
control de nuevo inmediatamente.
Con la orden delay( num ) hacemos que el hilo actual espere durante las centsimas de
segundo indicadas por num. El hilo actual no usa su porcin de tiempo y cuando le toca pasa el
control de nuevo inmediatamente.
Con la orden KillThread eliminamos el hilo actual.
No se han implementado an mecanismos de acceso concurrente a una variable. Sin
embargo, se resuelve casi por completo porque las operaciones y las primitivas de la mquina
virtual son atmicas.
2.7.- Manejo de excepciones

Si se produce un error Rembo eleva una excepcin. Esto provoca la suspensin temporal del
hilo que la provoc y se crea un nuevo hilo que ejecuta el manejador de excepciones.
Con with ... try se puede definir un manejador local de excepciones.
Pgina 89

Las funciones de dicho manejador son:
Almacena o indica la excepcin.

Decide que hacer a continuacin :
1. Propagar la excepcin ( por defecto ).
2. Resumir la ejecucin del hilo a partir del bloque try.
3. Eliminar el hilo que provoc el error con KillThread y cancelar la propagacin de la
excepcin.
Si no se define un manejador local, o si la excepcin ha sido propagada, se llama a la funcin

predefinida ExceptionHandler. Por defecto las acciones que realiza son las siguientes :
Mata al hilo que la provoc.

Muestra un mensaje de error en la pantalla.
Lo manda al servidor usando SysLog.
El argumento de dicha funcin es una estructura que nos indica el tipo de excepcin que se
ha producido.
Si se produce una excepcin dentro de un manejador se eliminan ambos.
Es posible provocar una excepcin con la orden RaiseError.
2.8.- Programacin orientada a objetos

Rembo-C no es un lenguaje orientado a objetos. Sin embargo, es posible adaptarlo fcilmente
para ello.
Ver el ejemplo en el manual.
2.9.- Directivas pragma

Son tres :
#pragma purge <variable global>

Elimina la definicin de una variable global.
#pragma clear <variable global>

Resetea el contenido de la variable a NIL. til para las variables protegidas.
#pragma protect <variable >

Evita que la variable cambie su tipo con las expresiones =, := o<=>.
2.10.- Palabras reservadas

Estas palabras no pueden ser redefinidas ni usarse como identificadores. Son las siguientes :
int, bool, str, var, const.

void, enum, struct.
NIL, sizeof, typeof.
if, else, switch, break, case, default.
for, while, do, continue, goto, return.
Pgina 90
join, delay, SELF.

with, try.
Pragma, purge, clear, protect, debug.
2.11.- Resumen de diferencias entre C y Rembo-C
Sintaxis
1.
2.
3.
4.
5.
No existen constantes de tipo carcter: se usan cadenas de un solo carcter.

Es posible anidar declaraciones de funciones.
Se permiten colocar sentencias fuera de las funciones.
Se puede declarar una variable en todo lugar donde se permitan sentencias.
No hay modificador static, pero las variables locales hacen la misma funcin.
Operadores
1.
2.
3.
4.
5.
6.
Se pueden usar los operadores +, <, <=, >=, >, ==, != con cadenas.
Los operadores a nivel de bit tienen mayor prioridad que los relacionales.
Los operadores booleanos y condicionales no ejecutan evaluacin en cortocircuito.
Aparecen dos nuevos operadores ( <=> y := ) para manipular variables.
El operador [ ] proporciona comprobacin automtica de rangos.
El operador sizeof nos da el nmero de elementos de una tabla o estructura, la
longitud de una cadena u objeto binario, o 1 en caso de valores atmicos.
7. El operador typeof nos devuelve el nombre del tipo de cualquier objeto.
Variables
1.
2.
3.
4.
5.
Los enteros no son equivalentes a los booleanos. Usa el tipo bool.

Solo hay una clase de nmero: enteros de 32 bits con signo.
Las cadenas son un tipo bsico ( str ).
Todas las variables se inicializan implcitamente a un valor cero.
No hay punteros como en el lenguaje C. El tipo var permite almacenar referencias a
objetos.
Las constantes enumeradas no se manejan como constantes sino como cadenas.
Las tablas sin tamao inicial indicado son dinmicas.
Los valores iniciales tanto de tablas como de estructuras no tienen por qu ser constantes.
No hay uniones.
6.
7.
8.
9.
Pgina 91
CAPTULO 3 : Bibliotecas de funciones

Las bibliotecas incluidas con Rembo-C son muy similares a las que se incluyen con la
mayora de los lenguajes.
Podemos dividirlas en varias categoras :
Cadenas.
Objetos binarios.
Tablas y estructuras.
Directorios.
Ficheros.
Contenido de un fichero.
Interfaz de usuario.
Primitivas relacionadas con la evaluacin.
Variables persistentes.
Primitivas relacionadas con la red.
Primitivas del sistema.
Con este documento no pretendemos resumir una por una todas las funciones incluidas en las
libreras: solo destacaremos las que nos han parecido ms tiles.
Para informarse detalladamente de su uso y ver otras que pueden ser tiles en determinadas
circunstancias es recomendable consultar el manual de referencia del lenguaje. .
3.1.- Cadenas
Nombre
StrCopy
Prototipo
str StrCopy ( str origen, int pos_inic, int pos_final );
Descripcin
Pgina
Duplica el fragmento indicado entre pos_inic y pos_final de la cadena origen.

339
Nombre
StrCompare
Prototipo
int StrCompare ( str cad1, str cad2 );
Descripcin
Compara las dos cadenas y devuelve:

-1 si cad1 < cad2.
0 si cad1 = cad2.
1 si cad1 > cad2.
Pgina
Es sensible a maysculas y minsculas.

344
Pgina 92

Nombre
StrToUpper / StrToLower
Prototipo
str StrToUpper / StrToLower ( str cad );
Descripcin
Pgina
Devuelve la representacin en maysculas / minsculas de la cadena dada.

354 / 355
3.2.- Objetos binarios

Nombre
BinCreate
Prototipo
var BinCreate ( int tam, int valor_inicial );
Descripcin
Pgina
Crea un nuevo objeto binario de tam bytes y los inicializa con valor_inicial.
365
3.3.- Tablas y estructuras

Nombre
DeepCopy
Prototipo
var DeepCopy ( var objeto );
Descripcin
Pgina
Duplica de forma recursiva el objeto dado, incluso si dicho objeto es una

variable compleja que contiene, p.e., tablas de estructuras o tablas anidadas.
386
Nombre
DeepFreeze
Prototipo
var DeepFreeze ( var objeto, bool solo_lectura );
Descripcin
Protege todos los elementos de la variable objeto. Si solo_lectura vale

FALSE slo se evita que puedan cambiar de tipo. En otro caso tambin se
convierte en una variable de slo lectura.
388
Pgina
3.4.- Directorios
Nombre
CreateDir / Mkdir
Prototipo
void CreateDir / Mkdir ( str path );
Descripcin
Pgina
Crea el directorio indicado en la localizacin indicada en el path.

393
Pgina 93

Nombre
RemoveDir / RmDir
Prototipo
void RemoveDir / Rmdir ( str path );
Descripcin
Pgina
Elimina el directorio indicado en la localizacin indicada en el path.

395
Nombre
CopyTree / MoveTree
Prototipo
Void CopyTree / MoveTree ( str path_orig, str path_dest );
Descripcin
Pgina
Copia / Mueve recursivamente el directorio indicado en el path_orig al

path_dest..
396 / 397
Nombre
ChDir
Prototipo
void ChDir ( str path );
Descripcin
Pgina
Cambia el path del directorio actual de REMBO al indicado en el path.

399
3.5.- Ficheros
Nombre
CopyFile / FileCopy
Prototipo
void CopyFile / FileCopy ( str path_orig, str path_dest);
Descripcin
Pgina
Copia el fichero indicado en el path_orig al path_dest.

402
3.6.- Contenido de un fichero

Nombre
FileOpen
Prototipo
var FileOpen ( str path, str modo );
Descripcin
Pgina
Abre el fichero indicado en el path con el modo indicado y devuelve un

descriptor de fichero asociado.
429
Nombre
FileRead
Prototipo
int FileRead ( var fich, var obj, int pos_inic, int long );
Descripcin
Lee long bytes del fichero indicado por el descriptor de fichero fich a partir de
la posicin actual del puntero y los almacena en el buffer binario obj en la
posicin pos_inic.
431
Pgina
Pgina 94
Nombre
FileWrite
Prototipo
int FileWrite ( var fich, var obj, int pos_inic, int long );
Descripcin
Pgina
Escribe long bytes en el fichero indicado por el descriptor de fichero fich a

partir de la posicin actual del puntero, leyndolos del buffer binario obj a
partir de la posicin pos_inic.
432
Nombre
FileClose
Prototipo
void FileClose ( var fich );
Descripcin
Pgina
Cierra el fichero indicado.

439
3.7.- Interfaz de usuario

Nombre
OpenWindow
Prototipo
var OpenWindow ( str win, int izq, int arr, int der, int abajo );
Descripcin
Pgina
Abre una nueva ventana con las coordenadas de las esquinas indicadas en
% con respecto al tamao de la ventana. Le asocia el nombre indicado con
win.
440
Nombre
HideWindow / ShowWIndow / CloseWindow
Prototipo
void HideWindow / ShowWindow / CloseWindow ( str win );
Descripcin
Pgina
Oculta / Muestra / Cierra la ventana indicada por win.

444 / 445 /446
3.8.- Primitivas relacionadas con la evaluacin

Nombre
Exec
Prototipo
int Exec ( str rbxpath );
Descripcin
Carga y ejecuta el script de Rembo-C del fichero indicado por rbxpath en un

nuevo hilo. Devuelve el identificador del nuevo hilo.
464
Pgina
Pgina 95

Nombre
Eval
Prototipo
int Exec ( str expresion );
Descripcin
Pgina
Evala una expresin de Rembo-C en un nuevo hilo y devuelve su

identificador asociado.
465
Nombre
KillThread
Prototipo
void KillThread ( int IDThread );
Descripcin
Pgina
Elimina el hilo identificado por IDThread.

467
Nombre
RaiseError
Prototipo
void RaiseError ( int errno, str mensaje );
Descripcin
Eleva una excepcin. Ver pgs. 468 / 469 / 470 y 471 para ms detalles
sobre las excepciones existentes.
468
Pgina
3.9.- Variables persistentes

Nombre
Export
Prototipo
void Export ( var cont, str nombre, str rango );
Descripcin
Pgina
Declara una variable de nombre nombre y contenido cont que permanece en

el sistema aunque se reinicie ( persistente ). El mbito viene indicado por
rango.
476
Nombre
UnExport
Prototipo
void UnExport ( str nombre, str rango );
Descripcin
Elimina la declaracin de la variable persistente de nombre nombre del

mbito indicado por rango.
478
Pgina
3.10.- Primitivas relacionadas con la red

Nombre
SysLog
Prototipo
void SysLog ( str mensaje );
Descripcin
Pgina
Manda un mensaje al fichero de log del servidor

485
Pgina 96
3.11.- Primitivas del sistema

Nombre
ShowConsole / HideConsole
Prototipo
void ShowConsole / HideConsole (void );
Descripcin
Pgina
Muestra / Oculta la ventana de errores de Rembo

500 / 501
Nombre
Print / Printf
Prototipo
Descripcin
Pgina
Muestran mensajes en la ventana. Se usan para depuracin.

502 / 503
Nombre
Keyb
Prototipo
void Keyb ( str pais );
Descripcin
Pgina
Carga el mapa de tecla del pas indicado. El valor por defecto es us (

Estados Unidos ). El valor para el teclado espaol es es.
507
Nombre
CodePage
Prototipo
void CodePage ( int IdPgina);
Descripcin
Carga la pgina de cdigos indicada por IdPgina. El valor por defecto es

437 ( IBM PC-8 ). El usual es 850 IBM Latin I.
509
Pgina
Pgina 97
ANEXO A : GUA RPIDA DE

INSTALACIN DE REMBO
GUA RPIDA DE INSTALACIN DE REMBO

1.- Consideraciones previas
Nota : Esta gua rpida de instalacin de Rembo recoge los pasos bsicos necesarios para
que ponga a funcionar un servidor Rembo en su mquina. Tenga en cuenta que no resuelve
las posibles dudas planteadas, en cuyo caso debe dirigirse al manual de usuario.
Se van a instalar 3 sistemas operativos en una misma mquina que sern gestionados por el
gestor de arranque remoto REMBO. Los sistemas operativos en cuestin son:
Windows 2000 Profesional.

Windows 98 SE.
Linux Redhat 7.1.
La mquina servidora es un PC con el sistema Linux instalado. El REMBO se instalar bajo

dicho sistema operativo. Esta misma mquina proveer todos los servicios caractersticos de
un servidor (DHCP, TFTP, SAMBA, etc) si bien tan solo DHCP ser imprescindible para
proveer el arranque remoto. Vamos a omitir los pasos de instalacin de dichos servicios
suponiendo que ya los ha instalado (en caso contrario consultar manuales) para centrarnos en
el propio REMBO. En nuestro caso se ha instalado REMBO por encima de una mquina que ya
suministraba arranque remoto a travs de BpBatch. La mquina no genera ningn conflicto ya
que ste gestor puede ser sustituido por Rembo sin ninguna dificultad ni problemas aadidos.
Advertencia : el servicio TFTP debe ser desactivado ya que entrar en conflicto con Rembo
por la utilizacin de un puerto udp. Hgalo antes de instalar Rembo.
2.- Instalando REMBO

Elija el directorio donde quiera instalar el servidor REMBO bajo Unix / Linux. En nuestro caso
por ejemplo se ha utilizado usr/local/rembo. Extraiga en dicho directorio el contenido del
paquete REMBO y debera ver lo siguiente:
Un programa llamado rembo (el servidor).

Un fichero de texto llamado rembo.conf (el fichero de configuracin del servidor).
Un fichero de texto llamado srvfiles.nc (el paquete de ficheros bsico del servidor).
Un subdirectorio llamado misc, con varios ficheros que puede necesitar ms adelante.
Edite el contenido del fichero rembo.conf indicando al menos el directorio base de instalacin
de Rembo (Basedir) y el password que utilizar (NetPassword).
El fichero de texto srvfiles.nc contiene un conjunto mnimo de ficheros que REMBO necesita
para arrancar. Llegado a este punto deber arrancar Rembo por primera vez. Arranque el
servidor escribiendo rembo d v 4 en la lnea de comandos. Durante esta primera ejecucin
tardar un poco ms de tiempo para generar una clave criptogrfica aleatoria.
Con el servidor en ejecucin edite el fichero srvfiles.nc y sustituya la lnea open 127.0.0.1
install con open 127.0.0.1 xxxx donde xxxx es la clave que ha utilizado como NetPassword en
el fichero rembo.conf.
Ya puede ejecutar el comando misc/netclnt srvfiles.nc en el directorio de instalacin del
servidor. Se transferirn varios ficheros al servidor y NetClnt volver a la lnea de comandos
despus de transferir el ltimo fichero.
Su servidor Rembo ya est instalado y listo para recibir peticiones de arranque remoto.
Pgina 100
3.- Instalando los Sistemas Operativos.

Las operaciones de instalacin de los sistemas operativos se efectuarn desde una mquina
cliente con opciones de administracin. En ella, se ejecutarn tanto el Wizard como los scripts
necesarios para generar las imgenes que sern transferidas al sistema servidor.
Es recomendable instalar cualquier sistema operativo en un ordenador totalmente limpio, y
hacer la imagen desde ste. Asimismo utilice otro equipo diferente para restaurar las imgenes
durante las pruebas, ya que si algo fall al hacer la imagen siempre tendr oportunidad de
repetir la operacin sin tener que reinstalar el sistema.
Para la instalacin final le recomendamos los siguientes parmetros:
Particin 1:Primaria:NTFS => Windows 2000 Profesional.

Particin 2:Primaria:FAT32 => Windows 98 SE.
Particin 5:Lgica:LinuxExt2 => Linux Redhat 7.1.
Particin 6:Lgica:LinuxSwap => LinuxSwap para la Redhat.
En primer lugar, no ocupe ms particiones primarias de las necesarias. Dado que linux puede
instalarse en una particin lgica es recomendable hacerlo as. Asimismo tenga en cuenta un
pequeo conflicto existente entre Windows 2000 y 98, que no permitir al Windows 2000
arrancar correctamente si no ocupa la primera particin, en lugar del Windows 98.
4.- Clonando Windows 2000

Normalmente las operaciones de clonado de los sistemas operativos se hacen sin problemas
desde el Wizard siempre que respete las peculiaridades de cada sistema. En concreto
Windows 2000 tiene un detalle que no podemos pasar por alto. La carpeta dllcache est
comprimida, y Rembo no puede trabajar con carpetas ya comprimidas en el momento de
restaurar un sistema. Por ello, siga los siguientes pasos para clonar Windows 2000:
1. Instale Windows 2000 en un ordenador limpio.
2. Descomprima la carpeta WINNT/System32/dllcache.
3. Haga la imagen de este sistema y transfirala al servidor con el Wizard.
Asimismo Windows 2000 tiene otra peculiaridad: instale el SO en una particin del mismo
tamao que tendr en el equipo final. Cualquier cambio en el tamao de la particin har que
Windows 2000 lo detecte como cambio de hardware y siempre arrancar el asistente de
hardware despus de cada restauracin.
No existen ms consideraciones particulares.
5.- Restaurando y arrancando Windows 2000

La funcin NetInfo resulta de gran utilidad para obtener informacin de la mquina cliente.
Podemos obtener su direccin IP, MAC, etc. Esto permitir personalizar los datos de cada
mquina despus del arranque. En Windows 2000 hemos integrado en la pgina del men un
pequeo script que realiza esta funcin, y el parcheo se efecta tal que:
var ip=StrParse(NetInfo.IPAddress,".");
str nombre="pem"+ip[3];
NTChangeName(nombre);
Se captura el ltimo nmero de la IP de la mquina y se almacena. La funcin

NTChangeName cambia integralmente el nombre de la mquina (su nombre de red,
hostname, netbios...). Puede verse el script completo en la pgina del men.
Pgina 101
El arranque de Windows 2000 se efecta con un simple HDBoot(0,1); en nuestro caso, disco
0, particin 1.
6.- Clonando Windows 98 SE

El Windows 98 SE resulta ms permisivo que el Windows 2000 para clonarse. Siga los
siguientes pasos:
1. Instale Windows 98 SE en un ordenador limpio.
2. Cree en el directorio raz un fichero c:\rembo.bat. (ste ser el encargado del parcheo
del nombre y podr ser modificado en tiempo de arranque).
3. Aada una lnea call rembo al autoexec.bat de modo que se ejecute en el arranque.
Este fichero rembo.bat ser el que podr personalizar segn sus necesidades. En nuestro
caso se utilizar para parchear el nombre de cada mquina. Al contrario que Windows 2000, el
98SE no tendr restricciones con el tamao de la particin y podr instalarse en una particin
que no tiene por qu coincidir con la final.
7.- Restaurando y arrancando Windows 98 SE

Se deber crear un script de restauracin que contenga el parcheo del nombre. En nuestro
men de arranque puede verse el proceso, bsicamente tomados del manual puntos 4.2.3 y
4.2.4. Veamos un fragmento del mismo.
Hostname = "pem"+ipa[3];
PatchFile("cache://global/rembo.reg","disk://0:2/rembo.reg");
" c:\\rembo.reg");
Como vemos se captura de nuevo la IP y comprobamos sus parmetros para parchear el

nombre de la mquina. Puede hacerse usando el propio regedit o a travs de la funcin
PatchFile. Despus de muchas pruebas el sistema de regedit es ms fiable y hemos optado
por l tras llegar a una conclusin muy simple: regedit es un programa de 120Kb, portable en
cualquier disquette o fcilmente descargable de internet. Borrarlo o cualquier actividad similar
no supone ninguna restriccin para su uso por su fcil disponibilidad.
El contenido de rembo.reg puede verlo en el apartado 4.2.4 del manual. Bsicamente
consiste en cambiar los parmetros del nombre de la mquina parcheando el registro.
El arranque de Windows 98 SE se efecta con un simple HDBoot(0,2); en nuestro caso, disco
0, particin 2.
Pgina 102
9.- Clonando Linux

El clonado de Linux se efecta sin problemas, siguiendo los siguientes pasos:
1. Instale Linux en una mquina limpia.
2. Transfiera la imagen al servidor.
3. Transfiera el kernell al directorio donde ubica la imagen de linux, ya que le har falta
para arrancar.
4. Transfiera el fichero etc/fstab donde ubica la imagen de linux para poder modificarlo
durante el arranque.
Puede instalarse en cualquier particin ya que posteriormente se podr modificar el fstab
para reubicar el arranque de la mquina.
10.- Restaurando y arrancando Linux

En la restauracin edite el fichero local fstab para ubicar las particiones de arranque y swap
segn su conveniencia. En nuestro caso lo hemos probado indistintamente en 3-4 y en 5-6, sin
haber producido problemas. Veamos un fragmento:
RestoreDiskImage(0,3,"cache://global/hdimages/linux/linuxbase.base");
CopyFile("net://global/hdimages/linux/linuxbase.fstab",
"disk://0:3/etc/fstab");
Como puede verse no es ms que transferir el fstab adecuado. Puede ver el script completo
en nuestro men.
En el arranque de Linux deberemos especificarle dnde est ubicado el kernell. En nuestro
caso puede arrancarse con la orden:
LXBoot("cache://global/hdimages/linux/linuxbase.krn","","root=/dev/hda5");
Como puede verse es el nico que no utiliza el HDBoot estndar.
En estas circunstancias, posee usted un sistema con Rembo instalado y preparado

para arrancar los 3 sistemas operativos mencionados.
Puede utilizar las claves del propio Linux (a travs del samba o el fichero de claves)
para autentificar usuarios en el arranque de rembo. Edite el fichero rembo.conf segn
lo especificado en el manual para los dominios de autentificacin.
Es conveniente proteger el acceso al men de inicio del Wizard. Vea el script de
ejemplo para ms informacin.
Pgina 103
ANEXO B : OTROS ASPECTOS DE

REMBO
Otros aspectos de Rembo
CAPTULO 1 : PERSONALIZANDO REMBO

1.1.- Men personalizado
Para crear un men personalizado podemos partir de la siguiente estructura:
OpenMenu("nombre", 30, 30,
"<title>Mi cabecera</title>"
"<style>B {font-weight: normal; color: red}</style>"
"<base href='cache://global/images'>",
{{"<br><br><b>titulo1</b>","miicono1.pcx","MiFuncion1();"},
{"<br><br><b>titulo2</b>","miicono2.pcx","MiFuncion2();"},
........................................................
{"<br><br><b>titulon</b>","miiconoN.pcx","MiFuncionn();"}
});
Para cada una de las opciones que queremos que aparezca colocamos una nueva rama con
el ttulo que queremos que muestre, el icono, y la funcin que se ejecutar si se selecciona la
opcin.
1.2.- Modificar el men raz

Si queremos modificar las opciones que aparecen en la esquina inferior derecha de nuestra
pantalla de Rembo basta con ejecutar la siguiente funcin en nuestra pgina de inicio :
SaveText(<html>
<select menu style="color: navy;">
<option onmouseup="Mifuncion1();">Mimensaje1...
<option onmouseup="Mifuncion2();">Mimensaje2...
............................................
<option onmouseup="MifuncionN();">MimensajeN
</select>
</html>,"display://root/menu/SELF");
En donde para cada rama le indicamos que funcin queremos llamar y que mensaje
aparecer el men
Si lo que queremos es que no aparezca nada, pues nada, no le indicamos ninguna rama y ya
est. Quedara entonces como sigue :
SaveText(<html>
</select>
De este modo al pulsar la tecla inicio de Windows no nos aparece nada en el men
desplegable.
Nota : Parece que no es posible eliminar este men completamente, puesto que es parte del
copyright de Rembo.
Pgina 106
1.3.- Rembo en castellano

Es posible aadir un nuevo nivel de personalizacin a Rembo : cambiar todos los mensajes
que muestra al castellano.
Para ello tenemos que utilizar unos archivos que aparecen en el directorio SDK/samples del
directorio de Rembo. En este directorio tenemos una serie de archivos con extensin .rbc, que
son los fuentes sin compilar.
Si editamos el contenido de cada uno de ellos, podemos cambiar los mensajes, mens,
cabeceras, etc., de nuestro programa del ingls al espaol, o incluso modificarlos segn
nuestras necesidades.
Una vez modificados, basta con compilarlos con el programa rbcc que est en el directorio
SDK, obteniendo as los ficheros con extensin .rbx. Estos ficheros hay que subirlos al servidor
al directorio plugins. Una vez hecho esto ya podemos disfrutar de nuestro querido Rembo en
castellano.
1.4.- Cambio pantalla de autentificacin

La personalizacin de la pantalla de autentificacin de Rembo no es un proceso muy
complicado.
Si partimos de la pantalla original de Rembo ( ver utils.rbc en el directorio /SDK/samples ) es
fcil modificarla para adaptarla a nuestras necesidades: con un poco de imaginacin y algo de
conocimientos sobre HTML podremos tener una nueva pantalla de autentificacin.
Como ejemplo mostramos una realizada por nosotros :
/* Cdigo para cambiar la pantalla de autentificacin de usuario */
bool Autentificar(void)
{
if (Offline())
{
Log("Modo
sin
red:
ignorando
peticion
autentificacion<br>");
return false;
}
// Ventana de autentificacin
// Siempre arriba, no se puede mover ni redimensionar
var win = OpenWindow("authwin",20,20,80,60);
win.alwaysOnTop = true;
win.movable = false;
win.resizable = false;
de
LogonCanceled = true; // Si se cierra la ventana, se cancela la

// autentificacin
SaveText("<title>Escuela
Tcnica
Superior
de
Informtica</title>"
"<table>"
"<td text=navy face='sans-serif'>"
Ingeniera
en
"<tr><td><tr><td><td><br><br>  Usuario: "
"<td><br><br><input name=username size=16>"
"<tr><td><tr><td><td>  Password: "
"<td><input name=password size=16 "
"type=password
onsubmit='TryLogon(username,password);'>"
"<tr><td><tr><td><td colspan=2 text=blue>"
"<tr><td><td colspan=2><br><center>"
"<button onmouseup='TryLogon(username,password);'>"
" Aceptar </button> "
Pgina 107
"<button onmouseup='CloseWindow(\"authwin\");'>"
" Cancelar </button>"
"</center></table>",
"display://authwin/SELF");
// Esto es para hacer que la ventana se ajuste al contenido
// Pero solo al que hay dentro, y no al titulo :(
// AutoResizeWindow("authwin",true,true);
// Wait for the window to close
while(FileExists("display://authwin"))
delay(20);
return AuthInfo.Success && !LogonCanceled;
}
Con este cdigo creamos una pantalla de autentificacin que no se puede mover ni
redimensionar.
1.5.- Ejecucin de scripts

Si queremos utilizar funciones en nuestra pgina de inicio que aparezcan en un mdulo de
librera externo ( ficheros .rbx ) debemos ejecutar el siguiente comando :
join(Exec("plugins/micodigo.rbx"));
De esta forma no es necesario tener nuestra pgina de inicio repleta de funciones o cdigo.
Este comando es posible utilizarlo tambin dentro de nuestro propios scripts.
1.6.- Instalacin asistentes avanzados

Por defecto, las versiones Empresa y Campus utilizan los asistentes bsicos que se incluyen
en la versin Profesional. Es necesario activarlos para poder utilizarlos.
El proceso es el siguiente :
Compilar los scripts advwiz.rbc y advforms.rbc situados en el directorio

misc/SDK/samples.
Mediante la sconsole cargar los ficheros compilados .rbx en el directorio files/plugins/
del servidor Rembo.
Descargar
el
archivo
enterpr.zip
de
la
direccin
https://rembo.com/secure/public/enterpr.zip.
Descomprimir el archivo y cargar los 3 ficheros obtenidos al servidor Rembo :
Menu.seq y rembo.shtml al directorio files/.

Enterprise.pcxs al directorio files/images/.
Pgina 108
CAPTULO 2 : ALGUNAS CUESTIONES DE SEGURIDAD

2.1.- Proceso de autentificacin
En nuestra pgina de inicio personalizada tratamos el proceso de autentificacin de la
siguiente forma :
Mostramos la pantalla de autentificacin personalizada.

Solicitamos al usuario que se identifique. A partir de aqu tenemos 3 posibilidades :
Si el usuario se identifica adecuadamente mostramos el men principal.
Si la contrasea es incorrecta borramos la contrasea introducida y esperamos que la
vuelva a introducir.
Si el usuario cancela la autentificacin, ya sea cerrando la ventana o pulsando el botn
Cancelar, le mostramos un mensaje indicando que el nombre de usuario o la contrasea
son incorrectos y le volvemos a mostrar la pantalla de autentificacin.
Los nombres de usuario y password los hemos tomado de la mquina Linux que acta como
servidora. Es posible tambin que la autentificacin se realice mediante dominio NT o Radius (
ver Manual del Servidor de Rembo para ms detalles ).
Como ejemplo mostramos el cdigo que hemos utilizado en nuestra pgina de inicio
personalizada:
bool aut = false;
while (!aut)
{
aut = Autentificar();
if(!aut)
{
OpenMessage("auten","Nombre de usuario o contrasea incorrectos");
delay(300);
CloseWindow("auten");
}
}
2.2.- Asegurar arranque en Rembo

Para evitar que un usuario se salte el arranque en red usando la tecla escape cuando se
inicia el ordenador podemos utilizar una opcin que nos da Rembo.
Consiste en borrar la bandera de particin activa de todas las particiones, de modo que
cuando un usuario se quiera saltar el arranque en red para arrancar el disco local directamente
le salte un mensaje de aviso y el ordenador se quede bloqueado.
El fragmento de cdigo que realiza esta operacin es el siguiente :
OpenMessage("limphd","Limpiando MBR ...");
delay(200);
CloseWindow("limphd");
SaveText("Solo se puede arrancar en red, pilln :D",
"disk://0:0/BootMessage");
HDClean(0,0);
SetBootablePartition(0,0);
Pgina 109
Este script se puede ejecutar al crear toda la estructura de particiones del disco duro y de esta
forma se evita el uso del equipo si no se ha autentificado previamente.
Nota : Es evidente que si por cualquier motivo la red o el servidor de autentificacin deja de
funcionar el ordenador queda totalmente inutilizado.
2.3.- Bloqueo de perifricos

Se pueden definir para cada grupo un bloqueo de una serie de perifricos mediante la funcin
Lockout.
Esta funcin nos permite bloquear lo siguiente:
1.
2.
3.
4.
5.
6.
Ratn
Teclado
Reset
Power off
Pantalla
Todo
->
->
->
->
->
->
Lockout
Lockout
Lockout
Lockout
Lockout
Lockout
mouse
keys
reset
poweroff
screen
all
Este bloqueo se mantiene mientras Rembo est activo, y se desbloquean al darle el control al
sistema operativo con HDBoot, LXBoot, RDBoot o DeviceBoot.
El bloqueo se ejecuta para todos los hosts pertenecientes al grupo.
Otra posibilidad es usar en los scripts las funciones LockKeyboard, LockMouse o
LockScreen, que permite bloquear el teclado, el ratn o la pantalla del ordenador local. Esta
opcin es la que hemos utilizado para evitar que el usuario toque nada mientras se restaura un
sistema operativo.
Pgina 110
ANEXO C : MEN DE EJEMPLO
Men de ejemplo
MEN DE EJEMPLO
Para terminar este documento, queremos mostrar un ejemplo de pgina de inicio que hemos
creado para usarla durante las prcticas. Puede servir de base para su propia pgina si as lo
desea. Con un poco de imaginacin y algo de conocimientos de programacin (sobre todo,
HTML) es posible conseguir algunas cosas sorprendentes.
Ejemplo : practicas.shtml

<script type="text/rembo-c">
// Compatibilidad con versiones anteriores a la 0.99.
if(FileExists("cache://global/plugins/rembo099.rbx"))
{
join(Exec("plugins/rembo099.rbx"));
}
// Cargando utils.rbx
if(FileExists("cache://global/plugins/utils.rbx"))
{
join(Exec("plugins/utils.rbx"));
}
// Para declarar los modos por defecto
str DefVideoMode;
str DefKeyMap;
str DefCodeMap;
// Para parchear W98
str Hostname;
var BasicErrorHandler(var exc) { return exc; }
with(BasicErrorHandler) try
{
// Obligamos modo 800x600 y teclado en espaol
Settings.VideoMode = "800x600";
Keyb("es");
if(DefCodeMap != "")
CodePage((int)DefCodeMap);
}
/* Cdigo para cambiar la pantalla de autentificacin de usuario */
bool Autentificar(void)
{
if (Offline())
{
Log("Modo sin red: ignorando peticion de
autentificacion<br>");
return false;
}
// Ventana de autentificacin
// Siempre arriba, no se puede mover ni redimensionar
var win = OpenWindow("authwin",20,20,80,60);
win.alwaysOnTop = true;
win.movable = false;
win.resizable = false;
LogonCanceled = true; // Si se cierra la ventana,
//se cancela la autentificacin
SaveText("<title>Escuela Tcnica Superior de Ingeniera en
Informtica</title>"
"<table>"
"<td text=navy face='sans-serif'>"
"<tr><td><tr><td><td><br><br>  Usuario: "
"<td><br><br><input name=username size=16>"
Pgina 112
Men de ejemplo
<tr><td><tr><td><td>  Password: "
<td><input name=password size=16 "
"type=password onsubmit='TryLogon(username,password);'>"
"<tr><td><tr><td><td colspan=2 text=blue>"
"<tr><td><td colspan=2><br><center>"
"<button onmouseup='TryLogon(username,password);'>"
" Aceptar </button> "
"<button onmouseup='CloseWindow(\"authwin\");'>"
" Cancelar </button>"
</center></table>",
display://authwin/SELF");
// Esto es para hacer que la ventana se ajuste al contenido
// Pero solo al que hay dentro, y no al titulo :(
// AutoResizeWindow("authwin",true,true);
// Wait for the window to close
while(FileExists("display://authwin"))
delay(20);
return AuthInfo.Success && !LogonCanceled;
}
void LimpiarHD (void)
{
/* Las particiones que vamos a utilizar son las siguientes :
* Particin 1:
* Particin 2:
* Particin 3:
* Particin 4:
* Libres para cach_
*/
NTFS
FAT32
EXT2
LINUX-SWAP
:
1 Gb
500 Mb
1,5 Gb
256 Mb
+900 Mb
HideWindow("Menuppal");
OpenMessage("limphd","Limpiando HD ...");
delay(200);
SetPrimaryPartitions(0, "NTFS:1000000 FAT32:500000 EXT2:1500000
LINUX-SWAP:256000");
HDClean(0,1);
HDClean(0,2);
HDClean(0,3);
HDClean(0,4);
// Lo siguiente es para impedir que se salten el arranque remoto
// dandole al escape
OpenMessage("limphd","Limpiando MBR ...");
delay(200);
SaveText("Solo se puede arrancar en red:D",
"disk://0:0/BootMessage");
HDClean(0,0);
SetBootablePartition(0,0);
OpenMessage("finlimphd","Fin de limpieza");
delay(300);
CloseWindow("finlimphd");
ShowWindow("Menuppal");
}
void ArrancarW2K (void)
{
CloseWindow("Menuppal");
OpenMessage("aw2k","Arrancando Windows 2000 ...");
delay(300);
CloseWindow("aw2k");
HDBoot(0,1);
}
Pgina 113
Men de ejemplo
void ArrancarW98 (void)

{
OpenMessage("aw98","Arrancando Windows 98 SE ...");
delay(300);
CloseWindow("aw98");
HDBoot(0,2);
}
void ArrancarLinux (void)
{
OpenMessage("alinux","Arrancando Linux Red Hat 7.1 ...");
delay(300);
CloseWindow("alinux");
LXBoot("cache://global/hdimages/linux/linuxbase.krn","",
"root=/dev/hda3");
}
void RestaurarW2K (void)
{
LockKeyboard(true);
LockMouse(true);
OpenMessage("rw2k","Restaurando Windows 2000 ...");
delay(300);
CloseWindow("rw2k");
//HDClean(0,1);
//RestoreDiskImage(0,1,
//
"cache://global/hdimages/winnt/win2000base.img");
Synchronize("cache://global/hdimages/win9x/win2000base.img",
"disk://0:1","b");
var ip=StrParse(NetInfo.IPAddress,".");
str nombre="pem"+ip[3];
NTChangeName(nombre);
OpenMessage("finrw2k","Fin de la restauracin");
delay(300);
CloseWindow("finrw2k");
LockMouse(false);
LockKeyboard(false);
}
void RestaurarW98 (void)
{
LockKeyboard(true);
LockMouse(true);
OpenMessage("rw98","Restaurando Windows 98 SE ...");
delay(300);
CloseWindow("rw98");
//HDClean(0,2);
//RestoreDiskImage(0,2,
//
"cache://global/hdimages/win9x/win98se.img");
Synchronize("cache://global/hdimages/win9x/win98se.img",
"disk://0:2","b");
Pgina 114
Men de ejemplo

Hostname = "pem"+ipa[3];
PatchFile("cache://global/rembo.reg","disk://0:2/rembo.reg");
" c:\\rembo.reg");
OpenMessage("finrw98","Fin de la restauracin");
delay(300);
CloseWindow("finrw98");
LockMouse(false);
}
void RestaurarLinux (void)
{
LockKeyboard(true);
LockMouse(true);
OpenMessage("rlinux","Restaurando Linux Red Hat 7.1 ...");
delay(300);
CloseWindow("rlinux");
HDClean(0,3);
RestoreDiskImage(0,3,
"cache://global/hdimages/linux/linuxbase.base");
CopyFile("net://global/hdimages/linux/linuxbase.fstab",
"disk://0:3/etc/fstab");
OpenMessage("finrlinux","Fin de la restauracin");
delay(300);
CloseWindow("finrlinux");
LockMouse(false);
}
var w = Window("root");
//
//
//
//
Para eliminar el men del Rembo que sale como el de inicio de

Windows. Parece que no puede eliminarse debido al copyright (es su
identificacin)
Pero si que se puede dejar sin entradas :D.
SaveText(<html>
</select>
// Para indicar el color de fondo
w.widgets.color="#CCCC99";
// Y, por ltimo, los mens
Pgina 115
Men de ejemplo
// Primero hay que autentificar

bool aut = false;
while (!aut)
{
aut = Autentificar();
if(!aut)
{
OpenMessage("auten",
"Nombre de usuario o contrasea incorrectos");
delay(300);
CloseWindow("auten");
}
}
// Y despus nos sale ya el men de arranque
OpenMenu("Menuppal", 30, 30,
"<title>Menu principal</title>"
"<style>B {font-weight: normal; color: red}</style>"
"<base href='cache://global/images'>",
{{"<br><br><b>Volver a autentificar</b>","zergface.pcx","Autentificar();"},
{"<br><br><b>Dejar limpito el HD</b>","cnf-overlord.pcx","LimpiarHD();"},
{"<br><br>Arrancar <b>Windows2000</b>","cnf-nexo.pcx","ArrancarW2K();"},
{"<br><br>Arrancar <b>Windows98SE</b>","cnf-crucero.pcx","ArrancarW98();"},
{<br>Arrancar <b>Linux Red Hat 7.1</b>","over.pcx","ArrancarLinux();"},
{"<br><br>Restaurar <b>Windows2000</b>","cnf-nexo.pcx","RestaurarW2K();"},
{"<br><br>Restaurar <b>Windows98SE</b>","cnf-crucero.pcx","RestaurarW98();"},
{"<br><br>Restaurar <b>Linux Red Hat 7.1</b>","over.pcx","RestaurarLinux();"}
});
</script>
<body>
</body>
Pgina 116

Manual de Rembo 2.0 - ForPAS Sevilla

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Manual de Rembo 2.0 - ForPAS Sevilla

Enviado por

Direitos autorais:

Formatos disponíveis

Traduccin al Espaol realizada por:

(en orden alfabtico)

Sergio Baos Calvo (elrothbaco@hotmail.com)

Escuela Tcnica Superior de Ingenieros en Informtica

Viernes, 15 de Febrero de 2002

2.2.- Parmetros Globales ................................................................................................21

MANUAL DE ADMINISTRACIN DEL CLIENTE ......................................................39

CAPTULO 2: Comenzando a usar REMBO ..........................................................................42

3.7.- Uso de canales TCP para acceder a recursos remotos ...........................................59

CAPTULO 4: INSTRUCCIONES ESPECFICAS PARA CADA

MANUAL DE REFERENCIA DE REMBO-C...............................................................84

ANEXO A : GUA RPIDA DE

INSTALACIN DE REMBO .................................99

GUA RPIDA DE INSTALACIN DE REMBO ...................................................................100

4.- Clonando Windows 2000 ...........................................................................................101

ANEXO B : OTROS ASPECTOS DE REMBO .........................................................105

ANEXO C : MEN DE EJEMPLO ............................................................................111

MANUAL DE ADMINISTRACIN DEL

Manual de Administracin del Servidor

CAPTULO 1: Instalacin del servidor REMBO

1.1.- Conceptos y requisitos

1.1.1.- Cmo funciona?

1.1.2.- Requisitos del Servidor

1.1.2.1.- Servidor DHCP

Prcticas de Empresa 2001/02 1er Turno

Manual de Administracin del Servidor

1.1.2.2.- Servidor REMBO

1.2.- Configuracin del servidor DHCP

El servidor DHCP y el servidor REMBO no estn en la misma mquina.

1.2.1.- Servidor DHCP y REMBO en equipos diferentes

Si las opciones DHCP 43 y 60 estn puestas, elimnelas.

1.2.2.- Servidor DHCP y REMBO en el mismo equipo

Si la opcin 43 est puesta, elimnela;

1.2.2.1.- Aadiendo la opcin 60 al servidor DHCP de WinNT 4

Prcticas de Empresa 2001/02 1er Turno

Manual de Administracin del Servidor

Paso 2. Aadir la opcin 60 al mbito DHCP.

1.2.2.2.- Aadiendo la opcin 60 al servidor DHCP de Win2000

Abra una ventana de smbolo del sistema.

1.2.2.3.- Aadiendo la opcin 60 a un host con servidor ISC

Aada vendor-class-identifier "PXEClient"; para los hosts usando REMBO.

1.2.3.- Aadiendo REMBO a una infraestructura con Boot

1.3.- Instalacin de REMBO en Windows NT / 2000

Prcticas de Empresa 2001/02 1er Turno

Manual de Administracin del Servidor

rembo.exe : este es el servidor. Como el servidor es un servicio NT, usted no

1.3.2.- Configuracin mnima

La consola de servidor REMBO.

1.3.3.- Comprobando la configuracin

1.3.4.- Solucin de problemas con el servicio NT

Prcticas de Empresa 2001/02 1er Turno

Manual de Administracin del Servidor

1.4.- Instalacin de REMBO en Unix

1.4.2.- Configuracin mnima

Muchos componentes adicionales pueden ser especificados en el fichero de configuracin. Sin

Prcticas de Empresa 2001/02 1er Turno

Manual de Administracin del Servidor

1.4.3.- Instalando los ficheros del servidor

1.4.4.- Comprobando la configuracin

Arrancar el servidor sin privilegios de administrador (root), evitando la reserva de

Prcticas de Empresa 2001/02 1er Turno

Manual de Administracin del Servidor

1.4.5.- Opciones de lnea de comandos del servidor REMBO

-d : muestra informacin de depuracin a la salida estndar, no se ejecuta como