#971 remove obsolete code

2 files changed, 8 insertions, 1560 deletions

diff --git a/sources/ogAdmServer.c b/sources/ogAdmServer.c
index 71c4093..b4ba9b2 100644
--- a/sources/ogAdmServer.c
+++ b/sources/ogAdmServer.c
@@ -224,278 +224,6 @@ bool clienteExistente(char *ip, int* idx)
 	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
-// ________________________________________________________________________________________________________
-static bool 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: InclusionClienteWin
-//
-//	Descripción:
-//		Esta función incorpora el socket de un nuevo cliente Windows o Linux a la tabla de clientes 
-//	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
-// ________________________________________________________________________________________________________
-static bool InclusionClienteWinLnx(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int socket_c = og_client_socket(cli);
-	int res,idordenador,lon;
-	char nombreordenador[LONFIL];
-
-	res = procesoInclusionClienteWinLnx(socket_c, ptrTrama, &idordenador,
-					    nombreordenador);
-
-	// Prepara la trama de respuesta
-
-	initParametros(ptrTrama,0);
-	ptrTrama->tipo=MSG_RESPUESTA;
-	lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_InclusionClienteWinLnx\r");
-	lon += sprintf(ptrTrama->parametros + lon, "ido=%d\r", idordenador);
-	lon += sprintf(ptrTrama->parametros + lon, "npc=%s\r", nombreordenador);	
-	lon += sprintf(ptrTrama->parametros + lon, "res=%d\r", res);	
-
-	if (!mandaTrama(&socket_c, ptrTrama)) {
-		syslog(LOG_ERR, "failed to send response to %s:%hu reason=%s\n",
-		       inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
-		       strerror(errno));
-		return false;
-	}
-	return true;
-}
-// ________________________________________________________________________________________________________
-// Función: procesoInclusionClienteWinLnx
-//
-//	Descripción:
-//		Implementa el proceso de inclusión en el sistema del Cliente Windows o Linux
-//	Parámetros de entrada:
-//		- socket_c: Socket del cliente que envió el mensaje
-//		- ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
-//	Parámetros de salida:
-//		- ido: Identificador del ordenador
-//		- nombreordenador: Nombre del ordenador
-//	Devuelve:
-//		Código del error producido en caso de ocurrir algún error, 0 si el proceso es correcto
-// ________________________________________________________________________________________________________
-bool procesoInclusionClienteWinLnx(int socket_c, TRAMA *ptrTrama, int *idordenador, char *nombreordenador)
- {
-	struct og_dbi *dbi;
-	const char *msglog;
-	dbi_result result;
-	char *iph;
-
-	// Toma parámetros
-	iph = copiaParametro("iph",ptrTrama); // Toma ip
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		goto err_dbi_open;
-	}
-
-	result = dbi_conn_queryf(dbi->conn,
-			"SELECT idordenador,nombreordenador FROM ordenadores "
-				" WHERE ordenadores.ip = '%s'", iph);
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		goto err_query_fail;
-	}
-
-	if (!dbi_result_next_row(result)) {
-		syslog(LOG_ERR, "client does not exist in database (%s:%d)\n",
-		       __func__, __LINE__);
-		dbi_result_free(result);
-		goto err_query_fail;
-	}
-
-	syslog(LOG_DEBUG, "Client %s requesting inclusion\n", iph);
-
-	*idordenador = dbi_result_get_uint(result, "idordenador");
-	nombreordenador = (char *)dbi_result_get_string(result, "nombreordenador");
-
-	dbi_result_free(result);
-	og_dbi_close(dbi);
-
-	if (!registraCliente(iph)) { // Incluyendo al cliente en la tabla de sokets
-		liberaMemoria(iph);
-		syslog(LOG_ERR, "client table is full\n");
-		return false;
-	}
-	liberaMemoria(iph);
-	return true;
-
-err_query_fail:
-	og_dbi_close(dbi);
-err_dbi_open:
-	liberaMemoria(iph);
-	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
-// ________________________________________________________________________________________________________
-static bool InclusionCliente(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int socket_c = og_client_socket(cli);
-
-	if (!procesoInclusionCliente(cli, ptrTrama)) {
-		initParametros(ptrTrama,0);
-		strcpy(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\rres=0\r");
-		if (!mandaTrama(&socket_c, ptrTrama)) {
-			syslog(LOG_ERR, "failed to send response to %s:%hu reason=%s\n",
-			       inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
-			       strerror(errno));
-			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
-// ________________________________________________________________________________________________________
-bool procesoInclusionCliente(struct og_client *cli, TRAMA *ptrTrama)
-{
-	int socket_c = og_client_socket(cli);
-	const char *msglog, *str;
-	struct og_dbi *dbi;
-	dbi_result result;
-
-	char *iph, *cfg;
-	char nombreordenador[LONFIL];
-	int lon, resul, idordenador, cache, idproautoexec, idaula, idcentro;
-
-	// Toma parámetros
-	iph = copiaParametro("iph",ptrTrama); // Toma ip
-	cfg = copiaParametro("cfg",ptrTrama); // Toma configuracion
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		goto err_dbi_open;
-        }
-
-	// Recupera los datos del cliente
-	result = dbi_conn_queryf(dbi->conn,
-			"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 (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		goto err_query_fail;
-	}
-
-	if (!dbi_result_next_row(result)) {
-		syslog(LOG_ERR, "client does not exist in database (%s:%d)\n",
-		       __func__, __LINE__);
-		dbi_result_free(result);
-		goto err_query_fail;
-	}
-
-	syslog(LOG_DEBUG, "Client %s requesting inclusion\n", iph);
-
-	idordenador = dbi_result_get_uint(result, "idordenador");
-	str = (char *)dbi_result_get_string(result, "nombreordenador");
-	sprintf(nombreordenador, "%s", str);
-	cache = dbi_result_get_uint(result, "cache");
-	idproautoexec = dbi_result_get_uint(result, "idproautoexec");
-	idaula = dbi_result_get_uint(result, "idaula");
-	idcentro = dbi_result_get_uint(result, "idcentro");
-	dbi_result_free(result);
-
-	resul = actualizaConfiguracion(dbi, cfg, idordenador); // Actualiza la configuración del ordenador
-	liberaMemoria(cfg);
-	og_dbi_close(dbi);
-
-	if (!resul) {
-		liberaMemoria(iph);
-		syslog(LOG_ERR, "Cannot add client to database\n");
-		return false;
-	}
-
-	if (!registraCliente(iph)) { // Incluyendo al cliente en la tabla de sokets
-		liberaMemoria(iph);
-		syslog(LOG_ERR, "client table is full\n");
-		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)) {
-		syslog(LOG_ERR, "failed to send response to %s:%hu reason=%s\n",
-		       inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
-		       strerror(errno));
-		return false;
-	}
-	liberaMemoria(iph);
-	return true;
-
-err_query_fail:
-	og_dbi_close(dbi);
-err_dbi_open:
-	liberaMemoria(iph);
-	liberaMemoria(cfg);
-	return false;
-}
-// ________________________________________________________________________________________________________
 // Función: actualizaConfiguracion
 //
 //	Descripción:
@@ -735,137 +463,6 @@ int checkDato(struct og_dbi *dbi, char *dato, const char *tabla,
 
 	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
-// ________________________________________________________________________________________________________
-bool 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
-// ________________________________________________________________________________________________________
-static bool AutoexecCliente(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int socket_c = og_client_socket(cli);
-	int lon;
-	char *iph, *exe;
-	FILE *fileexe;
-	char fileautoexec[LONPRM];
-	char parametros[LONGITUD_PARAMETROS];
-	struct og_dbi *dbi;
-
-	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);
-	liberaMemoria(iph);
-	fileexe = fopen(fileautoexec, "wb"); // Abre fichero de script
-	if (fileexe == NULL) {
-		syslog(LOG_ERR, "cannot create temporary file\n");
-		return false;
-	}
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-	initParametros(ptrTrama,0);
-	if (recorreProcedimientos(dbi, 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");
-	}
-
-	og_dbi_close(dbi);
-	fclose(fileexe);
-
-	if (!mandaTrama(&socket_c, ptrTrama)) {
-		liberaMemoria(exe);
-		syslog(LOG_ERR, "failed to send response to %s:%hu reason=%s\n",
-		       inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
-		       strerror(errno));
-		return false;
-	}
-	liberaMemoria(exe);
-	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
-// ________________________________________________________________________________________________________
-bool recorreProcedimientos(struct og_dbi *dbi, char *parametros, FILE *fileexe, char *idp)
-{
-	char idprocedimiento[LONPRM];
-	int procedimientoid, lsize;
-	const char *msglog, *param;
-	dbi_result result;
-
-	result = dbi_conn_queryf(dbi->conn,
-			"SELECT procedimientoid,parametros FROM procedimientos_acciones"
-				" WHERE idprocedimiento=%s ORDER BY orden", idp);
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		return false;
-	}
-	while (dbi_result_next_row(result)) {
-		procedimientoid = dbi_result_get_uint(result, "procedimientoid");
-		if (procedimientoid > 0) { // Procedimiento recursivo
-			sprintf(idprocedimiento, "%d", procedimientoid);
-			if (!recorreProcedimientos(dbi, parametros, fileexe, idprocedimiento)) {
-				return false;
-			}
-		} else {
-			param = dbi_result_get_string(result, "parametros");
-			sprintf(parametros, "%s@", param);
-			lsize = strlen(parametros);
-			fwrite(parametros, 1, lsize, fileexe); // Escribe el código a ejecutar
-		}
-	}
-	dbi_result_free(result);
-
-	return true;
-}
 
 struct og_task {
 	uint32_t	procedure_id;
@@ -911,282 +508,6 @@ static void og_cmd_free(const struct og_cmd *cmd)
 static TRAMA *og_msg_alloc(char *data, unsigned int len);
 static void og_msg_free(TRAMA *ptrTrama);
 
-static int og_deliver_pending_command(const struct og_cmd *cmd, int *socket,
-				      int idx)
-{
-	char buf[4096];
-	TRAMA *msg;
-	int len;
-
-	len = snprintf(buf, sizeof(buf), "%s\r", cmd->params);
-
-	msg = og_msg_alloc(buf, len);
-	if (!msg)
-		return false;
-
-	strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO);
-	if (!mandaTrama(socket, msg)) {
-		syslog(LOG_ERR, "failed to send response to %s reason=%s\n",
-				cmd->ip, strerror(errno));
-		return false;
-	}
-	og_msg_free(msg);
-	og_cmd_free(cmd);
-
-	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
-// ________________________________________________________________________________________________________
-static bool ComandosPendientes(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int socket_c = og_client_socket(cli);
-	char *ido,*iph,pids[LONPRM];
-	const struct og_cmd *cmd;
-	int ids, idx;
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección IP
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!clienteExistente(iph, &idx)) { // Busca índice del cliente
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "client does not exist\n");
-		return false;
-	}
-
-	cmd = og_cmd_find(iph);
-	if (cmd) {
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		return og_deliver_pending_command(cmd, &socket_c, idx);
-	} else 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)) {
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to send response to %s:%hu reason=%s\n",
-		       inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
-		       strerror(errno));
-		return false;
-	}
-	liberaMemoria(iph);
-	liberaMemoria(ido);	
-	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 sesion(Salida)
-//	Devuelve:
-//		true: Si el proceso es correcto
-//		false: En caso de ocurrir algún error
-// ________________________________________________________________________________________________________
-bool buscaComandos(char *ido, TRAMA *ptrTrama, int *ids)
-{
-	const char *param, *msglog;
-	struct og_dbi *dbi;
-	dbi_result result;
-	unsigned int lonprm;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		goto err_dbi_open;
-	}
-	result = dbi_conn_queryf(dbi->conn,
-			"SELECT sesion, parametros"\
-			" FROM acciones WHERE idordenador=%s AND estado='%d'"\
-			" ORDER BY idaccion", ido, ACCION_INICIADA);
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		goto err_query_fail;
-	}
-	if (!dbi_result_next_row(result)) {
-		dbi_result_free(result);
-		og_dbi_close(dbi);
-		return false; // No hay comandos pendientes
-	}
-
-	*ids = dbi_result_get_uint(result, "sesion");
-	param = dbi_result_get_string(result, "parametros");
-	lonprm = strlen(param);
-
-	if(!initParametros(ptrTrama,lonprm + LONGITUD_PARAMETROS)){
-		syslog(LOG_ERR, "%s:%d OOM\n", __FILE__, __LINE__);
-		goto err_init_params;
-	}
-	sprintf(ptrTrama->parametros, "%s", param);
-
-	dbi_result_free(result);
-	og_dbi_close(dbi);
-
-	return true; // Hay comandos pendientes, se toma el primero de la cola
-
-err_init_params:
-	dbi_result_free(result);
-err_query_fail:
-	og_dbi_close(dbi);
-err_dbi_open:
-	return false;
-}
-// ________________________________________________________________________________________________________
-// 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
-// ________________________________________________________________________________________________________
-//
-static bool DisponibilidadComandos(TRAMA *ptrTrama, struct og_client *cli)
-{
-	char *iph, *tpc;
-	int idx;
-
-	iph = copiaParametro("iph",ptrTrama); // Toma ip
-	if (!clienteExistente(iph, &idx)) { // Busca índice del cliente
-		liberaMemoria(iph);
-		syslog(LOG_ERR, "client does not exist\n");
-		return false;
-	}
-	tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.)
-	strcpy(tbsockets[idx].estado, tpc);
-	cli->keepalive_idx = idx;
-	liberaMemoria(iph);
-	liberaMemoria(tpc);		
-	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 sesión
-//		- 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
-// ________________________________________________________________________________________________________
-static bool respuestaEstandar(TRAMA *ptrTrama, char *iph, char *ido,
-			      struct og_dbi *dbi)
-{
-	char *res, *ids, *der;
-	char fechafin[LONPRM];
-	const char *msglog;
-	dbi_result result;
-	struct tm* st;
-	int idaccion;
-
-	ids = copiaParametro("ids",ptrTrama);
-	res = copiaParametro("res",ptrTrama);
-
-	if (ids == NULL) {
-		if (atoi(res) == ACCION_FALLIDA) {
-			liberaMemoria(res);
-			return false;
-		}
-		liberaMemoria(res);
-		return true;
-	}
-
-	if (atoi(ids) == 0) {
-		liberaMemoria(ids);
-		if (atoi(res) == ACCION_FALLIDA) {
-			liberaMemoria(res);
-			return false;
-		}
-		liberaMemoria(res);
-		return true;
-	}
-
-	result = dbi_conn_queryf(dbi->conn,
-			"SELECT * FROM acciones WHERE idordenador=%s"
-			" AND sesion=%s ORDER BY idaccion", ido,ids);
-
-	liberaMemoria(ids);
-
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		return false;
-	}
-	if (!dbi_result_next_row(result)) {
-		syslog(LOG_ERR, "no actions available\n");
-		dbi_result_free(result);
-		return true;
-	}
-
-	idaccion = dbi_result_get_uint(result, "idaccion");
-	dbi_result_free(result);
-
-	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);
-
-	der = copiaParametro("der",ptrTrama); // Toma descripción del error (si hubiera habido)
-
-	result = dbi_conn_queryf(dbi->conn,
-			"UPDATE acciones"\
-			"   SET resultado='%s',estado='%d',fechahorafin='%s',descrinotificacion='%s'"\
-			" WHERE idordenador=%s AND idaccion=%d",
-			res, ACCION_FINALIZADA, fechafin, der, ido, idaccion);
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		liberaMemoria(res);
-		liberaMemoria(der);
-		og_info((char *)msglog);
-		return false;
-	}
-	dbi_result_free(result);
-
-	liberaMemoria(der);
-
-	if (atoi(res) == ACCION_FALLIDA) {
-		liberaMemoria(res);
-		return false;
-	}
-
-	liberaMemoria(res);
-	return true;
-}
-
 static bool og_send_cmd(char *ips_array[], int ips_array_len,
 			const char *state, TRAMA *ptrTrama)
 {
@@ -1207,66 +528,6 @@ static bool og_send_cmd(char *ips_array[], int ips_array_len,
 }
 
 // ________________________________________________________________________________________________________
-// 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
-// ________________________________________________________________________________________________________
-bool enviaComando(TRAMA* ptrTrama, const char *estado)
-{
-	char *iph, *Ipes, *ptrIpes[MAXIMOS_CLIENTES];
-	int lon;
-
-	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) {
-		syslog(LOG_ERR, "%s:%d OOM\n", __FILE__, __LINE__);
-		return false;
-	}
-	
-	strcpy(Ipes, iph); // Copia cadena de IPES
-	liberaMemoria(iph);
-
-	lon = splitCadena(ptrIpes, Ipes, ';');
-	FINCADaINTRO(ptrTrama);
-
-	if (!og_send_cmd(ptrIpes, lon, estado, ptrTrama))
-		return false;
-
-	liberaMemoria(Ipes);
-	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
-// ________________________________________________________________________________________________________
-bool respuestaConsola(int socket_c, TRAMA *ptrTrama, int res)
-{
-	initParametros(ptrTrama,0);
-	sprintf(ptrTrama->parametros, "res=%d\r", res);
-	if (!mandaTrama(&socket_c, ptrTrama)) {
-		syslog(LOG_ERR, "%s:%d failed to send response: %s\n",
-		       __func__, __LINE__, strerror(errno));
-		return false;
-	}
-	return true;
-}
-// ________________________________________________________________________________________________________
 // Función: Levanta
 //
 //	Descripción:
@@ -1445,156 +706,7 @@ bool WakeUp(int s, char* iph, char *mac, char *mar)
 	}
 	return ret;
 }
