#971 remove ogAdmClient and ogAdmAgent

ogAdmClient has been replaced by ogClient.
ogAdmAgent has been integrated into ogAdmServer.

8 files changed, 0 insertions, 3594 deletions

diff --git a/admin/Sources/Clients/ogAdmClient/Makefile b/admin/Sources/Clients/ogAdmClient/Makefile
deleted file mode 100644
index d3628c9d..00000000
--- a/admin/Sources/Clients/ogAdmClient/Makefile
+++ /dev/null
@@ -1,31 +0,0 @@
-# makefile
-
-# Nombre del proyecto
-PROYECTO := ogAdmClient
-
-# Directorios y librerias
-DIRS :=
-LIBS := -static
-
-# Opciones de compilacion
-OPCS := -m32 -O0 -g -Wall	# Depuracion
-#OPCS := -m32 -O3 -Wall		# Optimizacion
-
-# Ficheros objetos
-OBJS := sources/ogAdmClient.o
-
-all: $(PROYECTO)
-
-$(PROYECTO): $(OBJS)
-	gcc $(OPCS) $(DIRS) $(LIBS) $(OBJS) -o $(PROYECTO)
-#	strip $(PROYECTO)	# Optimizacion
-
-clean:
-	rm -f $(PROYECTO) $(OBJS)
-
-sources/%.o: sources/%.c
-	gcc $(OPCS) -I ../../Includes -c -o"$@" "$<"
-
-
-
-
diff --git a/admin/Sources/Clients/ogAdmClient/ogAdmClient.cfg b/admin/Sources/Clients/ogAdmClient/ogAdmClient.cfg
deleted file mode 100644
index b15e7407..00000000
--- a/admin/Sources/Clients/ogAdmClient/ogAdmClient.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-ServidorAdm=SERVERIP
-PUERTO=2008
-PATHINTERFACE=/opt/opengnsys/interfaceAdm
-UrlMenu=OPENGNSYSURL/varios/menubrowser.php
-UrlMsg=http://localhost/cgi-bin/httpd-log.sh
\ No newline at end of file
diff --git a/admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c b/admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c
deleted file mode 100644
index 6f87cc45..00000000
--- a/admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c
+++ /dev/null
@@ -1,2331 +0,0 @@
-// ********************************************************************************************************

-// Cliernte: ogAdmClient

-// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla

-// Fecha Creación: Marzo-2010

-// Fecha Última modificación: Abril-2010

-// Nombre del fichero: ogAdmClient.c

-// Descripción :Este fichero implementa el cliente general del sistema

-// ********************************************************************************************************

-

-#include "ogAdmClient.h"

-#include "ogAdmLib.c"

-//________________________________________________________________________________________________________

-//	Función: tomaConfiguracion

-//

-//	Descripción:

-//		Lee el fichero de configuración del servicio

-//	Parámetros:

-//		filecfg : Ruta completa al fichero de configuración

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error 

-//________________________________________________________________________________________________________

-BOOLEAN tomaConfiguracion(char* filecfg)

