git-svn-id: https://opengnsys.es/svn/trunk@1314 a21b9725-9963-47de-94b9-378ad31fedc9

2 files changed, 3145 insertions, 0 deletions

diff --git a/sources/ogAdmServer.cpp b/sources/ogAdmServer.cpp
new file mode 100644
index 0000000..25316df
--- /dev/null
+++ b/sources/ogAdmServer.cpp
@@ -0,0 +1,3027 @@
+// ********************************************************************************************************
+// Servicio: ogAdmServer
+// 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: ogAdmServer.cpp
+// Descripción :Este fichero implementa el servicio de administración general del sistema
+// ********************************************************************************************************
+#include "ogAdmServer.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;
+	aulaup[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]);
+		resul = strcmp(StrToUpper(dualparametro[0]), "AULAUP");
+		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);
+	}
+	if (aulaup[0] == (char) NULL) {
+		strcpy(aulaup, "0"); // Por defecto el conmutador de registro automático esta en off
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: gestionaTrama
+//
+//		Descripción:
+//			Procesa las tramas recibidas .
+//		Parametros:
+//			- s : Socket usado para comunicaciones
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN gestionaTrama(SOCKET *socket_c)
+{
+	TRAMA* ptrTrama;
+	int i, res;
+	char *nfn;
+	char modulo[] = "gestionaTrama()";
+
+	ptrTrama=recibeTrama(socket_c);
+	if (ptrTrama){
+		INTROaFINCAD(ptrTrama);
+		nfn = copiaParametro("nfn",ptrTrama); // Toma dirección/es IP
+		for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
+			res = strcmp(tbfuncionesServer[i].nf, nfn);
+			if (res == 0) { // Encontrada la función que procesa el mensaje
+				return (tbfuncionesServer[i].fptr(socket_c, ptrTrama)); // Invoca la función
+			}
+		}
+		/* Sólo puede ser un comando personalizado o su notificación */
+		if (ptrTrama->tipo == MSG_COMANDO)
+			return (Comando(socket_c, ptrTrama));
+		else {
+			if (ptrTrama->tipo == MSG_NOTIFICACION)
+				return (RESPUESTA_Comando(socket_c, ptrTrama));
+			else
+				errorLog(modulo, 18, FALSE); // No se reconoce el mensaje
+		}
+	}
+	else
+		errorLog(modulo, 17, FALSE); // Error en la recepción
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Sondeo
+//
+//	Descripción:
+//		Solicita a los clientes su disponibiliad para recibir comandos interactivos
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN Sondeo(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Sondeo()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: respuestaSondeo
+//
+//	Descripción:
+//		Recupera el estatus de los ordenadores solicitados leyendo la tabla de sockets
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN respuestaSondeo(SOCKET *socket_c, TRAMA* ptrTrama) {
+	int i;
+	long lSize;
+	char *iph, *Ipes;
+	char modulo[] = "respuestaSondeo()";
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP
+	lSize = strlen(iph); // Calcula longitud de la cadena de direccion/es IPE/S
+	Ipes = (char*) reservaMemoria(lSize + 1);
+	if (Ipes == NULL) {
+		errorLog(modulo, 3, FALSE);
+		return (FALSE);
+	}
+	strcpy(Ipes, iph); // Copia cadena de IPES
+	initParametros(ptrTrama,0);
+	strcpy(ptrTrama->parametros, "tso="); // Compone retorno tso (sistemas operativos de los clientes )
+	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
+		if (strncmp(tbsockets[i].ip, "\0", 1) != 0) { // Si es un cliente activo
+			if (contieneIP(Ipes, tbsockets[i].ip)) { // Si existe la IP en la cadena
+				strcat(ptrTrama->parametros, tbsockets[i].ip); // Compone retorno
+				strcat(ptrTrama->parametros, "/"); // "ip/sistema operativo;"
+				strcat(ptrTrama->parametros, tbsockets[i].estado);
+				strcat(ptrTrama->parametros, ";");
+			}
+		}
+	}
+	strcat(ptrTrama->parametros, "\r");
+	if (!mandaTrama(socket_c, ptrTrama)) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Actualizar
+//
+//	Descripción:
+//		Obliga a los clientes a iniciar sesión en el sistema
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN Actualizar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Actualizar()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Purgar
+//
+//	Descripción:
+//		Detiene la ejecución del browser en el cliente
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN Purgar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Purgar()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: ConsolaRemota
+//
+//	Descripción:
+// 		Envia un script al cliente, éste lo ejecuta y manda el archivo que genera la salida por pantalla
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN ConsolaRemota(SOCKET *socket_c, TRAMA* ptrTrama)
+{
+	char *iph,fileco[LONPRM],msglog[LONSTD],*ptrIpes[MAXIMOS_CLIENTES];;
+	FILE* f;
+	int i,lon;
+	char modulo[] = "ConsolaRemota()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	INTROaFINCAD(ptrTrama);
+	/* Destruye contenido del fichero de eco anterior */
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
+	lon = splitCadena(ptrIpes,iph,';');
+	for (i = 0; i < lon; i++) {
+		sprintf(fileco,"/tmp/_Seconsola_%s",ptrIpes[i]); // Nombre que tendra el archivo en el Servidor
+		f = fopen(fileco, "wt");
+		fclose(f);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: EcoConsola
+//
+//	Descripción:
+//		Solicita el eco de una consola remota almacenado en un archivo de eco
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN EcoConsola(SOCKET *socket_c, TRAMA* ptrTrama)
+{
+	char *iph,fileco[LONPRM],*buffer;
+	int lSize;
+	char modulo[] = "EcoConsola()";
+
+	INTROaFINCAD(ptrTrama);
+	// Lee archivo de eco de consola
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
+	sprintf(fileco,"/tmp/_Seconsola_%s",iph); // Nombre del archivo en el Servidor
+	lSize=lonArchivo(fileco);
+	if(lSize>0){ // Si el fichero tiene contenido...
+		initParametros(ptrTrama,lSize+LONGITUD_PARAMETROS);
+		buffer=leeArchivo(fileco);
+		sprintf(ptrTrama->parametros,"res=%s\r",buffer);
+	}
+	else{
+		initParametros(ptrTrama,0);
+		sprintf(ptrTrama->parametros,"res=\r");
+	}
+	ptrTrama->tipo=MSG_RESPUESTA; // Tipo de mensaje
+	if (!mandaTrama(socket_c, ptrTrama)) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: clienteDisponible
+//
+//	Descripción:
+//		Comprueba la disponibilidad del cliente para recibir comandos interactivos
+//	Parametros:
+//		- ip : La ip del cliente a buscar
+//		- idx: (Salida)  Indice que ocupa el cliente, de estar ya registrado
+//	Devuelve:
+//		TRUE: Si el cliente está disponible
+//		FALSE: En caso contrario
+// ________________________________________________________________________________________________________
+BOOLEAN clienteDisponible(char *ip, int* idx) {
+	int estado;
+
+	if (clienteExistente(ip, idx)) {
+		estado = strcmp(tbsockets[*idx].estado, CLIENTE_OCUPADO); // Cliente ocupado
+		if (estado == 0)
+			return (FALSE);
+
+		estado = strcmp(tbsockets[*idx].estado, CLIENTE_APAGADO); // Cliente apagado
+		if (estado == 0)
+			return (FALSE);
+
+		estado = strcmp(tbsockets[*idx].estado, CLIENTE_INICIANDO); // Cliente en proceso de inclusión
+		if (estado == 0)
+			return (FALSE);
+
+		return (TRUE); // En caso contrario el cliente está disponible
+	}
+	return (FALSE); // Cliente no está registrado en el sistema
+}
+// ________________________________________________________________________________________________________
+// Función: clienteExistente
+//
+//	Descripción:
+//		Comprueba si el cliente está registrado en la tabla de socket del sistema
+//	Parametros:
+//		- ip : La ip del cliente a buscar
+//		- idx:(Salida)  Indice que ocupa el cliente, de estar ya registrado
+//	Devuelve:
+//		TRUE: Si el cliente está registrado
+//		FALSE: En caso contrario
+// ________________________________________________________________________________________________________
+BOOLEAN clienteExistente(char *ip, int* idx) {
+	int i;
+	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
+		if (contieneIP(ip, tbsockets[i].ip)) { // Si existe la IP en la cadena
+			*idx = i;
+			return (TRUE);
+		}
+	}
+	return (FALSE);
+}
+// ________________________________________________________________________________________________________
+// Función: hayHueco
+// 
+// 	Descripción:
+// 		Esta función devuelve TRUE o FALSE dependiendo de que haya hueco en la tabla de sockets para un nuevo cliente.
+// 	Parametros:
+// 		- idx:   Primer indice libre que se podrn utilizar
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN hayHueco(int *idx) {
+	int i;
+
+	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
+		if (strncmp(tbsockets[i].ip, "\0", 1) == 0) { // Hay un hueco
+			*idx = i;
+			return (TRUE);
+		}
+	}
+	return (FALSE);
+}
+// ________________________________________________________________________________________________________
+// Función: InclusionCliente
+//
+//	Descripción:
+//		Esta función incorpora el socket de un nuevo cliente a la tabla de clientes y le devuelve alguna de sus propiedades:
+//		nombre, identificador, tamaño de la caché , etc ...
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 InclusionCliente(SOCKET *socket_c, TRAMA *ptrTrama) {
+	char modulo[] = "InclusionCliente()";
+
+	if (!procesoInclusionCliente(socket_c, ptrTrama)) { // Ha habido algún error...
+		initParametros(ptrTrama,0);
+		strcpy(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\rres=0\r");
+		if (!mandaTrama(socket_c, ptrTrama)) {
+			errorLog(modulo, 26, FALSE);
+			return (FALSE);
+		}
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: procesoInclusionCliente
+//
+//	Descripción:
+//		Implementa el proceso de inclusión en el sistema del Cliente
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 procesoInclusionCliente(SOCKET *socket_c, TRAMA *ptrTrama) {
+	char msglog[LONSTD], sqlstr[LONSQL];
+	Database db;
+	Table tbl;
+
+	char *iph, *cfg;
+	char nombreordenador[LONFIL];
+	int lon, resul, idordenador, idmenu, cache, idproautoexec, idaula, idcentro;
+	char modulo[] = "InclusionCliente()";
+
+	// Toma parámetros
+	iph = copiaParametro("iph",ptrTrama); // Toma ip
+	cfg = copiaParametro("cfg",ptrTrama); // Toma configuracion
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	// Recupera los datos del cliente
+	sprintf(sqlstr,
+			"SELECT ordenadores.*,aulas.idaula,centros.idcentro FROM ordenadores "
+				" INNER JOIN aulas ON aulas.idaula=ordenadores.idaula"
+				" INNER JOIN centros ON centros.idcentro=aulas.idcentro"
+				" WHERE ordenadores.ip = '%s'", iph);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	if (tbl.ISEOF()) { // Si no existe el cliente
+		errorLog(modulo, 22, FALSE);
+		return (FALSE);
+	}
+
+	if (ndebug == DEBUG_ALTO) {
+		sprintf(msglog, "%s IP:%s", tbMensajes[2], iph);
+		infoDebug(msglog);
+	}
+	if (!tbl.Get("idordenador", idordenador)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("nombreordenador", nombreordenador)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idmenu", idmenu)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("cache", cache)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idproautoexec", idproautoexec)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idaula", idaula)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idcentro", idcentro)) {
+		tbl.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	resul = actualizaConfiguracion(db, tbl, cfg, idordenador); // Actualiza la configuración del ordenador
+	db.Close();
+
+	if (!resul) {
+		errorLog(modulo, 29, FALSE);
+		return (FALSE);
+	}
+
+	if (!registraCliente(iph)) { // Incluyendo al cliente en la tabla de sokets
+		errorLog(modulo, 25, FALSE);
+		return (FALSE);
+	}
+
+	/*------------------------------------------------------------------------------------------------------------------------------
+	 Prepara la trama de respuesta
+	 -------------------------------------------------------------------------------------------------------------------------------*/
+	initParametros(ptrTrama,0);
+	ptrTrama->tipo=MSG_RESPUESTA;
+	lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\r");
+	lon += sprintf(ptrTrama->parametros + lon, "ido=%d\r", idordenador);
+	lon += sprintf(ptrTrama->parametros + lon, "npc=%s\r", nombreordenador);
+	lon += sprintf(ptrTrama->parametros + lon, "che=%d\r", cache);
+	lon += sprintf(ptrTrama->parametros + lon, "exe=%d\r", idproautoexec);
+	lon += sprintf(ptrTrama->parametros + lon, "ida=%d\r", idaula);
+	lon += sprintf(ptrTrama->parametros + lon, "idc=%d\r", idcentro);
+	lon += sprintf(ptrTrama->parametros + lon, "res=%d\r", 1); // Confirmación proceso correcto
+
+	if (!mandaTrama(socket_c, ptrTrama)) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: actualizaConfiguracion
+//
+//	Descripción:
+//		Esta función actualiza la base de datos con la configuracion de particiones de un cliente
+//	Parámetros:
+//		- db: Objeto base de datos (ya operativo)
+//		- tbl: Objeto tabla
+//		- cfg: cadena con una Configuración
+//		- ido: Identificador del ordenador cliente
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+//	Especificaciones:
+//		Los parametros de la configuración son:
+//			par= Número de partición
+//			cpt= Codigo o tipo de partición
+//			sfi= Sistema de ficheros que está implementado en la partición
+//			soi= Nombre del sistema de ficheros instalado en la partición
+//			tam= Tamaño de la partición
+// ________________________________________________________________________________________________________
+BOOLEAN actualizaConfiguracion(Database db, Table tbl, char* cfg, int ido)
+{
+	char msglog[LONSTD], sqlstr[LONSQL];
+	int lon, p, c, i, dato, swu, idsoi, idsfi,k;
+	char *ptrPar[MAXPAR], *ptrCfg[5], *ptrDual[2], tbPar[LONSTD];
+	char *par, *cpt, *sfi, *soi, *tam; // Parametros que definen una partición
+	char modulo[] = "actualizaConfiguracion()";
+
+	lon = sprintf(tbPar, "(");
+	p = splitCadena(ptrPar, cfg, '\n');
+	for (i = 0; i < p; i++) {
+		c = splitCadena(ptrCfg, ptrPar[i], '\t');
+		par = cpt = sfi = soi = tam = NULL;
+		splitCadena(ptrDual, ptrCfg[0], '=');
+		par = ptrDual[1]; // Número de partición
+
+		splitCadena(ptrDual, ptrCfg[1], '=');
+		cpt = ptrDual[1]; // Código de partición
+
+		k=splitCadena(ptrDual, ptrCfg[2], '=');
+		if(k==2){
+			sfi = ptrDual[1]; // Sistema de ficheros
+			/* Comprueba existencia del sistema de ficheros instalado */
+			idsfi = checkDato(db, tbl, sfi, "sistemasficheros", "descripcion","idsistemafichero");
+		}
+		else
+			idsfi=0;
+
+		k=splitCadena(ptrDual, ptrCfg[3], '=');
+		if(k==2){ // Sistema operativo detecdtado
+			soi = ptrDual[1]; // Nombre del S.O. instalado
+			/* Comprueba existencia del sistema operativo instalado */
+			idsoi = checkDato(db, tbl, soi, "nombresos", "nombreso", "idnombreso");
+		}
+		else
+			idsoi=0;
+
+		splitCadena(ptrDual, ptrCfg[4], '=');
+		tam = ptrDual[1]; // Tamaño de la partición
+
+		lon += sprintf(tbPar + lon, "%s,", par);
+
+		sprintf(
+				sqlstr,
+				"SELECT numpar,codpar,tamano,idsistemafichero,idnombreso"
+					" FROM ordenadores_particiones WHERE idordenador=%d AND numpar=%s",
+				ido, par);
+		if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+			errorLog(modulo, 21, FALSE);
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if (tbl.ISEOF()) { // Si no existe el registro
+			sprintf(
+					sqlstr,
+					"INSERT INTO ordenadores_particiones(idordenador,numpar,codpar,tamano,idsistemafichero,idnombreso,idimagen)"
+						" VALUES(%d,%s,0x%s,%s,%d,%d,0)", ido, par, cpt, tam,
+					idsfi, idsoi);
+
+			if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+				db.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+		} else { // Existe el registro
+			swu = TRUE; // Se supone que algún dato ha cambiado
+			if (!tbl.Get("codpar", dato)) { // Toma dato
+				tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			if (atoi(cpt) == dato) {// Parámetro tipo de partición igual al almacenado
+				if (!tbl.Get("tamano", dato)) { // Toma dato
+					tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+					errorInfo(modulo, msglog);
+					return (FALSE);
+				}
+				if (atoi(tam) == dato) {// Parámetro tamaño igual al almacenado
+					if (!tbl.Get("idsistemafichero", dato)) { // Toma dato
+						tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+						errorInfo(modulo, msglog);
+						return (FALSE);
+					}
+					if (idsfi == dato) {// Parámetro sistema de fichero igual al almacenado
+						if (!tbl.Get("idnombreso", dato)) { // Toma dato
+							tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+							errorInfo(modulo, msglog);
+							return (FALSE);
+						}
+						if (idsoi == dato) {// Parámetro sistema de fichero distinto al almacenado
+							swu = FALSE; // Todos los parámetros de la partición son iguales, no se actualiza
+						}
+					}
+				}
+			}
+			if (swu) { // Hay que actualizar los parámetros de la partición
+				sprintf(sqlstr, "UPDATE ordenadores_particiones SET "
+					" codpar=0x%s,"
+					" tamano=%s,"
+					" idsistemafichero=%d,"
+					" idnombreso=%d,"
+					" idimagen=%d,"
+					" idperfilsoft=%d"
+					" WHERE idordenador=%d AND numpar=%s"\
+, cpt, tam, idsfi,
+						idsoi, 0, 0, ido, par);
+
+				if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+					errorLog(modulo, 21, FALSE);
+					db.GetErrorErrStr(msglog);
+					errorInfo(modulo, msglog);
+					return (FALSE);
+				}
+			}
+		}
+	}
+	lon += sprintf(tbPar + lon, "%d)", 0);
+	// Eliminar particiones almacenadas que ya no existen
+	sprintf(
+			sqlstr,
+			"DELETE FROM ordenadores_particiones WHERE idordenador=%d AND numpar NOT IN %s",
+			ido, tbPar);
+	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: checkDato
+//
+//	Descripción:
+//		 Esta función comprueba si existe un dato en una tabla y si no es así lo incluye. devuelve en
+//		cualquier caso el identificador del registro existenet o del insertado
+//	Parámetros:
+//		- db: Objeto base de datos (ya operativo)
+//		- tbl: Objeto tabla
+//		- dato: Dato
+//		- tabla: Nombre de la tabla
+//		- nomdato: Nombre del dato en la tabla
+//		- nomidentificador: Nombre del identificador en la tabla
+//	Devuelve:
+//		El identificador del registro existente o el del insertado
+//
+//	Especificaciones:
+//		En caso de producirse algún error se devuelve el valor 0
+// ________________________________________________________________________________________________________
+
+int checkDato(Database db, Table tbl, char *dato, const char*tabla,
+		const char* nomdato, const char *nomidentificador) {
+	char msglog[LONSTD], sqlstr[LONSQL];
+	char modulo[] = "checkDato()";
+	int identificador;
+
+	if (strlen(dato) == 0)
+		return (0); // EL dato no tiene valor
+	sprintf(sqlstr, "SELECT %s FROM %s WHERE %s ='%s'", nomidentificador,
+			tabla, nomdato, dato);
+
+	// Ejecuta consulta
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (0);
+	}
+	if (tbl.ISEOF()) { //  Software NO existente
+		sprintf(sqlstr, "INSERT INTO %s (%s) VALUES('%s')", tabla, nomdato,
+				dato);
+		if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+			db.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (0);
+		}
+		// Recupera el identificador del software
+		sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
+		if (!db.Execute(sqlstr, tbl)) { // Error al leer
+			db.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (0);
+		}
+		if (!tbl.ISEOF()) { // Si existe registro
+			if (!tbl.Get("identificador", identificador)) {
+				tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (0);
+			}
+		}
+	} else {
+		if (!tbl.Get(nomidentificador, identificador)) { // Toma dato
+			tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (0);
+		}
+	}
+	return (identificador);
+}
+// ________________________________________________________________________________________________________
+// Función: registraCliente
+//
+//	Descripción:
+//		 Incluye al cliente en la tabla de sokets
+//	Parámetros:
+//		- iph: Dirección ip del cliente
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN registraCliente(char *iph) {
+	int idx;
+
+	if (!clienteExistente(iph, &idx)) { // Si no existe la IP ...
+		if (!hayHueco(&idx)) { // Busca hueco para el nuevo cliente
+			return (FALSE); // No hay huecos
+		}
+	}
+	strcpy(tbsockets[idx].ip, iph); // Copia IP
+	strcpy(tbsockets[idx].estado, CLIENTE_INICIANDO); // Actualiza el estado del cliente
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: AutoexecCliente
+//
+//	Descripción:
+//		Envía archivo de autoexec al cliente
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 AutoexecCliente(SOCKET *socket_c, TRAMA *ptrTrama) {
+	int lon;
+	char *iph, *exe, msglog[LONSTD];
+	Database db;
+	FILE *fileexe;
+	char fileautoexec[LONPRM];
+	char parametros[LONGITUD_PARAMETROS];
+	char modulo[] = "AutoexecCliente()";
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección IP del cliente
+	exe = copiaParametro("exe",ptrTrama); // Toma identificador del procedimiento inicial
+
+	sprintf(fileautoexec, "/tmp/Sautoexec-%s", iph);
+	fileexe = fopen(fileautoexec, "wb"); // Abre fichero de script
+	if (fileexe == NULL) {
+		errorLog(modulo, 52, FALSE);
+		return (FALSE);
+	}
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	initParametros(ptrTrama,0);
+	if (recorreProcedimientos(db, parametros, fileexe, exe)) {
+		lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_AutoexecCliente\r");
+		lon += sprintf(ptrTrama->parametros + lon, "nfl=%s\r", fileautoexec);
+		lon += sprintf(ptrTrama->parametros + lon, "res=1\r");
+	} else {
+		lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_AutoexecCliente\r");
+		lon += sprintf(ptrTrama->parametros + lon, "res=0\r");
+	}
+
+	fclose(fileexe);
+
+	if (!mandaTrama(socket_c, ptrTrama)) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: recorreProcedimientos
+//
+//	Descripción:
+//		Crea un archivo con el código de un procedimiento separando cada comando  por un salto de linea
+//	Parámetros:
+//		Database db,char* parametros,FILE* fileexe,char* idp
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN recorreProcedimientos(Database db, char* parametros, FILE* fileexe,
+		char* idp) {
+	int procedimientoid, lsize;
+	char idprocedimiento[LONPRM], msglog[LONSTD], sqlstr[LONSQL];
+	Table tbl;
+	char modulo[] = "recorreProcedimientos()";
+
+	/* Busca procedimiento */
+	sprintf(sqlstr,
+			"SELECT procedimientoid,parametros FROM procedimientos_acciones"
+				" WHERE idprocedimiento=%s ORDER BY orden", idp);
+	// Ejecuta consulta
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	while (!tbl.ISEOF()) { // Recorre procedimientos
+		if (!tbl.Get("procedimientoid", procedimientoid)) { // Toma dato
+			tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if (procedimientoid > 0) { // Procedimiento recursivo
+			sprintf(idprocedimiento, "%d", procedimientoid);
+			if (!recorreProcedimientos(db, parametros, fileexe, idprocedimiento)) {
+				return (FALSE);
+			}
+		} else {
+			if (!tbl.Get("parametros", parametros)) { // Toma dato
+				tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			strcat(parametros, "@");
+			lsize = strlen(parametros);
+			fwrite(parametros, 1, lsize, fileexe); // Escribe el código a ejecutar
+		}
+		tbl.MoveNext();
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: ComandosPendientes
+//
+//	Descripción:
+//		Esta función busca en la base de datos,comandos pendientes de ejecutar por un  ordenador  concreto
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 ComandosPendientes(SOCKET *socket_c, TRAMA *ptrTrama) {
+	char *ido, pids[LONPRM], iph[LONIP];
+	int ids, idx;
+	char modulo[] = "ComandosPendientes()";
+
+	strcpy(iph, copiaParametro("iph",ptrTrama)); // Toma direción IP
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!clienteExistente(iph, &idx)) { // Busca índice del cliente
+		errorLog(modulo, 47, FALSE);
+		return (FALSE);
+	}
+	if (buscaComandos(ido, ptrTrama, &ids)) { // Existen comandos pendientes
+		ptrTrama->tipo = MSG_COMANDO;
+		sprintf(pids, "\rids=%d\r", ids);
+		strcat(ptrTrama->parametros, pids);
+		strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO);
+	} else {
+		initParametros(ptrTrama,0);
+		strcpy(ptrTrama->parametros, "nfn=NoComandosPtes\r");
+	}
+	if (!mandaTrama(socket_c, ptrTrama)) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: buscaComandos
+//
+//	Descripción:
+//		Busca en la base de datos,comandos pendientes de ejecutar por el cliente
+//	Parámetros:
+//		- ido: Identificador del ordenador
+//		- cmd: Parámetros del comando (Salida)
+//		- ids: Identificador de la acción (Salida)
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN buscaComandos(char *ido, TRAMA *ptrTrama, int *ids)
+{
+	char msglog[LONSTD], sqlstr[LONSQL];
+	Database db;
+	Table tbl;
+	int lonprm;
+
+	char modulo[] = "buscaComandos()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	sprintf(sqlstr,"SELECT sesion,parametros,length( parametros) as lonprm"\
+			" FROM acciones WHERE idordenador=%s AND estado='%d' ORDER BY idaccion", ido, ACCION_INICIADA);
+	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (tbl.ISEOF()) {
+		db.Close();
+		return (FALSE); // No hay comandos pendientes
+	} else { // Busca entre todas las acciones de diversos ambitos
+		if (!tbl.Get("sesion", *ids)) { // Toma identificador de la acción
+			tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if (!tbl.Get("lonprm", lonprm)) { // Toma parámetros del comando
+			tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if(!initParametros(ptrTrama,lonprm+LONGITUD_PARAMETROS)){
+			db.Close();
+			errorLog(modulo, 3, FALSE);
+			return (FALSE);
+		}
+		if (!tbl.Get("parametros", ptrTrama->parametros)) { // Toma parámetros del comando
+			tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+	}
+	db.Close();
+	return (TRUE); // Hay comandos pendientes, se toma el primero de la cola
+}
+// ________________________________________________________________________________________________________
+// Función: DisponibilidadComandos
+//
+//	Descripción:
+//		Esta función habilita a un cliente para recibir comandos desde la consola
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 DisponibilidadComandos(SOCKET *socket_c, TRAMA *ptrTrama) {
+	char *iph, *tpc;
+	int idx;
+	char modulo[] = "DisponibilidadComandos()";
+
+	iph = copiaParametro("iph",ptrTrama); // Toma ip
+	tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.)
+
+	if (!clienteExistente(iph, &idx)) { // Busca índice del cliente
+		errorLog(modulo, 47, FALSE);
+		return (FALSE);
+	}
+	strcpy(tbsockets[idx].estado, tpc);
+	tbsockets[idx].sock = *socket_c;
+	swcSocket = TRUE; // El socket permanece abierto para recibir comandos desde el servidor
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: respuestaEstandar
+//
+//	Descripción:
+//		Esta función actualiza la base de datos con el resultado de la ejecución de un comando con seguimiento
+//	Parámetros:
+//		- res: resultado de la ejecución del comando
+//		- der: Descripción del error si hubiese habido
+//		- iph: Dirección IP
+//		- ids: identificador de la acción notificada
+//		- ido: Identificador del ordenador que notifica
+//		- db: Objeto base de datos (operativo)
+//		- tbl: Objeto tabla
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN respuestaEstandar(TRAMA *ptrTrama, char *iph, char *ido, Database db,
+		Table tbl) {
+	char msglog[LONSTD], sqlstr[LONSQL];
+	char *res, *ids, *der;
+	char fechafin[LONPRM];
+	struct tm* st;
+	char modulo[] = "respuestaEstandar()";
+
+	res = copiaParametro("res",ptrTrama); // Toma resultado
+	ids = copiaParametro("ids",ptrTrama); // Toma identificador de la sesión
+	der = copiaParametro("der",ptrTrama); // Toma descripción del error (si hubiera habido)
+
+	if (ids == NULL) // No existe seguimiento de la acción
+		return (TRUE);
+
+	sprintf(sqlstr,
+			"SELECT * FROM acciones WHERE idordenador=%s AND sesion=%s", ido,
+			ids);
+	if (!db.Execute(sqlstr, tbl)) { // Error al consultar
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (tbl.ISEOF()) { // No existe registro de acciones
+		errorLog(modulo, 31, FALSE);
+		return (TRUE);
+	}
+
+	st = tomaHora();
+	sprintf(fechafin, "%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 resultado='%s',estado='%d',fechahorafin='%s',descrinotificacion='%s'"\
+			" WHERE idordenador=%s AND sesion=%s",
+			res, ACCION_FINALIZADA, fechafin, der, ido, ids);
+	if (!db.Execute(sqlstr, tbl)) { // Error al actualizar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	if (atoi(res) == ACCION_FALLIDA)
+		return (FALSE); // Error en la ejecución del comando
+
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: enviaComando
+//
+//	Descripción:
+//		Envía un comando a los clientes
+//	Parámetros:
+//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
+//		- estado: Estado en el se deja al cliente mientras se ejecuta el comando
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN enviaComando(TRAMA* ptrTrama, const char *estado) {
+	char *iph, *Ipes, *ptrIpes[MAXIMOS_CLIENTES];
+	int i, idx, lon;
+	char modulo[] = "enviaComando()";
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP
+	lon = strlen(iph); // Calcula longitud de la cadena de direccion/es IPE/S
+	Ipes = (char*) reservaMemoria(lon + 1);
+	if (Ipes == NULL) {
+		errorLog(modulo, 3, FALSE);
+		return (FALSE);
+	}
+	strcpy(Ipes, iph); // Copia cadena de IPES
+	lon = splitCadena(ptrIpes, Ipes, ';');
+	FINCADaINTRO(ptrTrama);
+	for (i = 0; i < lon; i++) {
+		if (clienteDisponible(ptrIpes[i], &idx)) { // Si el cliente puede recibir comandos
+			strcpy(tbsockets[idx].estado, estado); // Actualiza el estado del cliente
+			if (!mandaTrama(&tbsockets[idx].sock, ptrTrama)) {
+				errorLog(modulo, 26, FALSE);
+				return (FALSE);
+			}
+			close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad
+		}
+	}
+	return (TRUE);
+}
+//______________________________________________________________________________________________________
+// Función: respuestaConsola
+//
+//	Descripción:
+// 		Envia una respuesta a la consola sobre el resultado de la ejecución de un comando
+//	Parámetros:
+//		- socket_c: (Salida) Socket utilizado para el envío
+//		- res: Resultado del envío del comando
+// 	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN respuestaConsola(SOCKET *socket_c, TRAMA *ptrTrama, int res) {
+	char modulo[] = "respuestaConsola()";
+	initParametros(ptrTrama,0);
+	sprintf(ptrTrama->parametros, "res=%d\r", res);
+	if (!mandaTrama(socket_c, ptrTrama)) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Arrancar
+//
+//	Descripción:
+//		Procesa el comando Apagar
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 Arrancar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char *mac, msglog[LONSTD];
+	char modulo[] = "Arrancar()";
+
+	mac = copiaParametro("mac",ptrTrama); // Toma dirección/es MAC
+	if (!Levanta(mac)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Levanta
+//
+//	Descripción:
+//		Enciende ordenadores a través de la red cuyas macs se pasan como parámetro
+//	Parámetros:
+//		- mac: Cadena de direcciones mac separadas por ";"
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN Levanta(char *mac) {
+	char *ptrMacs[MAXIMOS_CLIENTES];
+	int i, lon, res;
+	SOCKET s;
+	BOOLEAN bOpt;
+	sockaddr_in local;
+	char modulo[] = "Levanta()";
+
+	/* Creación de socket para envío de magig packet */
+	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (s == SOCKET_ERROR) { // Error al crear el socket del servicio
+		errorLog(modulo, 13, TRUE);
+		return (FALSE);
+	}
+	bOpt = TRUE; // Pone el socket en modo Broadcast
+	res = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *) &bOpt, sizeof(bOpt));
+	if (res == SOCKET_ERROR) {
+		errorLog(modulo, 48, TRUE);
+		return (FALSE);
+	}
+	local.sin_family = AF_INET;
+	local.sin_port = htons((short) PUERTO_WAKEUP);
+	local.sin_addr.s_addr = htonl(INADDR_ANY); // cualquier interface
+	if (bind(s, (sockaddr *) &local, sizeof(local)) == SOCKET_ERROR) {
+		errorLog(modulo, 14, TRUE);
+		exit(EXIT_FAILURE);
+	}
+	/* fin creación de socket */
+	lon = splitCadena(ptrMacs, mac, ';');
+	for (i = 0; i < lon; i++) {
+		if (!WakeUp(&s, ptrMacs[i])) {
+			errorLog(modulo, 49, TRUE);
+			close(s);
+			return (FALSE);
+		}
+	}
+	close(s);
+	return (TRUE);
+}
+//_____________________________________________________________________________________________________________
+// Función: WakeUp
+//
+//	 Descripción:
+//		Enciende el ordenador cuya MAC se pasa como parámetro
+//	Parámetros:
+//		- s : Socket para enviar trama magic packet
+//		- mac : Cadena con la dirección mac en formato XXXXXXXXXXXX
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+//_____________________________________________________________________________________________________________
+BOOLEAN WakeUp(SOCKET *s, char *mac) {
+	int i, res;
+	char HDaddress_bin[6];
+	struct {
+		BYTE secuencia_FF[6];
+		char macbin[16][6];
+	} Trama_WakeUp;
+	sockaddr_in WakeUpCliente;
+	char modulo[] = "WakeUp()";
+
+	for (i = 0; i < 6; i++) // Primera secuencia de la trama Wake Up (0xFFFFFFFFFFFF)
+		Trama_WakeUp.secuencia_FF[i] = 0xFF;
+
+	PasaHexBin(mac, HDaddress_bin); // Pasa a binario la MAC
+
+	for (i = 0; i < 16; i++) // Segunda secuencia de la trama Wake Up , repetir 16 veces su la MAC
+		memcpy(&Trama_WakeUp.macbin[i][0], &HDaddress_bin, 6);
+
+	/* Creación de socket del cliente que recibe la trama magic packet */
+	WakeUpCliente.sin_family = AF_INET;
+	WakeUpCliente.sin_port = htons((short) PUERTO_WAKEUP);
+	WakeUpCliente.sin_addr.s_addr = htonl(INADDR_BROADCAST); //  Para hacerlo con broadcast
+
+	res = sendto(*s, (char *) &Trama_WakeUp, sizeof(Trama_WakeUp), 0,
+			(sockaddr *) &WakeUpCliente, sizeof(WakeUpCliente));
+	if (res == SOCKET_ERROR) {
+		errorLog(modulo, 26, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+//_____________________________________________________________________________________________________________
+// Función: PasaHexBin
+//
+//	Descripción:
+//		Convierte a binario una dirección mac desde una cadena con formato XXXXXXXXXXXX
+//
+//	Parámetros de entrada:
+//		- cadena : Cadena con el contenido de la mac
+//		- numero : la dirección mac convertida a binario (6 bytes)
+//_____________________________________________________________________________________________________________
+void PasaHexBin(char *cadena, char *numero) {
+	int i, j, p;
+	char matrizHex[] = "0123456789ABCDEF";
+	char Ucadena[12], aux;
+
+	for (i = 0; i < 12; i++)
+		Ucadena[i] = toupper(cadena[i]);
+	p = 0;
+	for (i = 0; i < 12; i++) {
+		for (j = 0; j < 16; j++) {
+			if (Ucadena[i] == matrizHex[j]) {
+				if (i % 2) {
+					aux = numero[p];
+					aux = (aux << 4);
+					numero[p] = j;
+					numero[p] = numero[p] | aux;
+					p++;
+				} else
+					numero[p] = j;
+				break;
+			}
+		}
+	}
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_Arrancar
+//
+//	Descripción:
+//		Respuesta del cliente al comando Apagar
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_Arrancar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	int i;
+	char *iph, *ido;
+	char *tpc;
+	char modulo[] = "RESPUESTA_Arrancar()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.)
+	if (clienteExistente(iph, &i)) // Actualiza estado
+		strcpy(tbsockets[i].estado, tpc);
+
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Comando
+//
+//	Descripción:
+//		Procesa un comando personalizado
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 Comando(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Comando()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_Comando
+//
+//	Descripción:
+//		Respuesta del cliente al un comando personalizado
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_Comando(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *ido;
+	char modulo[] = "RESPUESTA_Comando()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Apagar
+//
+//	Descripción:
+//		Procesa el comando Apagar
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 Apagar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Apagar()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_Apagar
+//
+//	Descripción:
+//		Respuesta del cliente al comando Apagar
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_Apagar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	int i;
+	char *iph, *ido;
+	char modulo[] = "RESPUESTA_Apagar()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	if (clienteExistente(iph, &i)) // Actualiza estado
+		strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
+
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Reiniciar
+//
+//	Descripción:
+//		Procesa el comando Reiniciar
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 Reiniciar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Reiniciar()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_Reiniciar
+//
+//	Descripción:
+//		Respuesta del cliente al comando Reiniciar
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_Reiniciar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	int i;
+	char *iph, *ido;
+	char modulo[] = "RESPUESTA_Reiniciar()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	if (clienteExistente(iph, &i)) // Actualiza estado
+		strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
+
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: IniciarSesion
+//
+//	Descripción:
+//		Procesa el comando Iniciar Sesión
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 IniciarSesion(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "IniciarSesion()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_IniciarSesion
+//
+//	Descripción:
+//		Respuesta del cliente al comando Iniciar Sesión
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_IniciarSesion(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	int i;
+	char *iph, *ido;
+	char modulo[] = "RESPUESTA_IniciarSesion()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	if (clienteExistente(iph, &i)) // Actualiza estado
+		strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
+
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: CrearImagen
+//
+//	Descripción:
+//		Crea una imagen de una partición de un disco y la guarda o bien en un repositorio
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 CrearImagen(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "CrearImagen()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_CrearImagen
+//
+//	Descripción:
+//		Respuesta del cliente al comando CrearImagen
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_CrearImagen(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *par, *cpt, *ipr, *ido;
+	char *idi;
+	char modulo[] = "RESPUESTA_CrearImagen()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	// Acciones posteriores
+	idi = copiaParametro("idi",ptrTrama);
+	par = copiaParametro("par",ptrTrama);
+	cpt = copiaParametro("cpt",ptrTrama);
+	ipr = copiaParametro("ipr",ptrTrama);
+
+	if (!actualizaCreacionImagen(db, tbl, idi, par, cpt, ipr, ido)) {
+		errorLog(modulo, 53, FALSE);
+		db.Close(); // Cierra conexión
+		return (FALSE);
+	}
+
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: actualizaCreacionImagen
+//
+//	Descripción:
+//		Esta función actualiza la base de datos con el resultado de la creación de una imagen
+//	Parámetros:
+//		- db: Objeto base de datos (ya operativo)
+//		- tbl: Objeto tabla
+//		- idi: Identificador de la imagen
+//		- par: Partición de donde se creó
+//		- cpt: Código de partición
+//		- ipr: Ip del repositorio
+//		- ido: Identificador del ordenador modelo
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN actualizaCreacionImagen(Database db, Table tbl, char* idi, char* par,
+		char* cpt, char* ipr, char *ido) {
+	char msglog[LONSTD], sqlstr[LONSQL];
+	char modulo[] = "actualizaCreacionImagen()";
+	int idr,ifs;
+
+	/* Toma identificador del repositorio */
+	sprintf(sqlstr, "SELECT idrepositorio FROM repositorios WHERE ip='%s'", ipr);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idrepositorio", idr)) { // Toma dato
+		tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	/* Toma identificador del perfilsoftware */
+	sprintf(sqlstr, "SELECT idperfilsoft FROM ordenadores_particiones WHERE idordenador=%s AND numpar=%s", ido,par);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idperfilsoft", ifs)) { // Toma dato
+		tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	/* Actualizar los datos de la imagen */
+	sprintf(sqlstr,
+			"UPDATE imagenes SET numpar=%s,codpar=%s,idperfilsoft=%d,idrepositorio='%d'"
+				" WHERE idimagen=%s", par, cpt, ifs, idr, idi);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RestaurarImagen
+//
+//	Descripción:
+//		Restaura una imagen en una partición
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 RestaurarImagen(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "RestaurarImagen()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_RestaurarImagen
+//
+//	Descripción:
+//		Respuesta del cliente al comando RestaurarImagen
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_RestaurarImagen(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *ido, *idi, *par, *ifs;
+	char modulo[] = "RESPUESTA_RestaurarImagen()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	// Acciones posteriores
+	idi = copiaParametro("idi",ptrTrama); // Toma identificador de la imagen
+	par = copiaParametro("par",ptrTrama); // Número de partición
+	ifs = copiaParametro("ifs",ptrTrama); // Identificador del perfil software contenido
+	if (!actualizaRestauracionImagen(db, tbl, idi, par, ido, ifs)) {
+		errorLog(modulo, 53, FALSE);
+		db.Close(); // Cierra conexión
+		return (FALSE);
+	}
+
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: actualizaRestauracionImagen
+//
+//	Descripción:
+//		Esta función actualiza la base de datos con el resultado de la creación de una imagen
+//	Parámetros:
+//		- db: Objeto base de datos (ya operativo)
+//		- tbl: Objeto tabla
+//		- idi: Identificador de la imagen
+//		- par: Partición de donde se restauró
+//		- ido: Identificador del cliente donde se restauró
+//		- ifs: Identificador del perfil software contenido	en la imagen
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN actualizaRestauracionImagen(Database db, Table tbl, char* idi,
+		char* par, char* ido, char* ifs) {
+	char msglog[LONSTD], sqlstr[LONSQL];
+	char modulo[] = "actualizaRestauracionImagen()";
+
+	/* Actualizar los datos de la imagen */
+	sprintf(sqlstr,
+			"UPDATE ordenadores_particiones SET idimagen=%s,idperfilsoft=%s"
+				" WHERE idordenador=%s AND numpar=%s", idi, ifs, ido, par);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: Configurar
+//
+//	Descripción:
+//		Configura la tabla de particiones
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 Configurar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "Configurar()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_Configurar
+//
+//	Descripción:
+//		Respuesta del cliente al comando Configurar
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_Configurar(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *ido,*cfg;
+	char modulo[] = "RESPUESTA_Configurar()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	cfg = copiaParametro("cfg",ptrTrama); // Toma configuración de particiones
+	if(!actualizaConfiguracion(db, tbl, cfg, atoi(ido))){ // Actualiza la configuración del ordenador
+		errorLog(modulo, 24, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: EjecutarScript
+//
+//	Descripción:
+//		Ejecuta un script de código
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 EjecutarScript(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "EjecutarScript()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_EjecutarScript
+//
+//	Descripción:
+//		Respuesta del cliente al comando EjecutarScript
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_EjecutarScript(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *ido;
+
+	char modulo[] = "RESPUESTA_EjecutarScript()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+
+	// Acciones posteriores
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: InventarioHardware
+//
+//	Descripción:
+//		Solicita al cliente un inventario de su hardware
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 InventarioHardware(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "InventarioHardware()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_InventarioHardware
+//
+//	Descripción:
+//		Respuesta del cliente al comando InventarioHardware
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_InventarioHardware(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *ido, *idc, *npc, *hrd, *buffer;
+	char modulo[] = "RESPUESTA_InventarioHardware()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del cliente
+	npc = copiaParametro("npc",ptrTrama); // Toma Nombre del cliente
+	idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+	// Lee archivo de inventario enviado anteriormente
+	hrd = copiaParametro("hrd",ptrTrama);
+	buffer = rTrim(leeArchivo(hrd));
+
+	if (buffer) {
+		if (!actualizaHardware(db, tbl, buffer, ido, npc, idc)) {
+			errorLog(modulo, 53, FALSE);
+			return (FALSE);
+		}
+	}
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: actualizaHardware
+//
+//		Descripción:
+//			Actualiza la base de datos con la configuracion hardware del cliente
+//		Parámetros:
+//			- db: Objeto base de datos (ya operativo)
+//			- tbl: Objeto tabla
+//			- hrd: cadena con el inventario hardware
+//			- ido: Identificador del ordenador
+//			- npc: Nombre del ordenador
+//			- idc: Identificador del centro o Unidad organizativa
+// ________________________________________________________________________________________________________
+BOOLEAN actualizaHardware(Database db, Table tbl, char* hrd, char*ido,
+		char* npc, char *idc) {
+	char msglog[LONSTD], sqlstr[LONSQL];
+	int idtipohardware, idperfilhard;
+	int lon, i, j, aux;
+	char *tbHardware[MAXHARDWARE];
+	int tbidhardware[MAXHARDWARE];
+	char *dualHardware[2], descripcion[250], strInt[LONINT], *idhardwares;
+	char modulo[] = "actualizaHardware()";
+
+	/* Toma Centro (Unidad Organizativa) */
+	sprintf(sqlstr, "SELECT * FROM ordenadores WHERE idordenador=%s", ido);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	if (!tbl.Get("idperfilhard", idperfilhard)) { // Toma dato
+		tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	hrd=escaparCadena(hrd); // Codificar comillas simples
+	if(!hrd)
+		return (FALSE);
+	/* Recorre componentes hardware*/
+	lon = splitCadena(tbHardware, hrd, '\n');
+	if (lon > MAXHARDWARE)
+		lon = MAXHARDWARE; // Limita el número de componentes hardware
+	/*
+	 for (i=0;i<lon;i++){
+	 sprintf(msglog,"Linea de inventario: %s",tbHardware[i]);
+	 RegistraLog(msglog,FALSE);
+	 }
+	 */
+	for (i = 0; i < lon; i++) {
+		splitCadena(dualHardware, rTrim(tbHardware[i]), '=');
+		//sprintf(msglog,"nemonico: %s",dualHardware[0]);
+		//RegistraLog(msglog,FALSE);
+		//sprintf(msglog,"valor: %s",dualHardware[1]);
+		//RegistraLog(msglog,FALSE);
+		sprintf(sqlstr, "SELECT idtipohardware,descripcion FROM tipohardwares "
+			" WHERE nemonico='%s'", dualHardware[0]);
+		if (!db.Execute(sqlstr, tbl)) { // Error al leer
+			errorLog(modulo, 21, FALSE);
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if (tbl.ISEOF()) { //  Tipo de Hardware NO existente
+			sprintf(msglog, "%s: %s)", tbErrores[54], dualHardware[0]);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		} else { //  Tipo de Hardware Existe
+			if (!tbl.Get("idtipohardware", idtipohardware)) { // Toma dato
+				tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			if (!tbl.Get("descripcion", descripcion)) { // Toma dato
+				tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+
+			sprintf(sqlstr, "SELECT idhardware FROM hardwares "
+				" WHERE idtipohardware=%d AND descripcion='%s'",
+					idtipohardware, dualHardware[1]);
+
+			// Ejecuta consulta
+			if (!db.Execute(sqlstr, tbl)) { // Error al leer
+				errorLog(modulo, 21, FALSE);
+				db.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+
+			if (tbl.ISEOF()) { //  Hardware NO existente
+				sprintf(sqlstr,
+						"INSERT hardwares (idtipohardware,descripcion,idcentro,grupoid) "
+							" VALUES(%d,'%s',%s,0)", idtipohardware,
+						dualHardware[1], idc);
+				if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+					db.GetErrorErrStr(msglog); // Error al acceder al registro
+					errorInfo(modulo, msglog);
+					return (FALSE);
+				}
+				// Recupera el identificador del hardware
+				sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
+				if (!db.Execute(sqlstr, tbl)) { // Error al leer
+					errorLog(modulo, 21, FALSE);
+					db.GetErrorErrStr(msglog);
+					errorInfo(modulo, msglog);
+					return (FALSE);
+				}
+				if (!tbl.ISEOF()) { // Si existe registro
+					if (!tbl.Get("identificador", tbidhardware[i])) {
+						tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+						errorInfo(modulo, msglog);
+						return (FALSE);
+					}
+				}
+			} else {
+				if (!tbl.Get("idhardware", tbidhardware[i])) { // Toma dato
+					tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+					errorInfo(modulo, msglog);
+					return (FALSE);
+				}
+			}
+		}
+	}
+	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
+
+	for (i = 0; i < lon - 1; i++) {
+		for (j = i + 1; j < lon; j++) {
+			if (tbidhardware[i] > tbidhardware[j]) {
+				aux = tbidhardware[i];
+				tbidhardware[i] = tbidhardware[j];
+				tbidhardware[j] = aux;
+			}
+		}
+	}
+	/* Crea cadena de identificadores de componentes hardware separados por coma */
+	sprintf(strInt, "%d", tbidhardware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
+	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
+	idhardwares = reservaMemoria(sizeof(aux) * lon + lon);
+	if (idhardwares == NULL) {
+		errorLog(modulo, 3, FALSE);
+		return (FALSE);
+	}
+	aux = sprintf(idhardwares, "%d", tbidhardware[0]);
+	for (i = 1; i < lon; i++)
+		aux += sprintf(idhardwares + aux, ",%d", tbidhardware[i]);
+
+	if (!cuestionPerfilHardware(db, tbl, idc, ido, idperfilhard, idhardwares,
+			npc, tbidhardware, lon)) {
+		errorLog(modulo, 55, FALSE);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: cuestionPerfilHardware
+//
+//		Descripción:
+//			Comprueba existencia de perfil hardware y actualización de éste para el ordenador
+//		Parámetros:
+//			- db: Objeto base de datos (ya operativo)
+//			- tbl: Objeto tabla
+//			- idc: Identificador de la Unidad organizativa donde se encuentra el cliente
+//			- ido: Identificador del ordenador
+//			- tbidhardware: Identificador del tipo de hardware
+//			- con: Número de componentes detectados para configurar un el perfil hardware
+//			- npc: Nombre del cliente
+// ________________________________________________________________________________________________________
+BOOLEAN cuestionPerfilHardware(Database db, Table tbl, char* idc, char* ido,
+		int idperfilhardware, char*idhardwares, char *npc, int *tbidhardware,
+		int lon)
+{
+	char msglog[LONSTD], *sqlstr;
+	int i;
+	int nwidperfilhard;
+	char modulo[] = "cuestionPerfilHardware()";
+
+	sqlstr = reservaMemoria(strlen(idhardwares)+LONSQL); // Reserva para escribir sentencia SQL
+	if (sqlstr == NULL) {
+		errorLog(modulo, 3, FALSE);
+		return (FALSE);
+	}
+	// Busca perfil hard del ordenador que contenga todos los componentes hardware encontrados
+	sprintf(sqlstr, "SELECT idperfilhard FROM"
+		" (SELECT perfileshard_hardwares.idperfilhard as idperfilhard,"
+		"	group_concat(cast(perfileshard_hardwares.idhardware AS char( 11) )"
+		"	ORDER BY perfileshard_hardwares.idhardware SEPARATOR ',' ) AS idhardwares"
+		" FROM	perfileshard_hardwares"
+		" GROUP BY perfileshard_hardwares.idperfilhard) AS temp"
+		" WHERE idhardwares LIKE '%s'", idhardwares);
+	// Ejecuta consulta
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	if (tbl.ISEOF()) { // No existe un perfil hardware con esos componentes de componentes hardware, lo crea
+		sprintf(sqlstr, "INSERT perfileshard  (descripcion,idcentro,grupoid)"
+			" VALUES('Perfil hardware (%s) ',%s,0)", npc, idc);
+		if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+		// Recupera el identificador del nuevo perfil hardware
+		sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
+		if (!db.Execute(sqlstr, tbl)) { // Error al leer
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+		if (!tbl.ISEOF()) { // Si existe registro
+			if (!tbl.Get("identificador", nwidperfilhard)) {
+				tbl.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (false);
+			}
+		}
+		// Crea la relación entre perfiles y componenetes hardware
+		for (i = 0; i < lon; i++) {
+			sprintf(sqlstr,
+					"INSERT perfileshard_hardwares  (idperfilhard,idhardware)"
+						" VALUES(%d,%d)", nwidperfilhard, tbidhardware[i]);
+			if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+				db.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (false);
+			}
+		}
+	} else { // Existe un perfil con todos esos componentes
+		if (!tbl.Get("idperfilhard", nwidperfilhard)) {
+			tbl.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+	}
+	if (idperfilhardware != nwidperfilhard) { // No coinciden los perfiles
+		// Actualiza el identificador del perfil hardware del ordenador
+		sprintf(sqlstr, "UPDATE ordenadores SET idperfilhard=%d"
+			" WHERE idordenador=%s", nwidperfilhard, ido);
+		if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+	}
+	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
+	sprintf(sqlstr, "DELETE FROM perfileshard_hardwares WHERE idperfilhard IN "
+		" (SELECT idperfilhard FROM perfileshard WHERE idperfilhard NOT IN"
+		" (SELECT DISTINCT idperfilhard from ordenadores))");
+	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+
+	/* Eliminar Perfiles hardware que quedan húerfanos */
+	sprintf(sqlstr, "DELETE FROM perfileshard WHERE idperfilhard NOT IN"
+		" (SELECT DISTINCT idperfilhard from ordenadores)");
+	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
+	sprintf(sqlstr,
+			"DELETE FROM perfileshard_hardwares WHERE idperfilhard NOT IN"
+				" (SELECT idperfilhard from perfileshard)");
+	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: InventarioSoftware
+//
+//	Descripción:
+//		Solicita al cliente un inventario de su software
+//	Parámetros:
+//		- socket_c: Socket de la consola al envió el mensaje
+//		- 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 InventarioSoftware(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	char modulo[] = "InventarioSoftware()";
+
+	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
+		sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+		errorInfo(modulo, msglog);
+		respuestaConsola(socket_c, ptrTrama, FALSE);
+		return (FALSE);
+	}
+	respuestaConsola(socket_c, ptrTrama, TRUE);
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: RESPUESTA_InventarioSoftware
+//
+//	Descripción:
+//		Respuesta del cliente al comando InventarioSoftware
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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_InventarioSoftware(SOCKET *socket_c, TRAMA* ptrTrama) {
+	char msglog[LONSTD];
+	Database db;
+	Table tbl;
+	char *iph, *ido, *npc, *idc, *par, *sft, *buffer;
+	char modulo[] = "RESPUESTA_InventarioSoftware()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
+	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
+	npc = copiaParametro("npc",ptrTrama); // Toma Nombre del cliente
+	idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro
+
+	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
+		errorLog(modulo, 30, FALSE);
+		return (FALSE); // Error al registrar notificacion
+	}
+	par = copiaParametro("par",ptrTrama);
+	// Lee archivo de inventario enviado anteriormente
+	sft = copiaParametro("sft",ptrTrama);
+
+	buffer = rTrim(leeArchivo(sft));
+	if (buffer) {
+		if (!actualizaSoftware(db, tbl, buffer, par, ido, npc, idc)) {
+			errorLog(modulo, 82, FALSE);
+			return (FALSE);
+		}
+	}
+	db.Close(); // Cierra conexión
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: actualizaSoftware
+//
+//	Descripción:
+//		Actualiza la base de datos con la configuración software del cliente
+//	Parámetros:
+//		- db: Objeto base de datos (ya operativo)
+//		- tbl: Objeto tabla
+//		- sft: cadena con el inventario software
+//		- par: Número de la partición
+//		- ido: Identificador del ordenador del cliente en la tabla
+//		- npc: Nombre del ordenador
+//		- idc: Identificador del centro o Unidad organizativa
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+// ________________________________________________________________________________________________________
+BOOLEAN actualizaSoftware(Database db, Table tbl, char* sft, char* par,
+		char* ido, char* npc, char* idc) {
+	int i, j, lon, aux, idperfilsoft;
+	char *tbSoftware[MAXSOFTWARE];
+	int tbidsoftware[MAXSOFTWARE];
+	char msglog[LONSTD], sqlstr[LONSQL], strInt[LONINT], *idsoftwares;
+	char modulo[] = "actualizaSoftware()";
+
+	/* Toma Centro (Unidad Organizativa) y perfil software */
+	sprintf(sqlstr, "SELECT idperfilsoft,numpar"
+		" FROM ordenadores_particiones"
+		" WHERE idordenador=%s", ido);
+
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	idperfilsoft = 0; // Por defecto se supone que el ordenador no tiene aún detectado el perfil software
+	while (!tbl.ISEOF()) { // Recorre particiones
+		if (!tbl.Get("numpar", aux)) {
+			tbl.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if (aux == atoi(par)) { // Se encuentra la partición
+			if (!tbl.Get("idperfilsoft", idperfilsoft)) {
+				tbl.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			break;
+		}
+		tbl.MoveNext();
+	}
+	sft=escaparCadena(sft); // Codificar comillas simples
+	if(!sft)
+		return (FALSE);
+
+	/* Recorre componentes software*/
+	lon = splitCadena(tbSoftware, sft, '\n');
+	if (lon == 0)
+		return (true); // No hay lineas que procesar
+	if (lon > MAXSOFTWARE)
+		lon = MAXSOFTWARE; // Limita el número de componentes software
+
+	for (i = 0; i < lon; i++) {
+		sprintf(sqlstr,
+				"SELECT idsoftware FROM softwares WHERE descripcion ='%s'",
+				rTrim(tbSoftware[i]));
+
+		// Ejecuta consulta
+		if (!db.Execute(sqlstr, tbl)) { // Error al leer
+			errorLog(modulo, 21, FALSE);
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+
+		if (tbl.ISEOF()) { //  Software NO existente
+			sprintf(sqlstr,
+					"INSERT INTO softwares (idtiposoftware,descripcion,idcentro,grupoid)"
+						" VALUES(2,'%s',%s,0)", tbSoftware[i], idc);
+
+			if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+				db.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			// Recupera el identificador del software
+			sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
+			if (!db.Execute(sqlstr, tbl)) { // Error al leer
+				db.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			if (!tbl.ISEOF()) { // Si existe registro
+				if (!tbl.Get("identificador", tbidsoftware[i])) {
+					tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+					errorInfo(modulo, msglog);
+					return (FALSE);
+				}
+			}
+		} else {
+			if (!tbl.Get("idsoftware", tbidsoftware[i])) { // Toma dato
+				tbl.GetErrorErrStr(msglog); // Error al acceder al registro
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+		}
+	}
+
+	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
+
+	for (i = 0; i < lon - 1; i++) {
+		for (j = i + 1; j < lon; j++) {
+			if (tbidsoftware[i] > tbidsoftware[j]) {
+				aux = tbidsoftware[i];
+				tbidsoftware[i] = tbidsoftware[j];
+				tbidsoftware[j] = aux;
+			}
+		}
+	}
+	/* Crea cadena de identificadores de componentes software separados por coma */
+	sprintf(strInt, "%d", tbidsoftware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
+	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
+	idsoftwares = reservaMemoria((sizeof(aux)+1) * lon + lon);
+	if (idsoftwares == NULL) {
+		errorLog(modulo, 3, FALSE);
+		return (FALSE);
+	}
+	aux = sprintf(idsoftwares, "%d", tbidsoftware[0]);
+	for (i = 1; i < lon; i++)
+		aux += sprintf(idsoftwares + aux, ",%d", tbidsoftware[i]);
+
+	// Comprueba existencia de perfil software y actualización de éste para el ordenador
+	if (!cuestionPerfilSoftware(db, tbl, idc, ido, idperfilsoft, idsoftwares,
+			npc, par, tbidsoftware, lon)) {
+		errorLog(modulo, 83, FALSE);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: CuestionPerfilSoftware
+//
+//	Parámetros:
+//		- db: Objeto base de datos (ya operativo)
+//		- tbl: Objeto tabla
+//		- idcentro: Identificador del centro en la tabla
+//		- ido: Identificador del ordenador del cliente en la tabla
+//		- idsoftwares: Cadena con los identificadores de componentes software separados por comas
+//		- npc: Nombre del ordenador del cliente
+//		- particion: Número de la partición
+//		- tbidsoftware: Array con los identificadores de componentes software
+//		- lon: Número de componentes
+//	Devuelve:
+//		TRUE: Si el proceso es correcto
+//		FALSE: En caso de ocurrir algún error
+//________________________________________________________________________________________________________/
+BOOLEAN cuestionPerfilSoftware(Database db, Table tbl, char* idc, char* ido,
+		int idperfilsoftware, char *idsoftwares, char *npc, char *par,
+		int *tbidsoftware, int lon) {
+	char *sqlstr, msglog[LONSTD];
+	int i, nwidperfilsoft;
+	char modulo[] = "cuestionPerfilSoftware()";
+
+	sqlstr = reservaMemoria(strlen(idsoftwares)+LONSQL); // Reserva para escribir sentencia SQL
+	if (sqlstr == NULL) {
+		errorLog(modulo, 3, FALSE);
+		return (FALSE);
+	}
+	// Busca perfil soft del ordenador que contenga todos los componentes software encontrados
+	sprintf(sqlstr, "SELECT idperfilsoft FROM"
+		" (SELECT perfilessoft_softwares.idperfilsoft as idperfilsoft,"
+		"	group_concat(cast(perfilessoft_softwares.idsoftware AS char( 11) )"
+		"	ORDER BY perfilessoft_softwares.idsoftware SEPARATOR ',' ) AS idsoftwares"
+		" FROM	perfilessoft_softwares"
+		" GROUP BY perfilessoft_softwares.idperfilsoft) AS temp"
+		" WHERE idsoftwares LIKE '%s'", idsoftwares);
+	// Ejecuta consulta
+	if (!db.Execute(sqlstr, tbl)) { // Error al leer
+		errorLog(modulo, 21, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	if (tbl.ISEOF()) { // No existe un perfil software con esos componentes de componentes software, lo crea
+		sprintf(sqlstr, "INSERT perfilessoft  (descripcion,idcentro,grupoid)"
+			" VALUES('Perfil Software (%s, Part:%s) ',%s,0)", npc, par, idc);
+		if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+		// Recupera el identificador del nuevo perfil software
+		sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
+		if (!db.Execute(sqlstr, tbl)) { // Error al leer
+			tbl.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+		if (!tbl.ISEOF()) { // Si existe registro
+			if (!tbl.Get("identificador", nwidperfilsoft)) {
+				tbl.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (false);
+			}
+		}
+		// Crea la relación entre perfiles y componenetes software
+		for (i = 0; i < lon; i++) {
+			sprintf(sqlstr,
+					"INSERT perfilessoft_softwares  (idperfilsoft,idsoftware)"
+						" VALUES(%d,%d)", nwidperfilsoft, tbidsoftware[i]);
+			if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+				db.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (false);
+			}
+		}
+	} else { // Existe un perfil con todos esos componentes
+		if (!tbl.Get("idperfilsoft", nwidperfilsoft)) {
+			tbl.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+	}
+
+	if (idperfilsoftware != nwidperfilsoft) { // No coinciden los perfiles
+		// Actualiza el identificador del perfil software del ordenador
+		sprintf(sqlstr,
+				"UPDATE ordenadores_particiones SET idperfilsoft=%d,idimagen=0"
+					" WHERE idordenador=%s AND numpar=%s", nwidperfilsoft, ido,
+				par);
+		if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+			db.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (false);
+		}
+	}
+
+	/* DEPURACIÓN DE PERFILES SOFTWARE */
+
+	 /* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
+	sprintf(sqlstr, "DELETE FROM perfilessoft_softwares WHERE idperfilsoft IN "\
+		" (SELECT idperfilsoft FROM perfilessoft WHERE idperfilsoft NOT IN"\
+		" (SELECT DISTINCT idperfilsoft from ordenadores_particiones) AND idperfilsoft NOT IN"\
+		" (SELECT DISTINCT idperfilsoft from imagenes))");
+	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	/* Eliminar Perfiles software que quedan húerfanos */
+	sprintf(sqlstr, "DELETE FROM perfilessoft WHERE idperfilsoft NOT IN"
+		" (SELECT DISTINCT idperfilsoft from ordenadores_particiones)"\
+		" AND  idperfilsoft NOT IN"\
+		" (SELECT DISTINCT idperfilsoft from imagenes)");
+	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
+	sprintf(sqlstr,
+			"DELETE FROM perfilessoft_softwares WHERE idperfilsoft NOT IN"
+				" (SELECT idperfilsoft from perfilessoft)");
+	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (false);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: enviaArchivo
+//
+//	Descripción:
+//		Envia un archivo por la red, por bloques
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 enviaArchivo(SOCKET *socket_c, TRAMA *ptrTrama) {
+	char *nfl;
+	char modulo[] = "enviaArchivo()";
+
+	// Toma parámetros
+	nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo
+	if (!sendArchivo(socket_c, nfl)) {
+		errorLog(modulo, 57, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: enviaArchivo
+//
+//	Descripción:
+//		Envia un archivo por la red, por bloques
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 recibeArchivo(SOCKET *socket_c, TRAMA *ptrTrama) {
+	char *nfl;
+	char modulo[] = "recibeArchivo()";
+
+	// Toma parámetros
+	nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo
+	ptrTrama->tipo = MSG_NOTIFICACION;
+	enviaFlag(socket_c, ptrTrama);
+	if (!recArchivo(socket_c, nfl)) {
+		errorLog(modulo, 58, FALSE);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+// ________________________________________________________________________________________________________
+// Función: envioProgramacion
+//
+//	Descripción:
+//		Envia un comando de actualización a todos los ordenadores que han sido programados con
+//		alguna acción para que entren en el bucle de comandos pendientes y las ejecuten
+//	Parámetros:
+//		- socket_c: Socket del cliente que envió el mensaje
+//		- 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 envioProgramacion(SOCKET *socket_c, TRAMA *ptrTrama)
+{
+	char sqlstr[LONSQL], msglog[LONSTD];
+	char *idp,iph[LONIP],mac[LONMAC];
+	Database db;
+	Table tbl;
+	int idx,idcomando;
+	char modulo[] = "envioProgramacion()";
+
+	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
+		errorLog(modulo, 20, FALSE);
+		db.GetErrorErrStr(msglog);
+		errorInfo(modulo, msglog);
+		return (FALSE);
+	}
+
+	idp = copiaParametro("idp",ptrTrama); // Toma identificador de laprogramación de la tabla acciones
+
+	sprintf(sqlstr, "SELECT ordenadores.ip,ordenadores.mac,acciones.idcomando FROM acciones "\
+			" INNER JOIN ordenadores ON ordenadores.ip=acciones.ip"\
+			" WHERE acciones.idprogramacion=%s",idp);
+	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 existen registros
+
+	/* Prepara la trama de actualizacion */
+
+	initParametros(ptrTrama,0);
+	ptrTrama->tipo=MSG_COMANDO;
+	sprintf(ptrTrama->parametros, "nfn=Actualizar\r");
+
+	while (!tbl.ISEOF()) { // Recorre particiones
+		if (!tbl.Get("ip", iph)) {
+			tbl.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if (!tbl.Get("idcomando", idcomando)) {
+			tbl.GetErrorErrStr(msglog);
+			errorInfo(modulo, msglog);
+			return (FALSE);
+		}
+		if(idcomando==1){ // Arrancar
+			if (!tbl.Get("mac", mac)) {
+				tbl.GetErrorErrStr(msglog);
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+			if (!Levanta(mac)) {
+				sprintf(msglog, "%s:%s", tbErrores[32], modulo);
+				errorInfo(modulo, msglog);
+				return (FALSE);
+			}
+		}
+		if (clienteDisponible(iph, &idx)) { // Si el cliente puede recibir comandos
+			strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO); // Actualiza el estado del cliente
+			if (!mandaTrama(&tbsockets[idx].sock, ptrTrama)) {
+				errorLog(modulo, 26, FALSE);
+				return (FALSE);
+			}
+			close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad
+		}
+		tbl.MoveNext();
+	}
+	return (TRUE); // No existen registros
+}
+
+// ********************************************************************************************************
+// PROGRAMA PRINCIPAL (SERVICIO)
+// ********************************************************************************************************
+int main(int argc, char *argv[]) {
+	int i;
+	SOCKET socket_s; // Socket donde escucha el servidor
+	SOCKET socket_c; // Socket de los clientes que se conectan
+	socklen_t iAddrSize;
+	struct sockaddr_in local, cliente;
+	char modulo[] = "main()";
+
+	/*--------------------------------------------------------------------------------------------------------
+	 Validación de parámetros de ejecución y lectura del fichero de configuración del servicio
+	 ---------------------------------------------------------------------------------------------------------*/
+	if (!validacionParametros(argc, argv, 1)) // Valida parámetros de ejecución
+		exit(EXIT_FAILURE);
+
+	if (!tomaConfiguracion(szPathFileCfg)) { // Toma parametros de configuracion
+		exit(EXIT_FAILURE);
+	}
+	/*--------------------------------------------------------------------------------------------------------
+	 Carga del catálogo de funciones que procesan las tramas (referencia directa por puntero a función)
+	 ---------------------------------------------------------------------------------------------------------*/
+	int cf = 0;
+
+	strcpy(tbfuncionesServer[cf].nf, "Sondeo");
+	tbfuncionesServer[cf++].fptr = &Sondeo;
+	strcpy(tbfuncionesServer[cf].nf, "respuestaSondeo");
+	tbfuncionesServer[cf++].fptr = &respuestaSondeo;
+
+	strcpy(tbfuncionesServer[cf].nf, "ConsolaRemota");
+	tbfuncionesServer[cf++].fptr = &ConsolaRemota;
+
+	strcpy(tbfuncionesServer[cf].nf, "EcoConsola");
+	tbfuncionesServer[cf++].fptr = &EcoConsola;
+
+	strcpy(tbfuncionesServer[cf].nf, "Actualizar");
+	tbfuncionesServer[cf++].fptr = &Actualizar;
+
+	strcpy(tbfuncionesServer[cf].nf, "Purgar");
+	tbfuncionesServer[cf++].fptr = &Purgar;
+
+	strcpy(tbfuncionesServer[cf].nf, "InclusionCliente");
+	tbfuncionesServer[cf++].fptr = &InclusionCliente;
+
+	strcpy(tbfuncionesServer[cf].nf, "AutoexecCliente");
+	tbfuncionesServer[cf++].fptr = &AutoexecCliente;
+
+	strcpy(tbfuncionesServer[cf].nf, "ComandosPendientes");
+	tbfuncionesServer[cf++].fptr = &ComandosPendientes;
+
+	strcpy(tbfuncionesServer[cf].nf, "DisponibilidadComandos");
+	tbfuncionesServer[cf++].fptr = &DisponibilidadComandos;
+
+	strcpy(tbfuncionesServer[cf].nf, "Arrancar");
+	tbfuncionesServer[cf++].fptr = &Arrancar;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Arrancar");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_Arrancar;
+
+	strcpy(tbfuncionesServer[cf].nf, "Apagar");
+	tbfuncionesServer[cf++].fptr = &Apagar;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Apagar");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_Apagar;
+
+	strcpy(tbfuncionesServer[cf].nf, "Reiniciar");
+	tbfuncionesServer[cf++].fptr = &Reiniciar;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Reiniciar");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_Reiniciar;
+
+	strcpy(tbfuncionesServer[cf].nf, "IniciarSesion");
+	tbfuncionesServer[cf++].fptr = &IniciarSesion;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_IniciarSesion");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_IniciarSesion;
+
+	strcpy(tbfuncionesServer[cf].nf, "CrearImagen");
+	tbfuncionesServer[cf++].fptr = &CrearImagen;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_CrearImagen");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_CrearImagen;
+
+	strcpy(tbfuncionesServer[cf].nf, "RestaurarImagen");
+	tbfuncionesServer[cf++].fptr = &RestaurarImagen;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_RestaurarImagen");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_RestaurarImagen;
+
+	strcpy(tbfuncionesServer[cf].nf, "Configurar");
+	tbfuncionesServer[cf++].fptr = &Configurar;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Configurar");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_Configurar;
+
+	strcpy(tbfuncionesServer[cf].nf, "EjecutarScript");
+	tbfuncionesServer[cf++].fptr = &EjecutarScript;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_EjecutarScript");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_EjecutarScript;
+
+	strcpy(tbfuncionesServer[cf].nf, "InventarioHardware");
+	tbfuncionesServer[cf++].fptr = &InventarioHardware;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_InventarioHardware");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_InventarioHardware;
+
+	strcpy(tbfuncionesServer[cf].nf, "InventarioSoftware");
+	tbfuncionesServer[cf++].fptr = &InventarioSoftware;
+	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_InventarioSoftware");
+	tbfuncionesServer[cf++].fptr = &RESPUESTA_InventarioSoftware;
+
+	strcpy(tbfuncionesServer[cf].nf, "enviaArchivo");
+	tbfuncionesServer[cf++].fptr = &enviaArchivo;
+
+	strcpy(tbfuncionesServer[cf].nf, "recibeArchivo");
+	tbfuncionesServer[cf++].fptr = &recibeArchivo;
+
+	strcpy(tbfuncionesServer[cf].nf, "envioProgramacion");
+	tbfuncionesServer[cf++].fptr = &envioProgramacion;
+
+	/*--------------------------------------------------------------------------------------------------------
+	 // Inicializa array de información de los clientes
+	 ---------------------------------------------------------------------------------------------------------*/
+	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
+		tbsockets[i].ip[0] = '\0';
+		tbsockets[i].sock = INVALID_SOCKET;
+	}
+	/*--------------------------------------------------------------------------------------------------------
+	 Creación y configuración del socket del servicio
+	 ---------------------------------------------------------------------------------------------------------*/
+	socket_s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Crea socket del servicio
+	if (socket_s == SOCKET_ERROR) { // Error al crear el socket del servicio
+		errorLog(modulo, 13, TRUE);
+		exit(EXIT_FAILURE);
+	}
+
+	local.sin_addr.s_addr = htonl(INADDR_ANY); // Configura el socket del servicio
+	local.sin_family = AF_INET;
+	local.sin_port = htons(atoi(puerto));
+
+	if (bind(socket_s, (struct sockaddr *) &local, sizeof(local))
+			== SOCKET_ERROR) { // Enlaza socket
+		errorLog(modulo, 14, TRUE);
+		exit(EXIT_FAILURE);
+	}
+
+	listen(socket_s, 250); // Pone a escuchar al socket
+	iAddrSize = sizeof(cliente);
+	/*--------------------------------------------------------------------------------------------------------
+	 Bucle para acceptar conexiones
+	 ---------------------------------------------------------------------------------------------------------*/
+	infoLog(1); // Inicio de sesión
+	while (TRUE) {
+		socket_c = accept(socket_s, (struct sockaddr *) &cliente, &iAddrSize);
+		if (socket_c == INVALID_SOCKET) {
+			errorLog(modulo, 15, TRUE);
+			exit(EXIT_FAILURE);
+		}
+		swcSocket = FALSE; // Por defecto se cerrara el socket de cliente después del anális de la trama
+		if (!gestionaTrama(&socket_c)) {
+			errorLog(modulo, 39, TRUE);
+			//close(socket_c);
+			//break;
+		}
+		if (!swcSocket) // Sólo se cierra cuando el cliente NO espera comandos ineractivos
+			close(socket_c);
+	}
+	/*--------------------------------------------------------------------------------------------------------
+	 Fin del servicio
+	 ---------------------------------------------------------------------------------------------------------*/
+	close(socket_s);
+	exit(EXIT_SUCCESS);
+}
diff --git a/sources/ogAdmServer.h b/sources/ogAdmServer.h
new file mode 100644
index 0000000..13a5357
--- /dev/null
+++ b/sources/ogAdmServer.h
@@ -0,0 +1,118 @@
+// ********************************************************************************************************
+// Servicio: ogAdmServer
+// 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: ogAdmServer.h
+// Descripción: Este fichero implementa el servicio de administración 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 <netinet/in.h>
+#include <arpa/inet.h>
+#include </usr/include/mysql/mysql.h>
+#include "Database.h"
+#include "ogAdmLib.h"
+// ________________________________________________________________________________________________________
+// 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
+char aulaup[LONPRM];	// Conmutador para registro automático de clientes
+
+typedef struct{ // Estructura usada para guardar información de los clientes
+	char ip[LONIP]; // IP del cliente
+	char estado[4]; // Tipo de Sistema Operativo en que se encuentra el cliente
+	SOCKET sock; // Socket por el que se comunica
+}SOCKETCL;
+SOCKETCL tbsockets[MAXIMOS_CLIENTES];
+
+BOOLEAN swcSocket; // Switch para indicar si se debe cerrar el socket del cliente
+
+typedef struct{  // Estructura usada para referenciar las funciones que procesan las tramas
+	char nf[LONFUN]; // Nombre de la función
+	BOOLEAN (*fptr)(SOCKET*,TRAMA*); // Puntero a la función que procesa la trama
+}MSGFUN;
+MSGFUN tbfuncionesServer[MAXIMAS_FUNCIONES];
+// ________________________________________________________________________________________________________
+// Prototipo de funciones
+// ________________________________________________________________________________________________________
+
+BOOLEAN tomaConfiguracion(char*);
+BOOLEAN gestionaTrama(SOCKET*);
+BOOLEAN Sondeo(SOCKET*,TRAMA*);
+BOOLEAN respuestaSondeo(SOCKET *,TRAMA*);
+BOOLEAN InclusionCliente(SOCKET*,TRAMA*);
+BOOLEAN registraCliente(char *);
+
+BOOLEAN procesoInclusionCliente(SOCKET*,TRAMA*);
+BOOLEAN clienteExistente(char *,int *);
+BOOLEAN clienteDisponible(char *,int *);
+BOOLEAN hayHueco(int *);
+BOOLEAN actualizaConfiguracion(Database , Table ,char* ,int);
+BOOLEAN AutoexecCliente(SOCKET *, TRAMA *);
+BOOLEAN recorreProcedimientos(Database ,char* ,FILE*,char*);
+
+BOOLEAN tomaRepositorio(Database ,Table ,char*,int*);
+BOOLEAN buscaComandos(char *,TRAMA *,int *);
+BOOLEAN DisponibilidadComandos(SOCKET*,TRAMA*);
+BOOLEAN respuestaEstandar(TRAMA *,char **,char **,char ** ,Database *,Table *);
+BOOLEAN respuestaConsola(SOCKET *,TRAMA *,int);
+BOOLEAN enviaComando(TRAMA *ptrTrama,const char*);
+
+BOOLEAN Actualizar(SOCKET *, TRAMA* );
+BOOLEAN Purgar(SOCKET *, TRAMA* );
+
+BOOLEAN ConsolaRemota(SOCKET *,TRAMA*);
+BOOLEAN RESPUESTA_ConsolaRemota(SOCKET *,TRAMA*);
+BOOLEAN EcoConsola(SOCKET *,TRAMA*);
+
+BOOLEAN Comando(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_Comando(SOCKET *,TRAMA *);
+
+BOOLEAN Arrancar(SOCKET *,TRAMA *);
+BOOLEAN Levanta(char*);
+BOOLEAN WakeUp(SOCKET *,char *);
+void PasaHexBin(char *,char *);
+BOOLEAN RESPUESTA_Arrancar(SOCKET *,TRAMA*);
+BOOLEAN Apagar(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_Apagar(SOCKET *,TRAMA *);
+BOOLEAN Reiniciar(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_Reiniciar(SOCKET *,TRAMA *);
+BOOLEAN IniciarSesion(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_IniciarSesion(SOCKET *,TRAMA *);
+BOOLEAN CrearImagen(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_CrearImagen(SOCKET *,TRAMA *);
+BOOLEAN actualizaCreacionImagen(Database,Table,char*,char*,char*,char*,char*);
+BOOLEAN RestaurarImagen(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_RestaurarImagen(SOCKET *,TRAMA *);
+BOOLEAN actualizaRestauracionImagen(Database,Table,char*,char*,char*,char*);
+BOOLEAN Configurar(SOCKET *,TRAMA* );
+BOOLEAN RESPUESTA_Configurar(SOCKET *,TRAMA* );
+BOOLEAN actualizaConfigurar(Database , Table , char* );
+BOOLEAN InventarioHardware(SOCKET *,TRAMA *);
+BOOLEAN RESPUESTA_InventarioHardware(SOCKET *,TRAMA *);
+BOOLEAN actualizaHardware(Database, Table,char* ,char*,char*,char*);
+BOOLEAN cuestionPerfilHardware(Database,Table,char*,char*,int,char*,char*,int *,int);
+BOOLEAN actualizaSoftware(Database , Table , char* , char* , char*,char*,char*);
+BOOLEAN cuestionPerfilSoftware(Database, Table, char*, char*,int,char*,char*,char*,int *,int);
+
+BOOLEAN enviaArchivo(SOCKET *, TRAMA *);
+BOOLEAN recibeArchivo(SOCKET *, TRAMA *);
+BOOLEAN envioProgramacion(SOCKET *, TRAMA *);
+
+int checkDato(Database,Table,char*,const char*,const char*,const char*);
+
+
+