-// ________________________________________________________________________________________________________
-// Función: RESPUESTA_Arrancar
-//
-//	Descripción:
-//		Respuesta del cliente al comando Arrancar
-//	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_Arrancar(TRAMA* ptrTrama, struct og_client *cli)
-{
-	struct og_dbi *dbi;
-	char *iph, *ido;
-	char *tpc;
-	int i;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		og_dbi_close(dbi);
-		return false;
-	}
-
-	tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.)
-	if (clienteExistente(iph, &i)) // Actualiza estado
-		strcpy(tbsockets[i].estado, tpc);
-
-	liberaMemoria(iph);
-	liberaMemoria(ido);
-	liberaMemoria(tpc);
-	og_dbi_close(dbi);
-
-	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_Apagar(TRAMA* ptrTrama, struct og_client *cli)
-{
-	struct og_dbi *dbi;
-	char *iph, *ido;
-	int i;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
 
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		og_dbi_close(dbi);
-		return false; // Error al registrar notificacion
-	}
-
-	if (clienteExistente(iph, &i)) // Actualiza estado
-		strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
-
-	liberaMemoria(iph);
-	liberaMemoria(ido);
-	og_dbi_close(dbi);
-
-	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_CrearImagen(TRAMA* ptrTrama, struct og_client *cli)
-{
-	char *iph, *dsk, *par, *cpt, *ipr, *ido;
-	struct og_dbi *dbi;
-	char *idi;
-	bool res;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		og_dbi_close(dbi);
-		return false; // Error al registrar notificacion
-	}
-
-	// Acciones posteriores
-	idi = copiaParametro("idi",ptrTrama);
-	dsk = copiaParametro("dsk",ptrTrama);
-	par = copiaParametro("par",ptrTrama);
-	cpt = copiaParametro("cpt",ptrTrama);
-	ipr = copiaParametro("ipr",ptrTrama);
-
-	res=actualizaCreacionImagen(dbi, idi, dsk, par, cpt, ipr, ido);
-
-	liberaMemoria(idi);
-	liberaMemoria(par);
-	liberaMemoria(cpt);
-	liberaMemoria(ipr);
-	og_dbi_close(dbi);
-
-	if (!res)
-		syslog(LOG_ERR, "Problem processing update\n");
-
-	return res;
-}
 // ________________________________________________________________________________________________________
 // Función: actualizaCreacionImagen
 //