-{

-	char modulo[] = "tomaConfiguracion()";

-

-	if (filecfg == NULL || strlen(filecfg) == 0) {

-		errorLog(modulo, 1, FALSE); // Fichero de configuración del cliente vacío

-		return (FALSE);

-	}

-	FILE *fcfg;

-	int lSize;

-	char * buffer, *lineas[MAXPRM], *dualparametro[2];

-	int i, numlin, resul;

-

-	fcfg = fopen(filecfg, "rt");

-	if (fcfg == NULL) {

-		errorLog(modulo, 2, FALSE); // No existe fichero de configuración del cliente

-		return (FALSE);

-	}

-

-	fseek(fcfg, 0, SEEK_END);

-	lSize = ftell(fcfg); // Obtiene tamaño del fichero.

-	rewind(fcfg);

-	buffer = (char*) reservaMemoria(lSize+1); // Toma memoria para el buffer de lectura.

-	if (buffer == NULL) { // No hay memoria suficiente para el buffer

-		errorLog(modulo, 3, FALSE);

-		return (FALSE);

-	}

-	lSize=fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero

-	buffer[lSize]=CHARNULL;

-	fclose(fcfg);

-

-	/* Inicializar variables globales */

-	servidoradm[0]=CHARNULL;

-	puerto[0] = CHARNULL;

-	pathinterface[0]=CHARNULL;

-	urlmenu[0]=CHARNULL;

-	urlmsg[0]=CHARNULL;

-

-	numlin = splitCadena(lineas, buffer, '\n');

-	for (i = 0; i < numlin; i++) {

-		splitCadena(dualparametro, lineas[i], '=');

-

-		resul = strcmp(StrToUpper(dualparametro[0]), "SERVIDORADM");

-		if (resul == 0)

-			strcpy(servidoradm, dualparametro[1]);

-

-		resul = strcmp(StrToUpper(dualparametro[0]), "PUERTO");

-		if (resul == 0)

-			strcpy(puerto, dualparametro[1]);

-

-		resul = strcmp(StrToUpper(dualparametro[0]), "PATHINTERFACE");

-		if (resul == 0)

-			strcpy(pathinterface, dualparametro[1]);

-

-		resul = strcmp(StrToUpper(dualparametro[0]), "URLMENU");

-		if (resul == 0)

-			strcpy(urlmenu, dualparametro[1]);

-

-		resul = strcmp(StrToUpper(dualparametro[0]), "URLMSG");

-		if (resul == 0)

-			strcpy(urlmsg, dualparametro[1]);

-	}

-

-	if (servidoradm[0] == CHARNULL) {

-		liberaMemoria(buffer);

-		errorLog(modulo,4, FALSE); // Falta parámetro SERVIDORADM

-		return (FALSE);

-	}

-

-	if (puerto[0] == CHARNULL) {

-		liberaMemoria(buffer);

-		errorLog(modulo,5, FALSE); // Falta parámetro PUERTO

-		return (FALSE);

-	}

-	if (pathinterface[0] == CHARNULL) {

-		liberaMemoria(buffer);

-		errorLog(modulo,56, FALSE); // Falta parámetro PATHINTERFACE

-		return (FALSE);

-	}

-

-	if (urlmenu[0] == CHARNULL) {

-		liberaMemoria(buffer);

-		errorLog(modulo,89, FALSE); // Falta parámetro URLMENU

-		return (FALSE);

-	}

-	if (urlmsg[0] == CHARNULL) {

-		liberaMemoria(buffer);

-		errorLog(modulo,90, FALSE); // Falta parámetro URLMSG

-		return (FALSE);

-	}

-	liberaMemoria(buffer);

-	return (TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: FinterfaceAdmin

-//

-//	 Descripción:

-//		Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.

-//		La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;

-//		esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface

-//		podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.

-//

-//	Parámetros:

-//		- script: Nombre del módulo,función o script de la interface

-//		- parametros: Parámetros que se le pasarán a la interface

-//		- salida: Recoge la salida que genera la llamada a la interface

-

-// 	Devuelve:

-//		Código de error de la ejecución al módulo , función o script de la interface

-//

-//	Especificaciones:

-//		El parámetro salida recoge la salida desde un fichero que se genera en la ejecución del script siempre que

-//		sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.

-//		Este fichero tiene una ubicación fija: /tmp/_retinterface

-//______________________________________________________________________________________________________

-

-int FinterfaceAdmin( char *script,char* parametros,char* salida)

-{

-    FILE *f;

-	int lSize,nargs,i,resul;

-    char msglog[LONSTD],*argumentos[MAXARGS];

-	char modulo[] = "FinterfaceAdmin()";

-

-

-	if (ndebug>= DEBUG_MEDIO) {

-		sprintf(msglog, "%s:%s", tbMensajes[8], script);

-		infoDebug(msglog);

-	}

-

-	/* Crea matriz de los argumentos */

-	nargs=splitCadena(argumentos,parametros,32);

-	for(i=nargs;i<MAXARGS;i++){

-		argumentos[i]=NULL;

-	}

-

-	/* Muestra matriz de los argumentos */

-	for(i=0;i<nargs;i++){

-		if (ndebug>= DEBUG_ALTO) {

-			sprintf(msglog, "%s: #%d-%s", tbMensajes[9],i+1,argumentos[i]);

-			infoDebug(msglog);

-		}

-	}

-	/* Elimina fichero de retorno */

-	if(salida!=(char*)NULL){

-		f = fopen("/tmp/_retinterface_","w" );

-		if (f==NULL){  // Error de eliminación

-			scriptLog(modulo,10);

-			resul=8;

-			scriptLog(modulo,resul);

-			return(resul);

-		}

-		fclose(f);

-	}

-	/* Compone linea de comando */

-	if(parametros){

-		strcat(script," ");

-		strcat(script,parametros);

-	}

-	/* LLamada función interface */

-	resul=system(script);

-	if(resul){

-		scriptLog(modulo,10);

-		scriptLog(modulo,resul);

-		return(resul);

-	}

-	/* Lee fichero de retorno */

-	if(salida!=(char*)NULL){

-		f = fopen("/tmp/_retinterface_","rb" );

-		if (f==NULL){ // Error de apertura

-			scriptLog(modulo,10);

-			resul=9;

-			scriptLog(modulo,resul);

-			return(resul);

-		}

-		else{

-			fseek (f ,0,SEEK_END);  // Obtiene tamaño del fichero.

-			lSize = ftell (f);

-			rewind (f);

-			if(lSize>LONGITUD_SCRIPTSALIDA){

-				scriptLog(modulo,10);

-				resul=11;

-				scriptLog(modulo,resul);

-				return(resul);

-			}

-			fread (salida,1,lSize,f); 	// Lee contenido del fichero

-			rTrim(salida);

-			fclose(f);

-		}

-	}

-	/* Muestra información de retorno */

-	if(salida!=(char*)NULL){

-		if(ndebug>2){

-			sprintf(msglog,"Información devuelta %s",salida);

-			infoDebug(msglog);

-		}

-	}

-	return(resul);

-}

-//______________________________________________________________________________________________________

-// Función: interfaceAdmin

-//

-//	 Descripción:

-//		Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.

-//		La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;

-//		esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface

-//		podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.

-//

-//	Parámetros:

-//		- script: Nombre del módulo,función o script de la interface

-//		- parametros: Parámetros que se le pasarán a la interface

-//		- salida: Recoge la salida que genera la llamada a la interface

-

-// 	Devuelve:

-//		Código de error de la ejecución al módulo , función o script de la interface

-//

-//	Especificaciones:

-//		El parámetro salida recoge la salida desde el procedimiento hijo que se genera en la ejecución de éste

-//		siempre que sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se

-//		recogerá dicha salida.

-//______________________________________________________________________________________________________

-

-int interfaceAdmin( char *script,char* parametros,char* salida)

-{

-	int  descr[2];	/* Descriptores de E y S de la turbería */

-	int  bytesleidos;	/* Bytes leidos en el mensaje */

-	int estado;

-	pid_t  pid;

-	char buffer[LONBLK];	// Buffer de lectura de fichero

-	pipe (descr);

-	int i,nargs,resul;

-	int lon;		// Longitud de cadena

-	char msglog[LONSUC];	// Mensaje de registro de sucesos

-	char *argumentos[MAXARGS];

-	char modulo[] = "interfaceAdmin()";

-	if (ndebug>= DEBUG_MEDIO) {

-		sprintf(msglog, "%s:%s", tbMensajes[8], script);

-		infoDebug(msglog);

-	}

-

-	/* Crea matriz de los argumentos */

-	nargs=splitCadena(argumentos,parametros,32);

-	for(i=nargs;i<MAXARGS;i++){

-		argumentos[i]=NULL;

-	}

-	/* Muestra matriz de los argumentos */

-	for(i=1;i<nargs;i++){

-		if (ndebug>= DEBUG_ALTO) {

-			// Truncar la cadena si es mayor que el tamaño de la línea de log.

-			sprintf(msglog, "%s: #%d-", tbMensajes[9], i+1);

-			lon = strlen (msglog);

-			if (lon + strlen (argumentos[i]) < LONSUC) {

-				strcat (msglog, argumentos[i]);

-			}

-			else

-			{

-				strncat (msglog, argumentos[i], LONSUC - lon - 4);

-				strcat (msglog, "...");

-			}

-			infoDebug(msglog);

-		}

-	}

-

-	if((pid=fork())==0)

-	{

-		//_______________________________________________________________

-

-		/* Proceso hijo que ejecuta la función de interface */

-

-		close (descr[LEER]);

-		dup2 (descr[ESCRIBIR], 1);

-		close (descr[ESCRIBIR]);

-		resul=execv(script,argumentos);

-		//resul=execlp (script, script, argumentos[0],argumentos[1],NULL);

-		exit(resul);

-

-		/* Fin de proceso hijo */

-		//_______________________________________________________________

-	}

-	else

-	{

-		//_______________________________________________________________

-

-		/* Proceso padre que espera la ejecución del hijo */

-

-		if (pid ==-1){ // Error en la creación del proceso hijo

-			scriptLog(modulo,10);

-			resul=13;

-			scriptLog(modulo,resul);

-			return(resul);

-		}

-		close (descr[ESCRIBIR]);

-		bytesleidos = read (descr[LEER], buffer, LONBLK-1);

-		while(bytesleidos>0){

-			if(salida!=(char*)NULL){ // Si se solicita retorno de información...

-				buffer[bytesleidos]='\0';

-				// Error si se supera el tamaño máximo de cadena de salida.

-				if(strlen(buffer)+strlen(salida)>LONGITUD_SCRIPTSALIDA){

-					scriptLog(modulo,10);

-					resul=11;

-					scriptLog(modulo,resul);

-					return(resul);

-				}

-				rTrim(buffer);

-				strcat(salida,buffer);

-			}

-			bytesleidos = read (descr[LEER], buffer, LONBLK-1);

-		}

-		close (descr[LEER]);

-		//kill(pid,SIGQUIT);

-		waitpid(pid,&estado,0);

-		resul=WEXITSTATUS(estado);

-		if(resul){

-			scriptLog(modulo,10);

-			scriptLog(modulo,resul);

-			return(resul);

-		}

-		/* Fin de proceso padre */

-		//_______________________________________________________________

-	}

-

-	/* Muestra información de retorno */

-	if(salida!=(char*)NULL){

-		if(ndebug>2){

-			// Truncar la cadena si es mayor que el tamaño de la línea de log.

-			strcpy(msglog,"Informacion devuelta ");

-			lon = strlen (msglog);

-			if (lon + strlen (salida) < LONSUC) {

-				strcat (msglog, salida);

-			}

-			else

-			{

-				strncat (msglog, salida, LONSUC-lon-4);

-				strcat (msglog, "...");

-			}

-			infoDebug(msglog);

-		}

-	}

-	return(resul);

-}

-//______________________________________________________________________________________________________

-// Función: scriptLog

-//

-//	Descripción:

-//		Registra los sucesos de errores de scripts en el fichero de log

-//	Parametros:

-//		- modulo: Módulo donde se produjo el error

-//		- coderr : Código del mensaje de error del script

-//______________________________________________________________________________________________________

-void scriptLog(const char *modulo,int coderr)

-{

-	char msglog[LONSUC];

-

-	if(coderr<MAXERRORSCRIPT)

-		errorInfo(modulo,tbErroresScripts[coderr]); // Se ha producido algún error registrado

-	else{

-		sprintf(msglog,"%s: %d",tbErroresScripts[MAXERRORSCRIPT],coderr);

-		errorInfo(modulo,msglog);

-	}

-}

-//______________________________________________________________________________________________________

-// Función: TomaIPlocal

-//

-//	 Descripción:

-//		Recupera la IP local

-//	Parámetros:

-//		Ninguno

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//	Especificaciones:

-//		En caso de no encontrar la IP o generarse algún error la IP local sería 0.0.0.0

-//______________________________________________________________________________________________________

-BOOLEAN tomaIPlocal()

-{

-	char modulo[] = "tomaIPlocal()";

-

-	// Para debug

-	//strcpy(IPlocal,"10.1.15.203");

-	//return(TRUE);

-

-	sprintf(interface,"%s/getIpAddress",pathinterface);

-	herror=interfaceAdmin(interface,NULL,IPlocal);

-	if(herror){

-		errorLog(modulo,85,FALSE);

-		return(FALSE);

-	}

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-//

-// Función: cuestionCache

-//

-//	 Descripción:

-//		Procesa la cache en caso de existir.

-//	Parámetros:

-//		tam : Tamaño de la cache

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN cuestionCache(char* tam)

-{

-	return(TRUE);

-	//>>>>>>>>>>>>>>>>>>>>>>>>>>

-	char msglog[LONSTD];

-	char modulo[] = "cuestionCache()";

-

-	sprintf(interface,"%s/%s",pathinterface,"procesaCache");

-	sprintf(parametros,"%s %s","procesaCache",tam);

-

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s",tbErrores[88]);

-		errorInfo(modulo,msglog);

-		return(FALSE);

-	}

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: cargaPaginaWeb

-//

-//	Descripción:

-// 		Muestra una pégina web usando el browser

-//	Parámetros:

-//	  urp: Dirección url de la página

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-// ________________________________________________________________________________________________________

-int cargaPaginaWeb(char *url)

-{

-	pid_t pidbrowser; // Identificador del proceso que se crea para mostrar una página web con el browser

-	int resul=0;

-	char* argumentos[4];

-	char modulo[] = "cargaPaginaWeb()";

-

-	// Destruye los procesos del Browser y lanza uno nuevo.

-	system("pkill -9 browser");

-

-	sprintf(interface,"/opt/opengnsys/bin/browser");

-	sprintf(parametros,"browser -qws %s",url);

-

-	splitCadena(argumentos,parametros,' '); // Crea matriz de los argumentos del scripts

-	argumentos[3]=NULL;

-	if((pidbrowser=fork())==0){

-		/* Proceso hijo que ejecuta el script */

-		resul=execv(interface,argumentos);

-		exit(resul);

-	}

-	else {

-		if (pidbrowser ==-1){

-			scriptLog(modulo,10);

-			resul=13;

-			scriptLog(modulo,resul);

-			return(resul);

-		}

-	}

-	return(resul);

-}

-//________________________________________________________________________________________________________

-//	Función: muestraMenu

-//

-//	Descripción:

-//		Muestra el menu inicial del cliente

-//	Parámetros:

-//		Ninguno

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//________________________________________________________________________________________________________

-void muestraMenu()

-{

-	cargaPaginaWeb(urlmenu);

-}

-//______________________________________________________________________________________________________

-// Función: muestraMensaje

-//

-//	Descripción:

-// 		Muestra un mensaje en pantalla

-//	Parámetros:

-//		- idx: Indice del mensaje

-//		- msg: Descripción Mensaje

-// ________________________________________________________________________________________________________

-void muestraMensaje(int idx,char*msg)

-{

-	char *msgpan,url[250];

-	

-	if(msg){

-		msgpan=URLEncode(msg);

-		sprintf(url,"%s?msg=%s",urlmsg,msgpan); // Url de la página de mensajes

-		liberaMemoria(msgpan);

-	}

-	else

-		sprintf(url,"%s?idx=%d",urlmsg,idx); // Url de la página de mensajes

-	cargaPaginaWeb(url);

-}

-//______________________________________________________________________________________________________

-// Función: InclusionCliente

-//	 Descripción:

-//		Abre una sesión en el servidor de administración y registra al cliente en el sistema

-//	Parámetros:

-//		Ninguno

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN inclusionCliente(TRAMA* ptrTrama)

-{

-	int lon;		// Longitud de cadena

-	char msglog[LONSUC];	// Mensaje de registro de sucesos

-	char *cfg;		// Datos de configuración

-	SOCKET socket_c;

-	char modulo[] = "inclusionCliente()";

-

-	cfg=LeeConfiguracion();

-	

-	if(!cfg){ // No se puede recuperar la configuración del cliente

-		errorLog(modulo,36,FALSE);

-		errorLog(modulo,37,FALSE);

-		return(FALSE);

-	}

-	if (ndebug>= DEBUG_ALTO) {

-		// Truncar la cadena si es mayor que el tamaño de la línea de log.

-		sprintf(msglog, "%s", tbMensajes[14]);

-		lon = strlen (msglog);

-		if (lon + strlen (cfg) < LONSUC) {

-			strcat (msglog, cfg);

-		}

-		else

-		{

-			strncat (msglog, cfg, LONSUC - lon - 4);

-			strcat (msglog, "...");

-		}

-		infoDebug(msglog);

-	}

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor

-	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente

-	liberaMemoria(cfg);

-	

-	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){

-		errorLog(modulo,37,FALSE);

-		return(FALSE);

-	}

-	ptrTrama=recibeMensaje(&socket_c);

-	if(!ptrTrama){

-		errorLog(modulo,45,FALSE);

-		return(FALSE);

-	}

-

-	close(socket_c);

-

-	if(!gestionaTrama(ptrTrama)){	// Análisis de la trama

-		errorLog(modulo,39,FALSE);

-		return(FALSE);

-	}

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: RESPUESTA_InclusionCliente

-//

-//	Descripción:

-//  	Respuesta del servidor de administración a la petición de inicio

-//		enviando los datos identificativos del cliente y otras configuraciones

-//	Parámetros:

-//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN RESPUESTA_InclusionCliente(TRAMA* ptrTrama)

-{

-	char* res;

-	char modulo[] = "RESPUESTA_InclusionCliente()";

-

-	res=copiaParametro("res",ptrTrama); // Resultado del proceso de inclusión

-	if(atoi(res)==0){ // Error en el proceso de inclusión

-		liberaMemoria(res);

-		errorLog(modulo,41,FALSE);

-		return (FALSE);

-	}

-	liberaMemoria(res);

-

-	idordenador=copiaParametro("ido",ptrTrama); // Identificador del ordenador

-	nombreordenador=copiaParametro("npc",ptrTrama);	//  Nombre del ordenador

-	cache=copiaParametro("che",ptrTrama); // Tamaño de la caché reservada al cliente

-	idproautoexec=copiaParametro("exe",ptrTrama); // Procedimento de inicio (Autoexec)

-	idcentro=copiaParametro("idc",ptrTrama); // Identificador de la Unidad Organizativa

-	idaula=copiaParametro("ida",ptrTrama); // Identificador del aula

-

-	if(idordenador==NULL || nombreordenador==NULL){

-		errorLog(modulo,40,FALSE);

-		return (FALSE);

-	}

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-//

-// Función: LeeConfiguracion

-//	 Descripción:

-//		Abre una sesión en el servidor de administración y registra al cliente en el sistema

-//	Parámetros:

-//		Ninguno

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-

-char* LeeConfiguracion()

-{

-	char* parametroscfg;

-	char modulo[] = "LeeConfiguracion()";

-	int herrorcfg;

-

-	// Reservar memoria para los datos de cofiguración.

-	parametroscfg=(char*)reservaMemoria(LONGITUD_SCRIPTSALIDA);

-	if(!parametroscfg){

-		errorLog(modulo,3,FALSE);

-		return(NULL);

-	}

-	// Ejecutar script y obtener datos.

-	sprintf(interface,"%s/%s",pathinterface,"getConfiguration");

-	herrorcfg=interfaceAdmin(interface,NULL,parametroscfg);

-

-	if(herrorcfg){ // No se puede recuperar la configuración del cliente

-		liberaMemoria(parametroscfg);

-		errorLog(modulo,36,FALSE);

-		return(NULL);

-	}

-	return(parametroscfg);

-}

-//________________________________________________________________________________________________________

-//	Función: autoexecCliente

-//

-//	Descripción:

-//		Solicita procedimiento de autoexec para el cliebnte

-//	Parámetros:

-//		Ninguno

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//________________________________________________________________________________________________________

-BOOLEAN autoexecCliente(TRAMA* ptrTrama)

-{

-	SOCKET socket_c;

-	char modulo[] = "autoexecCliente()";

-

-	initParametros(ptrTrama,0);

-	sprintf(ptrTrama->parametros,"nfn=AutoexecCliente\rexe=%s\r",idproautoexec);

-

-	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){

-		errorLog(modulo,42,FALSE);

-		return(FALSE);

-	}

-	ptrTrama=recibeMensaje(&socket_c);

-	if(!ptrTrama){

-		errorLog(modulo,45,FALSE);

-		return(FALSE);

-	}

-

-	close(socket_c);

-

-	if(!gestionaTrama(ptrTrama)){	// Análisis de la trama

-		errorLog(modulo,39,FALSE);

-		return(FALSE);

-	}

-

-	return(TRUE);

-}

-//________________________________________________________________________________________________________

-//	Función: autoexecCliente

-//

-//	Descripción:

-//		Ejecuta un script de autoexec personalizado en todos los inicios para el cliente

-//	Parámetros:

-//		Ninguno

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//________________________________________________________________________________________________________

-BOOLEAN RESPUESTA_AutoexecCliente(TRAMA* ptrTrama)

-{

-	SOCKET socket_c;

-	char *res,*nfl;

-	char modulo[] = "RESPUESTA_AutoexecCliente()";

-

-	res=copiaParametro("res",ptrTrama);

-	if(atoi(res)==0){ // Error en el proceso de autoexec

-		liberaMemoria(res);

-		return (FALSE);

-	}

-	liberaMemoria(res);

-

-	nfl=copiaParametro("nfl",ptrTrama);

-	initParametros(ptrTrama,0);

-	sprintf(ptrTrama->parametros,"nfn=enviaArchivo\rnfl=%s\r",nfl);

-	liberaMemoria(nfl);

-

-	/* Envía petición */

-	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){

-		errorLog(modulo,42,FALSE);

-		return(FALSE);

-	}

-	/* Nombre del archivo destino (local)*/

-	char fileautoexec[LONPRM];

-	sprintf(fileautoexec,"/tmp/_autoexec_%s",IPlocal);

-

-	/* Recibe archivo */

-	if(!recArchivo(&socket_c,fileautoexec)){

-		errorLog(modulo,58, FALSE);

-		close(socket_c);

-		return(FALSE);

-	}

-

-	close(socket_c);

-

-	/* Ejecuta archivo */

-	ejecutaArchivo(fileautoexec,ptrTrama);

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: comandosPendientes

-//

-//	 Descripción:

-// 		 Búsqueda de acciones pendientes en el servidor de administración

-//	Parámetros:

-//		Ninguno

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN comandosPendientes(TRAMA* ptrTrama)

-{

-	SOCKET socket_c;

-	char modulo[] = "comandosPendientes()";

-

-	CMDPTES=TRUE;

-	initParametros(ptrTrama,0);

-

-	while(CMDPTES){

-		sprintf(ptrTrama->parametros,"nfn=ComandosPendientes\r");

-		if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){

-			errorLog(modulo,42,FALSE);

-			return(FALSE);

-		}

-		ptrTrama=recibeMensaje(&socket_c);

-		if(!ptrTrama){

-			errorLog(modulo,45,FALSE);

-			return(FALSE);

-		}

-

- 		close(socket_c);

-

-		if(!gestionaTrama(ptrTrama)){	// Análisis de la trama

-			errorLog(modulo,39,FALSE);

-			return(FALSE);

-		}

-	}

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: NoComandosPtes

-//

-//	 Descripción:

-//		 Conmuta el switch de los comandos pendientes y lo pone a false

-//	Parámetros:

-//		- ptrTrama: contenido del mensaje

-// 	Devuelve:

-//		TRUE siempre

-//	Especificaciones:

-//		Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el

-//		servidor y el cliente pasa a a estar disponible para recibir comandos desde el éste.

-//______________________________________________________________________________________________________

-BOOLEAN NoComandosPtes(TRAMA* ptrTrama)

-{

-	CMDPTES=FALSE; // Corta el bucle de comandos pendientes

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: ProcesaComandos

-//

-//	Descripción:

-// 		Espera comando desde el Servidor de Administración para ejecutarlos

-//	Parámetros:

-//		Ninguno

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-// ________________________________________________________________________________________________________

-void procesaComandos(TRAMA* ptrTrama)

-{

-	int lon;

-	SOCKET socket_c;

-	char modulo[] = "procesaComandos()";

-

-	initParametros(ptrTrama,0);

-	while(TRUE){

-		lon=sprintf(ptrTrama->parametros,"nfn=DisponibilidadComandos\r");

-		lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS); // Activar disponibilidad

-		if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_INFORMACION)){

-			errorLog(modulo,43,FALSE);

-			return;

-		}

-		infoLog(19); // Disponibilidad de cliente activada

-		ptrTrama=recibeMensaje(&socket_c);

-		if(!ptrTrama){

-			errorLog(modulo,46,FALSE);

-			return;

-		}

-

-		close(socket_c);

-

-		if(!gestionaTrama(ptrTrama)){	// Análisis de la trama

-			errorLog(modulo,39,FALSE);

-			return;

-		}

-		if(!comandosPendientes(ptrTrama)){

-			errorLog(modulo,42,FALSE);

-		}

-	}

-}

-//______________________________________________________________________________________________________

-// Función: Actualizar

-//

-//	 Descripción:

-//		Actualiza los datos de un ordenador como si volviera a solicitar la entrada

-//		en el sistema al  servidor de administración

-//	Parámetros:

-//		ptrTrama: contenido del mensajede

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN Actualizar(TRAMA* ptrTrama)

-{

-	char msglog[LONSTD];	// Mensaje de log

-	char *cfg;		// Cadena de datos de configuración

-	int lon;		// Longitud de cadena

-	char modulo[] = "Actualizar()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	muestraMensaje(1,NULL);

-	if(!comandosPendientes(ptrTrama)){

-		errorLog(modulo,84,FALSE);

-		return(FALSE);

-	}

-

-	cfg=LeeConfiguracion();

-	herror=0;

-	if(!cfg){ // No se puede recuperar la configuración del cliente

-		errorLog(modulo,36,FALSE);

-		herror=3;

-	}

-	// Envia Configuracion al servidor

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");

-	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente

-	respuestaEjecucionComando(ptrTrama,herror,0);

-

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: Purgar

-//

-//	 Descripción:

-//		Detiene la ejecución del browser

-//	Parámetros:

-//		ptrTrama: contenido del mensajede

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-int Purgar(TRAMA* ptrTrama)

-{

-

-	exit(EXIT_SUCCESS);

-}

-//______________________________________________________________________________________________________

-// Función: Sondeo

-//

-//	 Descripción:

-//		Envía al servidor una confirmación de que está dentro del sistema

-//	Parámetros:

-//		ptrTrama: contenido del mensajede

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN Sondeo(TRAMA* ptrTrama)

-{

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: ConsolaRemota

-//

-//	Descripción:

-// 		Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN ConsolaRemota(TRAMA* ptrTrama)

-{

-	SOCKET socket_c;

-	char *nfn,*scp,*aux,ecosrc[LONPRM],ecodst[LONPRM],msglog[LONSTD];;

-	char modulo[] = "ConsolaRemota()";

-

-	/* Nombre del archivo de script */

-	char filescript[LONPRM];

-	sprintf(filescript,"/tmp/_script_%s",IPlocal);

-	

-	aux=copiaParametro("scp",ptrTrama);

-	scp=URLDecode(aux);

-	escribeArchivo(filescript,scp);

-	liberaMemoria(aux);

-	liberaMemoria(scp);

-	

-	nfn=copiaParametro("nfn",ptrTrama);

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(ecosrc,"/tmp/_econsola_%s",IPlocal);

-	sprintf(parametros,"%s %s %s",nfn,filescript,ecosrc);

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-	}

-	else{

-		/* Envía fichero de inventario al servidor */

-		sprintf(ecodst,"/tmp/_Seconsola_%s",IPlocal); // Nombre que tendra el archivo en el Servidor

-		initParametros(ptrTrama,0);

-		sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",ecodst);

-		if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){

-			errorLog(modulo,42,FALSE);

-			return(FALSE);

-		}

-		 /* Espera señal para comenzar el envío */

-		liberaMemoria(ptrTrama);

-		recibeFlag(&socket_c,ptrTrama);

-		/* Envía archivo */

-		if(!sendArchivo(&socket_c,ecosrc)){

-			errorLog(modulo,57, FALSE);

-			herror=12; // Error de envío de fichero por la red

-		}

-		close(socket_c);

-	}

-	liberaMemoria(nfn);

-	return(TRUE);

-}

-//_____________________________________________________________________________________________________

-// Función: Comando

-//

-//	 Descripción:

-//		COmando personalizado enviado desde el servidor

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//_____________________________________________________________________________________________________

-BOOLEAN Comando(TRAMA* ptrTrama)

-{

-	char *ids,*nfn,msglog[LONSTD];

-	char modulo[] = "Comando()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	herror=interfaceAdmin(interface,NULL,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-	}

-	/* Envia respuesta de ejecucución del comando */

-	initParametros(ptrTrama,0);

-	sprintf(ptrTrama->parametros,"nfn=RESPUESTA_%s\r",nfn);

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	liberaMemoria(nfn);

-	liberaMemoria(ids);

-	return(TRUE);

-}

-//_____________________________________________________________________________________________________

-// Función: Arrancar

-//

-//	 Descripción:

-//		Responde a un comando de encendido por la red

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//_____________________________________________________________________________________________________

-BOOLEAN Arrancar(TRAMA* ptrTrama)

-{

-	int lon;

-	char *ids,msglog[LONSTD];

-	char modulo[] = "Arrancar()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-

-	ids=copiaParametro("ids",ptrTrama);

-

-	/* Envia respuesta de ejecucución del script */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Arrancar");

-	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS);

-	respuestaEjecucionComando(ptrTrama,0,ids);

-	liberaMemoria(ids);

-	return(TRUE);

-}

-//_____________________________________________________________________________________________________

-// Función: Apagar

-//

-//	 Descripción:

-//		Apaga el cliente

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//_____________________________________________________________________________________________________

-BOOLEAN Apagar(TRAMA* ptrTrama)

-{

-	char *ids,*nfn,msglog[LONSTD];

-	char modulo[] = "Apagar()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-

-	initParametros(ptrTrama,0);

-	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Apagar");

-	respuestaEjecucionComando(ptrTrama,0,ids);

-

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	herror=interfaceAdmin(interface,NULL,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		liberaMemoria(nfn);

-		liberaMemoria(ids);			

-		errorInfo(modulo,msglog);

-		return(FALSE);

-	}

-	liberaMemoria(nfn);

-	liberaMemoria(ids);	

-	return(TRUE);

-}

-//_____________________________________________________________________________________________________

-// Función: Reiniciar

-//

-//	 Descripción:

-//		Apaga el cliente

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//_____________________________________________________________________________________________________

-BOOLEAN Reiniciar(TRAMA* ptrTrama)

-{

-	char *nfn,*ids,msglog[LONSTD];

-	char modulo[] = "Reiniciar()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-

-	initParametros(ptrTrama,0);

-	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Reiniciar");

-	respuestaEjecucionComando(ptrTrama,0,ids);

-

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	herror=interfaceAdmin(interface,NULL,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		liberaMemoria(nfn);

-		liberaMemoria(ids);			

-		errorInfo(modulo,msglog);

-		return(FALSE);

-	}

-	liberaMemoria(nfn);

-	liberaMemoria(ids);		

-	return(TRUE);

-}

-//_____________________________________________________________________________________________________

-// Función: IniciarSesion

-//

-//	 Descripción:

-//		Inicia sesión en el Sistema Operativo de una de las particiones

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//_____________________________________________________________________________________________________

-BOOLEAN IniciarSesion(TRAMA* ptrTrama)

-{

-	char *nfn,*ids,*disk,*par,msglog[LONSTD];

-	char modulo[] = "IniciarSesion()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	disk=copiaParametro("dsk",ptrTrama);

-	par=copiaParametro("par",ptrTrama);

-	

-	initParametros(ptrTrama,0);

-	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_IniciarSesion");

-	respuestaEjecucionComando(ptrTrama,0,ids);

-	liberaMemoria(ids);			

-

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(parametros,"%s %s %s",nfn,disk,par);

-	liberaMemoria(par);			

-	

-	herror=interfaceAdmin(interface,parametros,NULL);

-

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		liberaMemoria(nfn);

-		errorInfo(modulo,msglog);

-		return(FALSE);

-	}

-	liberaMemoria(nfn);

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: CrearImagen

-//

-//	 Descripción:

-//		Crea una imagen de una partición

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN CrearImagen(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*par,*cpt,*idi,*ipr,*nci,*ids,msglog[LONSTD];

-	char modulo[] = "CrearImagen()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-

-	dsk=copiaParametro("dsk",ptrTrama); // Disco

-	par=copiaParametro("par",ptrTrama); // Número de partición

-	cpt=copiaParametro("cpt",ptrTrama); // Código de la partición

-	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen

-	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen

-	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio

-

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(7,NULL);

-

-	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente

-		muestraMensaje(2,NULL);

-		sprintf(interface,"%s/%s",pathinterface,nfn);

-		sprintf(parametros,"%s %s %s %s %s",nfn,dsk,par,nci,ipr);

-		herror=interfaceAdmin(interface,parametros,NULL);

-		if(herror){

-			sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-			errorInfo(modulo,msglog);

-			muestraMensaje(10,NULL);

-		}

-		else

-			muestraMensaje(9,NULL);

-	}

-	else{

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-	}

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagen");

-	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen

-	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó

-	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición

-	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	

-	liberaMemoria(dsk);	

-	liberaMemoria(par);	

-	liberaMemoria(cpt);	

-	liberaMemoria(idi);	

-	liberaMemoria(nci);	

-	liberaMemoria(ipr);	

-	liberaMemoria(nfn);	

-	liberaMemoria(ids);	

-

-	muestraMenu();

-	

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: CrearImagenBasica

-//

-//	 Descripción:

-//		Crea una imagen básica a travers dela sincronización

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//

-//	FDevuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN CrearImagenBasica(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*par,*cpt,*idi,*nci,*rti,*ipr,*msy,*whl,*eli,*cmp,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];

-	char modulo[] = "CrearImagenBasica()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-	dsk=copiaParametro("dsk",ptrTrama); // Disco

-	par=copiaParametro("par",ptrTrama); // Número de partición

-	cpt=copiaParametro("cpt",ptrTrama); // Tipo de partición

-	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen

-	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen

-	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen

-	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio

-

-	msy=copiaParametro("msy",ptrTrama); // Método de sincronización

-	

-	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias		

-	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen	

-	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

-

-	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla

-	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache

-	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella

-	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

-

-	muestraMensaje(7,NULL); // Creando Inventario Software

-	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente

-		muestraMensaje(30,NULL);// Creando Imagen Básica, por favor espere...

-		sprintf(interface,"%s/%s",pathinterface,nfn);

-		sprintf(parametros,"%s %s %s %s %s %s%s%s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,whl,eli,cmp,bpi,cpc,bpc,nba,msy,rti);

-		herror=interfaceAdmin(interface,parametros,NULL);

-		if(herror){

-			sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-			errorInfo(modulo,msglog);

-			muestraMensaje(29,NULL);// Ha habido algún error en el proceso de creación de imagen básica

-		}

-		else

-			muestraMensaje(28,NULL);// El proceso de creación de imagen básica ha terminado correctamente

-	}

-	else{

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-	}

-

-	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagenBasica");

-	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen

-	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó

-	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición

-	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-		

-	liberaMemoria(nfn);	

-	liberaMemoria(dsk);	

-	liberaMemoria(par);	

-	liberaMemoria(cpt);	

-	liberaMemoria(idi);	

-	liberaMemoria(nci);	

-	liberaMemoria(rti);	

-	liberaMemoria(ipr);	

-

-	liberaMemoria(msy);	

-	

-	liberaMemoria(whl);	

-	liberaMemoria(eli);	

-	liberaMemoria(cmp);	

-

-	liberaMemoria(bpi);	

-	liberaMemoria(cpc);	

-	liberaMemoria(bpc);	

-	liberaMemoria(nba);

-	liberaMemoria(ids);		

-	

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: CrearSoftIncremental

-//

-//	 Descripción:

-//		Crea una software incremental comparando una partición con una imagen básica

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN CrearSoftIncremental(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*par,*idi,*idf,*ipr,*nci,*rti,*ncf,*msy,*whl,*eli,*cmp,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];

-	char modulo[] = "CrearSoftIncremental()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-

-	dsk=copiaParametro("dsk",ptrTrama); // Disco

-	par=copiaParametro("par",ptrTrama); // Número de partición

-	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen

-	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen

-	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen

-	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio

-	idf=copiaParametro("idf",ptrTrama); // Identificador de la imagen diferencial

-	ncf=copiaParametro("ncf",ptrTrama); // Nombre canónico de la imagen diferencial

-

-	msy=copiaParametro("msy",ptrTrama); // Método de sincronización

-

-	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias	

-	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen	

-	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

-

-	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla

-	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache

-	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella

-	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

-

-	muestraMensaje(7,NULL); // Creando Inventario Software

-	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente

-		muestraMensaje(25,NULL);// Creando Imagen Incremental, por favor espere...

-		sprintf(interface,"%s/%s",pathinterface,nfn);

-		sprintf(parametros,"%s %s %s %s %s %s %s%s%s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,ncf,whl,eli,cmp,bpi,cpc,bpc,nba,msy,rti);

-

-		herror=interfaceAdmin(interface,parametros,NULL);

-		if(herror){

-			sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-			errorInfo(modulo,msglog);

-			muestraMensaje(27,NULL);// Ha habido algún error en el proceso de creación de imagen básica

-		}

-		else

-			muestraMensaje(26,NULL);// El proceso de creación de imagen incremental ha terminado correctamente

-	}

-	else{

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-	}

-

-	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearSoftIncremental");

-	lon+=sprintf(ptrTrama->parametros+lon,"idf=%s\r",idf); // Identificador de la imagen incremental

-	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	

-	liberaMemoria(nfn);	

-	liberaMemoria(dsk);	

-	liberaMemoria(par);	

-	liberaMemoria(idi);	

-	liberaMemoria(nci);	

-	liberaMemoria(rti);	

-	liberaMemoria(ipr);	

-	liberaMemoria(idf);	

-	liberaMemoria(ncf);	

-	liberaMemoria(msy);	

-	liberaMemoria(whl);

-	liberaMemoria(eli);

-	liberaMemoria(cmp);

-	liberaMemoria(bpi);	

-	liberaMemoria(cpc);	

-	liberaMemoria(bpc);	

-	liberaMemoria(nba);

-	liberaMemoria(ids);		

-	

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: RestaurarImagen

-//

-//	 Descripción:

-//		Restaura una imagen en una partición

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En bpccaso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN RestaurarImagen(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*par,*idi,*ipr,*ifs,*cfg,*nci,*ids,*ptc,msglog[LONSTD];

-	char modulo[] = "RestaurarImagen()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-

-	dsk=copiaParametro("dsk",ptrTrama);

-	par=copiaParametro("par",ptrTrama);

-	idi=copiaParametro("idi",ptrTrama);

-	ipr=copiaParametro("ipr",ptrTrama);

-	nci=copiaParametro("nci",ptrTrama);

-	ifs=copiaParametro("ifs",ptrTrama);

-	ptc=copiaParametro("ptc",ptrTrama);

-

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(3,NULL);

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(parametros,"%s %s %s %s %s %s",nfn,dsk,par,nci,ipr,ptc);

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(12,NULL);

-	}

-	else

-		muestraMensaje(11,NULL);

-

-	/* Obtener nueva configuración */

-	cfg=LeeConfiguracion();

-	if(!cfg){ // No se puede recuperar la configuración del cliente

-		errorLog(modulo,36,FALSE);

-	}

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagen");

-	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen

-	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición

-	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software

-	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de discos

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	

-	liberaMemoria(nfn);	

-	liberaMemoria(dsk);	