@@ -1698,204 +810,7 @@ bool actualizaCreacionImagen(struct og_dbi *dbi, char *idi, char *dsk,
 
 	return true;
 }
-// ________________________________________________________________________________________________________
-// Función: RESPUESTA_CrearImagenBasica
-//
-//	Descripción:
-//		Respuesta del cliente al comando CrearImagenBasica
-//	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_CrearImagenBasica(TRAMA* ptrTrama, struct og_client *cli)
-{
-	// La misma respuesta que la creación de imagen monolítica
-	return RESPUESTA_CrearImagen(ptrTrama, cli);
-}
-// ________________________________________________________________________________________________________
-// Función: RESPUESTA_CrearSoftIncremental
-//
-//	Descripción:
-//		Respuesta del cliente al comando crearImagenDiferencial
-//	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_CrearSoftIncremental(TRAMA* ptrTrama, struct og_client *cli)
-{
-	char *iph,*par,*ido,*idf;
-	int ifs;
-	const char *msglog;
-	struct og_dbi *dbi;
-	dbi_result result;
 
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		og_dbi_close(dbi);
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		return false;
-	}
-
-	par = copiaParametro("par",ptrTrama);
-
-	/* Toma identificador del perfilsoftware creado por el inventario de software */
-	result = dbi_conn_queryf(dbi->conn,
-				 "SELECT idperfilsoft FROM ordenadores_particiones WHERE idordenador=%s AND numpar=%s",
-				 ido, par);
-	liberaMemoria(iph);
-	liberaMemoria(ido);	
-	liberaMemoria(par);	
-
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		og_dbi_close(dbi);
-		return false;
-	}
-	if (!dbi_result_next_row(result)) {
-		syslog(LOG_ERR,
-		       "software profile does not exist in database (%s:%d)\n",
-		       __func__, __LINE__);
-		dbi_result_free(result);
-		og_dbi_close(dbi);
-		return false;
-	}
-	ifs = dbi_result_get_uint(result, "idperfilsoft");
-	dbi_result_free(result);
-
-	/* Actualizar los datos de la imagen */
-	idf = copiaParametro("idf", ptrTrama);
-	result = dbi_conn_queryf(dbi->conn,
-				 "UPDATE imagenes SET idperfilsoft=%d WHERE idimagen=%s",
-				 ifs, idf);
-	liberaMemoria(idf);	
-
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		og_dbi_close(dbi);
-		return false;
-	}
-	dbi_result_free(result);
-
-	og_dbi_close(dbi);
-
-	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
-// ________________________________________________________________________________________________________
-//
-static bool RESPUESTA_RestaurarImagen(TRAMA* ptrTrama, struct og_client *cli)
-{
-	bool res;
-	char *iph, *ido, *idi, *dsk, *par, *ifs, *cfg;
-	struct og_dbi *dbi;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		og_dbi_close(dbi);
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		return false;
-	}
-
-	// Acciones posteriores
-	idi = copiaParametro("idi",ptrTrama); // Toma identificador de la imagen
-	dsk = copiaParametro("dsk",ptrTrama); // Número de disco
-	par = copiaParametro("par",ptrTrama); // Número de partición
-	ifs = copiaParametro("ifs",ptrTrama); // Identificador del perfil software contenido
-	cfg = copiaParametro("cfg",ptrTrama); // Configuración de discos
-	if(cfg){
-		actualizaConfiguracion(dbi, cfg, atoi(ido)); // Actualiza la configuración del ordenador
-		liberaMemoria(cfg);	
-	}
-	res=actualizaRestauracionImagen(dbi, idi, dsk, par, ido, ifs);
-	
-	liberaMemoria(iph);
-	liberaMemoria(ido);
-	liberaMemoria(idi);
-	liberaMemoria(par);
-	liberaMemoria(ifs);
-	og_dbi_close(dbi);
-
-	if(!res)
-		syslog(LOG_ERR, "Problem after restoring image\n");
-
-	return res;
-}
-// ________________________________________________________________________________________________________
-//
-// Función: RESPUESTA_RestaurarImagenBasica
-//
-//	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
-// ________________________________________________________________________________________________________
-//
-static bool RESPUESTA_RestaurarImagenBasica(TRAMA* ptrTrama, struct og_client *cli)
-{
-	return RESPUESTA_RestaurarImagen(ptrTrama, cli);
-}
-// ________________________________________________________________________________________________________
-// Función: RESPUESTA_RestaurarSoftIncremental
-//
-//	Descripción:
-//		Respuesta del cliente al comando RestaurarSoftIncremental
-//	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_RestaurarSoftIncremental(TRAMA* ptrTrama, struct og_client *cli)
-{
-	return RESPUESTA_RestaurarImagen(ptrTrama, cli);
-}
 // ________________________________________________________________________________________________________
 // Función: actualizaRestauracionImagen
 //