-	liberaMemoria(par);	

-	liberaMemoria(idi);

-	liberaMemoria(nci);	

-	liberaMemoria(ipr);	

-	liberaMemoria(ifs);	

-	liberaMemoria(cfg);	

-	liberaMemoria(ptc);	

-	liberaMemoria(ids);			

-

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: RestaurarImagenBasica

-//

-//	 Descripción:

-//		Restaura una imagen básica en una partición

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN RestaurarImagenBasica(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*par,*idi,*ipr,*met,*nci,*rti,*ifs,*cfg,*msy,*whl,*eli,*cmp,*tpt,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];

-	char modulo[] = "RestaurarImagenBasica()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	dsk=copiaParametro("dsk",ptrTrama);

-	par=copiaParametro("par",ptrTrama);

-	idi=copiaParametro("idi",ptrTrama);

-	ipr=copiaParametro("ipr",ptrTrama);

-	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio

-	nci=copiaParametro("nci",ptrTrama);

-	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen

-	ifs=copiaParametro("ifs",ptrTrama);

-

-	tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast	

-	msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion 

-

-	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias	

-	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen	

-	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

-

-	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla

-	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache

-	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella

-	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

-

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(31,NULL);

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(parametros,"%s %s %s %s %s %s %s%s%s %s%s%s%s %s %s %s",nfn,dsk,par,nci,ipr,tpt,whl,eli,cmp,bpi,cpc,bpc,nba,met,msy,rti);

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(33,NULL);

-	}

-	else

-		muestraMensaje(32,NULL);

-

-	/* Obtener nueva configuración */

-	cfg=LeeConfiguracion();

-	if(!cfg){ // No se puede recuperar la configuración del cliente

-		errorLog(modulo,36,FALSE);

-	}

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagenBasica");

-	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen

-	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición

-	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software

-	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de discos

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-

-	liberaMemoria(nfn);

-	liberaMemoria(dsk);

-	liberaMemoria(par);

-	liberaMemoria(idi);

-	liberaMemoria(nci);

-	liberaMemoria(rti);

-	liberaMemoria(ifs);

-	liberaMemoria(cfg);

-	liberaMemoria(ipr);

-	liberaMemoria(met);

-

-	liberaMemoria(tpt);

-	liberaMemoria(msy);

-

-	liberaMemoria(whl);

-	liberaMemoria(eli);

-	liberaMemoria(cmp);

-

-	liberaMemoria(bpi);

-	liberaMemoria(cpc);

-	liberaMemoria(bpc);

-	liberaMemoria(nba);

-	liberaMemoria(ids);

-

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: RestaurarSoftIncremental

-//

-//	 Descripción:

-//		Restaura software incremental en una partición

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN RestaurarSoftIncremental(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*par,*idi,*ipr,*met,*ifs,*nci,*rti,*idf,*ncf,*msy,*whl,*eli,*cmp,*tpt,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];

-	char modulo[] = "RestaurarSoftIncremental()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	dsk=copiaParametro("dsk",ptrTrama);

-	par=copiaParametro("par",ptrTrama);

-	idi=copiaParametro("idi",ptrTrama);

-	idf=copiaParametro("idf",ptrTrama);

-	ipr=copiaParametro("ipr",ptrTrama);

-	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio

-	ifs=copiaParametro("ifs",ptrTrama);

-	nci=copiaParametro("nci",ptrTrama);

-	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen

-	ncf=copiaParametro("ncf",ptrTrama);

-

-	tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast	

-	msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion 

-

-	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias	

-	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen	

-	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar

-

-	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla

-	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache

-	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella

-	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino

-

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(31,NULL);

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(parametros,"%s %s %s %s %s %s %s %s%s%s %s%s%s%s %s %s %s",nfn,dsk,par,nci,ipr,ncf,tpt,whl,eli,cmp,bpi,cpc,bpc,nba,met,msy,rti);

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(35,NULL);

-	}

-	else

-		muestraMensaje(34,NULL);

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarSoftIncremental");

-	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idf); // Identificador de la imagen incremental (Forzada a idi)

-	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición

-	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software

-

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	

-	liberaMemoria(nfn);	

-	liberaMemoria(dsk);	

-	liberaMemoria(par);	

-	liberaMemoria(idi);	

-	liberaMemoria(idf);	

-	liberaMemoria(nci);	

-	liberaMemoria(rti);	

-	liberaMemoria(ncf);	

-	liberaMemoria(ifs);	

-	liberaMemoria(ipr);	

-	liberaMemoria(met);

-

-	liberaMemoria(tpt);	

-	liberaMemoria(msy);	

-

-	liberaMemoria(whl);	

-	liberaMemoria(eli);	

-	liberaMemoria(cmp);	

-

-	liberaMemoria(bpi);	

-	liberaMemoria(cpc);	

-	liberaMemoria(bpc);	

-	liberaMemoria(nba);

-	liberaMemoria(ids);		

-	

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: Configurar

-//

-//	 Descripción:

-//		Configura la tabla de particiones y formatea

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN Configurar(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*dsk,*cfg,*ids,msglog[LONSTD];

-	char modulo[] = "Configurar()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-

-	dsk=copiaParametro("dsk",ptrTrama);

-	cfg=copiaParametro("cfg",ptrTrama);

-	/* Sustituir caracteres */

-	sustituir(cfg,'\n','$');

-	sustituir(cfg,'\t','#');

-

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(4,NULL);

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(parametros,"%s %s %s",nfn,dsk,cfg);

-

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(13,NULL);

-	}

-	else

-		muestraMensaje(14,NULL);

-

-	cfg=LeeConfiguracion();

-	if(!cfg){ // No se puede recuperar la configuración del cliente

-		errorLog(modulo,36,FALSE);

-		return(FALSE);

-	}

-

-	/* Envia respuesta de ejecución del comando*/

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");

-	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	

-	liberaMemoria(dsk);

-	liberaMemoria(cfg);

-	liberaMemoria(nfn);

-	liberaMemoria(ids);

-

-	muestraMenu();

-

-	return(TRUE);

-}

-// ________________________________________________________________________________________________________

-// Función: InventarioHardware

-//

-//	Descripción:

-//		Envia al servidor el nombre del archivo de inventario de su hardware para posteriormente

-//		esperar que éste lo solicite y enviarlo por la red.

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN InventarioHardware(TRAMA* ptrTrama)

-{

-	int lon;

-	SOCKET socket_c;

-	char *nfn,*ids,msglog[LONSTD],hrdsrc[LONPRM],hrddst[LONPRM];

-	char modulo[] = "InventarioHardware()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(6,NULL);

-

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(hrdsrc,"/tmp/Chrd-%s",IPlocal); // Nombre que tendra el archivo de inventario

-	sprintf(parametros,"%s %s",nfn,hrdsrc);

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(18,NULL);

-	}

-	else{

-		/* Envía fichero de inventario al servidor */

-		sprintf(hrddst,"/tmp/Shrd-%s",IPlocal); // Nombre que tendra el archivo en el Servidor

-		initParametros(ptrTrama,0);

-		sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",hrddst);

-		if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){

-			liberaMemoria(nfn);

-			liberaMemoria(ids);

-			errorLog(modulo,42,FALSE);

-			return(FALSE);

-		}

-		 /* Espera señal para comenzar el envío */

-		liberaMemoria(ptrTrama);

-		recibeFlag(&socket_c,ptrTrama);

-		/* Envía archivo */

-		if(!sendArchivo(&socket_c,hrdsrc)){

-			errorLog(modulo,57, FALSE);

-			herror=12; // Error de envío de fichero por la red

-		}

-		close(socket_c);

-		muestraMensaje(17,NULL);

-	}

-

-	/* Envia respuesta de ejecución de la función de interface */

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioHardware");

-	lon+=sprintf(ptrTrama->parametros+lon,"hrd=%s\r",hrddst);

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	liberaMemoria(nfn);

-	liberaMemoria(ids);

-	

-	muestraMenu();

-

-	return(TRUE);

-}

-// ________________________________________________________________________________________________________

-// Función: InventarioSoftware

-//

-//	Descripción:

-//		Crea el inventario software de un sistema operativo instalado en una partición.

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN InventarioSoftware(TRAMA* ptrTrama)

-{

-	char *nfn,*ids,msglog[LONSTD];

-	char modulo[] = "InventarioSoftware()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	nfn=copiaParametro("nfn",ptrTrama);

-	ids=copiaParametro("ids",ptrTrama);

-	muestraMensaje(7,NULL);

-	InventariandoSoftware(ptrTrama,TRUE,nfn);

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	liberaMemoria(nfn);

-	liberaMemoria(ids);		

-	muestraMenu();

-	return(TRUE);

-}

-// ________________________________________________________________________________________________________

-//

-// Función: InventariandoSoftware

-//

-//	Descripción:

-//		Envia al servidor el nombre del archivo de inventario de su software para posteriormente

-//		esperar que éste lo solicite y enviarlo por la red.

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//		sw: switch que indica si la función es llamada por el comando InventarioSoftware(true) o CrearImagen(false)

-//		nfn: Nombre de la función del Interface que implementa el comando

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN InventariandoSoftware(TRAMA* ptrTrama,BOOLEAN sw,char *nfn)

-{

-	int lon;

-	SOCKET socket_c;

-	char *dsk,*par,msglog[LONSTD],sftsrc[LONPRM],sftdst[LONPRM];

-	char modulo[] = "InventariandoSoftware()";

-

-	dsk=copiaParametro("dsk",ptrTrama); // Disco

-	par=copiaParametro("par",ptrTrama);

-

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(sftsrc,"/tmp/CSft-%s-%s",IPlocal,par); // Nombre que tendra el archivo de inventario

-	sprintf(parametros,"%s %s %s %s",nfn,dsk,par,sftsrc);

-

-	herror=interfaceAdmin(interface,parametros,NULL);

-	herror=0;

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(20,NULL);

-	}

-	else{

-		/* Envía fichero de inventario al servidor */

-		sprintf(sftdst,"/tmp/Ssft-%s-%s",IPlocal,par); // Nombre que tendra el archivo en el Servidor

-		initParametros(ptrTrama,0);

-

-		sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",sftdst);

-		if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){

-			errorLog(modulo,42,FALSE);

-			liberaMemoria(dsk);

-			liberaMemoria(par);				

-			return(FALSE);

-		}

-		/* Espera señal para comenzar el envío */

-		liberaMemoria(ptrTrama);

-		if(!recibeFlag(&socket_c,ptrTrama)){

-			errorLog(modulo,17,FALSE);

-		}

-		/* Envía archivo */

-		if(!sendArchivo(&socket_c,sftsrc)){

-			errorLog(modulo,57, FALSE);

-			herror=12; // Error de envío de fichero por la red

-		}

-		close(socket_c);

-		muestraMensaje(19,NULL);

-	}

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioSoftware");

-	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par);

-	lon+=sprintf(ptrTrama->parametros+lon,"sft=%s\r",sftdst);

-	if(!sw)

-		respuestaEjecucionComando(ptrTrama,herror,"0");

-

-	liberaMemoria(dsk);

-	liberaMemoria(par);			

-	return(TRUE);

-}

-// ________________________________________________________________________________________________________

-// Función: EjecutarScript

-//

-//	Descripción:

-//		Ejecuta código de script

-//	Parámetros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//______________________________________________________________________________________________________

-BOOLEAN EjecutarScript(TRAMA* ptrTrama)

-{

-	int lon;

-	char *nfn,*aux,*ids,*scp,*cfg,msglog[LONSTD];

-	char modulo[] = "EjecutarScript()";

-

-	if (ndebug>=DEBUG_MAXIMO) {

-		sprintf(msglog, "%s:%s",tbMensajes[21],modulo);

-		infoDebug(msglog);

-	}

-	aux=copiaParametro("scp",ptrTrama);

-	scp=URLDecode(aux);

-

-

-	muestraMensaje(8,NULL);

-	/* Nombre del archivo de script */

-	char filescript[LONPRM];

-	sprintf(filescript,"/tmp/_script_%s",IPlocal);

-	escribeArchivo(filescript,scp);

-	nfn=copiaParametro("nfn",ptrTrama);

-	sprintf(interface,"%s/%s",pathinterface,nfn);

-	sprintf(parametros,"%s %s",nfn,filescript);

-	herror=interfaceAdmin(interface,parametros,NULL);

-	if(herror){

-		sprintf(msglog,"%s:%s",tbErrores[86],nfn);

-		errorInfo(modulo,msglog);

-		muestraMensaje(21,NULL);

-	}

-	else

-		muestraMensaje(22,NULL);

-

-	// Toma configuración de particiones

-	cfg=LeeConfiguracion();

-	if(!cfg){ // No se puede recuperar la configuración del cliente

-		errorLog(modulo,36,FALSE);

-		herror=36;

-	}

-

-	ids=copiaParametro("ids",ptrTrama);

-

-	//herror=ejecutarCodigoBash(scp);

-	initParametros(ptrTrama,0);

-	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_EjecutarScript");

-	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente

-	respuestaEjecucionComando(ptrTrama,herror,ids);

-	

-	liberaMemoria(nfn);

-	liberaMemoria(ids);		

-	liberaMemoria(aux);		

-	liberaMemoria(scp);	

-	liberaMemoria(cfg);

-

-	muestraMenu();

-

-	return(TRUE);

-}

-//______________________________________________________________________________________________________

-// Función: respuestaEjecucionComando

-//

-//	Descripción:

-// 		Envia una respuesta a una ejecucion de comando al servidor de Administración

-//	Parámetros:

-//		- ptrTrama: contenido del mensaje

-//		- res: Resultado de la ejecución (Código de error devuelto por el script ejecutado)

-//		- ids: Identificador de la sesion (En caso de no haber seguimiento es NULO)

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-// ________________________________________________________________________________________________________

-BOOLEAN respuestaEjecucionComando(TRAMA* ptrTrama,int res,char *ids)

-{

-	int lon;

-	SOCKET socket_c;

-	char modulo[] = "respuestaEjecucionComando()";

-

-	lon=strlen(ptrTrama->parametros);

-	if(ids){ // Existe seguimiento

-		lon+=sprintf(ptrTrama->parametros+lon,"ids=%s\r",ids); // Añade identificador de la sesión

-	}

-	if (res==0){ // Resultado satisfactorio

-		lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","1");

-		lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r","");

-	}

-	else{ // Algún error

-		lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","2");

-		if(res>MAXERRORSCRIPT)

-			lon+=sprintf(ptrTrama->parametros+lon,"der=%s (Error de script:%d)\r",tbErroresScripts[0],res);// Descripción del error

-		else

-			lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r",tbErroresScripts[res]);// Descripción del error

-	}

-	if(!(enviaMensajeServidor(&socket_c,ptrTrama,MSG_NOTIFICACION))){

-		errorLog(modulo,44,FALSE);

-		return(FALSE);

-	}

-

-	close(socket_c);

-	return(TRUE);

-}

-// ________________________________________________________________________________________________________

-// Función: gestionaTrama

-//

-//	Descripción:

-//		Procesa las tramas recibidas.

-//	Parametros:

-//		ptrTrama: contenido del mensaje

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-// ________________________________________________________________________________________________________

-BOOLEAN gestionaTrama(TRAMA *ptrTrama)

-{

-	int i, res;

-	char *nfn;

-	char modulo[] = "gestionaTrama()";

-

-	INTROaFINCAD(ptrTrama);

-	nfn = copiaParametro("nfn", ptrTrama); // Toma nombre de función

-	for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas

-		res = strcmp(tbfuncionesClient[i].nf, nfn);

-		if (res == 0) { // Encontrada la función que procesa el mensaje

-			liberaMemoria(nfn);

-			return(tbfuncionesClient[i].fptr(ptrTrama)); // Invoca la función

-		}

-	}

-

-	liberaMemoria(nfn);

-

-	/* Sólo puede ser un comando personalizado

-	if (ptrTrama->tipo==MSG_COMANDO)

-		return(Comando(ptrTrama));

-	 */

-	errorLog(modulo, 18, FALSE);

-	return (FALSE);

-}

-//________________________________________________________________________________________________________

-//	Función: ejecutaArchivo

-//

-//	Descripción:

-//		Ejecuta los comando contenido en un archivo (cada comando y sus parametros separados por un

-//		salto de linea.

-//	Parámetros:

-//		filecmd: Nombre del archivo de comandos

-//		ptrTrama: Puntero a una estructura TRAMA usada en las comunicaciones por red (No debe ser NULL)

-//	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-//________________________________________________________________________________________________________

-BOOLEAN ejecutaArchivo(char* filecmd,TRAMA *ptrTrama)

-{

-	char* buffer,*lineas[MAXIMAS_LINEAS];

-	int i,numlin;

-	char modulo[] = "ejecutaArchivo()";

-

-	buffer=leeArchivo(filecmd);

-	if(buffer){

-		numlin = splitCadena(lineas, buffer, '@');

-		initParametros(ptrTrama,0);

-		for (i = 0; i < numlin; i++) {

-			if(strlen(lineas[i])>0){

-				strcpy(ptrTrama->parametros,lineas[i]);

-				//strcat(ptrTrama->parametros,"\rMCDJ@");	// Fin de trama

-				if(!gestionaTrama(ptrTrama)){	// Análisis de la trama

-					errorLog(modulo,39,FALSE);

-					//return(FALSE);

-				}

-			}

-		}

-	}

-	liberaMemoria(buffer);

-	return(TRUE);

-}

-

-BOOLEAN EjecutaComandosPendientes(TRAMA* ptrTrama)

-{

-	return(TRUE);

-}

-

-//______________________________________________________________________________________________________

-// Función: enviaMensajeServidor

-//

-//	Descripción:

-// 		Envia un mensaje al servidor de Administración

-//	Parámetros:

-//		- socket_c: (Salida) Socket utilizado para el envío

-//		- ptrTrama: contenido del mensaje

-//		- tipo: Tipo de mensaje

-//				C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion

-// 	Devuelve:

-//		TRUE: Si el proceso es correcto

-//		FALSE: En caso de ocurrir algún error

-// ________________________________________________________________________________________________________

-BOOLEAN enviaMensajeServidor(SOCKET *socket_c,TRAMA *ptrTrama,char tipo)

-{

-	int lon;

-	char modulo[] = "enviaMensajeServidor()";

-

-	*socket_c=abreConexion();

-	if(*socket_c==INVALID_SOCKET){

-		errorLog(modulo,38,FALSE); // Error de conexión con el servidor

-		return(FALSE);

-	}

-	ptrTrama->arroba='@'; // Cabecera de la trama

-	strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14);	// identificador de la trama

-	ptrTrama->tipo=tipo; // Tipo de mensaje

-	lon=strlen(ptrTrama->parametros); // Compone la trama

-	lon+=sprintf(ptrTrama->parametros+lon,"iph=%s\r",IPlocal);	// Ip del ordenador

-	lon+=sprintf(ptrTrama->parametros+lon,"ido=%s\r",idordenador);	// Identificador del ordenador

-	lon+=sprintf(ptrTrama->parametros+lon,"npc=%s\r",nombreordenador);	// Nombre del ordenador

-	lon+=sprintf(ptrTrama->parametros+lon,"idc=%s\r",idcentro);	// Identificador del centro

-	lon+=sprintf(ptrTrama->parametros+lon,"ida=%s\r",idaula);	// Identificador del aula

-

-	if (!mandaTrama(socket_c,ptrTrama)) {

-		errorLog(modulo,26,FALSE);

-		return (FALSE);

-	}

-	return(TRUE);

-}

-// ********************************************************************************************************

-// PROGRAMA PRINCIPAL (CLIENTE)

-// ********************************************************************************************************

-int main(int argc, char *argv[])

-{

-	TRAMA *ptrTrama;

-	char modulo[] = "main()";

-

-	ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));

-	if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas

-		errorLog(modulo, 3, FALSE);

-		exit(EXIT_FAILURE);

-	}

-	/*--------------------------------------------------------------------------------------------------------

-		Validación de parámetros de ejecución y fichero de configuración 

-	 ---------------------------------------------------------------------------------------------------------*/

-	if (!validacionParametros(argc, argv,3)) // Valida parámetros de ejecución

-		exit(EXIT_FAILURE);

-

-	if (!tomaConfiguracion(szPathFileCfg)) // Toma parametros de configuración

-		exit(EXIT_FAILURE);

-	/*--------------------------------------------------------------------------------------------------------

-		Carga catálogo de funciones que procesan las tramas 

-	 ---------------------------------------------------------------------------------------------------------*/

-	int cf = 0;

-

-	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_AutoexecCliente");

-	tbfuncionesClient[cf++].fptr = &RESPUESTA_AutoexecCliente;

-

-	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_InclusionCliente");

-	tbfuncionesClient[cf++].fptr = &RESPUESTA_InclusionCliente;

-

-	strcpy(tbfuncionesClient[cf].nf, "NoComandosPtes");

-	tbfuncionesClient[cf++].fptr = &NoComandosPtes;

-

-	strcpy(tbfuncionesClient[cf].nf, "Actualizar");

-	tbfuncionesClient[cf++].fptr = &Actualizar;

-

-	strcpy(tbfuncionesClient[cf].nf, "Purgar");

-	tbfuncionesClient[cf++].fptr = &Purgar;

-

-	strcpy(tbfuncionesClient[cf].nf, "ConsolaRemota");

-	tbfuncionesClient[cf++].fptr = &ConsolaRemota;

-

-	strcpy(tbfuncionesClient[cf].nf, "Sondeo");

-	tbfuncionesClient[cf++].fptr = &Sondeo;

-

-	strcpy(tbfuncionesClient[cf].nf, "Arrancar");

-	tbfuncionesClient[cf++].fptr = &Arrancar;

-

-	strcpy(tbfuncionesClient[cf].nf, "Apagar");

-	tbfuncionesClient[cf++].fptr = &Apagar;

-

-	strcpy(tbfuncionesClient[cf].nf, "Reiniciar");

-	tbfuncionesClient[cf++].fptr = &Reiniciar;

-

-	strcpy(tbfuncionesClient[cf].nf, "IniciarSesion");

-	tbfuncionesClient[cf++].fptr = &IniciarSesion;

-

-	strcpy(tbfuncionesClient[cf].nf, "CrearImagen");

-	tbfuncionesClient[cf++].fptr = &CrearImagen;

-

-	strcpy(tbfuncionesClient[cf].nf, "CrearImagenBasica");

-	tbfuncionesClient[cf++].fptr = &CrearImagenBasica;

-

-	strcpy(tbfuncionesClient[cf].nf, "CrearSoftIncremental");

-	tbfuncionesClient[cf++].fptr = &CrearSoftIncremental;

-

-	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagen");

-	tbfuncionesClient[cf++].fptr = &RestaurarImagen;

-

-	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagenBasica");

-	tbfuncionesClient[cf++].fptr = &RestaurarImagenBasica;

-

-	strcpy(tbfuncionesClient[cf].nf, "RestaurarSoftIncremental");

-	tbfuncionesClient[cf++].fptr = &RestaurarSoftIncremental;

-

-

-	strcpy(tbfuncionesClient[cf].nf, "Configurar");

-	tbfuncionesClient[cf++].fptr = &Configurar;

-

-	strcpy(tbfuncionesClient[cf].nf, "EjecutarScript");

-	tbfuncionesClient[cf++].fptr = &EjecutarScript;

-

-	strcpy(tbfuncionesClient[cf].nf, "InventarioHardware");

-	tbfuncionesClient[cf++].fptr = &InventarioHardware;

-

-	strcpy(tbfuncionesClient[cf].nf, "InventarioSoftware");

-	tbfuncionesClient[cf++].fptr = &InventarioSoftware;

-

-	strcpy(tbfuncionesClient[cf].nf, "EjecutaComandosPendientes");

-	tbfuncionesClient[cf++].fptr = &EjecutaComandosPendientes;

-

-	/*--------------------------------------------------------------------------------------------------------

-		Toma dirección IP del cliente 	

-	 ---------------------------------------------------------------------------------------------------------*/

-	if(!tomaIPlocal()){ // Error al recuperar la IP local

-		errorLog(modulo,0,FALSE);

-		exit(EXIT_FAILURE);

-	}

-	/*--------------------------------------------------------------------------------------------------------

-		Inicio de sesión

-	 ---------------------------------------------------------------------------------------------------------*/

-	infoLog(1); // Inicio de sesión

-	infoLog(3); // Abriendo sesión en el servidor de Administración;		

-	/*--------------------------------------------------------------------------------------------------------

-		Inclusión del cliente en el sistema

-	 ---------------------------------------------------------------------------------------------------------*/

-	if(!inclusionCliente(ptrTrama)){	// Ha habido algún problema al abrir sesión

-		errorLog(modulo,0,FALSE);

-		exit(EXIT_FAILURE);

-	}

-	infoLog(4); // Cliente iniciado

-

-	/*--------------------------------------------------------------------------------------------------------

-		Procesamiento de la cache

-	 ---------------------------------------------------------------------------------------------------------*/

-	infoLog(23); // Abriendo sesión en el servidor de Administración;

-	if(!cuestionCache(cache)){

-		errorLog(modulo,0,FALSE);

-		exit(EXIT_FAILURE);

-	}

-	/*--------------------------------------------------------------------------------------------------------

-		Ejecución del autoexec

-	 ---------------------------------------------------------------------------------------------------------*/

-	if(atoi(idproautoexec)>0){  // Ejecución de procedimiento Autoexec

-		infoLog(5);

-		if(!autoexecCliente(ptrTrama)){  // Ejecución fichero autoexec

-			errorLog(modulo,0,FALSE);

-			exit(EXIT_FAILURE);

-		}

-	}

-	/*--------------------------------------------------------------------------------------------------------

-		Comandos pendientes

-	 ---------------------------------------------------------------------------------------------------------*/

-	infoLog(6); // Procesa comandos pendientes

-	if(!comandosPendientes(ptrTrama)){  // Ejecución de acciones pendientes

-		errorLog(modulo,0,FALSE);

-		exit(EXIT_FAILURE);

-	}

-	infoLog(7); // Acciones pendientes procesadas

-	/*--------------------------------------------------------------------------------------------------------

-		Bucle de recepción de comandos

-	 ---------------------------------------------------------------------------------------------------------*/

-	muestraMenu();

-	procesaComandos(ptrTrama); // Bucle para procesar comandos interactivos

-	/*--------------------------------------------------------------------------------------------------------

-		Fin de la sesión

-	 ---------------------------------------------------------------------------------------------------------*/

-	exit(EXIT_SUCCESS);

-}