@@ -1938,116 +853,6 @@ bool actualizaRestauracionImagen(struct og_dbi *dbi, char *idi,
 	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_EjecutarScript(TRAMA* ptrTrama, struct og_client *cli)
-{
-	char *iph, *ido,*cfg;
-	struct og_dbi *dbi;
-	bool res = true;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		og_dbi_close(dbi);
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		return false;
-	}
-	
-	cfg = copiaParametro("cfg",ptrTrama); // Toma configuración de particiones
-	if(cfg){
-		res = actualizaConfiguracion(dbi, cfg, atoi(ido)); // Actualiza la configuración del ordenador
-		liberaMemoria(cfg);	
-	}
-
-	liberaMemoria(iph);
-	liberaMemoria(ido);
-	og_dbi_close(dbi);
-
-	if (!res)
-		syslog(LOG_ERR, "Problem updating client configuration\n");
-
-	return res;
-}
-// ________________________________________________________________________________________________________
-// 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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_InventarioHardware(TRAMA* ptrTrama, struct og_client *cli)
-{
-	bool res;
-	char *iph, *ido, *idc, *npc, *hrd, *buffer;
-	struct og_dbi *dbi;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del cliente
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		og_dbi_close(dbi);
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		return false;
-	}
-	// Lee archivo de inventario enviado anteriormente
-	hrd = copiaParametro("hrd",ptrTrama);
-	buffer = rTrim(leeArchivo(hrd));
-	
-	npc = copiaParametro("npc",ptrTrama); 
-	idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro
-	
-	if (buffer) 
-		res=actualizaHardware(dbi, buffer, ido, npc, idc);
-	else
-		res = false;
-
-	liberaMemoria(iph);
-	liberaMemoria(ido);			
-	liberaMemoria(npc);			
-	liberaMemoria(idc);		
-	liberaMemoria(buffer);		
-	og_dbi_close(dbi);
-
-	if (!res)
-		syslog(LOG_ERR, "Problem updating client configuration\n");
-
-	return res;
-}
-// ________________________________________________________________________________________________________
 // Función: actualizaHardware
 //
 //		Descripción:
@@ -2320,66 +1125,6 @@ bool cuestionPerfilHardware(struct og_dbi *dbi, char *idc, char *ido,
 	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
-// ________________________________________________________________________________________________________
-static bool RESPUESTA_InventarioSoftware(TRAMA* ptrTrama, struct og_client *cli)
-{
-	bool res;
-	char *iph, *ido, *npc, *idc, *par, *sft, *buffer;
-	struct og_dbi *dbi;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
-	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
-
-	if (!respuestaEstandar(ptrTrama, iph, ido, dbi)) {
-		og_dbi_close(dbi);
-		liberaMemoria(iph);
-		liberaMemoria(ido);
-		syslog(LOG_ERR, "failed to register notification\n");
-		return false;
-	}
-
-	npc = copiaParametro("npc",ptrTrama); 
-	idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro	
-	par = copiaParametro("par",ptrTrama);
-	sft = copiaParametro("sft",ptrTrama);
-
-	buffer = rTrim(leeArchivo(sft));
-	if (buffer)
-		res=actualizaSoftware(dbi, buffer, par, ido, npc, idc);
-	else
-		res = false;
-
-	liberaMemoria(iph);
-	liberaMemoria(ido);	
-	liberaMemoria(npc);	
-	liberaMemoria(idc);	
-	liberaMemoria(par);	
-	liberaMemoria(sft);	
-	og_dbi_close(dbi);
-
-	if (!res)
-		syslog(LOG_ERR, "cannot update software\n");
-
-	return res;
-}
-// ________________________________________________________________________________________________________
 // Función: actualizaSoftware
 //
 //	Descripción:
@@ -2646,230 +1391,6 @@ bool cuestionPerfilSoftware(struct og_dbi *dbi, char *idc, char *ido,
 
 	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
-// ________________________________________________________________________________________________________
-static bool enviaArchivo(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int socket_c = og_client_socket(cli);
-	char *nfl;
-
-	// Toma parámetros
-	nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo
-	if (!sendArchivo(&socket_c, nfl)) {
-		liberaMemoria(nfl);
-		syslog(LOG_ERR, "Problem sending file\n");
-		return false;
-	}
-	liberaMemoria(nfl);
-	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
-// ________________________________________________________________________________________________________
-static bool recibeArchivo(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int socket_c = og_client_socket(cli);
-	char *nfl;
-
-	// 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)) {
-		liberaMemoria(nfl);
-		syslog(LOG_ERR, "Problem receiving file\n");
-		return false;
-	}
-	liberaMemoria(nfl);
-	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
-// ________________________________________________________________________________________________________
-static bool envioProgramacion(TRAMA *ptrTrama, struct og_client *cli)
-{
-	char *ptrIP[MAXIMOS_CLIENTES],*ptrMacs[MAXIMOS_CLIENTES];
-	char *idp, *iph, *mac;
-	int idx,idcomando,lon;
-	const char *msglog;
-	struct og_dbi *dbi;
-	dbi_result result;
-
-	dbi = og_dbi_open(&dbi_config);
-	if (!dbi) {
-		syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
-		       __func__, __LINE__);
-		return false;
-	}
-
-	idp = copiaParametro("idp",ptrTrama); // Toma identificador de la programación de la tabla acciones
-
-	result = dbi_conn_queryf(dbi->conn,
-			"SELECT ordenadores.ip,ordenadores.mac,acciones.idcomando FROM acciones "\
-			" INNER JOIN ordenadores ON ordenadores.ip=acciones.ip"\
-			" WHERE acciones.idprogramacion=%s",idp);
-
-	liberaMemoria(idp);
-
-	if (!result) {
-		dbi_conn_error(dbi->conn, &msglog);
-		syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
-		       __func__, __LINE__, msglog);
-		og_dbi_close(dbi);
-		return false;
-	}
-
-	/* Prepara la trama de actualizacion */
-
-	initParametros(ptrTrama,0);
-	ptrTrama->tipo=MSG_COMANDO;
-	sprintf(ptrTrama->parametros, "nfn=Actualizar\r");
-
-	while (dbi_result_next_row(result)) {
-		iph = (char *)dbi_result_get_string(result, "ip");
-		idcomando = dbi_result_get_uint(result, "idcomando");
-
-		if (idcomando == 1){ // Arrancar
-			mac = (char *)dbi_result_get_string(result, "mac");
-			lon = splitCadena(ptrIP, iph, ';');
-			lon = splitCadena(ptrMacs, mac, ';');
-
-			// Se manda por broadcast y por unicast
-			if (!Levanta(ptrIP, ptrMacs, lon, (char*)"1")) {
-				dbi_result_free(result);
-				og_dbi_close(dbi);
-				return false;
-			}
-
-			if (!Levanta(ptrIP, ptrMacs, lon, (char*)"2")) {
-				dbi_result_free(result);
-				og_dbi_close(dbi);
-				return false;
-			}
-
-		}
-		if (clienteDisponible(iph, &idx)) { // Si el cliente puede recibir comandos
-			int sock = tbsockets[idx].cli ? tbsockets[idx].cli->io.fd : -1;
-
-			strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO); // Actualiza el estado del cliente
-			if (sock >= 0 && !mandaTrama(&sock, ptrTrama)) {
-				syslog(LOG_ERR, "failed to send response: %s\n",
-				       strerror(errno));
-			}
-			//close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad
-		}
-	}
-	dbi_result_free(result);
-	og_dbi_close(dbi);
-
-	return true; // No existen registros
-}
-
-// This object stores function handler for messages
-static struct {
-	const char *nf; // Nombre de la función
-	bool (*fcn)(TRAMA *, struct og_client *cli);
-} tbfuncionesServer[] = {
-	{ "InclusionCliente",			InclusionCliente,	},
-	{ "InclusionClienteWinLnx",		InclusionClienteWinLnx, },
-	{ "AutoexecCliente",			AutoexecCliente,	},
-	{ "ComandosPendientes",			ComandosPendientes,	},
-	{ "DisponibilidadComandos",		DisponibilidadComandos, },
-	{ "RESPUESTA_Arrancar",			RESPUESTA_Arrancar,	},
-	{ "RESPUESTA_Apagar",			RESPUESTA_Apagar,	},
-	{ "RESPUESTA_Reiniciar",		RESPUESTA_Apagar,	},
-	{ "RESPUESTA_IniciarSesion",		RESPUESTA_Apagar, },
-	{ "RESPUESTA_CrearImagen",		RESPUESTA_CrearImagen,	},
-	{ "RESPUESTA_CrearImagenBasica",	RESPUESTA_CrearImagenBasica, },
-	{ "RESPUESTA_CrearSoftIncremental",	RESPUESTA_CrearSoftIncremental, },
-	{ "RESPUESTA_RestaurarImagen",		RESPUESTA_RestaurarImagen },
-	{ "RESPUESTA_RestaurarImagenBasica",	RESPUESTA_RestaurarImagenBasica, },
-	{ "RESPUESTA_RestaurarSoftIncremental",	RESPUESTA_RestaurarSoftIncremental, },
-	{ "RESPUESTA_Configurar",		RESPUESTA_EjecutarScript, },
-	{ "RESPUESTA_EjecutarScript",		RESPUESTA_EjecutarScript, },
-	{ "RESPUESTA_InventarioHardware",	RESPUESTA_InventarioHardware, },
-	{ "RESPUESTA_InventarioSoftware",	RESPUESTA_InventarioSoftware, },
-	{ "enviaArchivo",			enviaArchivo,		},
-	{ "recibeArchivo",			recibeArchivo, 		},
-	{ "envioProgramacion",			envioProgramacion,	},
-	{ NULL,					NULL,			},
-};
-
-// ________________________________________________________________________________________________________
-// 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
-// ________________________________________________________________________________________________________
-static void gestionaTrama(TRAMA *ptrTrama, struct og_client *cli)
-{
-	int i, res;
-	char *nfn;
-
-	if (ptrTrama){
-		INTROaFINCAD(ptrTrama);
-		nfn = copiaParametro("nfn",ptrTrama); // Toma nombre de la función
-
-		for (i = 0; tbfuncionesServer[i].fcn; i++) {
-			if (!strncmp(tbfuncionesServer[i].nf, nfn,
-				     strlen(tbfuncionesServer[i].nf))) {
-				res = tbfuncionesServer[i].fcn(ptrTrama, cli);
-				if (!res) {
-					syslog(LOG_ERR, "Failed handling of %s for client %s:%hu\n",
-					       tbfuncionesServer[i].nf,
-					       inet_ntoa(cli->addr.sin_addr),
-					       ntohs(cli->addr.sin_port));
-				} else {
-					syslog(LOG_DEBUG, "Successful handling of %s for client %s:%hu\n",
-					       tbfuncionesServer[i].nf,
-					       inet_ntoa(cli->addr.sin_addr),
-					       ntohs(cli->addr.sin_port));
-				}
-				break;
-			}
-		}
-		if (!tbfuncionesServer[i].fcn)
-			syslog(LOG_ERR, "unknown request %s from client %s:%hu\n",
-			       nfn, inet_ntoa(cli->addr.sin_addr),
-			       ntohs(cli->addr.sin_port));
-
-		liberaMemoria(nfn);
-	}
-}
 
 static void og_client_release(struct ev_loop *loop, struct og_client *cli)
 {
@@ -2907,37 +1428,6 @@ static void og_client_reset_state(struct og_client *cli)
 	cli->buf_len = 0;
 }
 
-static int og_client_state_recv_hdr(struct og_client *cli)
-{
-	char hdrlen[LONHEXPRM];
-
-	/* Still too short to validate protocol fingerprint and message
-	 * length.
-	 */
-	if (cli->buf_len < 15 + LONHEXPRM)
-		return 0;
-
-	if (strncmp(cli->buf, "@JMMLCAMDJ_MCDJ", 15)) {
-		syslog(LOG_ERR, "bad fingerprint from client %s:%hu, closing\n",
-		       inet_ntoa(cli->addr.sin_addr),
-		       ntohs(cli->addr.sin_port));
-		return -1;
-	}
-
-	memcpy(hdrlen, &cli->buf[LONGITUD_CABECERATRAMA], LONHEXPRM);
-	cli->msg_len = strtol(hdrlen, NULL, 16);
-
-	/* Header announces more that we can fit into buffer. */
-	if (cli->msg_len >= sizeof(cli->buf)) {
-		syslog(LOG_ERR, "too large message %u bytes from %s:%hu\n",
-		       cli->msg_len, inet_ntoa(cli->addr.sin_addr),
-		       ntohs(cli->addr.sin_port));
-		return -1;
-	}
-
-	return 1;
-}
-
 static TRAMA *og_msg_alloc(char *data, unsigned int len)
 {
 	TRAMA *ptrTrama;
@@ -2962,26 +1452,6 @@ static void og_msg_free(TRAMA *ptrTrama)
 	liberaMemoria(ptrTrama);
 }
 