diff --git a/admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.h b/admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.h
deleted file mode 100644
index da0a5c34..00000000
--- a/admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.h
+++ /dev/null
@@ -1,183 +0,0 @@
-// ********************************************************************************************************
-// Cliernte: ogAdmClient
-// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
-// Fecha Creación: Marzo-2010
-// Fecha Última modificación: Marzo-2010
-// Nombre del fichero: ogAdmClient.h
-// Descripción :Este fichero implementa el cliente general del sistema
-// ********************************************************************************************************
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-#include <unistd.h>
-#include <time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <signal.h>
-#include "ogAdmLib.h"
-// ________________________________________________________________________________________________________
-// Variables globales
-// ________________________________________________________________________________________________________
-char *idordenador;	 // Identificador del ordenador
-char *nombreordenador; // Nombre del ordenador
-char *cache; // Tamaño de la caché
-char *idproautoexec; // Identificador del procedimiento de autoexec
-char *idcentro; // Identificador de la Unidad Organizativa
-char *idaula; // Identificador del aula
-char IPlocal[LONIP]; // Ip local
-
-char servidoradm[LONPRM]; // Dirección IP del servidor de administración
-char puerto[LONPRM]; // Puerto de comunicación
-char pathinterface[LONPRM]; // Path donde está la interface entre la administración y el módulo de clonación
-
-char interface[LONFUN]; // Nombre del módulo,función o script de la interface con el módulo de administración
-char parametros[LONSTD]; // Parámetros para la llamada
-int herror;
-
-BOOLEAN CMDPTES; // Para bucle de comandos pendientes
-
-
-char urlmenu[MAXLONURL]; // Url de la pagina de menu para el browser
-char urlmsg[MAXLONURL]; // Url de la página de mensajed para el browser
-
-
-typedef struct{  // Estructura usada para referenciar las funciones que procesan las tramas
-	char nf[LONFUN]; // Nombre de la función
-	BOOLEAN (*fptr)(TRAMA*); // Puntero a la función que procesa la trama
-}MSGFUN;
-MSGFUN tbfuncionesClient[MAXIMAS_FUNCIONES];
-// ________________________________________________________________________________________________________
-// Tabla de errores de la ejecución de los scripts
-// ________________________________________________________________________________________________________
-char* tbErroresScripts[]={"Se han generado errores desconocidos. No se puede continuar la ejecución de este módulo",\
-		"001-Formato de ejecución incorrecto.",\
-		"002-Fichero o dispositivo no encontrado",\
-		"003-Error en partición de disco",\
-		"004-Partición o fichero bloqueado",\
-		"005-Error al crear o restaurar una imagen",\
-		"006-Sin sistema operativo",\
-		"007-Programa o función BOOLEAN no ejecutable",\
-		"008-Error en la creación del archivo de eco para consola remota",\
-		"009-Error en la lectura del archivo temporal de intercambio",\
-		"010-Error al ejecutar la llamada a la interface de administración",\
-		"011-La información retornada por la interface de administración excede de la longitud permitida",\
-		"012-Error en el envío de fichero por la red",\
-		"013-Error en la creación del proceso hijo",\
-		"014-Error de escritura en destino",\
-		"015-Sin Cache en el Cliente",\
-		"016-No hay espacio en la cache para almacenar fichero-imagen",\
-		"017-Error al Reducir el Sistema Archivos",\
-		"018-Error al Expandir el Sistema Archivos",\
-		"019-Valor fuera de rango o no válido.",\
-		"020-Sistema de archivos desconocido o no se puede montar",\
-		"021-Error en partición de caché local",\
-		"022-El disco indicado no contiene una particion GPT",\
-		"023-Error no definido",\
-		"024-Error no definido",\
-		"025-Error no definido",\
-		"026-Error no definido",\
-		"027-Error no definido",\
-		"028-Error no definido",\
-		"029-Error no definido",\
-		"030-Error al restaurar imagen - Imagen mas grande que particion",\
-		"031-Error al realizar el comando updateCache",\
-		"032-Error al formatear",\
-		"033-Archivo de imagen corrupto o de otra versión de partclone",\
-		"034-Error no definido",\
-		"035-Error no definido",\
-		"036-Error no definido",\
-		"037-Error no definido",\
-		"038-Error no definido",\
-		"039-Error no definido",\
-		"040-Error imprevisto no definido",\
-		"041-Error no definido",\
-		"042-Error no definido",\
-		"043-Error no definido",\
-		"044-Error no definido",\
-		"045-Error no definido",\
-		"046-Error no definido",\
-		"047-Error no definido",\
-		"048-Error no definido",\
-		"049-Error no definido",\
-		"050-Error en la generación de sintaxis de transferenica unicast",\
-		"051-Error en envio UNICAST de una particion",\
-		"052-Error en envio UNICAST de un fichero",\
-		"053-Error en la recepcion UNICAST de una particion",\
-		"054-Error en la recepcion UNICAST de un fichero",\
-		"055-Error en la generacion de sintaxis de transferenica Multicast",\
-		"056-Error en envio MULTICAST de un fichero",\
-		"057-Error en la recepcion MULTICAST de un fichero",\
-		"058-Error en envio MULTICAST de una particion",\
-		"059-Error en la recepcion MULTICAST de una particion",\
-		"060-Error en la conexion de una sesion UNICAST|MULTICAST con el MASTER",\
-		"061-Error no definido",\
-		"062-Error no definido",\
-		"063-Error no definido",\
-		"064-Error no definido",\
-		"065-Error no definido",\
-		"066-Error no definido",\
-		"067-Error no definido",\
-		"068-Error no definido",\
-		"069-Error no definido",\
-		"070-Error al montar una imagen sincronizada.",\
-		"071-Imagen no sincronizable (es monolitica).",\
-		"072-Error al desmontar la imagen.",\
-		"073-No se detectan diferencias entre la imagen basica y la particion.",\
-		"074-Error al sincronizar, puede afectar la creacion/restauracion de la imagen.",\
-		"Error desconocido "
-	};
-	#define MAXERRORSCRIPT 74		// Error máximo cometido
-// ________________________________________________________________________________________________________
-// Prototipo de funciones
-// ________________________________________________________________________________________________________
-BOOLEAN autoexecCliente(TRAMA*);
-BOOLEAN RESPUESTA_AutoexecCliente(TRAMA*);
-void procesaComandos(TRAMA*);
-
-BOOLEAN tomaConfiguracion(char*);
-BOOLEAN tomaIPlocal(void);
-void scriptLog(const char *,int );
-
-BOOLEAN gestionaTrama(TRAMA *);
-BOOLEAN inclusionCliente();
-char* LeeConfiguracion();
-BOOLEAN RESPUESTA_InclusionCliente(TRAMA *);
-
-BOOLEAN comandosPendientes(TRAMA*);
-BOOLEAN NoComandosPtes(TRAMA *);
-
-BOOLEAN respuestaEjecucionComando(TRAMA *,int,char*);
-BOOLEAN Sondeo(TRAMA *);
-BOOLEAN Actualizar(TRAMA *);
-int Purgar(TRAMA* );
-
-BOOLEAN ConsolaRemota(TRAMA*);
-
-BOOLEAN Arrancar(TRAMA *);
-BOOLEAN Apagar(TRAMA *);
-BOOLEAN Reiniciar(TRAMA *);
-BOOLEAN IniciarSesion(TRAMA *);
-BOOLEAN CrearImagen(TRAMA *);
-BOOLEAN CrearImagenBasica(TRAMA *);
-BOOLEAN CrearSoftIncremental(TRAMA*);
-
-BOOLEAN InventarioHardware(TRAMA *);
-BOOLEAN InventariandoSoftware(TRAMA *,BOOLEAN,char*);
-BOOLEAN EjecutarScript(TRAMA *);
-BOOLEAN ejecutaArchivo(char*,TRAMA*);
-
-BOOLEAN cuestionCache(char*);
-int cargaPaginaWeb(char *);
-void muestraMenu(void);
-void muestraMensaje(int idx,char*);
-
-BOOLEAN enviaMensajeServidor(SOCKET *,TRAMA *,char);
-
-
-
-
diff --git a/admin/Sources/Services/ogAdmAgent/Makefile b/admin/Sources/Services/ogAdmAgent/Makefile
deleted file mode 100644
index b9d39b9b..00000000
--- a/admin/Sources/Services/ogAdmAgent/Makefile
+++ /dev/null
@@ -1,42 +0,0 @@
-# makefile
-
-# Nombre del proyecto
-PROYECTO := ogAdmAgent
-
-# Directorio de instalación
-INSTALL_DIR := /opt/opengnsys
-
-# Opciones de compilacion
-CFLAGS := $(shell mysql_config --cflags)
-CFLAGS += -g -Wall -I../../Includes
-CPPFLAGS := $(CFLAGS)
-
-# Opciones de linkado
-LDFLAGS := -Wl,--no-as-needed $(shell mysql_config --libs) -lpthread
-
-# Ficheros objetos
-OBJS := ../../Includes/Database.o sources/ogAdmAgent.o 
-
-
-all: $(PROYECTO)
-
-$(PROYECTO): $(OBJS)
-	g++ $(LDFLAGS) $(OBJS) -o $(PROYECTO)
-
-install: $(PROYECTO)
-	cp $(PROYECTO) $(INSTALL_DIR)/sbin
-	cp $(PROYECTO).cfg $(INSTALL_DIR)/etc
- 
-clean:
-	rm -f $(PROYECTO) $(OBJS)
-
-uninstall: clean
-	rm -f /usr/local/sbin/$(PROYECTO) /usr/local/etc/$(PROYECTO).cfg
-
-sources/%.o: sources/%.cpp
-	g++ $(CPPFLAGS) -c -o"$@" "$<"
-	
-sources/%.o: sources/%.c
-	gcc $(CFLAGS) -c -o"$@" "$<"
-
-
diff --git a/admin/Sources/Services/ogAdmAgent/ogAdmAgent.cfg b/admin/Sources/Services/ogAdmAgent/ogAdmAgent.cfg
deleted file mode 100644
index 20126d35..00000000
--- a/admin/Sources/Services/ogAdmAgent/ogAdmAgent.cfg
+++ /dev/null
@@ -1,7 +0,0 @@
-ServidorAdm=SERVERIP
-PUERTO=2008
-USUARIO=DBUSER
-PASSWORD=DBPASSWORD
-datasource=localhost
-CATALOG=DATABASE
-
diff --git a/admin/Sources/Services/ogAdmAgent/sources/ogAdmAgent.cpp b/admin/Sources/Services/ogAdmAgent/sources/ogAdmAgent.cpp
deleted file mode 100644
index 6bf23512..00000000
--- a/admin/Sources/Services/ogAdmAgent/sources/ogAdmAgent.cpp
+++ /dev/null
@@ -1,914 +0,0 @@
-// ********************************************************************************************************
-// Servicio: ogAdmAgent
-// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
-// Fecha Creación: Marzo-2010
-// Fecha Última modificación: Marzo-2010
-// Nombre del fichero: ogAdmAgent.cpp
-// Descripción: Este fichero implementa el servicio agente del sistema. Revisa a intervalos
-//				regulares la base de datos para comprobar si existen acciones programadas.
-// ********************************************************************************************************
-#include "ogAdmAgent.h"
-#include "ogAdmLib.c"
-//________________________________________________________________________________________________________
-//	Función: tomaConfiguracion
-//
-//	Descripción:
-//		Lee el fichero de configuración del servicio
-//	Parámetros:
-//		filecfg : Ruta completa al fichero de configuración
-//	Devuelve:
-//		TRUE: Si el proceso es correcto
-//		FALSE: En caso de ocurrir algún error 
-//________________________________________________________________________________________________________
-BOOLEAN tomaConfiguracion(char* filecfg)
-{
-	char modulo[] = "tomaConfiguracion()";
-
-	if (filecfg == NULL || strlen(filecfg) == 0) {
-		errorLog(modulo, 1, FALSE); // Fichero de configuración del servicio vacío
-		return (FALSE);
-	}
-	FILE *fcfg;
-	long lSize;
-	char * buffer, *lineas[MAXPRM], *dualparametro[2];
-	int i, numlin, resul;
-
-	fcfg = fopen(filecfg, "rt");
-	if (fcfg == NULL) {
-		errorLog(modulo, 2, FALSE); // No existe fichero de configuración del servicio
-		return (FALSE);
-	}
-
-	fseek(fcfg, 0, SEEK_END);
-	lSize = ftell(fcfg); // Obtiene tamaño del fichero.
-	rewind(fcfg);
-	buffer = (char*) reservaMemoria(lSize + 1); // Toma memoria para el buffer de lectura.
-	if (buffer == NULL) { // No hay memoria suficiente para el buffer
-		errorLog(modulo, 3, FALSE);
-		return (FALSE);
-	}
-	fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero
-	buffer[lSize] = (char) NULL;
-	fclose(fcfg);
-
-	servidoradm[0] = (char) NULL; //inicializar variables globales
-	puerto[0] = (char) NULL;
-	usuario[0] = (char) NULL;
-	pasguor[0] = (char) NULL;
-	datasource[0] = (char) NULL;
-	catalog[0] = (char) NULL;
-
-	numlin = splitCadena(lineas, buffer, '\n');
-	for (i = 0; i < numlin; i++) {
-		splitCadena(dualparametro, lineas[i], '=');
-		resul = strcmp(StrToUpper(dualparametro[0]), "SERVIDORADM");
-		if (resul == 0)
-			strcpy(servidoradm, dualparametro[1]);
-		resul = strcmp(StrToUpper(dualparametro[0]), "PUERTO");
-		if (resul == 0)
-			strcpy(puerto, dualparametro[1]);
-		resul = strcmp(StrToUpper(dualparametro[0]), "USUARIO");
-		if (resul == 0)
-			strcpy(usuario, dualparametro[1]);
-		resul = strcmp(StrToUpper(dualparametro[0]), "PASSWORD");
-		if (resul == 0)
-			strcpy(pasguor, dualparametro[1]);
-		resul = strcmp(StrToUpper(dualparametro[0]), "DATASOURCE");
-		if (resul == 0)
-			strcpy(datasource, dualparametro[1]);
-		resul = strcmp(StrToUpper(dualparametro[0]), "CATALOG");
-		if (resul == 0)
-			strcpy(catalog, dualparametro[1]);
-	}
-	if (servidoradm[0] == (char) NULL) {
-		errorLog(modulo, 4, FALSE); // Falta parámetro SERVIDORADM
-		return (FALSE);
-	}
-	if (puerto[0] == (char) NULL) {
-		errorLog(modulo, 5, FALSE); // Falta parámetro PUERTO
-		return (FALSE);
-	}
-	if (usuario[0] == (char) NULL) {
-		errorLog(modulo, 6, FALSE); // Falta parámetro USUARIO
-		return (FALSE);
-	}
-	if (pasguor[0] == (char) NULL) {
-		errorLog(modulo, 7, FALSE); // Falta parámetro PASSWORD
-		return (FALSE);
-	}
-	if (datasource[0] == (char) NULL) {
-		errorLog(modulo, 8, FALSE); // Falta parámetro DATASOURCE
-		return (FALSE);
-	}
-	if (catalog[0] == (char) NULL) {
-		errorLog(modulo, 9, FALSE); // Falta parámetro CATALOG
-		return (FALSE);
-	}
-	return (TRUE);
-}
-// ________________________________________________________________________________________________________
-//
-// Función: diadelaSemana
-//
-//	Descripción:
-//		Calcula el número del día de la semana que corresponde a una fecha
-//	Parámetros:
-//		- dia: Un día
-//		- mes: Un mes
-//		- anno: Un año
-//	Devuelve:
-//		El número del día de la semana: 1=Lunes, 2=martes ... 6=sábado  7=domingo
-// ________________________________________________________________________________________________________
-
-int diadelaSemana(WORD dia,WORD mes,WORD anno)
-{
-	int i,cont,dias_anuales;
-	int desplazamiento_dias=6;
-	int orddiasem;
-
-	cont =0;
-	for (i=1900;i<anno;i++){
-		if (bisiesto(i)) dias_anuales=366; else	dias_anuales=365;
-		cont+=dias_anuales;
-	}
-	for (i=1;i<mes;i++){
-		if (i!=2)
-			cont+=dias_meses[i];
-		else{
-			if (bisiesto(anno))
-				cont+=29;
-			else
-				cont+=28;
-		}
-	}
-	cont+=dia+desplazamiento_dias;
-	orddiasem=(cont%7);
-	if(orddiasem==0) orddiasem=7;
-	return(orddiasem);
-}
-// ________________________________________________________________________________________________________
-//
-// Función: bisiesto
-//
-//	Descripción:
-//		Calcula si un año es bisiesto o no lo es
-//	Parámetros:
-//		- anno: Un año
-//	Devuelve:
-//		TRUE si el año es bisiesto
-//		FALSE si no es bisiesto
-// ________________________________________________________________________________________________________
-
-BOOLEAN bisiesto(WORD anno){
-	return(anno%4==0);
-}
-// ________________________________________________________________________________________________________
-//
-// Función: semanadelMes
-//
-//	Descripción:
-//		Calcula el número de semana perteneciente a un día del mes
-//	Parámetros:
-//		- ordiasem_1: Orden semanal (1,2...) del primer dia del mes que se pasa como parámetro
-//		- diames: El mes concreto
-//	Devuelve:
-//		El número del día de la semana: 1=Lunes, 2=martes ... 6=sábado  7=domingo , de ese mes
-// ________________________________________________________________________________________________________
-
-int semanadelMes(int ordiasem_1,int diames)
-{
-	int nwdia,resto,cociente;
-
-	nwdia=diames+ordiasem_1-1;
-	cociente=nwdia/7;
-	resto=nwdia%7;
-	if(resto>0) cociente++;
-	return(cociente);
-}
-// ________________________________________________________________________________________________________
-//
-// Función: buscaAccion
-//
-//	Descripción:
-//		Busca en la base de datos, acciones programadas
-//	Parámetros:
-//		- db: Objeto base de datos (operativo)
-//		- dia : Día actual del mes
-//		- mes : mes en curso
-//		- anno : Año en curso
-//		- hora : Hora actual
-//		- minutos : Minutos actuales
-//		- diasemana : Dia de la semana 1=lunes,2=martes ... ( 0 Domingo)
-//	Devuelve:
-//		TRUE: Si el proceso es correcto
-//		FALSE: En caso de ocurrir algún error
-// ________________________________________________________________________________________________________
-
-BOOLEAN buscaAccion(Database db,WORD dia,WORD mes,WORD anno,WORD hora,WORD minutos,WORD diasemana)
-{
-	char msglog[LONSTD], sqlstr[LONSQL];
-	Table tbl;
-	BYTE swampm,bitsemana;
-	int ordsem,ordulsem,ordiasem_1,maxdias;
-	int sesionprog;
-	char modulo[] = "buscaAccion()";
-
-	/* Año de comienzo */
-	anno=anno-ANNOREF; //
-	/* Preparación hora */
-	if(hora>11){
-		hora-=12;
-		swampm=1; // Es P.M.
-	}
-	else
-		swampm=0; // Es am
-	/* Preparación semana */
-	if(diasemana==0) diasemana=7; // El domingo
-
-	// Cuestión semanas
-	ordiasem_1=diadelaSemana(1,mes,anno+2009);
-	ordsem=semanadelMes(ordiasem_1,dia); // Calcula el número de la semana
-	if (mes!=2) // Toma el último día de ese mes
-		maxdias=dias_meses[mes];
-	else{
-		if (bisiesto(anno+ANNOREF))
-			maxdias=29;
-		else
-			maxdias=28;
-	}
-	ordulsem=semanadelMes(ordiasem_1,maxdias); // Calcula el número de la última semana
-	bitsemana=HEX_semanas[ordsem];
-	if(ordsem==ordulsem) // Si es la última semana del mes
-		bitsemana|=HEX_semanas[6];
-
-	sprintf(sqlstr,"SELECT DISTINCT idprogramacion,tipoaccion,identificador,sesion,idcentro,"\
-					"tareas.descripcion as descritarea"\
-					" FROM programaciones"\
-					" LEFT OUTER JOIN tareas ON tareas.idtarea=programaciones.identificador"\
-					" WHERE suspendida=0 "\
-					" AND (annos & %d <> 0) "\
-					" AND (meses & %d<>0) "\
-					" AND ((diario & %d<>0) OR (dias & %d<>0) OR (semanas & %d<>0))"\
-					" AND (horas & %d<>0) AND ampm=%d AND minutos=%d",\
-					HEX_annos[anno],\
-					HEX_meses[mes],\
-					HEX_dias[dia],\
-					HEX_diasemana[diasemana],\
-					bitsemana,\
-					HEX_horas[hora],\
-					swampm,minutos);
-
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	if(tbl.ISEOF()){
-		return(TRUE);  // No hay acciones programadas
-	}
-	
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("idprogramacion",idprogramacion)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		if(!tbl.Get("tipoaccion",tipoaccion)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		if(!tbl.Get("identificador",idtipoaccion)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		if(!tbl.Get("sesion",sesionprog)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		if(!tbl.Get("idcentro",idcentro)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}		
-
-		if(tipoaccion==EJECUCION_COMANDO){ // Es una programación de un comando
-			return(ejecutarComando(db,idprogramacion,sesionprog));
-		}
-		else{
-		
-			if(tipoaccion==EJECUCION_TAREA){
-				if(!tbl.Get("descritarea",descriaccion)){
-					tbl.GetErrorErrStr(msglog);
-					errorInfo(modulo, msglog);
-					return (FALSE);
-				}					
-				return(ejecutarTarea(db,idprogramacion,idtipoaccion));
-			}
-			else{
-				if(tipoaccion==EJECUCION_RESERVA){
-					EjecutarReserva(idtipoaccion,db); // Es una programación de un trabajo
-				}
-			}
-		}
-		tbl.MoveNext();
-	}
-	return(TRUE);
-}
-// ________________________________________________________________________________________________________
-//
-// Función: ejecutarComando
-//
-//	Descripción:
-//		Ejecuta un comando programado
-//	Parámetros:
-//		- db: Objeto base de datos (operativo)
-//		- idcomando: Identificador del comando
-//		- sesion: Sesión correspondiente al comando cuando se grabó en la tabla acciones
-//	Devuelve:
-//		TRUE: Si el proceso es correcto
-//		FALSE: En caso de ocurrir algún error
-// ________________________________________________________________________________________________________
-
-BOOLEAN ejecutarComando(Database db,int idprogramacion,int sesion )
-{
-	struct tm* st;
-	char msglog[LONSTD], sqlstr[LONSQL];
-	char fechahorareg[24];
-	char modulo[] = "ejecutarComando()";
-
-	st = tomaHora();
-	sprintf(fechahorareg,"%d/%d/%d %d:%d:%d", st->tm_year + 1900, st->tm_mon + 1,
-			st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);
-
-	sprintf(sqlstr,"UPDATE acciones SET estado=%d,idprogramacion=%d,fechahorareg='%s'"\
-				" WHERE sesion=%d",	ACCION_INICIADA,idprogramacion,fechahorareg,sesion);
-
-	if (!db.Execute(sqlstr)) { // Error al recuperar los datos
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	return(enviaPeticion(idprogramacion));
-}
-// ________________________________________________________________________________________________________
-//
-// Función: ejecutarProcedimiento
-//
-//	Descripción:
-//		Ejecuta un procedimiento programado
-//	Parámetros:
-//		- db: Objeto base de datos (operativo)
-//		- idprocedimiento: Identificador del procedimiento
-//		- ambito: �mbito de aplicación
-//		- idambito: Identificador del ámbito
-//		- restrambito: cadena con los identificadores de los ordenadores a los que se aplica la acción 
-//	Devuelve:
-//		TRUE: Si el proceso es correcto
-//		FALSE: En caso de ocurrir algún error
-// ________________________________________________________________________________________________________
-
-BOOLEAN ejecutarProcedimiento(Database db,int idprocedimiento,int ambito,int idambito,char* restrambito)
-{	
-	char msglog[LONSTD], sqlstr[LONSQL],*parametros;
-	Table tbl;
-	int procedimientoid,idcomando,lonprm;
-	char modulo[] = "ejecutarProcedimiento()";
-	
-	sprintf(sqlstr,"SELECT idcomando,procedimientoid,parametros,length(parametros) as lonprm"\
-					" FROM procedimientos_acciones"\
-					" WHERE idprocedimiento=%d ORDER BY orden",idprocedimiento);
-
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	
-	if(tbl.ISEOF()){
-		return(TRUE);  // No exustde tarea
-	}
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("procedimientoid",procedimientoid)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		if(procedimientoid>0){ // Procedimiento recursivo
-			if(!ejecutarProcedimiento(db,procedimientoid,ambito,idambito,restrambito)){
-				return(false);
-			}
-		}
-		else{
-			if(!tbl.Get("lonprm",lonprm)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				return (FALSE);
-			}	
-			parametros = reservaMemoria(lonprm+1); // Reserva para almacenar los parametros del procedimiento
-			if (parametros == NULL) {
-				errorLog(modulo, 3, FALSE);
-				return (FALSE);
-			}			
-			if(!tbl.Get("parametros",parametros)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				liberaMemoria(parametros);
-				return (FALSE);
-			}
-			if(!tbl.Get("idcomando",idcomando)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				return (FALSE);
-			}
-
-			if(!insertaComando(db,idcomando,parametros,idprocedimiento,ambito,idambito,restrambito)) {
-
-				liberaMemoria(parametros);
-				return(false);
-			}
-			liberaMemoria(parametros);
-		}
-		tbl.MoveNext();
-	}		
-	return(TRUE);
-}
-// ________________________________________________________________________________________________________
-//
-// Función: ejecutarTarea
-//
-//	Descripción:
-//		Ejecuta una tarea programada
-//	Parámetros:
-//		- db: Objeto base de datos (operativo)
-//		- idtarea: Identificador de la tarea
-//		- idprogramacion: Identificador de la programación
-//	Devuelve:
-//		TRUE: Si el proceso es correcto
-//		FALSE: En caso de ocurrir algún error
-// ________________________________________________________________________________________________________
-
-BOOLEAN ejecutarTarea(Database db, int idprogramacion, int idtarea)
-{
-	char msglog[LONSTD], sqlstr[LONSQL];
-	Table tbl;
-	int tareaid,ambito,idambito,idprocedimiento,lonrestrambito;
-	char* restrambito;
-	char modulo[] = "ejecutarTarea()";
-
-	sprintf(sqlstr,"SELECT tareas_acciones.orden,tareas_acciones.idprocedimiento,tareas_acciones.tareaid,"\
-			" tareas.ambito,tareas.idambito,tareas.restrambito,length(tareas.restrambito) as lonrestrambito"\
-			" FROM tareas"\
-			" INNER JOIN tareas_acciones ON tareas_acciones.idtarea=tareas.idtarea"\
-			" WHERE tareas_acciones.idtarea=%d ORDER BY tareas_acciones.orden",idtarea);
-
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	
-	if(tbl.ISEOF()){
-		return(TRUE);  // No existe tarea
-	}	
-
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("tareaid",tareaid)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		if(tareaid>0){ // Tarea recursiva
-			if(!ejecutarTarea(db,idprogramacion,tareaid)){
-				return(false);
-			}
-		}
-		else{
-			if(!tbl.Get("ambito",ambito)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				return (FALSE);
-			}	
-			if(!tbl.Get("idambito",idambito)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				return (FALSE);
-			}		
-			if(!tbl.Get("lonrestrambito",lonrestrambito)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				return (FALSE);
-			}
-			restrambito = reservaMemoria(lonrestrambito+1);
-			if (restrambito == NULL) {
-				errorLog(modulo, 3, FALSE);
-				return (FALSE);
-			}			
-			if(!tbl.Get("restrambito",restrambito)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				liberaMemoria(restrambito);
-				return (FALSE);
-			}			
-			liberaMemoria(restrambito);
-			RecopilaIpesMacs(db,ambito,idambito,restrambito); // Recopila Ipes del ámbito
-			if(!tbl.Get("idprocedimiento",idprocedimiento)){
-				tbl.GetErrorErrStr(msglog);
-				errorInfo(modulo, msglog);
-				return (FALSE);
-			}
-			sesion=time(NULL);
-			
-			if(!ejecutarProcedimiento(db,idprocedimiento,ambito,idambito,restrambito))
-				return(FALSE);
-		}
-		tbl.MoveNext();
-	}		
-	return(enviaPeticion(idprogramacion));	
-}
-// ________________________________________________________________________________________________________
-//
-// Función: ejecutarTarea
-//
-//	Descripción:
-//		Registra un procedimiento para un ambito concreto
-//	Parámetros:
-//		- db: Objeto base de datos (operativo)
-//		- idcomando: Identificador del comando
-//		- idprocedimiento: Identificador del procedimiento
-//		- ambito: �mbito de aplicación
-//		- idambito: Identificador del ámbito
-//		- restrambito: cadena con los identificadores de los ordenadores a los que se aplica la acción 
-//	Devuelve:
-//		TRUE: Si el proceso es correcto
-//		FALSE: En caso de ocurrir algún error
-//________________________________________________________________________________________________________
-BOOLEAN insertaComando(Database db,int idcomando,char*parametros,int idprocedimiento,int ambito,int idambito,char*restrambito)
-{
-	char msglog[LONSTD], sqlstr[LONSQL];
-	struct tm* st;
-	char *auxID[MAXIMOS_CLIENTES],*auxIP[MAXIMOS_CLIENTES];
-	char fechahorareg[24];
-	int i;
-	char modulo[] = "insertaComando()";
-
-	if(concli==0) return(TRUE); // No hay ordenadores en el ámbito
-
-	st = tomaHora();
-	sprintf(fechahorareg,"%d/%d/%d %d:%d:%d", st->tm_year + 1900, st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);	
-
-	splitCadena(auxID,cadenaid,',');
-	splitCadena(auxIP,cadenaip,';');
-
-	for (i=0;i<concli;i++){
-		sprintf(sqlstr,"INSERT INTO acciones (idordenador,tipoaccion,idtipoaccion,descriaccion,ip,"\
-						"sesion,idcomando,parametros,fechahorareg,estado,resultado,ambito,idambito,"\
-						"restrambito,idprocedimiento,idcentro,idprogramacion)"\
-						" VALUES (%s,%d,%d,'%s','%s',%d,%d,'%s','%s',%d,%d,%d,%d,'%s',%d,%d,%d)",\
-						auxID[i],tipoaccion,idtipoaccion,descriaccion,auxIP[i],sesion,idcomando,parametros,fechahorareg,\
-						ACCION_INICIADA,ACCION_SINRESULTADO,ambito,idambito,restrambito,idprocedimiento,idcentro,idprogramacion);
-			if (!db.Execute(sqlstr)) { // Error al recuperar los datos
-			errorLog(modulo, 21, FALSE);
-			db.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-	}
-	return(TRUE);
-}
-// _____________________________________________________________________________________________________________
-// Función: EjecutarReserva
-//
-//		Descripción:
-//			Registra una acción (Tarea) y la envía para su ejecución
-//		Parámetros:
-//			- idreserva : Identificador de la reserva
-//			- db: una conexion ADO operativa
-//			- parametros: Parámetros de la acción
-// _____________________________________________________________________________________________________________
-BOOLEAN EjecutarReserva(int idreserva,Database db )
-{
-
-
-	return(true);
-}
-// _____________________________________________________________________________________________________________
-// Función: enviaPeticion
-//
-//		Descripción:
-//			Hace una petición al servidor para que actualice los ordenadores implicados en la programación
-//		Parámetros:
-//			- idprogramacion: Identificador de la programación
-// _____________________________________________________________________________________________________________
-BOOLEAN enviaPeticion(int idprogramacion)
-{
-	int lon;
-	TRAMA *ptrTrama;
-	SOCKET socket_c;
-	char modulo[] = "enviaPeticion()";
-
-	/* Envio de comandos a clientes */
-	ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
-	if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas
-		errorLog(modulo, 3, FALSE);
-		return(FALSE);
-	}
-	initParametros(ptrTrama,0);
-	lon=sprintf(ptrTrama->parametros,"nfn=envioProgramacion\r"); // Nombre de la función a ejecutar en el servidor
-	lon+=sprintf(ptrTrama->parametros+lon,"idp=%d\r",idprogramacion); // Configuración de los Sistemas Operativos del cliente
-
-	if(!enviaMensaje(&socket_c,ptrTrama,MSG_PETICION)){
-		errorLog(modulo,91,FALSE);
-		liberaMemoria(ptrTrama);
-		return(FALSE);
-	}
-	liberaMemoria(ptrTrama);
-	return(TRUE);
-}
-// _____________________________________________________________________________________________________________
-//
-// Función: RecopilaIpesMacs
-//
-// Descripción : 
-//		Recopila las IPes, las Macs y los identificadores de ordenadores de un ámbito determinado
-//
-// Especificaciones:
-//		Esta Función recibe tres parámatros:
-//			db : Un objeto Base de datos totalmente operativo
-//			ambito:  Tipo de ámbito
-//			idambito: Identificador del ámbito
-//	Devuelve:
-//		Todas los identificadores de ordenadores , las ipes y las macs de los ordenadores que componen el ámbito
-//		Para ellos habrá que tener declarada tres variables globales :
-//				cadenaid,cadenaip y cadenamac
-// _____________________________________________________________________________________________________________
-
-BOOLEAN RecopilaIpesMacs(Database db,int ambito,int idambito,char *restrambito)
-{
-	char sqlstr[LONSQL];
-
-	concli=0;
-	/* Reserva memoria al meno para caracter nulo */
-	cadenaid=(char*) reservaMemoria(1);
-	cadenaip=(char*) reservaMemoria(1);
-	cadenamac=(char*) reservaMemoria(1);
-	
-	switch(ambito){
-		case AMBITO_CENTROS :
-			sprintf(sqlstr,"SELECT ip,mac,idordenador FROM ordenadores INNER JOIN aulas WHERE ordenadores.idaula=aulas.idaula AND idcentro=%d ORDER BY ordenadores.idaula, ordenadores.ip;",idambito);
-			RecorreOrdenadores(db,sqlstr);
-			break;
-		case AMBITO_GRUPOSAULAS :
-			sprintf(sqlstr,"SELECT idgrupo FROM grupos WHERE idgrupo=%d AND tipo=%d",idambito,AMBITO_GRUPOSAULAS);
-			RecorreGruposAulas(db,sqlstr);
-			break;
-		case AMBITO_AULAS :
-			sprintf(sqlstr,"SELECT ip,mac,idordenador FROM ordenadores WHERE idaula=%d ORDER BY ip;",idambito);
-			RecorreOrdenadores(db,sqlstr);
-			break;
-		case AMBITO_GRUPOSORDENADORES :
-			sprintf(sqlstr,"SELECT idgrupo FROM gruposordenadores WHERE idgrupo=%d",idambito);
-			RecorreGruposOrdenadores(db,sqlstr);
-			break;
-		case AMBITO_ORDENADORES :
-			sprintf(sqlstr,"SELECT ip,mac,idordenador FROM ordenadores WHERE idordenador=%d",idambito);
-			RecorreOrdenadores(db,sqlstr);
-			break;
-		default: // Se trata de un conjunto aleatorio de ordenadores
-			sprintf(sqlstr,"SELECT ip,mac,idordenador  FROM ordenadores WHERE idordenador IN (%s)",restrambito);
-			RecorreOrdenadores(db,sqlstr);
-			
-	}
-	return (TRUE);
-}
-//________________________________________________________________________________________________________
-
-BOOLEAN RecorreCentro(Database db, char* sqlstr)
-{
-	char msglog[LONSTD];
-	Table tbl;
-	int idcentro;
-	char modulo[] = "RecorreCentro()";
-	
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	if(!tbl.ISEOF()){
-		if(!tbl.Get("idcentro",idcentro)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}		
-		sprintf(sqlstr,"SELECT idgrupo FROM grupos WHERE idcentro=%d AND grupoid=0  AND tipo=%d",idcentro,AMBITO_GRUPOSAULAS);
-		RecorreGruposAulas(db,sqlstr);
-		sprintf(sqlstr,"SELECT idaula FROM aulas WHERE idcentro=%d AND grupoid=0",idcentro);
-		RecorreAulas(db,sqlstr);
-	}
-	return (TRUE);
-}
-//________________________________________________________________________________________________________
-
-BOOLEAN RecorreGruposAulas(Database db, char* sqlstr)
-{
-	char msglog[LONSTD];
-	Table tbl;
-	int idgrupo;
-	char modulo[] = "RecorreGruposAulas()";
-	
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("idgrupo",idgrupo)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}		
-		sprintf(sqlstr,"SELECT idgrupo FROM grupos WHERE grupoid=%d AND tipo=%d",idgrupo,AMBITO_GRUPOSAULAS);
-		RecorreGruposAulas(db,sqlstr);
-		sprintf(sqlstr,"SELECT idaula FROM aulas WHERE  grupoid=%d",idgrupo);
-		RecorreAulas(db,sqlstr);
-		tbl.MoveNext();
-	}
-	return (TRUE);
-}
-//________________________________________________________________________________________________________
-
-BOOLEAN RecorreAulas(Database db, char* sqlstr)
-{
-	char msglog[LONSTD];
-	Table tbl;
-	int idaula;
-	char modulo[] = "RecorreAulas()";
-
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("idaula",idaula)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		sprintf(sqlstr,"SELECT idgrupo FROM gruposordenadores WHERE idaula=%d AND grupoid=0",idaula);
-		RecorreGruposOrdenadores(db,sqlstr);
-		sprintf(sqlstr,"SELECT ip,mac,idordenador FROM ordenadores WHERE  idaula=%d AND grupoid=0",idaula);
-		RecorreOrdenadores(db,sqlstr);
-		tbl.MoveNext();
-	}
-	return (TRUE);
-}
-//________________________________________________________________________________________________________
-
-BOOLEAN  RecorreGruposOrdenadores(Database db, char* sqlstr)
-{
-	char msglog[LONSTD];
-	Table tbl;
-	int idgrupo;
-	char modulo[] = "RecorreGruposOrdenadores()";
-
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("idgrupo",idgrupo)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		sprintf(sqlstr,"SELECT idgrupo FROM gruposordenadores WHERE grupoid=%d",idgrupo);
-		RecorreGruposOrdenadores(db,sqlstr);
-		sprintf(sqlstr,"SELECT ip,mac,idordenador FROM ordenadores WHERE grupoid=%d",idgrupo);
-		RecorreOrdenadores(db,sqlstr);
-		tbl.MoveNext();
-	}
-	return (TRUE);
-}
-//________________________________________________________________________________________________________
-
-BOOLEAN RecorreOrdenadores(Database db, char* sqlstr)
-{
-	char msglog[LONSTD];
-	Table tbl;
-	int idordenador,o,p,m,lon;
-	char ido[16],ip[LONIP],mac[LONMAC];
-	char modulo[] = "RecorreOrdenadores()";
-
-	if (!db.Execute(sqlstr, tbl)) { // Error al leer
-		errorLog(modulo, 21, FALSE);
-		db.GetErrorErrStr(msglog);
-		errorInfo(modulo, msglog);
-		return (FALSE);
-	}
-	o=p=m=0;
-	while(!tbl.ISEOF()){
-		if(!tbl.Get("idordenador",idordenador)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}	
-		if(!tbl.Get("ip",ip)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}	
-		if(!tbl.Get("mac",mac)){
-			tbl.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			return (FALSE);
-		}
-		sprintf(ido,"%d",idordenador);
-		lon=strlen(ido);
-		if(lon>16) lon=16;
-		cadenaid=(char*) ampliaMemoria(cadenaid,o+lon+1);
-		memcpy(&cadenaid[o],ido,lon);
-		o+=lon;
-		cadenaid[o++]=',';
-		
-		lon=strlen(ip);
-		if(lon>16) lon=LONIP;
-		cadenaip=(char*) ampliaMemoria(cadenaip,p+lon+1);
-		memcpy(&cadenaip[p],ip,lon);
-		p+=lon;
-		cadenaip[p++]=';';
-
-		lon=strlen(mac);
-		if(lon>16) lon=LONMAC;
-		cadenamac=(char*) ampliaMemoria(cadenamac,m+lon+1);
-		memcpy(&cadenamac[m],mac,lon);
-		m+=lon;
-		cadenamac[m++]=';';
-		
-		concli++;
-		tbl.MoveNext();
-	}
-	if(o>0) o--;
-	if(p>0) p--;
-	if(m>0) m--;
-	cadenaid[o]='\0';
-	cadenaip[p]='\0';
-	cadenamac[m]='\0';
-
-	return (TRUE);
-}
-// ********************************************************************************************************
-// PROGRAMA PRINCIPAL (SERVICIO)
-// ********************************************************************************************************
-int main(int argc, char *argv[])
-{
-	int pseg;
-	char msglog[LONSTD];
-	struct tm* st;
-	Database db;
-	char modulo[] = "main()";
-
-	/* Validación de parámetros de ejecución y lectura del fichero de configuración del servicio */
-
-	if (!validacionParametros(argc, argv, 5)) // Valida parámetros de ejecución
-		exit(EXIT_FAILURE);
-
-	if (!tomaConfiguracion(szPathFileCfg)) { // Toma parametros de configuracion
-		exit(EXIT_FAILURE);
-	}
-	
-	/* Bucle principal del servicio */
-
-	while (TRUE){
-		st = tomaHora();
-		pseg=65-st->tm_sec; // Calcula segundos de inactividad de la hebra
-		sleep(pseg);
-
-		// Toma la hora
-		st = tomaHora();
-
-		if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
-			errorLog(modulo, 20, FALSE);
-			db.GetErrorErrStr(msglog);
-			errorInfo(modulo, msglog);
-			exit(EXIT_FAILURE);
-		}
-		buscaAccion(db,st->tm_mday,st->tm_mon+1,st->tm_year+1900,st->tm_hour,st->tm_min,st->tm_wday );
-		db.Close(); // Cierra conexión
-	}
-	exit(EXIT_SUCCESS);
-}
-
-	
diff --git a/admin/Sources/Services/ogAdmAgent/sources/ogAdmAgent.h b/admin/Sources/Services/ogAdmAgent/sources/ogAdmAgent.h
deleted file mode 100644
index b1c429bb..00000000
--- a/admin/Sources/Services/ogAdmAgent/sources/ogAdmAgent.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// ********************************************************************************************************

-// Servicio: ogAdmAgent

-// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla

-// Fecha Creación: Marzo-2010

-// Fecha Última modificación: Marzo-2010

-// Nombre del fichero: ogAdmAgent.h

-// Descripción: Este fichero implementa el servicio agente del sistema. Revisa a intervalos

-//				regulares la base de datos para comprobar si existen acciones programadas.

-// ********************************************************************************************************

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-#include <ctype.h>

-#include <errno.h>

-#include <unistd.h>

-#include <time.h>

-#include <sys/types.h>

-#include <sys/socket.h>

-#include <netinet/in.h>

-#include <arpa/inet.h>

-#include </usr/include/mysql/mysql.h>

-#include "Database.h"

-#include "ogAdmLib.h"

-

-// ________________________________________________________________________________________________________

-//

-//	Valores hexadecimales para consultas

-// ________________________________________________________________________________________________________

-

-WORD HEX_annos[]={0,0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,0x0100,0x0200,0x0400,0x0800,0x1000,0x2000,0x4000,0x8000};

-WORD HEX_meses[]={0,0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,0x0100,0x0200,0x0400,0x0800};

-int	HEX_dias[]={0,0x00000001,0x00000002,0x00000004,0x00000008,0x00000010,0x00000020,0x00000040,0x00000080,0x00000100,0x00000200,

-		0x00000400,0x00000800,0x00001000,0x00002000,0x00004000,0x00008000,0x00010000,0x00020000,0x00040000,0x00080000,

-		0x00100000,0x00200000,0x00400000,0x00800000,0x01000000,0x02000000,0x04000000,0x08000000,0x10000000,0x20000000,0x40000000};