-static int og_client_state_process_payload(struct og_client *cli)
-{
-	TRAMA *ptrTrama;
-	char *data;
-	int len;
-
-	len = cli->msg_len - (LONGITUD_CABECERATRAMA + LONHEXPRM);
-	data = &cli->buf[LONGITUD_CABECERATRAMA + LONHEXPRM];
-
-	ptrTrama = og_msg_alloc(data, len);
-	if (!ptrTrama)
-		return -1;
-
-	gestionaTrama(ptrTrama, cli);
-
-	og_msg_free(ptrTrama);
-
-	return 1;
-}
-
 #define OG_CLIENTS_MAX	4096
 #define OG_PARTITION_MAX 4
 
@@ -5673,11 +4143,7 @@ static void og_client_read_cb(struct ev_loop *loop, struct ev_io *io, int events
 
 	switch (cli->state) {
 	case OG_CLIENT_RECEIVING_HEADER:
-		if (cli->rest)
-			ret = og_client_state_recv_hdr_rest(cli);
-		else
-			ret = og_client_state_recv_hdr(cli);
-
+		ret = og_client_state_recv_hdr_rest(cli);
 		if (ret < 0)
 			goto close;
 		if (!ret)
@@ -5693,15 +4159,11 @@ static void og_client_read_cb(struct ev_loop *loop, struct ev_io *io, int events
 		cli->state = OG_CLIENT_PROCESSING_REQUEST;
 		/* fall through. */
 	case OG_CLIENT_PROCESSING_REQUEST:
-		if (cli->rest) {
-			ret = og_client_state_process_payload_rest(cli);
-			if (ret < 0) {
-				syslog(LOG_ERR, "Failed to process HTTP request from %s:%hu\n",
-				       inet_ntoa(cli->addr.sin_addr),
-				       ntohs(cli->addr.sin_port));
-			}
-		} else {
-			ret = og_client_state_process_payload(cli);
+		ret = og_client_state_process_payload_rest(cli);
+		if (ret < 0) {
+			syslog(LOG_ERR, "Failed to process HTTP request from %s:%hu\n",
+			       inet_ntoa(cli->addr.sin_addr),
+			       ntohs(cli->addr.sin_port));
 		}
 		if (ret < 0)
 			goto close;
@@ -6492,7 +4954,7 @@ static void og_agent_send_probe(struct og_client *cli)
 	}
 }
 
-static int socket_s, socket_rest, socket_agent_rest;
+static int socket_rest, socket_agent_rest;
 
 static void og_server_accept_cb(struct ev_loop *loop, struct ev_io *io,
 				int events)
@@ -6579,7 +5041,7 @@ static int og_socket_server_init(const char *port)
 
 int main(int argc, char *argv[])
 {
-	struct ev_io ev_io_server, ev_io_server_rest, ev_io_agent_rest;
+	struct ev_io ev_io_server_rest, ev_io_agent_rest;
 	int i;
 
 	og_loop = ev_default_loop(0);
@@ -6609,12 +5071,6 @@ int main(int argc, char *argv[])
 	/*--------------------------------------------------------------------------------------------------------
 	 Creación y configuración del socket del servicio
 	 ---------------------------------------------------------------------------------------------------------*/
-	socket_s = og_socket_server_init(puerto);
-	if (socket_s < 0)
-		exit(EXIT_FAILURE);
-
-	ev_io_init(&ev_io_server, og_server_accept_cb, socket_s, EV_READ);
-	ev_io_start(og_loop, &ev_io_server);
 
 	socket_rest = og_socket_server_init("8888");
 	if (socket_rest < 0)
diff --git a/sources/ogAdmServer.h b/sources/ogAdmServer.h
index acc88c2..d5061cd 100644
--- a/sources/ogAdmServer.h
+++ b/sources/ogAdmServer.h
@@ -36,19 +36,11 @@ SOCKETCL tbsockets[MAXIMOS_CLIENTES];
 
 struct og_dbi;
 
-bool registraCliente(char *);
-bool procesoInclusionClienteWinLnx(int socket, TRAMA*,int*,char*);
-bool procesoInclusionCliente(struct og_client *, TRAMA*);
 bool clienteExistente(char *,int *);
 bool clienteDisponible(char *,int *);
 bool actualizaConfiguracion(struct og_dbi *,char* ,int);
-bool recorreProcedimientos(struct og_dbi *,char* ,FILE*,char*);
-bool buscaComandos(char *,TRAMA *,int *);
-bool respuestaConsola(int socket, TRAMA *,int);
-bool enviaComando(TRAMA *ptrTrama,const char*);
 bool Levanta(char**, char**, int, char*);
 bool WakeUp(int,char*,char*,char*);
-void PasaHexBin(char *,char *);
 bool actualizaCreacionImagen(struct og_dbi *,char*,char*,char*,char*,char*,char*);
 bool actualizaRestauracionImagen(struct og_dbi *,char*,char*,char*,char*,char*);
 bool actualizaHardware(struct og_dbi *dbi, char* ,char*,char*,char*);