-WORD	HEX_horas[]={0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,0x0100,0x0200,0x0400,0x0800 };

-BYTE	HEX_diasemana[]={0,0x01,0x02,0x04,0x08,0x10,0x20,0x40};

-BYTE	HEX_semanas[]={0,0x01,0x02,0x04,0x08,0x10,0x20};

-WORD	dias_meses[]={0,31,28,31,30,31,30,31,31,30,31,30,31};

-

-// ________________________________________________________________________________________________________

-//

-// Variables globales

-// ________________________________________________________________________________________________________

-

-char servidoradm[LONPRM];	// Dirección IP del servidor de administración

-char puerto[LONPRM];	// Puerto de comunicación

-char usuario[LONPRM];	// Usuario de acceso a la base de datos

-char pasguor[LONPRM];	// Password del usuario

-char datasource[LONPRM];	// Dirección IP del gestor de base de datos

-char catalog[LONPRM];	// Nombre de la base de datos

-

-int idprogramacion;

-int tipoaccion,idtipoaccion;

-char descriaccion[250];

-char *cadenaid;

-char *cadenaip;

-char *cadenamac;

-int concli;

-int sesion;

-int idcentro;

-

-// ________________________________________________________________________________________________________

-// Prototipo de funciones

-// ________________________________________________________________________________________________________

-BOOLEAN tomaConfiguracion(char*);

-int diadelaSemana(WORD,WORD,WORD);

-BOOLEAN bisiesto(WORD);

-BOOLEAN buscaAccion(Database,WORD,WORD,WORD,WORD,WORD,WORD);

-BOOLEAN ejecutarComando(Database,int,int );

-BOOLEAN ejecutarProcedimiento(Database,int,int,int,char*);

-BOOLEAN ejecutarTarea(Database,int, int);

-BOOLEAN insertaComando(Database,int,char*,int,int,int,char*);

-BOOLEAN EjecutarReserva(int,Database);

-BOOLEAN enviaPeticion(int);

-BOOLEAN RecopilaIpesMacs(Database,int,int,char *);

-BOOLEAN RecorreCentro(Database, char*);

-BOOLEAN RecorreGruposAulas(Database, char*);

-BOOLEAN RecorreAulas(Database, char*);

-BOOLEAN RecorreGruposOrdenadores(Database, char*);

-BOOLEAN RecorreOrdenadores(Database, char*);

-