Context Navigation

ogAdmServer.cpp @ 6777e3e

Visit:

918-git-images-111dconfigfileconfigure-oglivegit-imageslgromero-new-oglivemainmaint-cronmount-efivarfsmultivmmultivm-ogboot-installerogClonningEngineogboot-installer-jenkinsoglive-ipv6test-python-scriptsticket-301ticket-50ticket-50-oldticket-577ticket-585ticket-611ticket-612ticket-693ticket-700ubu24tplunification2use-local-agent-oglivevarios-instalacionwebconsole3

Last change on this file since 6777e3e was f029b3b, checked in by irina <irinagomez@…>, 9 years ago

#730 Se optimiza el código en EjecutarScripts?.js de los asistentes y el servicio ogAdmServer.

git-svn-id: https://opengnsys.es/svn/branches/version1.1@5043 a21b9725-9963-47de-94b9-378ad31fedc9

Property mode set to 100644

File size: 128.5 KB

Rev	Line
[f679cf0]	1	// *******************************************************************************************************
[3ec149c]	2	// Servicio: ogAdmServer
	3	// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
	4	// Fecha Creación: Marzo-2010
	5	// Fecha Última modificación: Marzo-2010
	6	// Nombre del fichero: ogAdmServer.cpp
	7	// Descripción :Este fichero implementa el servicio de administración general del sistema
[f679cf0]	8	// *******************************************************************************************************
[3ec149c]	9	#include "ogAdmServer.h"
	10	#include "ogAdmLib.c"
	11	//________________________________________________________________________________________________________
	12	// Función: tomaConfiguracion
	13	//
	14	// Descripción:
	15	// Lee el fichero de configuración del servicio
	16	// Parámetros:
	17	// filecfg : Ruta completa al fichero de configuración
	18	// Devuelve:
	19	// TRUE: Si el proceso es correcto
	20	// FALSE: En caso de ocurrir algún error
	21	//________________________________________________________________________________________________________
	22	BOOLEAN tomaConfiguracion(char* filecfg) {
	23	char modulo[] = "tomaConfiguracion()";
	24
	25	if (filecfg == NULL \|\| strlen(filecfg) == 0) {
	26	errorLog(modulo, 1, FALSE); // Fichero de configuración del servicio vacío
	27	return (FALSE);
	28	}
	29	FILE *fcfg;
	30	long lSize;
	31	char * buffer, lineas[MAXPRM], dualparametro[2];
	32	int i, numlin, resul;
	33
	34	fcfg = fopen(filecfg, "rt");
	35	if (fcfg == NULL) {
	36	errorLog(modulo, 2, FALSE); // No existe fichero de configuración del servicio
	37	return (FALSE);
	38	}
	39
	40	fseek(fcfg, 0, SEEK_END);
	41	lSize = ftell(fcfg); // Obtiene tamaño del fichero.
	42	rewind(fcfg);
	43	buffer = (char*) reservaMemoria(lSize + 1); // Toma memoria para el buffer de lectura.
	44	if (buffer == NULL) { // No hay memoria suficiente para el buffer
	45	errorLog(modulo, 3, FALSE);
	46	return (FALSE);
	47	}
	48	fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero
	49	buffer[lSize] = (char) NULL;
	50	fclose(fcfg);
	51
	52	servidoradm[0] = (char) NULL; //inicializar variables globales
	53	usuario[0] = (char) NULL;
	54	pasguor[0] = (char) NULL;
	55	datasource[0] = (char) NULL;
	56	catalog[0] = (char) NULL;
	57	aulaup[0] = (char) NULL;
	58
	59	numlin = splitCadena(lineas, buffer, '\n');
	60	for (i = 0; i < numlin; i++) {
	61	splitCadena(dualparametro, lineas[i], '=');
	62	resul = strcmp(StrToUpper(dualparametro[0]), "SERVIDORADM");
	63	if (resul == 0)
	64	strcpy(servidoradm, dualparametro[1]);
	65	resul = strcmp(StrToUpper(dualparametro[0]), "PUERTO");
	66	if (resul == 0)
	67	strcpy(puerto, dualparametro[1]);
	68	resul = strcmp(StrToUpper(dualparametro[0]), "USUARIO");
	69	if (resul == 0)
	70	strcpy(usuario, dualparametro[1]);
	71	resul = strcmp(StrToUpper(dualparametro[0]), "PASSWORD");
	72	if (resul == 0)
	73	strcpy(pasguor, dualparametro[1]);
	74	resul = strcmp(StrToUpper(dualparametro[0]), "DATASOURCE");
	75	if (resul == 0)
	76	strcpy(datasource, dualparametro[1]);
	77	resul = strcmp(StrToUpper(dualparametro[0]), "CATALOG");
	78	if (resul == 0)
	79	strcpy(catalog, dualparametro[1]);
	80	resul = strcmp(StrToUpper(dualparametro[0]), "AULAUP");
	81	if (resul == 0)
	82	strcpy(catalog, dualparametro[1]);
	83	}
	84	if (servidoradm[0] == (char) NULL) {
[0a73ecf7]	85	liberaMemoria(buffer);
[3ec149c]	86	errorLog(modulo, 4, FALSE); // Falta parámetro SERVIDORADM
	87	return (FALSE);
	88	}
	89	if (puerto[0] == (char) NULL) {
[0a73ecf7]	90	liberaMemoria(buffer);
[3ec149c]	91	errorLog(modulo, 5, FALSE); // Falta parámetro PUERTO
	92	return (FALSE);
	93	}
	94	if (usuario[0] == (char) NULL) {
[0a73ecf7]	95	liberaMemoria(buffer);
[3ec149c]	96	errorLog(modulo, 6, FALSE); // Falta parámetro USUARIO
	97	return (FALSE);
	98	}
	99	if (pasguor[0] == (char) NULL) {
[0a73ecf7]	100	liberaMemoria(buffer);
[3ec149c]	101	errorLog(modulo, 7, FALSE); // Falta parámetro PASSWORD
	102	return (FALSE);
	103	}
	104	if (datasource[0] == (char) NULL) {
[0a73ecf7]	105	liberaMemoria(buffer);
[3ec149c]	106	errorLog(modulo, 8, FALSE); // Falta parámetro DATASOURCE
	107	return (FALSE);
	108	}
	109	if (catalog[0] == (char) NULL) {
[0a73ecf7]	110	liberaMemoria(buffer);
[3ec149c]	111	errorLog(modulo, 9, FALSE); // Falta parámetro CATALOG
	112	return (FALSE);
	113	}
	114	if (aulaup[0] == (char) NULL) {
	115	strcpy(aulaup, "0"); // Por defecto el conmutador de registro automático esta en off
[0a73ecf7]	116
[3ec149c]	117	}
[0a73ecf7]	118	liberaMemoria(buffer);
[3ec149c]	119	return (TRUE);
	120	}
	121	// ________________________________________________________________________________________________________
	122	// Función: gestionaTrama
	123	//
	124	// Descripción:
	125	// Procesa las tramas recibidas .
	126	// Parametros:
	127	// - s : Socket usado para comunicaciones
	128	// Devuelve:
	129	// TRUE: Si el proceso es correcto
	130	// FALSE: En caso de ocurrir algún error
	131	// ________________________________________________________________________________________________________
	132	BOOLEAN gestionaTrama(SOCKET *socket_c)
	133	{
	134	TRAMA* ptrTrama;
	135	int i, res;
	136	char *nfn;
	137	char modulo[] = "gestionaTrama()";
	138
	139	ptrTrama=recibeTrama(socket_c);
[f679cf0]	140
[3ec149c]	141	if (ptrTrama){
	142	INTROaFINCAD(ptrTrama);
[0a73ecf7]	143	nfn = copiaParametro("nfn",ptrTrama); // Toma nombre de la función
	144
[3ec149c]	145	for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
	146	res = strcmp(tbfuncionesServer[i].nf, nfn);
	147	if (res == 0) { // Encontrada la función que procesa el mensaje
[0a73ecf7]	148	liberaMemoria(nfn);
	149	res=tbfuncionesServer[i].fptr(socket_c, ptrTrama); // Invoca la función
[4329e85]	150	liberaMemoria((char*)ptrTrama);
[0a73ecf7]	151	return(res);
[3ec149c]	152	}
	153	}
[0a73ecf7]	154
	155	/*
	156	Sólo puede ser un comando personalizado o su notificación
[3ec149c]	157	if (ptrTrama->tipo == MSG_COMANDO)
	158	return (Comando(socket_c, ptrTrama));
	159	else {
	160	if (ptrTrama->tipo == MSG_NOTIFICACION)
	161	return (RESPUESTA_Comando(socket_c, ptrTrama));
	162	else
	163	errorLog(modulo, 18, FALSE); // No se reconoce el mensaje
	164	}
[0a73ecf7]	165	*/
[3ec149c]	166	}
	167	else
	168	errorLog(modulo, 17, FALSE); // Error en la recepción
	169	return (TRUE);
	170	}
	171	// ________________________________________________________________________________________________________
	172	// Función: Sondeo
	173	//
	174	// Descripción:
	175	// Solicita a los clientes su disponibiliad para recibir comandos interactivos
	176	// Parámetros:
	177	// - socket_c: Socket del cliente que envió el mensaje
	178	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
	179	// Devuelve:
	180	// TRUE: Si el proceso es correcto
	181	// FALSE: En caso de ocurrir algún error
	182	// ________________________________________________________________________________________________________
	183	BOOLEAN Sondeo(SOCKET socket_c, TRAMA ptrTrama) {
	184	char msglog[LONSTD];
	185	char modulo[] = "Sondeo()";
	186
	187	if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) {
	188	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	189	errorInfo(modulo, msglog);
	190	respuestaConsola(socket_c, ptrTrama, FALSE);
	191	return (FALSE);
	192	}
	193	respuestaConsola(socket_c, ptrTrama, TRUE);
	194	return (TRUE);
	195	}
	196	// ________________________________________________________________________________________________________
	197	// Función: respuestaSondeo
	198	//
	199	// Descripción:
	200	// Recupera el estatus de los ordenadores solicitados leyendo la tabla de sockets
	201	// Parámetros:
	202	// - socket_c: Socket del cliente que envió el mensaje
	203	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
	204	// Devuelve:
	205	// TRUE: Si el proceso es correcto
	206	// FALSE: En caso de ocurrir algún error
	207	// ________________________________________________________________________________________________________
	208	BOOLEAN respuestaSondeo(SOCKET socket_c, TRAMA ptrTrama) {
	209	int i;
	210	long lSize;
	211	char iph, Ipes;
	212	char modulo[] = "respuestaSondeo()";
	213
	214	iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP
	215	lSize = strlen(iph); // Calcula longitud de la cadena de direccion/es IPE/S
	216	Ipes = (char*) reservaMemoria(lSize + 1);
	217	if (Ipes == NULL) {
	218	errorLog(modulo, 3, FALSE);
	219	return (FALSE);
	220	}
	221	strcpy(Ipes, iph); // Copia cadena de IPES
[0a73ecf7]	222	liberaMemoria(iph);
[3ec149c]	223	initParametros(ptrTrama,0);
	224	strcpy(ptrTrama->parametros, "tso="); // Compone retorno tso (sistemas operativos de los clientes )
	225	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
	226	if (strncmp(tbsockets[i].ip, "\0", 1) != 0) { // Si es un cliente activo
	227	if (contieneIP(Ipes, tbsockets[i].ip)) { // Si existe la IP en la cadena
	228	strcat(ptrTrama->parametros, tbsockets[i].ip); // Compone retorno
	229	strcat(ptrTrama->parametros, "/"); // "ip/sistema operativo;"
	230	strcat(ptrTrama->parametros, tbsockets[i].estado);
	231	strcat(ptrTrama->parametros, ";");
	232	}
	233	}
	234	}
	235	strcat(ptrTrama->parametros, "\r");
[fc480f2]	236	liberaMemoria(Ipes);
[3ec149c]	237	if (!mandaTrama(socket_c, ptrTrama)) {
	238	errorLog(modulo, 26, FALSE);
	239	return (FALSE);
	240	}
	241	return (TRUE);
	242	}
	243	// ________________________________________________________________________________________________________
	244	// Función: Actualizar
	245	//
	246	// Descripción:
	247	// Obliga a los clientes a iniciar sesión en el sistema
	248	// Parámetros:
	249	// - socket_c: Socket del cliente que envió el mensaje
	250	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
	251	// Devuelve:
	252	// TRUE: Si el proceso es correcto
	253	// FALSE: En caso de ocurrir algún error
	254	// ________________________________________________________________________________________________________
	255	BOOLEAN Actualizar(SOCKET socket_c, TRAMA ptrTrama) {
	256	char msglog[LONSTD];
	257	char modulo[] = "Actualizar()";
	258
	259	if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) {
	260	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	261	errorInfo(modulo, msglog);
	262	return (FALSE);
	263	}
	264	respuestaConsola(socket_c, ptrTrama, TRUE);
	265	return (TRUE);
	266	}
	267	// ________________________________________________________________________________________________________
	268	// Función: Purgar
	269	//
	270	// Descripción:
	271	// Detiene la ejecución del browser en el cliente
	272	// Parámetros:
	273	// - socket_c: Socket del cliente que envió el mensaje
	274	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
	275	// Devuelve:
	276	// TRUE: Si el proceso es correcto
	277	// FALSE: En caso de ocurrir algún error
	278	// ________________________________________________________________________________________________________
	279	BOOLEAN Purgar(SOCKET socket_c, TRAMA ptrTrama) {
	280	char msglog[LONSTD];
	281	char modulo[] = "Purgar()";
	282
	283	if (!enviaComando(ptrTrama, CLIENTE_APAGADO)) {
	284	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	285	errorInfo(modulo, msglog);
	286	return (FALSE);
	287	}
	288	respuestaConsola(socket_c, ptrTrama, TRUE);
	289	return (TRUE);
	290	}
	291	// ________________________________________________________________________________________________________
	292	// Función: ConsolaRemota
	293	//
	294	// Descripción:
	295	// Envia un script al cliente, éste lo ejecuta y manda el archivo que genera la salida por pantalla
	296	// Parámetros:
	297	// - socket_c: Socket del cliente que envió el mensaje
	298	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
	299	// Devuelve:
	300	// TRUE: Si el proceso es correcto
	301	// FALSE: En caso de ocurrir algún error
	302	// ________________________________________________________________________________________________________
	303	BOOLEAN ConsolaRemota(SOCKET socket_c, TRAMA ptrTrama)
	304	{
	305	char iph,fileco[LONPRM],msglog[LONSTD],ptrIpes[MAXIMOS_CLIENTES];;
	306	FILE* f;
	307	int i,lon;
	308	char modulo[] = "ConsolaRemota()";
	309
	310	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	311	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	312	errorInfo(modulo, msglog);
	313	respuestaConsola(socket_c, ptrTrama, FALSE);
	314	return (FALSE);
	315	}
	316	INTROaFINCAD(ptrTrama);
	317	/* Destruye contenido del fichero de eco anterior */
	318	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
	319	lon = splitCadena(ptrIpes,iph,';');
	320	for (i = 0; i < lon; i++) {
	321	sprintf(fileco,"/tmp/_Seconsola_%s",ptrIpes[i]); // Nombre que tendra el archivo en el Servidor
	322	f = fopen(fileco, "wt");
	323	fclose(f);
	324	}
[0a73ecf7]	325	liberaMemoria(iph);
[3ec149c]	326	respuestaConsola(socket_c, ptrTrama, TRUE);
	327	return (TRUE);
	328	}
	329	// ________________________________________________________________________________________________________
	330	// Función: EcoConsola
	331	//
	332	// Descripción:
	333	// Solicita el eco de una consola remota almacenado en un archivo de eco
	334	// Parámetros:
	335	// - socket_c: Socket del cliente que envió el mensaje
	336	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros del mensaje
	337	// Devuelve:
	338	// TRUE: Si el proceso es correcto
	339	// FALSE: En caso de ocurrir algún error
	340	// ________________________________________________________________________________________________________
	341	BOOLEAN EcoConsola(SOCKET socket_c, TRAMA ptrTrama)
	342	{
	343	char iph,fileco[LONPRM],buffer;
	344	int lSize;
	345	char modulo[] = "EcoConsola()";
	346
	347	INTROaFINCAD(ptrTrama);
	348	// Lee archivo de eco de consola
	349	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
	350	sprintf(fileco,"/tmp/_Seconsola_%s",iph); // Nombre del archivo en el Servidor
	351	lSize=lonArchivo(fileco);
	352	if(lSize>0){ // Si el fichero tiene contenido...
	353	initParametros(ptrTrama,lSize+LONGITUD_PARAMETROS);
	354	buffer=leeArchivo(fileco);
	355	sprintf(ptrTrama->parametros,"res=%s\r",buffer);
[0a73ecf7]	356	liberaMemoria(buffer);
[3ec149c]	357	}
	358	else{
	359	initParametros(ptrTrama,0);
	360	sprintf(ptrTrama->parametros,"res=\r");
	361	}
	362	ptrTrama->tipo=MSG_RESPUESTA; // Tipo de mensaje
	363	if (!mandaTrama(socket_c, ptrTrama)) {
	364	errorLog(modulo, 26, FALSE);
	365	return (FALSE);
	366	}
	367	return (TRUE);
	368	}
	369	// ________________________________________________________________________________________________________
	370	// Función: clienteDisponible
	371	//
	372	// Descripción:
	373	// Comprueba la disponibilidad del cliente para recibir comandos interactivos
	374	// Parametros:
	375	// - ip : La ip del cliente a buscar
	376	// - idx: (Salida) Indice que ocupa el cliente, de estar ya registrado
	377	// Devuelve:
	378	// TRUE: Si el cliente está disponible
	379	// FALSE: En caso contrario
	380	// ________________________________________________________________________________________________________
	381	BOOLEAN clienteDisponible(char ip, int idx) {
	382	int estado;
	383
	384	if (clienteExistente(ip, idx)) {
	385	estado = strcmp(tbsockets[*idx].estado, CLIENTE_OCUPADO); // Cliente ocupado
	386	if (estado == 0)
	387	return (FALSE);
	388
	389	estado = strcmp(tbsockets[*idx].estado, CLIENTE_APAGADO); // Cliente apagado
	390	if (estado == 0)
	391	return (FALSE);
	392
	393	estado = strcmp(tbsockets[*idx].estado, CLIENTE_INICIANDO); // Cliente en proceso de inclusión
	394	if (estado == 0)
	395	return (FALSE);
	396
	397	return (TRUE); // En caso contrario el cliente está disponible
	398	}
	399	return (FALSE); // Cliente no está registrado en el sistema
	400	}
	401	// ________________________________________________________________________________________________________
	402	// Función: clienteExistente
	403	//
	404	// Descripción:
	405	// Comprueba si el cliente está registrado en la tabla de socket del sistema
	406	// Parametros:
	407	// - ip : La ip del cliente a buscar
	408	// - idx:(Salida) Indice que ocupa el cliente, de estar ya registrado
	409	// Devuelve:
	410	// TRUE: Si el cliente está registrado
	411	// FALSE: En caso contrario
	412	// ________________________________________________________________________________________________________
	413	BOOLEAN clienteExistente(char ip, int idx) {
	414	int i;
	415	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
	416	if (contieneIP(ip, tbsockets[i].ip)) { // Si existe la IP en la cadena
	417	*idx = i;
	418	return (TRUE);
	419	}
	420	}
	421	return (FALSE);
	422	}
	423	// ________________________________________________________________________________________________________
	424	// Función: hayHueco
	425	//
	426	// Descripción:
	427	// Esta función devuelve TRUE o FALSE dependiendo de que haya hueco en la tabla de sockets para un nuevo cliente.
	428	// Parametros:
	429	// - idx: Primer indice libre que se podrn utilizar
	430	// Devuelve:
	431	// TRUE: Si el proceso es correcto
	432	// FALSE: En caso de ocurrir algún error
	433	// ________________________________________________________________________________________________________
	434	BOOLEAN hayHueco(int *idx) {
	435	int i;
	436
	437	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
	438	if (strncmp(tbsockets[i].ip, "\0", 1) == 0) { // Hay un hueco
	439	*idx = i;
	440	return (TRUE);
	441	}
	442	}
	443	return (FALSE);
	444	}
	445	// ________________________________________________________________________________________________________
[f679cf0]	446	// Función: InclusionClienteWin
	447	//
	448	// Descripción:
	449	// Esta función incorpora el socket de un nuevo cliente Windows o Linux a la tabla de clientes
	450	// Parámetros:
	451	// - socket_c: Socket del cliente que envió el mensaje
	452	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	453	// Devuelve:
	454	// TRUE: Si el proceso es correcto
	455	// FALSE: En caso de ocurrir algún error
	456	// ________________________________________________________________________________________________________
	457	BOOLEAN InclusionClienteWinLnx(SOCKET socket_c, TRAMA ptrTrama)
	458	{
	459	char modulo[] = "InclusionClienteWinLnx()";
	460	int res,idordenador,lon;
	461	char nombreordenador[LONFIL];
	462
	463	res=procesoInclusionClienteWinLnx(socket_c, ptrTrama,&idordenador,nombreordenador);
	464
	465	// Prepara la trama de respuesta
	466
	467	initParametros(ptrTrama,0);
	468	ptrTrama->tipo=MSG_RESPUESTA;
	469	lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_InclusionClienteWinLnx\r");
	470	lon += sprintf(ptrTrama->parametros + lon, "ido=%d\r", idordenador);
	471	lon += sprintf(ptrTrama->parametros + lon, "npc=%s\r", nombreordenador);
	472	lon += sprintf(ptrTrama->parametros + lon, "res=%d\r", res);
	473
	474	if (!mandaTrama(socket_c, ptrTrama)) {
	475	errorLog(modulo, 26, FALSE);
	476	return (FALSE);
	477	}
	478	return (TRUE);
	479	}
	480	// ________________________________________________________________________________________________________
	481	// Función: procesoInclusionClienteWinLnx
	482	//
	483	// Descripción:
	484	// Implementa el proceso de inclusión en el sistema del Cliente Windows o Linux
	485	// Parámetros de entrada:
	486	// - socket_c: Socket del cliente que envió el mensaje
	487	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	488	// Parámetros de salida:
	489	// - ido: Identificador del ordenador
	490	// - nombreordenador: Nombre del ordenador
	491	// Devuelve:
	492	// Código del error producido en caso de ocurrir algún error, 0 si el proceso es correcto
	493	// ________________________________________________________________________________________________________
	494	BOOLEAN procesoInclusionClienteWinLnx(SOCKET socket_c, TRAMA ptrTrama,int idordenador,char nombreordenador)
	495	{
	496	char msglog[LONSTD], sqlstr[LONSQL];
	497	Database db;
	498	Table tbl;
	499
	500	char *iph;
	501	char modulo[] = "procesoInclusionClienteWinLnx()";
	502
	503	// Toma parámetros
	504	iph = copiaParametro("iph",ptrTrama); // Toma ip
	505
	506	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
	507	errorLog(modulo, 20, FALSE);
	508	db.GetErrorErrStr(msglog);
	509	errorInfo(modulo, msglog);
	510	return (20);
	511	}
	512
	513	// Recupera los datos del cliente
	514	sprintf(sqlstr,
	515	"SELECT idordenador,nombreordenador FROM ordenadores "
	516	" WHERE ordenadores.ip = '%s'", iph);
	517
	518	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	519	errorLog(modulo, 21, FALSE);
	520	db.GetErrorErrStr(msglog);
	521	errorInfo(modulo, msglog);
	522	return (21);
	523	}
	524
	525	if (tbl.ISEOF()) { // Si no existe el cliente
	526	errorLog(modulo, 22, FALSE);
	527	return (22);
	528	}
	529
	530	if (ndebug == DEBUG_ALTO) {
	531	sprintf(msglog, "%s IP:%s", tbMensajes[2], iph);
	532	infoDebug(msglog);
	533	}
	534	if (!tbl.Get("idordenador", *idordenador)) {
	535	tbl.GetErrorErrStr(msglog);
	536	errorInfo(modulo, msglog);
	537	return (FALSE);
	538	}
	539	if (!tbl.Get("nombreordenador", nombreordenador)) {
	540	tbl.GetErrorErrStr(msglog);
	541	errorInfo(modulo, msglog);
	542	return (FALSE);
	543	}
	544	db.Close();
	545
	546	if (!registraCliente(iph)) { // Incluyendo al cliente en la tabla de sokets
[0a73ecf7]	547	liberaMemoria(iph);
[f679cf0]	548	errorLog(modulo, 25, FALSE);
	549	return (25);
	550	}
[0a73ecf7]	551	liberaMemoria(iph);
[f679cf0]	552	return(0);
	553	}
	554	// ________________________________________________________________________________________________________
[3ec149c]	555	// Función: InclusionCliente
	556	//
	557	// Descripción:
	558	// Esta función incorpora el socket de un nuevo cliente a la tabla de clientes y le devuelve alguna de sus propiedades:
	559	// nombre, identificador, tamaño de la caché , etc ...
	560	// Parámetros:
	561	// - socket_c: Socket del cliente que envió el mensaje
	562	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	563	// Devuelve:
	564	// TRUE: Si el proceso es correcto
	565	// FALSE: En caso de ocurrir algún error
	566	// ________________________________________________________________________________________________________
	567	BOOLEAN InclusionCliente(SOCKET socket_c, TRAMA ptrTrama) {
	568	char modulo[] = "InclusionCliente()";
	569
	570	if (!procesoInclusionCliente(socket_c, ptrTrama)) { // Ha habido algún error...
	571	initParametros(ptrTrama,0);
	572	strcpy(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\rres=0\r");
	573	if (!mandaTrama(socket_c, ptrTrama)) {
	574	errorLog(modulo, 26, FALSE);
	575	return (FALSE);
	576	}
	577	}
	578	return (TRUE);
[f679cf0]	579	}
[3ec149c]	580	// ________________________________________________________________________________________________________
	581	// Función: procesoInclusionCliente
	582	//
	583	// Descripción:
	584	// Implementa el proceso de inclusión en el sistema del Cliente
	585	// Parámetros:
	586	// - socket_c: Socket del cliente que envió el mensaje
	587	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	588	// Devuelve:
	589	// TRUE: Si el proceso es correcto
	590	// FALSE: En caso de ocurrir algún error
	591	// ________________________________________________________________________________________________________
	592	BOOLEAN procesoInclusionCliente(SOCKET socket_c, TRAMA ptrTrama) {
	593	char msglog[LONSTD], sqlstr[LONSQL];
	594	Database db;
	595	Table tbl;
	596
	597	char iph, cfg;
	598	char nombreordenador[LONFIL];
	599	int lon, resul, idordenador, idmenu, cache, idproautoexec, idaula, idcentro;
[f679cf0]	600	char modulo[] = "procesoInclusionCliente()";
[3ec149c]	601
	602	// Toma parámetros
	603	iph = copiaParametro("iph",ptrTrama); // Toma ip
	604	cfg = copiaParametro("cfg",ptrTrama); // Toma configuracion
	605
	606	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
	607	errorLog(modulo, 20, FALSE);
	608	db.GetErrorErrStr(msglog);
	609	errorInfo(modulo, msglog);
	610	return (FALSE);
	611	}
	612
	613	// Recupera los datos del cliente
	614	sprintf(sqlstr,
	615	"SELECT ordenadores.*,aulas.idaula,centros.idcentro FROM ordenadores "
	616	" INNER JOIN aulas ON aulas.idaula=ordenadores.idaula"
	617	" INNER JOIN centros ON centros.idcentro=aulas.idcentro"
	618	" WHERE ordenadores.ip = '%s'", iph);
	619
	620	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	621	errorLog(modulo, 21, FALSE);
	622	db.GetErrorErrStr(msglog);
	623	errorInfo(modulo, msglog);
	624	return (FALSE);
	625	}
	626
	627	if (tbl.ISEOF()) { // Si no existe el cliente
	628	errorLog(modulo, 22, FALSE);
	629	return (FALSE);
	630	}
	631
	632	if (ndebug == DEBUG_ALTO) {
	633	sprintf(msglog, "%s IP:%s", tbMensajes[2], iph);
	634	infoDebug(msglog);
	635	}
	636	if (!tbl.Get("idordenador", idordenador)) {
	637	tbl.GetErrorErrStr(msglog);
	638	errorInfo(modulo, msglog);
	639	return (FALSE);
	640	}
	641	if (!tbl.Get("nombreordenador", nombreordenador)) {
	642	tbl.GetErrorErrStr(msglog);
	643	errorInfo(modulo, msglog);
	644	return (FALSE);
	645	}
	646	if (!tbl.Get("idmenu", idmenu)) {
	647	tbl.GetErrorErrStr(msglog);
	648	errorInfo(modulo, msglog);
	649	return (FALSE);
	650	}
	651	if (!tbl.Get("cache", cache)) {
	652	tbl.GetErrorErrStr(msglog);
	653	errorInfo(modulo, msglog);
	654	return (FALSE);
	655	}
	656	if (!tbl.Get("idproautoexec", idproautoexec)) {
	657	tbl.GetErrorErrStr(msglog);
	658	errorInfo(modulo, msglog);
	659	return (FALSE);
	660	}
	661	if (!tbl.Get("idaula", idaula)) {
	662	tbl.GetErrorErrStr(msglog);
	663	errorInfo(modulo, msglog);
	664	return (FALSE);
	665	}
	666	if (!tbl.Get("idcentro", idcentro)) {
	667	tbl.GetErrorErrStr(msglog);
	668	errorInfo(modulo, msglog);
	669	return (FALSE);
	670	}
	671
	672	resul = actualizaConfiguracion(db, tbl, cfg, idordenador); // Actualiza la configuración del ordenador
[0a73ecf7]	673	liberaMemoria(cfg);
[3ec149c]	674	db.Close();
	675
	676	if (!resul) {
[0a73ecf7]	677	liberaMemoria(iph);
[3ec149c]	678	errorLog(modulo, 29, FALSE);
	679	return (FALSE);
	680	}
	681
	682	if (!registraCliente(iph)) { // Incluyendo al cliente en la tabla de sokets
[0a73ecf7]	683	liberaMemoria(iph);
[3ec149c]	684	errorLog(modulo, 25, FALSE);
	685	return (FALSE);
	686	}
	687
	688	/*------------------------------------------------------------------------------------------------------------------------------
	689	Prepara la trama de respuesta
	690	-------------------------------------------------------------------------------------------------------------------------------*/
	691	initParametros(ptrTrama,0);
	692	ptrTrama->tipo=MSG_RESPUESTA;
	693	lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_InclusionCliente\r");
	694	lon += sprintf(ptrTrama->parametros + lon, "ido=%d\r", idordenador);
	695	lon += sprintf(ptrTrama->parametros + lon, "npc=%s\r", nombreordenador);
	696	lon += sprintf(ptrTrama->parametros + lon, "che=%d\r", cache);
	697	lon += sprintf(ptrTrama->parametros + lon, "exe=%d\r", idproautoexec);
	698	lon += sprintf(ptrTrama->parametros + lon, "ida=%d\r", idaula);
	699	lon += sprintf(ptrTrama->parametros + lon, "idc=%d\r", idcentro);
	700	lon += sprintf(ptrTrama->parametros + lon, "res=%d\r", 1); // Confirmación proceso correcto
	701
	702	if (!mandaTrama(socket_c, ptrTrama)) {
	703	errorLog(modulo, 26, FALSE);
	704	return (FALSE);
	705	}
[0a73ecf7]	706	liberaMemoria(iph);
[3ec149c]	707	return (TRUE);
	708	}
	709	// ________________________________________________________________________________________________________
	710	// Función: actualizaConfiguracion
	711	//
	712	// Descripción:
	713	// Esta función actualiza la base de datos con la configuracion de particiones de un cliente
	714	// Parámetros:
	715	// - db: Objeto base de datos (ya operativo)
	716	// - tbl: Objeto tabla
	717	// - cfg: cadena con una Configuración
	718	// - ido: Identificador del ordenador cliente
	719	// Devuelve:
	720	// TRUE: Si el proceso es correcto
	721	// FALSE: En caso de ocurrir algún error
	722	// Especificaciones:
	723	// Los parametros de la configuración son:
	724	// par= Número de partición
	725	// cpt= Codigo o tipo de partición
	726	// sfi= Sistema de ficheros que está implementado en la partición
	727	// soi= Nombre del sistema de ficheros instalado en la partición
	728	// tam= Tamaño de la partición
	729	// ________________________________________________________________________________________________________
	730	BOOLEAN actualizaConfiguracion(Database db, Table tbl, char* cfg, int ido)
	731	{
	732	char msglog[LONSTD], sqlstr[LONSQL];
[7224a0a]	733	int lon, p, c,i, dato, swu, idsoi, idsfi,k;
[ba98026]	734	char ptrPar[MAXPAR], ptrCfg[6], *ptrDual[2], tbPar[LONSTD];
[db4d467]	735	char ser, disk, par, cpt, sfi, soi, tam, uso; // Parametros de configuración.
[3ec149c]	736	char modulo[] = "actualizaConfiguracion()";
	737
[0d6ed7ac]	738	lon = 0;
[3ec149c]	739	p = splitCadena(ptrPar, cfg, '\n');
	740	for (i = 0; i < p; i++) {
	741	c = splitCadena(ptrCfg, ptrPar[i], '\t');
[db4d467]	742
	743	// Si la 1ª línea solo incluye el número de serie del equipo; actualizar BD.
	744	if (i == 0 && c == 1) {
	745	splitCadena(ptrDual, ptrCfg[0], '=');
	746	ser = ptrDual[1];
	747	if (strlen(ser) > 0) {
	748	// Solo actualizar si número de serie no existía.
	749	sprintf(sqlstr, "UPDATE ordenadores SET numserie='%s'"
[ac933ca]	750	" WHERE idordenador=%d AND numserie IS NULL",
[db4d467]	751	ser, ido);
	752	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	753	db.GetErrorErrStr(msglog);
	754	errorInfo(modulo, msglog);
	755	return (FALSE);
	756	}
	757	}
	758	continue;
	759	}
	760
	761	// Distribución de particionado.
[b0c9683]	762	disk = par = cpt = sfi = soi = tam = uso = NULL;
[db4d467]	763
[3ec149c]	764	splitCadena(ptrDual, ptrCfg[0], '=');
[ba98026]	765	disk = ptrDual[1]; // Número de disco
[3ec149c]	766
	767	splitCadena(ptrDual, ptrCfg[1], '=');
[ba98026]	768	par = ptrDual[1]; // Número de partición
	769
[5f9eca0]	770	k=splitCadena(ptrDual, ptrCfg[2], '=');
	771	if(k==2){
	772	cpt = ptrDual[1]; // Código de partición
	773	}else{
[db4d467]	774	cpt = (char*)"0";
[5f9eca0]	775	}
[3ec149c]	776
[ba98026]	777	k=splitCadena(ptrDual, ptrCfg[3], '=');
[3ec149c]	778	if(k==2){
	779	sfi = ptrDual[1]; // Sistema de ficheros
[0a73ecf7]	780	/* Comprueba existencia del s0xistema de ficheros instalado */
[3ec149c]	781	idsfi = checkDato(db, tbl, sfi, "sistemasficheros", "descripcion","idsistemafichero");
	782	}
	783	else
	784	idsfi=0;
	785
[ba98026]	786	k=splitCadena(ptrDual, ptrCfg[4], '=');
[3ec149c]	787	if(k==2){ // Sistema operativo detecdtado
	788	soi = ptrDual[1]; // Nombre del S.O. instalado
	789	/* Comprueba existencia del sistema operativo instalado */
	790	idsoi = checkDato(db, tbl, soi, "nombresos", "nombreso", "idnombreso");
	791	}
	792	else
	793	idsoi=0;
	794
[ba98026]	795	splitCadena(ptrDual, ptrCfg[5], '=');
[3ec149c]	796	tam = ptrDual[1]; // Tamaño de la partición
	797
[b0c9683]	798	splitCadena(ptrDual, ptrCfg[6], '=');
	799	uso = ptrDual[1]; // Porcentaje de uso del S.F.
	800
[0d6ed7ac]	801	lon += sprintf(tbPar + lon, "(%s, %s),", disk, par);
[3ec149c]	802
[b0c9683]	803	sprintf(sqlstr, "SELECT numdisk, numpar, codpar, tamano, uso, idsistemafichero, idnombreso"
	804	" FROM ordenadores_particiones"
	805	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
[ba98026]	806	ido, disk, par);
[6e235cd]	807
	808
[3ec149c]	809	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	810	errorLog(modulo, 21, FALSE);
	811	db.GetErrorErrStr(msglog);
	812	errorInfo(modulo, msglog);
	813	return (FALSE);
	814	}
	815	if (tbl.ISEOF()) { // Si no existe el registro
[b0c9683]	816	sprintf(sqlstr, "INSERT INTO ordenadores_particiones(idordenador,numdisk,numpar,codpar,tamano,uso,idsistemafichero,idnombreso,idimagen)"
	817	" VALUES(%d,%s,%s,0x%s,%s,%s,%d,%d,0)",
	818	ido, disk, par, cpt, tam, uso, idsfi, idsoi);
[6e235cd]	819
	820
[3ec149c]	821	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	822	db.GetErrorErrStr(msglog);
	823	errorInfo(modulo, msglog);
	824	return (FALSE);
	825	}
	826	} else { // Existe el registro
	827	swu = TRUE; // Se supone que algún dato ha cambiado
	828	if (!tbl.Get("codpar", dato)) { // Toma dato
	829	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	830	errorInfo(modulo, msglog);
	831	return (FALSE);
	832	}
[e66ce87]	833	if (strtol(cpt, NULL, 16) == dato) {// Parámetro tipo de partición (hexadecimal) igual al almacenado (decimal)
[3ec149c]	834	if (!tbl.Get("tamano", dato)) { // Toma dato
	835	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	836	errorInfo(modulo, msglog);
	837	return (FALSE);
	838	}
	839	if (atoi(tam) == dato) {// Parámetro tamaño igual al almacenado
[bbd1290]	840	if (!tbl.Get("idsistemafichero", dato)) { // Toma dato
[3ec149c]	841	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	842	errorInfo(modulo, msglog);
	843	return (FALSE);
	844	}
[bbd1290]	845	if (idsfi == dato) {// Parámetro sistema de fichero igual al almacenado
	846	if (!tbl.Get("idnombreso", dato)) { // Toma dato
[3ec149c]	847	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	848	errorInfo(modulo, msglog);
	849	return (FALSE);
	850	}
[bbd1290]	851	if (idsoi == dato) {// Parámetro sistema de fichero distinto al almacenado
	852	swu = FALSE; // Todos los parámetros de la partición son iguales, no se actualiza
[3ec149c]	853	}
	854	}
	855	}
	856	}
	857	if (swu) { // Hay que actualizar los parámetros de la partición
	858	sprintf(sqlstr, "UPDATE ordenadores_particiones SET "
	859	" codpar=0x%s,"
	860	" tamano=%s,"
[b0c9683]	861	" uso=%s,"
[3ec149c]	862	" idsistemafichero=%d,"
	863	" idnombreso=%d,"
[c916af9]	864	" idimagen=0,"
	865	" idperfilsoft=0,"
	866	" fechadespliegue=NULL"
[ba98026]	867	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
[b0c9683]	868	cpt, tam, uso, idsfi, idsoi, ido, disk, par);
[bbd1290]	869	} else { // Actualizar porcentaje de uso.
	870	sprintf(sqlstr, "UPDATE ordenadores_particiones SET "
	871	" uso=%s"
	872	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
	873	uso, ido, disk, par);
	874	}
	875	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	876	errorLog(modulo, 21, FALSE);
	877	db.GetErrorErrStr(msglog);
	878	errorInfo(modulo, msglog);
	879	return (FALSE);
[3ec149c]	880	}
	881	}
	882	}
[0d6ed7ac]	883	lon += sprintf(tbPar + lon, "(0,0)");
[3ec149c]	884	// Eliminar particiones almacenadas que ya no existen
[0d6ed7ac]	885	sprintf(sqlstr, "DELETE FROM ordenadores_particiones WHERE idordenador=%d AND (numdisk, numpar) NOT IN (%s)",
	886	ido, tbPar);
[3ec149c]	887	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	888	errorLog(modulo, 21, FALSE);
	889	db.GetErrorErrStr(msglog);
	890	errorInfo(modulo, msglog);
	891	return (FALSE);
	892	}
	893	return (TRUE);
	894	}
	895	// ________________________________________________________________________________________________________
	896	// Función: checkDato
	897	//
	898	// Descripción:
	899	// Esta función comprueba si existe un dato en una tabla y si no es así lo incluye. devuelve en
	900	// cualquier caso el identificador del registro existenet o del insertado
	901	// Parámetros:
	902	// - db: Objeto base de datos (ya operativo)
	903	// - tbl: Objeto tabla
	904	// - dato: Dato
	905	// - tabla: Nombre de la tabla
	906	// - nomdato: Nombre del dato en la tabla
	907	// - nomidentificador: Nombre del identificador en la tabla
	908	// Devuelve:
	909	// El identificador del registro existente o el del insertado
	910	//
	911	// Especificaciones:
	912	// En caso de producirse algún error se devuelve el valor 0
	913	// ________________________________________________________________________________________________________
	914
	915	int checkDato(Database db, Table tbl, char dato, const chartabla,
	916	const char* nomdato, const char *nomidentificador) {
	917	char msglog[LONSTD], sqlstr[LONSQL];
	918	char modulo[] = "checkDato()";
	919	int identificador;
	920
	921	if (strlen(dato) == 0)
	922	return (0); // EL dato no tiene valor
	923	sprintf(sqlstr, "SELECT %s FROM %s WHERE %s ='%s'", nomidentificador,
	924	tabla, nomdato, dato);
	925
	926	// Ejecuta consulta
	927	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	928	errorLog(modulo, 21, FALSE);
	929	db.GetErrorErrStr(msglog);
	930	errorInfo(modulo, msglog);
	931	return (0);
	932	}
	933	if (tbl.ISEOF()) { // Software NO existente
[df052e1]	934	sprintf(sqlstr, "INSERT INTO %s (%s) VALUES('%s')", tabla, nomdato, dato);
[3ec149c]	935	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	936	db.GetErrorErrStr(msglog); // Error al acceder al registro
	937	errorInfo(modulo, msglog);
	938	return (0);
	939	}
	940	// Recupera el identificador del software
	941	sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
	942	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	943	db.GetErrorErrStr(msglog); // Error al acceder al registro
	944	errorInfo(modulo, msglog);
	945	return (0);
	946	}
	947	if (!tbl.ISEOF()) { // Si existe registro
	948	if (!tbl.Get("identificador", identificador)) {
	949	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	950	errorInfo(modulo, msglog);
	951	return (0);
	952	}
	953	}
	954	} else {
	955	if (!tbl.Get(nomidentificador, identificador)) { // Toma dato
	956	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	957	errorInfo(modulo, msglog);
	958	return (0);
	959	}
	960	}
	961	return (identificador);
	962	}
	963	// ________________________________________________________________________________________________________
	964	// Función: registraCliente
	965	//
	966	// Descripción:
	967	// Incluye al cliente en la tabla de sokets
	968	// Parámetros:
	969	// - iph: Dirección ip del cliente
	970	// Devuelve:
	971	// TRUE: Si el proceso es correcto
	972	// FALSE: En caso de ocurrir algún error
	973	// ________________________________________________________________________________________________________
	974	BOOLEAN registraCliente(char *iph) {
	975	int idx;
	976
	977	if (!clienteExistente(iph, &idx)) { // Si no existe la IP ...
	978	if (!hayHueco(&idx)) { // Busca hueco para el nuevo cliente
	979	return (FALSE); // No hay huecos
	980	}
	981	}
	982	strcpy(tbsockets[idx].ip, iph); // Copia IP
	983	strcpy(tbsockets[idx].estado, CLIENTE_INICIANDO); // Actualiza el estado del cliente
	984	return (TRUE);
	985	}
	986	// ________________________________________________________________________________________________________
	987	// Función: AutoexecCliente
	988	//
	989	// Descripción:
	990	// Envía archivo de autoexec al cliente
	991	// Parámetros:
	992	// - socket_c: Socket del cliente que envió el mensaje
	993	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	994	// Devuelve:
	995	// TRUE: Si el proceso es correcto
	996	// FALSE: En caso de ocurrir algún error
	997	// ________________________________________________________________________________________________________
	998	BOOLEAN AutoexecCliente(SOCKET socket_c, TRAMA ptrTrama) {
	999	int lon;
	1000	char iph, exe, msglog[LONSTD];
	1001	Database db;
	1002	FILE *fileexe;
	1003	char fileautoexec[LONPRM];
	1004	char parametros[LONGITUD_PARAMETROS];
	1005	char modulo[] = "AutoexecCliente()";
	1006
	1007	iph = copiaParametro("iph",ptrTrama); // Toma dirección IP del cliente
	1008	exe = copiaParametro("exe",ptrTrama); // Toma identificador del procedimiento inicial
	1009
	1010	sprintf(fileautoexec, "/tmp/Sautoexec-%s", iph);
[0a73ecf7]	1011	liberaMemoria(iph);
[3ec149c]	1012	fileexe = fopen(fileautoexec, "wb"); // Abre fichero de script
	1013	if (fileexe == NULL) {
	1014	errorLog(modulo, 52, FALSE);
	1015	return (FALSE);
	1016	}
	1017
	1018	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
	1019	errorLog(modulo, 20, FALSE);
	1020	db.GetErrorErrStr(msglog);
	1021	errorInfo(modulo, msglog);
	1022	return (FALSE);
	1023	}
	1024	initParametros(ptrTrama,0);
	1025	if (recorreProcedimientos(db, parametros, fileexe, exe)) {
	1026	lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_AutoexecCliente\r");
	1027	lon += sprintf(ptrTrama->parametros + lon, "nfl=%s\r", fileautoexec);
	1028	lon += sprintf(ptrTrama->parametros + lon, "res=1\r");
	1029	} else {
	1030	lon = sprintf(ptrTrama->parametros, "nfn=RESPUESTA_AutoexecCliente\r");
	1031	lon += sprintf(ptrTrama->parametros + lon, "res=0\r");
	1032	}
	1033
[4d2cdae]	1034	db.Close();
[3ec149c]	1035	fclose(fileexe);
	1036
	1037	if (!mandaTrama(socket_c, ptrTrama)) {
[0a73ecf7]	1038	liberaMemoria(exe);
[3ec149c]	1039	errorLog(modulo, 26, FALSE);
	1040	return (FALSE);
	1041	}
[0a73ecf7]	1042	liberaMemoria(exe);
[3ec149c]	1043	return (TRUE);
	1044	}
	1045	// ________________________________________________________________________________________________________
	1046	// Función: recorreProcedimientos
	1047	//
	1048	// Descripción:
	1049	// Crea un archivo con el código de un procedimiento separando cada comando por un salto de linea
	1050	// Parámetros:
	1051	// Database db,char* parametros,FILE* fileexe,char* idp
	1052	// Devuelve:
	1053	// TRUE: Si el proceso es correcto
	1054	// FALSE: En caso de ocurrir algún error
	1055	// ________________________________________________________________________________________________________
	1056	BOOLEAN recorreProcedimientos(Database db, char* parametros, FILE* fileexe,
	1057	char* idp) {
	1058	int procedimientoid, lsize;
	1059	char idprocedimiento[LONPRM], msglog[LONSTD], sqlstr[LONSQL];
	1060	Table tbl;
	1061	char modulo[] = "recorreProcedimientos()";
	1062
	1063	/* Busca procedimiento */
	1064	sprintf(sqlstr,
	1065	"SELECT procedimientoid,parametros FROM procedimientos_acciones"
	1066	" WHERE idprocedimiento=%s ORDER BY orden", idp);
	1067	// Ejecuta consulta
	1068	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	1069	errorLog(modulo, 21, FALSE);
	1070	db.GetErrorErrStr(msglog);
	1071	errorInfo(modulo, msglog);
	1072	return (FALSE);
	1073	}
	1074	while (!tbl.ISEOF()) { // Recorre procedimientos
	1075	if (!tbl.Get("procedimientoid", procedimientoid)) { // Toma dato
	1076	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	1077	errorInfo(modulo, msglog);
	1078	return (FALSE);
	1079	}
	1080	if (procedimientoid > 0) { // Procedimiento recursivo
	1081	sprintf(idprocedimiento, "%d", procedimientoid);
	1082	if (!recorreProcedimientos(db, parametros, fileexe, idprocedimiento)) {
	1083	return (FALSE);
	1084	}
	1085	} else {
	1086	if (!tbl.Get("parametros", parametros)) { // Toma dato
	1087	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	1088	errorInfo(modulo, msglog);
	1089	return (FALSE);
	1090	}
	1091	strcat(parametros, "@");
	1092	lsize = strlen(parametros);
	1093	fwrite(parametros, 1, lsize, fileexe); // Escribe el código a ejecutar
	1094	}
	1095	tbl.MoveNext();
	1096	}
	1097	return (TRUE);
	1098	}
	1099	// ________________________________________________________________________________________________________
	1100	// Función: ComandosPendientes
	1101	//
	1102	// Descripción:
	1103	// Esta función busca en la base de datos,comandos pendientes de ejecutar por un ordenador concreto
	1104	// Parámetros:
	1105	// - socket_c: Socket del cliente que envió el mensaje
	1106	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1107	// Devuelve:
	1108	// TRUE: Si el proceso es correcto
	1109	// FALSE: En caso de ocurrir algún error
	1110	// ________________________________________________________________________________________________________
[0a73ecf7]	1111	BOOLEAN ComandosPendientes(SOCKET socket_c, TRAMA ptrTrama)
	1112	{
	1113	char ido,iph,pids[LONPRM];
[3ec149c]	1114	int ids, idx;
	1115	char modulo[] = "ComandosPendientes()";
	1116
[0a73ecf7]	1117	iph = copiaParametro("iph",ptrTrama); // Toma dirección IP
[3ec149c]	1118	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1119
	1120	if (!clienteExistente(iph, &idx)) { // Busca índice del cliente
[0a73ecf7]	1121	liberaMemoria(iph);
	1122	liberaMemoria(ido);
[3ec149c]	1123	errorLog(modulo, 47, FALSE);
	1124	return (FALSE);
	1125	}
	1126	if (buscaComandos(ido, ptrTrama, &ids)) { // Existen comandos pendientes
	1127	ptrTrama->tipo = MSG_COMANDO;
	1128	sprintf(pids, "\rids=%d\r", ids);
	1129	strcat(ptrTrama->parametros, pids);
	1130	strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO);
	1131	} else {
	1132	initParametros(ptrTrama,0);
	1133	strcpy(ptrTrama->parametros, "nfn=NoComandosPtes\r");
	1134	}
	1135	if (!mandaTrama(socket_c, ptrTrama)) {
[0a73ecf7]	1136	liberaMemoria(iph);
	1137	liberaMemoria(ido);
[3ec149c]	1138	errorLog(modulo, 26, FALSE);
	1139	return (FALSE);
	1140	}
[0a73ecf7]	1141	liberaMemoria(iph);
	1142	liberaMemoria(ido);
[3ec149c]	1143	return (TRUE);
	1144	}
	1145	// ________________________________________________________________________________________________________
	1146	// Función: buscaComandos
	1147	//
	1148	// Descripción:
	1149	// Busca en la base de datos,comandos pendientes de ejecutar por el cliente
	1150	// Parámetros:
	1151	// - ido: Identificador del ordenador
	1152	// - cmd: Parámetros del comando (Salida)
[0a73ecf7]	1153	// - ids: Identificador de la sesion(Salida)
[3ec149c]	1154	// Devuelve:
	1155	// TRUE: Si el proceso es correcto
	1156	// FALSE: En caso de ocurrir algún error
	1157	// ________________________________________________________________________________________________________
	1158	BOOLEAN buscaComandos(char ido, TRAMA ptrTrama, int *ids)
	1159	{
	1160	char msglog[LONSTD], sqlstr[LONSQL];
	1161	Database db;
	1162	Table tbl;
	1163	int lonprm;
	1164
	1165	char modulo[] = "buscaComandos()";
	1166
	1167	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexión con la BD
	1168	errorLog(modulo, 20, FALSE);
	1169	db.GetErrorErrStr(msglog);
	1170	errorInfo(modulo, msglog);
	1171	return (FALSE);
	1172	}
[0a73ecf7]	1173	sprintf(sqlstr,"SELECT sesion,parametros,length( parametros) as lonprm"\
[3ec149c]	1174	" FROM acciones WHERE idordenador=%s AND estado='%d' ORDER BY idaccion", ido, ACCION_INICIADA);
	1175	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	1176	errorLog(modulo, 21, FALSE);
	1177	db.GetErrorErrStr(msglog);
	1178	errorInfo(modulo, msglog);
	1179	return (FALSE);
	1180	}
	1181	if (tbl.ISEOF()) {
	1182	db.Close();
	1183	return (FALSE); // No hay comandos pendientes
	1184	} else { // Busca entre todas las acciones de diversos ambitos
[0a73ecf7]	1185	if (!tbl.Get("sesion", *ids)) { // Toma identificador de la sesion
[3ec149c]	1186	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	1187	errorInfo(modulo, msglog);
	1188	return (FALSE);
	1189	}
	1190	if (!tbl.Get("lonprm", lonprm)) { // Toma parámetros del comando
	1191	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	1192	errorInfo(modulo, msglog);
	1193	return (FALSE);
	1194	}
	1195	if(!initParametros(ptrTrama,lonprm+LONGITUD_PARAMETROS)){
	1196	db.Close();
	1197	errorLog(modulo, 3, FALSE);
	1198	return (FALSE);
	1199	}
	1200	if (!tbl.Get("parametros", ptrTrama->parametros)) { // Toma parámetros del comando
	1201	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	1202	errorInfo(modulo, msglog);
	1203	return (FALSE);
	1204	}
	1205	}
	1206	db.Close();
	1207	return (TRUE); // Hay comandos pendientes, se toma el primero de la cola
	1208	}
	1209	// ________________________________________________________________________________________________________
	1210	// Función: DisponibilidadComandos
	1211	//
	1212	// Descripción:
	1213	// Esta función habilita a un cliente para recibir comandos desde la consola
	1214	// Parámetros:
	1215	// - socket_c: Socket del cliente que envió el mensaje
	1216	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1217	// Devuelve:
	1218	// TRUE: Si el proceso es correcto
	1219	// FALSE: En caso de ocurrir algún error
	1220	// ________________________________________________________________________________________________________
[0a73ecf7]	1221	//
	1222	BOOLEAN DisponibilidadComandos(SOCKET socket_c, TRAMA ptrTrama)
	1223	{
	1224	char iph, tpc;
[09f40008]	1225	int idx,port_old=0,port_new;
[3ec149c]	1226	char modulo[] = "DisponibilidadComandos()";
[09f40008]	1227
	1228
[3ec149c]	1229
[0a73ecf7]	1230	iph = copiaParametro("iph",ptrTrama); // Toma ip
[3ec149c]	1231	if (!clienteExistente(iph, &idx)) { // Busca índice del cliente
[0a73ecf7]	1232	liberaMemoria(iph);
[3ec149c]	1233	errorLog(modulo, 47, FALSE);
	1234	return (FALSE);
	1235	}
[0a73ecf7]	1236	tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.)
[3ec149c]	1237	strcpy(tbsockets[idx].estado, tpc);
[09f40008]	1238
	1239	port_new=tomaPuerto(*socket_c);
	1240
	1241	if(tbsockets[idx].sock!=INVALID_SOCKET){
	1242	port_old=tomaPuerto(tbsockets[idx].sock);
	1243	if(port_old!=port_new){
	1244	close(tbsockets[idx].sock); // Cierra el socket si ya existia uno
	1245	}
	1246	}
	1247
[3ec149c]	1248	tbsockets[idx].sock = *socket_c;
	1249	swcSocket = TRUE; // El socket permanece abierto para recibir comandos desde el servidor
[0a73ecf7]	1250	liberaMemoria(iph);
	1251	liberaMemoria(tpc);
[3ec149c]	1252	return (TRUE);
	1253	}
	1254	// ________________________________________________________________________________________________________
	1255	// Función: respuestaEstandar
	1256	//
	1257	// Descripción:
	1258	// Esta función actualiza la base de datos con el resultado de la ejecución de un comando con seguimiento
	1259	// Parámetros:
	1260	// - res: resultado de la ejecución del comando
	1261	// - der: Descripción del error si hubiese habido
	1262	// - iph: Dirección IP
[0a73ecf7]	1263	// - ids: identificador de la sesión
[3ec149c]	1264	// - ido: Identificador del ordenador que notifica
	1265	// - db: Objeto base de datos (operativo)
	1266	// - tbl: Objeto tabla
	1267	// Devuelve:
	1268	// TRUE: Si el proceso es correcto
	1269	// FALSE: En caso de ocurrir algún error
	1270	// ________________________________________________________________________________________________________
	1271	BOOLEAN respuestaEstandar(TRAMA ptrTrama, char iph, char *ido, Database db,
	1272	Table tbl) {
	1273	char msglog[LONSTD], sqlstr[LONSQL];
	1274	char res, ids, *der;
	1275	char fechafin[LONPRM];
	1276	struct tm* st;
[0a73ecf7]	1277	int idaccion;
[3ec149c]	1278	char modulo[] = "respuestaEstandar()";
	1279
	1280	ids = copiaParametro("ids",ptrTrama); // Toma identificador de la sesión
	1281
	1282	if (ids == NULL) // No existe seguimiento de la acción
	1283	return (TRUE);
[0a73ecf7]	1284
	1285	if (atoi(ids) == 0){ // No existe seguimiento de la acción
	1286	liberaMemoria(ids);
	1287	return (TRUE);
	1288	}
[3ec149c]	1289
	1290	sprintf(sqlstr,
[0a73ecf7]	1291	"SELECT * FROM acciones WHERE idordenador=%s"
	1292	" AND sesion=%s ORDER BY idaccion", ido,ids);
	1293
	1294	liberaMemoria(ids);
	1295
[3ec149c]	1296	if (!db.Execute(sqlstr, tbl)) { // Error al consultar
	1297	errorLog(modulo, 21, FALSE);
	1298	db.GetErrorErrStr(msglog);
	1299	errorInfo(modulo, msglog);
	1300	return (FALSE);
	1301	}
	1302	if (tbl.ISEOF()) { // No existe registro de acciones
	1303	errorLog(modulo, 31, FALSE);
	1304	return (TRUE);
	1305	}
[0a73ecf7]	1306	if (!tbl.Get("idaccion", idaccion)) { // Toma identificador de la accion
	1307	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	1308	errorInfo(modulo, msglog);
	1309	return (FALSE);
	1310	}
[3ec149c]	1311	st = tomaHora();
	1312	sprintf(fechafin, "%d/%d/%d %d:%d:%d", st->tm_year + 1900, st->tm_mon + 1,
	1313	st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);
	1314
[0a73ecf7]	1315	res = copiaParametro("res",ptrTrama); // Toma resultado
	1316	der = copiaParametro("der",ptrTrama); // Toma descripción del error (si hubiera habido)
	1317
[f55923d]	1318	sprintf(sqlstr,
	1319	"UPDATE acciones"\
	1320	" SET resultado='%s',estado='%d',fechahorafin='%s',descrinotificacion='%s'"\
[0a73ecf7]	1321	" WHERE idordenador=%s AND idaccion=%d",
	1322	res, ACCION_FINALIZADA, fechafin, der, ido, idaccion);
	1323
[3ec149c]	1324	if (!db.Execute(sqlstr, tbl)) { // Error al actualizar
[0a73ecf7]	1325	liberaMemoria(res);
	1326	liberaMemoria(der);
[3ec149c]	1327	db.GetErrorErrStr(msglog);
	1328	errorInfo(modulo, msglog);
	1329	return (FALSE);
	1330	}
[0a73ecf7]	1331
	1332	liberaMemoria(der);
	1333
[f55923d]	1334	if (atoi(res) == ACCION_FALLIDA) {
	1335	liberaMemoria(res);
[3ec149c]	1336	return (FALSE); // Error en la ejecución del comando
[f55923d]	1337	}
[3ec149c]	1338
[f55923d]	1339	liberaMemoria(res);
[3ec149c]	1340	return (TRUE);
	1341	}
	1342	// ________________________________________________________________________________________________________
	1343	// Función: enviaComando
	1344	//
	1345	// Descripción:
	1346	// Envía un comando a los clientes
	1347	// Parámetros:
	1348	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1349	// - estado: Estado en el se deja al cliente mientras se ejecuta el comando
	1350	// Devuelve:
	1351	// TRUE: Si el proceso es correcto
	1352	// FALSE: En caso de ocurrir algún error
	1353	// ________________________________________________________________________________________________________
[f679cf0]	1354	BOOLEAN enviaComando(TRAMA* ptrTrama, const char *estado)
	1355	{
[3ec149c]	1356	char iph, Ipes, *ptrIpes[MAXIMOS_CLIENTES];
	1357	int i, idx, lon;
	1358	char modulo[] = "enviaComando()";
	1359
	1360	iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP
	1361	lon = strlen(iph); // Calcula longitud de la cadena de direccion/es IPE/S
	1362	Ipes = (char*) reservaMemoria(lon + 1);
	1363	if (Ipes == NULL) {
	1364	errorLog(modulo, 3, FALSE);
	1365	return (FALSE);
	1366	}
[0a73ecf7]	1367
[3ec149c]	1368	strcpy(Ipes, iph); // Copia cadena de IPES
[0a73ecf7]	1369	liberaMemoria(iph);
	1370
[3ec149c]	1371	lon = splitCadena(ptrIpes, Ipes, ';');
	1372	FINCADaINTRO(ptrTrama);
	1373	for (i = 0; i < lon; i++) {
	1374	if (clienteDisponible(ptrIpes[i], &idx)) { // Si el cliente puede recibir comandos
	1375	strcpy(tbsockets[idx].estado, estado); // Actualiza el estado del cliente
	1376	if (!mandaTrama(&tbsockets[idx].sock, ptrTrama)) {
	1377	errorLog(modulo, 26, FALSE);
	1378	return (FALSE);
	1379	}
[eeeb98a]	1380	//close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad
[3ec149c]	1381	}
	1382	}
[fc480f2]	1383	liberaMemoria(Ipes);
[3ec149c]	1384	return (TRUE);
	1385	}
	1386	//______________________________________________________________________________________________________
	1387	// Función: respuestaConsola
	1388	//
	1389	// Descripción:
	1390	// Envia una respuesta a la consola sobre el resultado de la ejecución de un comando
	1391	// Parámetros:
	1392	// - socket_c: (Salida) Socket utilizado para el envío
	1393	// - res: Resultado del envío del comando
	1394	// Devuelve:
	1395	// TRUE: Si el proceso es correcto
	1396	// FALSE: En caso de ocurrir algún error
	1397	// ________________________________________________________________________________________________________
	1398	BOOLEAN respuestaConsola(SOCKET socket_c, TRAMA ptrTrama, int res) {
	1399	char modulo[] = "respuestaConsola()";
	1400	initParametros(ptrTrama,0);
	1401	sprintf(ptrTrama->parametros, "res=%d\r", res);
	1402	if (!mandaTrama(socket_c, ptrTrama)) {
	1403	errorLog(modulo, 26, FALSE);
	1404	return (FALSE);
	1405	}
	1406	return (TRUE);
	1407	}
	1408	// ________________________________________________________________________________________________________
	1409	// Función: Arrancar
	1410	//
	1411	// Descripción:
[f55923d]	1412	// Procesa el comando Arrancar
[3ec149c]	1413	// Parámetros:
	1414	// - socket_c: Socket de la consola al envió el mensaje
	1415	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1416	// Devuelve:
	1417	// TRUE: Si el proceso es correcto
	1418	// FALSE: En caso de ocurrir algún error
	1419	// ________________________________________________________________________________________________________
	1420	BOOLEAN Arrancar(SOCKET socket_c, TRAMA ptrTrama) {
[4329e85]	1421	char iph,mac,*mar, msglog[LONSTD];
	1422	BOOLEAN res;
[3ec149c]	1423	char modulo[] = "Arrancar()";
	1424
[4329e85]	1425	iph = copiaParametro("iph",ptrTrama); // Toma dirección/es IP
[3ec149c]	1426	mac = copiaParametro("mac",ptrTrama); // Toma dirección/es MAC
[4329e85]	1427	mar = copiaParametro("mar",ptrTrama); // Método de arranque (Broadcast o Unicast)
	1428
	1429	res=Levanta(iph,mac,mar);
	1430
	1431	liberaMemoria(iph);
	1432	liberaMemoria(mac);
	1433	liberaMemoria(mar);
	1434
	1435	if(!res){
[3ec149c]	1436	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1437	errorInfo(modulo, msglog);
	1438	respuestaConsola(socket_c, ptrTrama, FALSE);
	1439	return (FALSE);
	1440	}
[0a73ecf7]	1441
[3ec149c]	1442	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	1443	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1444	errorInfo(modulo, msglog);
	1445	respuestaConsola(socket_c, ptrTrama, FALSE);
	1446	return (FALSE);
	1447	}
	1448	respuestaConsola(socket_c, ptrTrama, TRUE);
	1449	return (TRUE);
	1450	}
	1451	// ________________________________________________________________________________________________________
	1452	// Función: Levanta
	1453	//
	1454	// Descripción:
	1455	// Enciende ordenadores a través de la red cuyas macs se pasan como parámetro
	1456	// Parámetros:
[4329e85]	1457	// - iph: Cadena de direcciones ip separadas por ";"
[3ec149c]	1458	// - mac: Cadena de direcciones mac separadas por ";"
[4329e85]	1459	// - mar: Método de arranque (1=Broadcast, 2=Unicast)
[3ec149c]	1460	// Devuelve:
	1461	// TRUE: Si el proceso es correcto
	1462	// FALSE: En caso de ocurrir algún error
	1463	// ________________________________________________________________________________________________________
[4329e85]	1464	BOOLEAN Levanta(char* iph,char mac, char mar)
	1465	{
	1466	char ptrIP[MAXIMOS_CLIENTES],ptrMacs[MAXIMOS_CLIENTES];
[3ec149c]	1467	int i, lon, res;
	1468	SOCKET s;
	1469	BOOLEAN bOpt;
	1470	sockaddr_in local;
	1471	char modulo[] = "Levanta()";
	1472
	1473	/* Creación de socket para envío de magig packet */
	1474	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	1475	if (s == SOCKET_ERROR) { // Error al crear el socket del servicio
	1476	errorLog(modulo, 13, TRUE);
	1477	return (FALSE);
	1478	}
	1479	bOpt = TRUE; // Pone el socket en modo Broadcast
	1480	res = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *) &bOpt, sizeof(bOpt));
	1481	if (res == SOCKET_ERROR) {
	1482	errorLog(modulo, 48, TRUE);
	1483	return (FALSE);
	1484	}
	1485	local.sin_family = AF_INET;
	1486	local.sin_port = htons((short) PUERTO_WAKEUP);
	1487	local.sin_addr.s_addr = htonl(INADDR_ANY); // cualquier interface
	1488	if (bind(s, (sockaddr *) &local, sizeof(local)) == SOCKET_ERROR) {
	1489	errorLog(modulo, 14, TRUE);
	1490	exit(EXIT_FAILURE);
	1491	}
	1492	/* fin creación de socket */
[4329e85]	1493	lon = splitCadena(ptrIP, iph, ';');
[3ec149c]	1494	lon = splitCadena(ptrMacs, mac, ';');
	1495	for (i = 0; i < lon; i++) {
[4329e85]	1496	if (!WakeUp(&s,ptrIP[i],ptrMacs[i],mar)) {
[3ec149c]	1497	errorLog(modulo, 49, TRUE);
	1498	close(s);
	1499	return (FALSE);
	1500	}
	1501	}
	1502	close(s);
	1503	return (TRUE);
	1504	}
	1505	//_____________________________________________________________________________________________________________
	1506	// Función: WakeUp
	1507	//
	1508	// Descripción:
	1509	// Enciende el ordenador cuya MAC se pasa como parámetro
	1510	// Parámetros:
	1511	// - s : Socket para enviar trama magic packet
[4329e85]	1512	// - iph : Cadena con la dirección ip
[3ec149c]	1513	// - mac : Cadena con la dirección mac en formato XXXXXXXXXXXX
[4329e85]	1514	// - mar: Método de arranque (1=Broadcast, 2=Unicast)
[3ec149c]	1515	// Devuelve:
	1516	// TRUE: Si el proceso es correcto
	1517	// FALSE: En caso de ocurrir algún error
	1518	//_____________________________________________________________________________________________________________
[4329e85]	1519	//
	1520	BOOLEAN WakeUp(SOCKET s, char iph,char mac,char mar)
	1521	{
[3ec149c]	1522	int i, res;
	1523	char HDaddress_bin[6];
	1524	struct {
	1525	BYTE secuencia_FF[6];
	1526	char macbin[16][6];
	1527	} Trama_WakeUp;
	1528	sockaddr_in WakeUpCliente;
	1529	char modulo[] = "WakeUp()";
	1530
	1531	for (i = 0; i < 6; i++) // Primera secuencia de la trama Wake Up (0xFFFFFFFFFFFF)
	1532	Trama_WakeUp.secuencia_FF[i] = 0xFF;
	1533
	1534	PasaHexBin(mac, HDaddress_bin); // Pasa a binario la MAC
	1535
	1536	for (i = 0; i < 16; i++) // Segunda secuencia de la trama Wake Up , repetir 16 veces su la MAC
	1537	memcpy(&Trama_WakeUp.macbin[i][0], &HDaddress_bin, 6);
	1538
	1539	/* Creación de socket del cliente que recibe la trama magic packet */
	1540	WakeUpCliente.sin_family = AF_INET;
	1541	WakeUpCliente.sin_port = htons((short) PUERTO_WAKEUP);
[4329e85]	1542	if(atoi(mar)==2)
	1543	WakeUpCliente.sin_addr.s_addr = inet_addr(iph); // Para hacerlo con IP
	1544	else
	1545	WakeUpCliente.sin_addr.s_addr = htonl(INADDR_BROADCAST); // Para hacerlo con broadcast
[3ec149c]	1546
	1547	res = sendto(s, (char ) &Trama_WakeUp, sizeof(Trama_WakeUp), 0,
	1548	(sockaddr *) &WakeUpCliente, sizeof(WakeUpCliente));
	1549	if (res == SOCKET_ERROR) {
	1550	errorLog(modulo, 26, FALSE);
	1551	return (FALSE);
	1552	}
	1553	return (TRUE);
	1554	}
	1555	//_____________________________________________________________________________________________________________
	1556	// Función: PasaHexBin
	1557	//
	1558	// Descripción:
	1559	// Convierte a binario una dirección mac desde una cadena con formato XXXXXXXXXXXX
	1560	//
	1561	// Parámetros de entrada:
	1562	// - cadena : Cadena con el contenido de la mac
	1563	// - numero : la dirección mac convertida a binario (6 bytes)
	1564	//_____________________________________________________________________________________________________________
	1565	void PasaHexBin(char cadena, char numero) {
	1566	int i, j, p;
	1567	char matrizHex[] = "0123456789ABCDEF";
	1568	char Ucadena[12], aux;
	1569
	1570	for (i = 0; i < 12; i++)
	1571	Ucadena[i] = toupper(cadena[i]);
	1572	p = 0;
	1573	for (i = 0; i < 12; i++) {
	1574	for (j = 0; j < 16; j++) {
	1575	if (Ucadena[i] == matrizHex[j]) {
	1576	if (i % 2) {
	1577	aux = numero[p];
	1578	aux = (aux << 4);
	1579	numero[p] = j;
	1580	numero[p] = numero[p] \| aux;
	1581	p++;
	1582	} else
	1583	numero[p] = j;
	1584	break;
	1585	}
	1586	}
	1587	}
	1588	}
	1589	// ________________________________________________________________________________________________________
	1590	// Función: RESPUESTA_Arrancar
	1591	//
	1592	// Descripción:
[f55923d]	1593	// Respuesta del cliente al comando Arrancar
[3ec149c]	1594	// Parámetros:
	1595	// - socket_c: Socket del cliente que envió el mensaje
	1596	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1597	// Devuelve:
	1598	// TRUE: Si el proceso es correcto
	1599	// FALSE: En caso de ocurrir algún error
	1600	// ________________________________________________________________________________________________________
	1601	BOOLEAN RESPUESTA_Arrancar(SOCKET socket_c, TRAMA ptrTrama) {
	1602	char msglog[LONSTD];
	1603	Database db;
	1604	Table tbl;
	1605	int i;
	1606	char iph, ido;
	1607	char *tpc;
	1608	char modulo[] = "RESPUESTA_Arrancar()";
	1609
	1610	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	1611	errorLog(modulo, 20, FALSE);
	1612	db.GetErrorErrStr(msglog);
	1613	errorInfo(modulo, msglog);
	1614	return (FALSE);
	1615	}
	1616
	1617	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	1618	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1619
	1620	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	1621	liberaMemoria(iph);
	1622	liberaMemoria(ido);
[3ec149c]	1623	errorLog(modulo, 30, FALSE);
	1624	return (FALSE); // Error al registrar notificacion
	1625	}
	1626
	1627	tpc = copiaParametro("tpc",ptrTrama); // Tipo de cliente (Plataforma y S.O.)
	1628	if (clienteExistente(iph, &i)) // Actualiza estado
	1629	strcpy(tbsockets[i].estado, tpc);
[0a73ecf7]	1630
	1631	liberaMemoria(iph);
	1632	liberaMemoria(ido);
	1633	liberaMemoria(tpc);
	1634
[3ec149c]	1635	db.Close(); // Cierra conexión
	1636	return (TRUE);
	1637	}
	1638	// ________________________________________________________________________________________________________
	1639	// Función: Comando
	1640	//
	1641	// Descripción:
	1642	// Procesa un comando personalizado
	1643	// Parámetros:
	1644	// - socket_c: Socket de la consola al envió el mensaje
	1645	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1646	// Devuelve:
	1647	// TRUE: Si el proceso es correcto
	1648	// FALSE: En caso de ocurrir algún error
	1649	// ________________________________________________________________________________________________________
	1650	BOOLEAN Comando(SOCKET socket_c, TRAMA ptrTrama) {
	1651	char msglog[LONSTD];
	1652	char modulo[] = "Comando()";
	1653
	1654	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	1655	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1656	errorInfo(modulo, msglog);
	1657	respuestaConsola(socket_c, ptrTrama, FALSE);
	1658	return (FALSE);
	1659	}
	1660	respuestaConsola(socket_c, ptrTrama, TRUE);
	1661	return (TRUE);
	1662	}
	1663	// ________________________________________________________________________________________________________
	1664	// Función: RESPUESTA_Comando
	1665	//
	1666	// Descripción:
	1667	// Respuesta del cliente al un comando personalizado
	1668	// Parámetros:
	1669	// - socket_c: Socket del cliente que envió el mensaje
	1670	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1671	// Devuelve:
	1672	// TRUE: Si el proceso es correcto
	1673	// FALSE: En caso de ocurrir algún error
	1674	// ________________________________________________________________________________________________________
[0a73ecf7]	1675	BOOLEAN RESPUESTA_Comando(SOCKET socket_c, TRAMA ptrTrama)
	1676	{
[3ec149c]	1677	char msglog[LONSTD];
	1678	Database db;
	1679	Table tbl;
	1680	char iph, ido;
	1681	char modulo[] = "RESPUESTA_Comando()";
	1682
	1683	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	1684	errorLog(modulo, 20, FALSE);
	1685	db.GetErrorErrStr(msglog);
	1686	errorInfo(modulo, msglog);
	1687	return (FALSE);
	1688	}
	1689
	1690	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	1691	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1692
	1693	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	1694	liberaMemoria(iph);
	1695	liberaMemoria(ido);
[3ec149c]	1696	errorLog(modulo, 30, FALSE);
	1697	return (FALSE); // Error al registrar notificacion
	1698	}
[0a73ecf7]	1699	liberaMemoria(iph);
	1700	liberaMemoria(ido);
[3ec149c]	1701	db.Close(); // Cierra conexión
	1702	return (TRUE);
	1703	}
	1704	// ________________________________________________________________________________________________________
	1705	// Función: Apagar
	1706	//
	1707	// Descripción:
	1708	// Procesa el comando Apagar
	1709	// Parámetros:
	1710	// - socket_c: Socket de la consola al envió el mensaje
	1711	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1712	// Devuelve:
	1713	// TRUE: Si el proceso es correcto
	1714	// FALSE: En caso de ocurrir algún error
	1715	// ________________________________________________________________________________________________________
	1716	BOOLEAN Apagar(SOCKET socket_c, TRAMA ptrTrama) {
	1717	char msglog[LONSTD];
	1718	char modulo[] = "Apagar()";
	1719
	1720	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	1721	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1722	errorInfo(modulo, msglog);
	1723	respuestaConsola(socket_c, ptrTrama, FALSE);
	1724	return (FALSE);
	1725	}
	1726	respuestaConsola(socket_c, ptrTrama, TRUE);
	1727	return (TRUE);
	1728	}
	1729	// ________________________________________________________________________________________________________
	1730	// Función: RESPUESTA_Apagar
	1731	//
	1732	// Descripción:
	1733	// Respuesta del cliente al comando Apagar
	1734	// Parámetros:
	1735	// - socket_c: Socket del cliente que envió el mensaje
	1736	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1737	// Devuelve:
	1738	// TRUE: Si el proceso es correcto
	1739	// FALSE: En caso de ocurrir algún error
	1740	// ________________________________________________________________________________________________________
	1741	BOOLEAN RESPUESTA_Apagar(SOCKET socket_c, TRAMA ptrTrama) {
	1742	char msglog[LONSTD];
	1743	Database db;
	1744	Table tbl;
	1745	int i;
	1746	char iph, ido;
	1747	char modulo[] = "RESPUESTA_Apagar()";
	1748
	1749	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	1750	errorLog(modulo, 20, FALSE);
	1751	db.GetErrorErrStr(msglog);
	1752	errorInfo(modulo, msglog);
	1753	return (FALSE);
	1754	}
	1755
	1756	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	1757	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1758
	1759	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	1760	liberaMemoria(iph);
	1761	liberaMemoria(ido);
[3ec149c]	1762	errorLog(modulo, 30, FALSE);
	1763	return (FALSE); // Error al registrar notificacion
	1764	}
	1765
	1766	if (clienteExistente(iph, &i)) // Actualiza estado
	1767	strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
[0a73ecf7]	1768
	1769	liberaMemoria(iph);
	1770	liberaMemoria(ido);
	1771
[3ec149c]	1772	db.Close(); // Cierra conexión
	1773	return (TRUE);
	1774	}
	1775	// ________________________________________________________________________________________________________
	1776	// Función: Reiniciar
	1777	//
	1778	// Descripción:
	1779	// Procesa el comando Reiniciar
	1780	// Parámetros:
	1781	// - socket_c: Socket de la consola al envió el mensaje
	1782	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1783	// Devuelve:
	1784	// TRUE: Si el proceso es correcto
	1785	// FALSE: En caso de ocurrir algún error
	1786	// ________________________________________________________________________________________________________
	1787	BOOLEAN Reiniciar(SOCKET socket_c, TRAMA ptrTrama) {
	1788	char msglog[LONSTD];
	1789	char modulo[] = "Reiniciar()";
	1790
	1791	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	1792	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1793	errorInfo(modulo, msglog);
	1794	respuestaConsola(socket_c, ptrTrama, FALSE);
	1795	return (FALSE);
	1796	}
	1797	respuestaConsola(socket_c, ptrTrama, TRUE);
	1798	return (TRUE);
	1799	}
	1800	// ________________________________________________________________________________________________________
	1801	// Función: RESPUESTA_Reiniciar
	1802	//
	1803	// Descripción:
	1804	// Respuesta del cliente al comando Reiniciar
	1805	// Parámetros:
	1806	// - socket_c: Socket del cliente que envió el mensaje
	1807	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1808	// Devuelve:
	1809	// TRUE: Si el proceso es correcto
	1810	// FALSE: En caso de ocurrir algún error
	1811	// ________________________________________________________________________________________________________
	1812	BOOLEAN RESPUESTA_Reiniciar(SOCKET socket_c, TRAMA ptrTrama) {
	1813	char msglog[LONSTD];
	1814	Database db;
	1815	Table tbl;
	1816	int i;
	1817	char iph, ido;
	1818	char modulo[] = "RESPUESTA_Reiniciar()";
	1819
	1820	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	1821	errorLog(modulo, 20, FALSE);
	1822	db.GetErrorErrStr(msglog);
	1823	errorInfo(modulo, msglog);
	1824	return (FALSE);
	1825	}
	1826
	1827	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	1828	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1829
	1830	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	1831	liberaMemoria(iph);
	1832	liberaMemoria(ido);
[3ec149c]	1833	errorLog(modulo, 30, FALSE);
	1834	return (FALSE); // Error al registrar notificacion
	1835	}
	1836
	1837	if (clienteExistente(iph, &i)) // Actualiza estado
	1838	strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
[0a73ecf7]	1839
	1840	liberaMemoria(iph);
	1841	liberaMemoria(ido);
[3ec149c]	1842
	1843	db.Close(); // Cierra conexión
	1844	return (TRUE);
	1845	}
	1846	// ________________________________________________________________________________________________________
	1847	// Función: IniciarSesion
	1848	//
	1849	// Descripción:
	1850	// Procesa el comando Iniciar Sesión
	1851	// Parámetros:
	1852	// - socket_c: Socket de la consola al envió el mensaje
	1853	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1854	// Devuelve:
	1855	// TRUE: Si el proceso es correcto
	1856	// FALSE: En caso de ocurrir algún error
	1857	// ________________________________________________________________________________________________________
	1858	BOOLEAN IniciarSesion(SOCKET socket_c, TRAMA ptrTrama) {
	1859	char msglog[LONSTD];
	1860	char modulo[] = "IniciarSesion()";
	1861
	1862	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	1863	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1864	errorInfo(modulo, msglog);
	1865	respuestaConsola(socket_c, ptrTrama, FALSE);
	1866	return (FALSE);
	1867	}
	1868	respuestaConsola(socket_c, ptrTrama, TRUE);
	1869	return (TRUE);
	1870	}
	1871	// ________________________________________________________________________________________________________
	1872	// Función: RESPUESTA_IniciarSesion
	1873	//
	1874	// Descripción:
	1875	// Respuesta del cliente al comando Iniciar Sesión
	1876	// Parámetros:
	1877	// - socket_c: Socket del cliente que envió el mensaje
	1878	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1879	// Devuelve:
	1880	// TRUE: Si el proceso es correcto
	1881	// FALSE: En caso de ocurrir algún error
	1882	// ________________________________________________________________________________________________________
	1883	BOOLEAN RESPUESTA_IniciarSesion(SOCKET socket_c, TRAMA ptrTrama) {
	1884	char msglog[LONSTD];
	1885	Database db;
	1886	Table tbl;
	1887	int i;
	1888	char iph, ido;
	1889	char modulo[] = "RESPUESTA_IniciarSesion()";
	1890
	1891	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	1892	errorLog(modulo, 20, FALSE);
	1893	db.GetErrorErrStr(msglog);
	1894	errorInfo(modulo, msglog);
	1895	return (FALSE);
	1896	}
	1897
	1898	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	1899	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1900
	1901	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	1902	liberaMemoria(iph);
	1903	liberaMemoria(ido);
[3ec149c]	1904	errorLog(modulo, 30, FALSE);
	1905	return (FALSE); // Error al registrar notificacion
	1906	}
	1907
	1908	if (clienteExistente(iph, &i)) // Actualiza estado
	1909	strcpy(tbsockets[i].estado, CLIENTE_APAGADO);
[0a73ecf7]	1910
	1911	liberaMemoria(iph);
	1912	liberaMemoria(ido);
	1913
[3ec149c]	1914	db.Close(); // Cierra conexión
	1915	return (TRUE);
	1916	}
	1917	// ________________________________________________________________________________________________________
	1918	// Función: CrearImagen
	1919	//
	1920	// Descripción:
	1921	// Crea una imagen de una partición de un disco y la guarda o bien en un repositorio
	1922	// Parámetros:
	1923	// - socket_c: Socket de la consola al envió el mensaje
	1924	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1925	// Devuelve:
	1926	// TRUE: Si el proceso es correcto
	1927	// FALSE: En caso de ocurrir algún error
	1928	// ________________________________________________________________________________________________________
	1929	BOOLEAN CrearImagen(SOCKET socket_c, TRAMA ptrTrama) {
	1930	char msglog[LONSTD];
	1931	char modulo[] = "CrearImagen()";
	1932
	1933	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	1934	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	1935	errorInfo(modulo, msglog);
	1936	respuestaConsola(socket_c, ptrTrama, FALSE);
	1937	return (FALSE);
	1938	}
	1939	respuestaConsola(socket_c, ptrTrama, TRUE);
	1940	return (TRUE);
	1941	}
	1942	// ________________________________________________________________________________________________________
	1943	// Función: RESPUESTA_CrearImagen
	1944	//
	1945	// Descripción:
	1946	// Respuesta del cliente al comando CrearImagen
	1947	// Parámetros:
	1948	// - socket_c: Socket del cliente que envió el mensaje
	1949	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	1950	// Devuelve:
	1951	// TRUE: Si el proceso es correcto
	1952	// FALSE: En caso de ocurrir algún error
	1953	// ________________________________________________________________________________________________________
[0a73ecf7]	1954	BOOLEAN RESPUESTA_CrearImagen(SOCKET socket_c, TRAMA ptrTrama)
	1955	{
[3ec149c]	1956	char msglog[LONSTD];
	1957	Database db;
	1958	Table tbl;
[c916af9]	1959	char iph, dsk, par, cpt, ipr, ido;
[3ec149c]	1960	char *idi;
[0a73ecf7]	1961	BOOLEAN res;
[3ec149c]	1962	char modulo[] = "RESPUESTA_CrearImagen()";
	1963
	1964	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	1965	errorLog(modulo, 20, FALSE);
	1966	db.GetErrorErrStr(msglog);
	1967	errorInfo(modulo, msglog);
	1968	return (FALSE);
	1969	}
	1970
	1971	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	1972	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	1973
	1974	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	1975	liberaMemoria(iph);
	1976	liberaMemoria(ido);
[3ec149c]	1977	errorLog(modulo, 30, FALSE);
	1978	return (FALSE); // Error al registrar notificacion
	1979	}
	1980
	1981	// Acciones posteriores
	1982	idi = copiaParametro("idi",ptrTrama);
[c916af9]	1983	dsk = copiaParametro("dsk",ptrTrama);
[3ec149c]	1984	par = copiaParametro("par",ptrTrama);
	1985	cpt = copiaParametro("cpt",ptrTrama);
	1986	ipr = copiaParametro("ipr",ptrTrama);
	1987
[c916af9]	1988	res=actualizaCreacionImagen(db, tbl, idi, dsk, par, cpt, ipr, ido);
[0a73ecf7]	1989
	1990	liberaMemoria(idi);
	1991	liberaMemoria(par);
	1992	liberaMemoria(cpt);
	1993	liberaMemoria(ipr);
	1994
	1995	if(!res){
	1996	errorLog(modulo, 94, FALSE);
[3ec149c]	1997	db.Close(); // Cierra conexión
	1998	return (FALSE);
	1999	}
	2000
	2001	db.Close(); // Cierra conexión
	2002	return (TRUE);
	2003	}
	2004	// ________________________________________________________________________________________________________
	2005	// Función: actualizaCreacionImagen
	2006	//
	2007	// Descripción:
	2008	// Esta función actualiza la base de datos con el resultado de la creación de una imagen
	2009	// Parámetros:
	2010	// - db: Objeto base de datos (ya operativo)
	2011	// - tbl: Objeto tabla
	2012	// - idi: Identificador de la imagen
[c916af9]	2013	// - dsk: Disco de donde se creó
[3ec149c]	2014	// - par: Partición de donde se creó
	2015	// - cpt: Código de partición
	2016	// - ipr: Ip del repositorio
	2017	// - ido: Identificador del ordenador modelo
	2018	// Devuelve:
	2019	// TRUE: Si el proceso es correcto
	2020	// FALSE: En caso de ocurrir algún error
	2021	// ________________________________________________________________________________________________________
[c916af9]	2022	BOOLEAN actualizaCreacionImagen(Database db, Table tbl, char* idi, char* dsk,
	2023	char* par, char* cpt, char* ipr, char *ido) {
[3ec149c]	2024	char msglog[LONSTD], sqlstr[LONSQL];
	2025	char modulo[] = "actualizaCreacionImagen()";
[f029b3b]	2026	int idr,ifs;
[3ec149c]	2027
[5a0e8ec]	2028	/* Toma identificador del repositorio correspondiente al ordenador modelo */
[c916af9]	2029	snprintf(sqlstr, LONSQL,
	2030	"SELECT repositorios.idrepositorio"
[5a0e8ec]	2031	" FROM repositorios"
	2032	" LEFT JOIN ordenadores USING (idrepositorio)"
	2033	" WHERE repositorios.ip='%s' AND ordenadores.idordenador=%s", ipr, ido);
[3ec149c]	2034
	2035	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2036	errorLog(modulo, 21, FALSE);
	2037	db.GetErrorErrStr(msglog);
	2038	errorInfo(modulo, msglog);
	2039	return (FALSE);
	2040	}
	2041	if (!tbl.Get("idrepositorio", idr)) { // Toma dato
	2042	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2043	errorInfo(modulo, msglog);
	2044	return (FALSE);
	2045	}
	2046
	2047	/* Toma identificador del perfilsoftware */
[c916af9]	2048	snprintf(sqlstr, LONSQL,
	2049	"SELECT idperfilsoft"
	2050	" FROM ordenadores_particiones"
	2051	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s", ido, dsk, par);
[3ec149c]	2052
	2053	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2054	errorLog(modulo, 21, FALSE);
	2055	db.GetErrorErrStr(msglog);
	2056	errorInfo(modulo, msglog);
	2057	return (FALSE);
	2058	}
	2059	if (!tbl.Get("idperfilsoft", ifs)) { // Toma dato
	2060	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2061	errorInfo(modulo, msglog);
	2062	return (FALSE);
	2063	}
	2064
	2065	/* Actualizar los datos de la imagen */
[c916af9]	2066	snprintf(sqlstr, LONSQL,
[ab4ab39]	2067	"UPDATE imagenes"
	2068	" SET idordenador=%s, numdisk=%s, numpar=%s, codpar=%s,"
	2069	" idperfilsoft=%d, idrepositorio=%d,"
	2070	" fechacreacion=NOW(), revision=revision+1"
	2071	" WHERE idimagen=%s", ido, dsk, par, cpt, ifs, idr, idi);
[3ec149c]	2072
	2073	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	2074	errorLog(modulo, 21, FALSE);
	2075	db.GetErrorErrStr(msglog);
	2076	errorInfo(modulo, msglog);
	2077	return (FALSE);
	2078	}
[ab4ab39]	2079	/* Actualizar los datos en el cliente */
	2080	snprintf(sqlstr, LONSQL,
	2081	"UPDATE ordenadores_particiones"
[f029b3b]	2082	" SET idimagen=%s, revision=(SELECT revision FROM imagenes WHERE idimagen=%s),"
	2083	" fechadespliegue=NOW()"
[ab4ab39]	2084	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s",
[f029b3b]	2085	idi, idi, ido, dsk, par);
[ab4ab39]	2086	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	2087	errorLog(modulo, 21, FALSE);
	2088	db.GetErrorErrStr(msglog);
	2089	errorInfo(modulo, msglog);
	2090	return (FALSE);
	2091	}
[3ec149c]	2092	return (TRUE);
	2093	}
	2094	// ________________________________________________________________________________________________________
[0a73ecf7]	2095	// Función: CrearImagenBasica
	2096	//
	2097	// Descripción:
	2098	// Crea una imagen basica usando sincronización
	2099	// Parámetros:
	2100	// - socket_c: Socket de la consola al envió el mensaje
	2101	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2102	// Devuelve:
	2103	// TRUE: Si el proceso es correcto
	2104	// FALSE: En caso de ocurrir algún error
	2105	// ________________________________________________________________________________________________________
	2106	BOOLEAN CrearImagenBasica(SOCKET socket_c, TRAMA ptrTrama) {
	2107	char msglog[LONSTD];
	2108	char modulo[] = "CrearImagenBasica()";
	2109
	2110	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2111	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2112	errorInfo(modulo, msglog);
	2113	respuestaConsola(socket_c, ptrTrama, FALSE);
	2114	return (FALSE);
	2115	}
	2116	respuestaConsola(socket_c, ptrTrama, TRUE);
	2117	return (TRUE);
	2118	}
	2119	// ________________________________________________________________________________________________________
	2120	// Función: RESPUESTA_CrearImagenBasica
	2121	//
	2122	// Descripción:
	2123	// Respuesta del cliente al comando CrearImagenBasica
	2124	// Parámetros:
	2125	// - socket_c: Socket del cliente que envió el mensaje
	2126	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2127	// Devuelve:
	2128	// TRUE: Si el proceso es correcto
	2129	// FALSE: En caso de ocurrir algún error
	2130	// ________________________________________________________________________________________________________
	2131	BOOLEAN RESPUESTA_CrearImagenBasica(SOCKET socket_c, TRAMA ptrTrama) {
	2132	return(RESPUESTA_CrearImagen(socket_c,ptrTrama)); // La misma respuesta que la creación de imagen monolítica
	2133	}
	2134	// ________________________________________________________________________________________________________
	2135	// Función: CrearSoftIncremental
	2136	//
	2137	// Descripción:
	2138	// Crea una imagen incremental entre una partición de un disco y una imagen ya creada guardandola en el
	2139	// mismo repositorio y en la misma carpeta donde está la imagen básica
	2140	// Parámetros:
	2141	// - socket_c: Socket de la consola al envió el mensaje
	2142	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2143	// Devuelve:
	2144	// TRUE: Si el proceso es correcto
	2145	// FALSE: En caso de ocurrir algún error
	2146	// ________________________________________________________________________________________________________
	2147	BOOLEAN CrearSoftIncremental(SOCKET socket_c, TRAMA ptrTrama) {
	2148	char msglog[LONSTD];
	2149	char modulo[] = "CrearSoftIncremental()";
	2150
	2151	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2152	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2153	errorInfo(modulo, msglog);
	2154	respuestaConsola(socket_c, ptrTrama, FALSE);
	2155	return (FALSE);
	2156	}
	2157	respuestaConsola(socket_c, ptrTrama, TRUE);
	2158	return (TRUE);
	2159	}
	2160	// ________________________________________________________________________________________________________
	2161	// Función: RESPUESTA_CrearSoftIncremental
	2162	//
	2163	// Descripción:
	2164	// Respuesta del cliente al comando crearImagenDiferencial
	2165	// Parámetros:
	2166	// - socket_c: Socket del cliente que envió el mensaje
	2167	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2168	// Devuelve:
	2169	// TRUE: Si el proceso es correcto
	2170	// FALSE: En caso de ocurrir algún error
	2171	// ________________________________________________________________________________________________________
	2172	BOOLEAN RESPUESTA_CrearSoftIncremental(SOCKET socket_c, TRAMA ptrTrama)
	2173	{
	2174	Database db;
	2175	Table tbl;
	2176	char iph,par,ido,idf;
	2177	int ifs;
	2178	char msglog[LONSTD],sqlstr[LONSQL];
	2179	char modulo[] = "RESPUESTA_CrearSoftIncremental()";
	2180
	2181	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	2182	errorLog(modulo, 20, FALSE);
	2183	db.GetErrorErrStr(msglog);
	2184	errorInfo(modulo, msglog);
	2185	return (FALSE);
	2186	}
	2187
	2188	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	2189	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	2190
	2191	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
	2192	liberaMemoria(iph);
	2193	liberaMemoria(ido);
	2194	errorLog(modulo, 30, FALSE);
	2195	return (FALSE); // Error al registrar notificacion
	2196	}
	2197
	2198	par = copiaParametro("par",ptrTrama);
	2199
	2200	/* Toma identificador del perfilsoftware creado por el inventario de software */
	2201	sprintf(sqlstr,"SELECT idperfilsoft FROM ordenadores_particiones WHERE idordenador=%s AND numpar=%s",ido,par);
	2202
	2203	liberaMemoria(iph);
	2204	liberaMemoria(ido);
	2205	liberaMemoria(par);
	2206
	2207	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2208	errorLog(modulo, 21, FALSE);
	2209	db.GetErrorErrStr(msglog);
	2210	errorInfo(modulo, msglog);
	2211	return (FALSE);
	2212	}
	2213	if (!tbl.Get("idperfilsoft", ifs)) { // Toma dato
	2214	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2215	errorInfo(modulo, msglog);
	2216	return (FALSE);
	2217	}
	2218
	2219	/* Actualizar los datos de la imagen */
	2220	idf = copiaParametro("idf",ptrTrama);
	2221	sprintf(sqlstr,"UPDATE imagenes SET idperfilsoft=%d WHERE idimagen=%s",ifs,idf);
	2222	liberaMemoria(idf);
	2223
	2224	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	2225	errorLog(modulo, 21, FALSE);
	2226	db.GetErrorErrStr(msglog);
	2227	errorInfo(modulo, msglog);
	2228	return (FALSE);
	2229	}
	2230	db.Close(); // Cierra conexión
	2231	return (TRUE);
	2232	}
	2233	// ________________________________________________________________________________________________________
	2234	// Función: actualizaCreacionSoftIncremental
	2235	//
	2236	// Descripción:
	2237	// Esta función actualiza la base de datos con el resultado de la creación de software incremental
	2238	// Parámetros:
	2239	// - db: Objeto base de datos (ya operativo)
	2240	// - tbl: Objeto tabla
	2241	// - idi: Identificador de la imagen
	2242	// - idf: Identificador del software incremental
	2243	// Devuelve:
	2244	// TRUE: Si el proceso es correcto
	2245	// FALSE: En caso de ocurrir algún error
	2246	// ________________________________________________________________________________________________________
	2247	BOOLEAN actualizaCreacionSoftIncremental(Database db, Table tbl, char* idi,char* idf)
	2248	{
	2249	char msglog[LONSTD], sqlstr[LONSQL];
	2250	char modulo[] = "actualizaCreacionSoftIncremental()";
	2251
	2252
	2253	/* Comprueba si existe ya relación entre la imagen y el software incremental */
	2254	sprintf(sqlstr, "SELECT * FROM imagenes_softincremental"
	2255	" WHERE idimagen=%s AND idsoftincremental=%s", idi,idf);
	2256
	2257	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2258	errorLog(modulo, 21, FALSE);
	2259	db.GetErrorErrStr(msglog);
	2260	errorInfo(modulo, msglog);
	2261	return (FALSE);
	2262	}
	2263	if (!tbl.ISEOF())
	2264	return (TRUE); // Ya existe relación
	2265
	2266	// Crea relación entre la imagen y el software incremental
	2267	sprintf(sqlstr,"INSERT INTO imagenes_softincremental (idimagen,idsoftincremental) VALUES (%s,%s)",idi,idf);
	2268	if (!db.Execute(sqlstr, tbl)) { // Error al ejecutar la sentencia
	2269	errorLog(modulo, 21, FALSE);
	2270	db.GetErrorErrStr(msglog);
	2271	errorInfo(modulo, msglog);
	2272	return (FALSE);
	2273	}
	2274	return (TRUE);
	2275	}
	2276	// ________________________________________________________________________________________________________
[3ec149c]	2277	// Función: RestaurarImagen
	2278	//
	2279	// Descripción:
	2280	// Restaura una imagen en una partición
	2281	// Parámetros:
	2282	// - socket_c: Socket de la consola al envió el mensaje
	2283	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2284	// Devuelve:
	2285	// TRUE: Si el proceso es correcto
	2286	// FALSE: En caso de ocurrir algún error
	2287	// ________________________________________________________________________________________________________
	2288	BOOLEAN RestaurarImagen(SOCKET socket_c, TRAMA ptrTrama) {
	2289	char msglog[LONSTD];
	2290	char modulo[] = "RestaurarImagen()";
	2291
	2292	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2293	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2294	errorInfo(modulo, msglog);
	2295	respuestaConsola(socket_c, ptrTrama, FALSE);
	2296	return (FALSE);
	2297	}
	2298	respuestaConsola(socket_c, ptrTrama, TRUE);
	2299	return (TRUE);
	2300	}
	2301	// ________________________________________________________________________________________________________
[0a73ecf7]	2302	// Función: RestaurarImagenBasica
	2303	//
	2304	// Descripción:
	2305	// Restaura una imagen básica en una partición
	2306	// Parámetros:
	2307	// - socket_c: Socket de la consola al envió el mensaje
	2308	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2309	// Devuelve:
	2310	// TRUE: Si el proceso es correcto
	2311	// FALSE: En caso de ocurrir algún error
	2312	// ________________________________________________________________________________________________________
	2313	BOOLEAN RestaurarImagenBasica(SOCKET socket_c, TRAMA ptrTrama) {
	2314	char msglog[LONSTD];
	2315	char modulo[] = "RestaurarImagenBasica()";
	2316
	2317	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2318	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2319	errorInfo(modulo, msglog);
	2320	respuestaConsola(socket_c, ptrTrama, FALSE);
	2321	return (FALSE);
	2322	}
	2323	respuestaConsola(socket_c, ptrTrama, TRUE);
	2324	return (TRUE);
	2325	}
	2326	// ________________________________________________________________________________________________________
	2327	// Función: RestaurarSoftIncremental
	2328	//
	2329	// Descripción:
	2330	// Restaura una imagen básica junto con software incremental en una partición
	2331	// Parámetros:
	2332	// - socket_c: Socket de la consola al envió el mensaje
	2333	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2334	// Devuelve:
	2335	// TRUE: Si el proceso es correcto
	2336	// FALSE: En caso de ocurrir algún error
	2337	// ________________________________________________________________________________________________________
	2338	BOOLEAN RestaurarSoftIncremental(SOCKET socket_c, TRAMA ptrTrama) {
	2339	char msglog[LONSTD];
	2340	char modulo[] = "RestaurarSoftIncremental()";
	2341
	2342	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2343	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2344	errorInfo(modulo, msglog);
	2345	respuestaConsola(socket_c, ptrTrama, FALSE);
	2346	return (FALSE);
	2347	}
	2348	respuestaConsola(socket_c, ptrTrama, TRUE);
	2349	return (TRUE);
	2350	}
	2351	// ________________________________________________________________________________________________________
[3ec149c]	2352	// Función: RESPUESTA_RestaurarImagen
	2353	//
	2354	// Descripción:
	2355	// Respuesta del cliente al comando RestaurarImagen
	2356	// Parámetros:
	2357	// - socket_c: Socket del cliente que envió el mensaje
	2358	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2359	// Devuelve:
	2360	// TRUE: Si el proceso es correcto
	2361	// FALSE: En caso de ocurrir algún error
	2362	// ________________________________________________________________________________________________________
[0a73ecf7]	2363	//
	2364	BOOLEAN RESPUESTA_RestaurarImagen(SOCKET socket_c, TRAMA ptrTrama)
	2365	{
[3ec149c]	2366	char msglog[LONSTD];
	2367	Database db;
	2368	Table tbl;
[0a73ecf7]	2369	BOOLEAN res;
[c916af9]	2370	char iph, ido, idi, dsk, par, ifs;
[3ec149c]	2371	char modulo[] = "RESPUESTA_RestaurarImagen()";
	2372
	2373	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	2374	errorLog(modulo, 20, FALSE);
	2375	db.GetErrorErrStr(msglog);
	2376	errorInfo(modulo, msglog);
	2377	return (FALSE);
	2378	}
	2379
	2380	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	2381	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	2382
	2383	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	2384	liberaMemoria(iph);
	2385	liberaMemoria(ido);
[3ec149c]	2386	errorLog(modulo, 30, FALSE);
	2387	return (FALSE); // Error al registrar notificacion
	2388	}
	2389
	2390	// Acciones posteriores
	2391	idi = copiaParametro("idi",ptrTrama); // Toma identificador de la imagen
[c916af9]	2392	dsk = copiaParametro("dsk",ptrTrama); // Número de disco
[3ec149c]	2393	par = copiaParametro("par",ptrTrama); // Número de partición
	2394	ifs = copiaParametro("ifs",ptrTrama); // Identificador del perfil software contenido
[0a73ecf7]	2395
[c916af9]	2396	res=actualizaRestauracionImagen(db, tbl, idi, dsk, par, ido, ifs);
[0a73ecf7]	2397
	2398	liberaMemoria(iph);
	2399	liberaMemoria(ido);
	2400	liberaMemoria(idi);
	2401	liberaMemoria(par);
	2402	liberaMemoria(ifs);
	2403
	2404	if(!res){
	2405	errorLog(modulo, 95, FALSE);
[3ec149c]	2406	db.Close(); // Cierra conexión
	2407	return (FALSE);
	2408	}
	2409
	2410	db.Close(); // Cierra conexión
	2411	return (TRUE);
	2412	}
	2413	// ________________________________________________________________________________________________________
[0a73ecf7]	2414	//
	2415	// Función: RESPUESTA_RestaurarImagenBasica
	2416	//
	2417	// Descripción:
	2418	// Respuesta del cliente al comando RestaurarImagen
	2419	// Parámetros:
	2420	// - socket_c: Socket del cliente que envió el mensaje
	2421	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2422	// Devuelve:
	2423	// TRUE: Si el proceso es correcto
	2424	// FALSE: En caso de ocurrir algún error
	2425	// ________________________________________________________________________________________________________
	2426	//
	2427	BOOLEAN RESPUESTA_RestaurarImagenBasica(SOCKET socket_c, TRAMA ptrTrama) {
	2428	return(RESPUESTA_RestaurarImagen(socket_c,ptrTrama));
	2429	}
	2430	// ________________________________________________________________________________________________________
	2431	// Función: RESPUESTA_RestaurarSoftIncremental
	2432	//
	2433	// Descripción:
	2434	// Respuesta del cliente al comando RestaurarSoftIncremental
	2435	// Parámetros:
	2436	// - socket_c: Socket del cliente que envió el mensaje
	2437	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2438	// Devuelve:
	2439	// TRUE: Si el proceso es correcto
	2440	// FALSE: En caso de ocurrir algún error
	2441	// ________________________________________________________________________________________________________
	2442	BOOLEAN RESPUESTA_RestaurarSoftIncremental(SOCKET socket_c, TRAMA ptrTrama) {
	2443	return(RESPUESTA_RestaurarImagen(socket_c,ptrTrama));
	2444	}
	2445	// ________________________________________________________________________________________________________
[3ec149c]	2446	// Función: actualizaRestauracionImagen
	2447	//
	2448	// Descripción:
[0a73ecf7]	2449	// Esta función actualiza la base de datos con el resultado de la restauración de una imagen
[3ec149c]	2450	// Parámetros:
	2451	// - db: Objeto base de datos (ya operativo)
	2452	// - tbl: Objeto tabla
	2453	// - idi: Identificador de la imagen
[c916af9]	2454	// - dsk: Disco de donde se restauró
[3ec149c]	2455	// - par: Partición de donde se restauró
	2456	// - ido: Identificador del cliente donde se restauró
	2457	// - ifs: Identificador del perfil software contenido en la imagen
	2458	// Devuelve:
	2459	// TRUE: Si el proceso es correcto
	2460	// FALSE: En caso de ocurrir algún error
	2461	// ________________________________________________________________________________________________________
	2462	BOOLEAN actualizaRestauracionImagen(Database db, Table tbl, char* idi,
[c916af9]	2463	char* dsk, char* par, char* ido, char* ifs) {
[3ec149c]	2464	char msglog[LONSTD], sqlstr[LONSQL];
	2465	char modulo[] = "actualizaRestauracionImagen()";
	2466
	2467	/* Actualizar los datos de la imagen */
[c916af9]	2468	snprintf(sqlstr, LONSQL,
	2469	"UPDATE ordenadores_particiones"
[84fa8d6]	2470	" SET idimagen=%s, idperfilsoft=%s, fechadespliegue=NOW(),"
[dbbe689]	2471	" revision=(SELECT revision FROM imagenes WHERE idimagen=%s),"
	2472	" idnombreso=(SELECT idnombreso FROM perfilessoft WHERE idperfilsoft=%s)"
	2473	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s", idi, ifs, idi, ifs, ido, dsk, par);
[3ec149c]	2474
	2475	if (!db.Execute(sqlstr, tbl)) { // Error al recuperar los datos
	2476	errorLog(modulo, 21, FALSE);
	2477	db.GetErrorErrStr(msglog);
	2478	errorInfo(modulo, msglog);
	2479	return (FALSE);
	2480	}
	2481	return (TRUE);
	2482	}
	2483	// ________________________________________________________________________________________________________
	2484	// Función: Configurar
	2485	//
	2486	// Descripción:
	2487	// Configura la tabla de particiones
	2488	// Parámetros:
	2489	// - socket_c: Socket de la consola al envió el mensaje
	2490	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2491	// Devuelve:
	2492	// TRUE: Si el proceso es correcto
	2493	// FALSE: En caso de ocurrir algún error
	2494	// ________________________________________________________________________________________________________
	2495	BOOLEAN Configurar(SOCKET socket_c, TRAMA ptrTrama) {
	2496	char msglog[LONSTD];
	2497	char modulo[] = "Configurar()";
	2498
	2499	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2500	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2501	errorInfo(modulo, msglog);
	2502	respuestaConsola(socket_c, ptrTrama, FALSE);
	2503	return (FALSE);
	2504	}
	2505	respuestaConsola(socket_c, ptrTrama, TRUE);
	2506	return (TRUE);
	2507	}
	2508	// ________________________________________________________________________________________________________
	2509	// Función: RESPUESTA_Configurar
	2510	//
	2511	// Descripción:
	2512	// Respuesta del cliente al comando Configurar
	2513	// Parámetros:
	2514	// - socket_c: Socket del cliente que envió el mensaje
	2515	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2516	// Devuelve:
	2517	// TRUE: Si el proceso es correcto
	2518	// FALSE: En caso de ocurrir algún error
	2519	// ________________________________________________________________________________________________________
[0a73ecf7]	2520	//
	2521	BOOLEAN RESPUESTA_Configurar(SOCKET socket_c, TRAMA ptrTrama)
	2522	{
[3ec149c]	2523	char msglog[LONSTD];
	2524	Database db;
	2525	Table tbl;
[0a73ecf7]	2526	BOOLEAN res;
[3ec149c]	2527	char iph, ido,*cfg;
	2528	char modulo[] = "RESPUESTA_Configurar()";
	2529
	2530	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	2531	errorLog(modulo, 20, FALSE);
	2532	db.GetErrorErrStr(msglog);
	2533	errorInfo(modulo, msglog);
	2534	return (FALSE);
	2535	}
	2536
	2537	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	2538	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	2539
	2540	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	2541	liberaMemoria(iph);
	2542	liberaMemoria(ido);
[3ec149c]	2543	errorLog(modulo, 30, FALSE);
	2544	return (FALSE); // Error al registrar notificacion
	2545	}
	2546
	2547	cfg = copiaParametro("cfg",ptrTrama); // Toma configuración de particiones
[0a73ecf7]	2548	res=actualizaConfiguracion(db, tbl, cfg, atoi(ido)); // Actualiza la configuración del ordenador
	2549
	2550	liberaMemoria(iph);
	2551	liberaMemoria(ido);
	2552	liberaMemoria(cfg);
	2553
	2554	if(!res){
[3ec149c]	2555	errorLog(modulo, 24, FALSE);
	2556	return (FALSE); // Error al registrar notificacion
	2557	}
[0a73ecf7]	2558
[3ec149c]	2559	db.Close(); // Cierra conexión
	2560	return (TRUE);
	2561	}
	2562	// ________________________________________________________________________________________________________
	2563	// Función: EjecutarScript
	2564	//
	2565	// Descripción:
	2566	// Ejecuta un script de código
	2567	// Parámetros:
	2568	// - socket_c: Socket de la consola al envió el mensaje
	2569	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2570	// Devuelve:
	2571	// TRUE: Si el proceso es correcto
	2572	// FALSE: En caso de ocurrir algún error
	2573	// ________________________________________________________________________________________________________
	2574	BOOLEAN EjecutarScript(SOCKET socket_c, TRAMA ptrTrama) {
	2575	char msglog[LONSTD];
	2576	char modulo[] = "EjecutarScript()";
	2577
	2578	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2579	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2580	errorInfo(modulo, msglog);
	2581	respuestaConsola(socket_c, ptrTrama, FALSE);
	2582	return (FALSE);
	2583	}
	2584	respuestaConsola(socket_c, ptrTrama, TRUE);
	2585	return (TRUE);
	2586	}
	2587	// ________________________________________________________________________________________________________
	2588	// Función: RESPUESTA_EjecutarScript
	2589	//
	2590	// Descripción:
	2591	// Respuesta del cliente al comando EjecutarScript
	2592	// Parámetros:
	2593	// - socket_c: Socket del cliente que envió el mensaje
	2594	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2595	// Devuelve:
	2596	// TRUE: Si el proceso es correcto
	2597	// FALSE: En caso de ocurrir algún error
	2598	// ________________________________________________________________________________________________________
[7224a0a]	2599	BOOLEAN RESPUESTA_EjecutarScript(SOCKET socket_c, TRAMA ptrTrama)
	2600	{
[3ec149c]	2601	char msglog[LONSTD];
	2602	Database db;
	2603	Table tbl;
[7224a0a]	2604	char iph, ido,*cfg;
[3ec149c]	2605
	2606	char modulo[] = "RESPUESTA_EjecutarScript()";
	2607
	2608	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	2609	errorLog(modulo, 20, FALSE);
	2610	db.GetErrorErrStr(msglog);
	2611	errorInfo(modulo, msglog);
	2612	return (FALSE);
	2613	}
	2614
	2615	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	2616	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	2617
	2618	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	2619	liberaMemoria(iph);
	2620	liberaMemoria(ido);
[3ec149c]	2621	errorLog(modulo, 30, FALSE);
	2622	return (FALSE); // Error al registrar notificacion
	2623	}
[0a73ecf7]	2624
[7224a0a]	2625	cfg = copiaParametro("cfg",ptrTrama); // Toma configuración de particiones
[46f7d6f]	2626
	2627	if(cfg){
[db4d467]	2628	actualizaConfiguracion(db, tbl, cfg, atoi(ido)); // Actualiza la configuración del ordenador
[46f7d6f]	2629	liberaMemoria(cfg);
	2630	}
[7224a0a]	2631
[0a73ecf7]	2632	liberaMemoria(iph);
[7224a0a]	2633	liberaMemoria(ido);
[46f7d6f]	2634
[0a73ecf7]	2635
[3ec149c]	2636	db.Close(); // Cierra conexión
	2637	return (TRUE);
	2638	}
	2639	// ________________________________________________________________________________________________________
	2640	// Función: InventarioHardware
	2641	//
	2642	// Descripción:
	2643	// Solicita al cliente un inventario de su hardware
	2644	// Parámetros:
	2645	// - socket_c: Socket de la consola al envió el mensaje
	2646	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2647	// Devuelve:
	2648	// TRUE: Si el proceso es correcto
	2649	// FALSE: En caso de ocurrir algún error
	2650	// ________________________________________________________________________________________________________
	2651	BOOLEAN InventarioHardware(SOCKET socket_c, TRAMA ptrTrama) {
	2652	char msglog[LONSTD];
	2653	char modulo[] = "InventarioHardware()";
	2654
	2655	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	2656	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	2657	errorInfo(modulo, msglog);
	2658	respuestaConsola(socket_c, ptrTrama, FALSE);
	2659	return (FALSE);
	2660	}
	2661	respuestaConsola(socket_c, ptrTrama, TRUE);
	2662	return (TRUE);
	2663	}
	2664	// ________________________________________________________________________________________________________
	2665	// Función: RESPUESTA_InventarioHardware
	2666	//
	2667	// Descripción:
	2668	// Respuesta del cliente al comando InventarioHardware
	2669	// Parámetros:
	2670	// - socket_c: Socket del cliente que envió el mensaje
	2671	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	2672	// Devuelve:
	2673	// TRUE: Si el proceso es correcto
	2674	// FALSE: En caso de ocurrir algún error
	2675	// ________________________________________________________________________________________________________
	2676	BOOLEAN RESPUESTA_InventarioHardware(SOCKET socket_c, TRAMA ptrTrama) {
	2677	char msglog[LONSTD];
	2678	Database db;
	2679	Table tbl;
[0a73ecf7]	2680	BOOLEAN res;
[3ec149c]	2681	char iph, ido, idc, npc, hrd, buffer;
	2682	char modulo[] = "RESPUESTA_InventarioHardware()";
	2683
	2684	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	2685	errorLog(modulo, 20, FALSE);
	2686	db.GetErrorErrStr(msglog);
	2687	errorInfo(modulo, msglog);
	2688	return (FALSE);
	2689	}
[0a73ecf7]	2690
[3ec149c]	2691	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip del cliente
	2692	ido = copiaParametro("ido",ptrTrama); // Toma identificador del cliente
	2693
	2694	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	2695	liberaMemoria(iph);
	2696	liberaMemoria(ido);
[3ec149c]	2697	errorLog(modulo, 30, FALSE);
	2698	return (FALSE); // Error al registrar notificacion
	2699	}
	2700	// Lee archivo de inventario enviado anteriormente
	2701	hrd = copiaParametro("hrd",ptrTrama);
	2702	buffer = rTrim(leeArchivo(hrd));
[0a73ecf7]	2703
	2704	npc = copiaParametro("npc",ptrTrama);
	2705	idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro
	2706
	2707	if (buffer)
	2708	res=actualizaHardware(db, tbl, buffer, ido, npc, idc);
	2709
	2710	liberaMemoria(iph);
	2711	liberaMemoria(ido);
	2712	liberaMemoria(npc);
	2713	liberaMemoria(idc);
	2714	liberaMemoria(buffer);
	2715
	2716	if(!res){
	2717	errorLog(modulo, 53, FALSE);
	2718	return (FALSE);
[3ec149c]	2719	}
[0a73ecf7]	2720
[3ec149c]	2721	db.Close(); // Cierra conexión
	2722	return (TRUE);
	2723	}
	2724	// ________________________________________________________________________________________________________
	2725	// Función: actualizaHardware
	2726	//
	2727	// Descripción:
	2728	// Actualiza la base de datos con la configuracion hardware del cliente
	2729	// Parámetros:
	2730	// - db: Objeto base de datos (ya operativo)
	2731	// - tbl: Objeto tabla
	2732	// - hrd: cadena con el inventario hardware
	2733	// - ido: Identificador del ordenador
	2734	// - npc: Nombre del ordenador
	2735	// - idc: Identificador del centro o Unidad organizativa
	2736	// ________________________________________________________________________________________________________
[0a73ecf7]	2737	//
	2738	BOOLEAN actualizaHardware(Database db, Table tbl, char* hrd, charido,char npc, char *idc)
	2739	{
[3ec149c]	2740	char msglog[LONSTD], sqlstr[LONSQL];
	2741	int idtipohardware, idperfilhard;
	2742	int lon, i, j, aux;
[fc480f2]	2743	bool retval;
[0a73ecf7]	2744	char *whard;
[3ec149c]	2745	int tbidhardware[MAXHARDWARE];
[0a73ecf7]	2746	char tbHardware[MAXHARDWARE],dualHardware[2], descripcion[250], strInt[LONINT], *idhardwares;
[3ec149c]	2747	char modulo[] = "actualizaHardware()";
	2748
	2749	/* Toma Centro (Unidad Organizativa) */
	2750	sprintf(sqlstr, "SELECT * FROM ordenadores WHERE idordenador=%s", ido);
	2751
	2752	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2753	errorLog(modulo, 21, FALSE);
	2754	db.GetErrorErrStr(msglog);
	2755	errorInfo(modulo, msglog);
	2756	return (FALSE);
	2757	}
	2758	if (!tbl.Get("idperfilhard", idperfilhard)) { // Toma dato
	2759	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2760	errorInfo(modulo, msglog);
	2761	return (FALSE);
	2762	}
[0a73ecf7]	2763	whard=escaparCadena(hrd); // Codificar comillas simples
	2764	if(!whard)
[3ec149c]	2765	return (FALSE);
	2766	/* Recorre componentes hardware*/
[0a73ecf7]	2767	lon = splitCadena(tbHardware, whard, '\n');
[3ec149c]	2768	if (lon > MAXHARDWARE)
	2769	lon = MAXHARDWARE; // Limita el número de componentes hardware
	2770	/*
	2771	for (i=0;i<lon;i++){
	2772	sprintf(msglog,"Linea de inventario: %s",tbHardware[i]);
	2773	RegistraLog(msglog,FALSE);
	2774	}
	2775	*/
	2776	for (i = 0; i < lon; i++) {
	2777	splitCadena(dualHardware, rTrim(tbHardware[i]), '=');
	2778	//sprintf(msglog,"nemonico: %s",dualHardware[0]);
	2779	//RegistraLog(msglog,FALSE);
	2780	//sprintf(msglog,"valor: %s",dualHardware[1]);
	2781	//RegistraLog(msglog,FALSE);
	2782	sprintf(sqlstr, "SELECT idtipohardware,descripcion FROM tipohardwares "
	2783	" WHERE nemonico='%s'", dualHardware[0]);
	2784	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2785	errorLog(modulo, 21, FALSE);
	2786	db.GetErrorErrStr(msglog);
	2787	errorInfo(modulo, msglog);
	2788	return (FALSE);
	2789	}
	2790	if (tbl.ISEOF()) { // Tipo de Hardware NO existente
	2791	sprintf(msglog, "%s: %s)", tbErrores[54], dualHardware[0]);
	2792	errorInfo(modulo, msglog);
	2793	return (FALSE);
	2794	} else { // Tipo de Hardware Existe
	2795	if (!tbl.Get("idtipohardware", idtipohardware)) { // Toma dato
	2796	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2797	errorInfo(modulo, msglog);
	2798	return (FALSE);
	2799	}
	2800	if (!tbl.Get("descripcion", descripcion)) { // Toma dato
	2801	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2802	errorInfo(modulo, msglog);
	2803	return (FALSE);
	2804	}
	2805
	2806	sprintf(sqlstr, "SELECT idhardware FROM hardwares "
	2807	" WHERE idtipohardware=%d AND descripcion='%s'",
	2808	idtipohardware, dualHardware[1]);
	2809
	2810	// Ejecuta consulta
	2811	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2812	errorLog(modulo, 21, FALSE);
	2813	db.GetErrorErrStr(msglog);
	2814	errorInfo(modulo, msglog);
	2815	return (FALSE);
	2816	}
	2817
	2818	if (tbl.ISEOF()) { // Hardware NO existente
[df052e1]	2819	sprintf(sqlstr, "INSERT hardwares (idtipohardware,descripcion,idcentro,grupoid) "
[3ec149c]	2820	" VALUES(%d,'%s',%s,0)", idtipohardware,
	2821	dualHardware[1], idc);
	2822	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	2823	db.GetErrorErrStr(msglog); // Error al acceder al registro
	2824	errorInfo(modulo, msglog);
	2825	return (FALSE);
	2826	}
	2827	// Recupera el identificador del hardware
	2828	sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
	2829	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2830	errorLog(modulo, 21, FALSE);
	2831	db.GetErrorErrStr(msglog);
	2832	errorInfo(modulo, msglog);
	2833	return (FALSE);
	2834	}
	2835	if (!tbl.ISEOF()) { // Si existe registro
	2836	if (!tbl.Get("identificador", tbidhardware[i])) {
	2837	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2838	errorInfo(modulo, msglog);
	2839	return (FALSE);
	2840	}
	2841	}
	2842	} else {
	2843	if (!tbl.Get("idhardware", tbidhardware[i])) { // Toma dato
	2844	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	2845	errorInfo(modulo, msglog);
	2846	return (FALSE);
	2847	}
	2848	}
	2849	}
	2850	}
	2851	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
	2852
	2853	for (i = 0; i < lon - 1; i++) {
	2854	for (j = i + 1; j < lon; j++) {
	2855	if (tbidhardware[i] > tbidhardware[j]) {
	2856	aux = tbidhardware[i];
	2857	tbidhardware[i] = tbidhardware[j];
	2858	tbidhardware[j] = aux;
	2859	}
	2860	}
	2861	}
	2862	/* Crea cadena de identificadores de componentes hardware separados por coma */
	2863	sprintf(strInt, "%d", tbidhardware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
	2864	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
	2865	idhardwares = reservaMemoria(sizeof(aux) * lon + lon);
	2866	if (idhardwares == NULL) {
	2867	errorLog(modulo, 3, FALSE);
	2868	return (FALSE);
	2869	}
	2870	aux = sprintf(idhardwares, "%d", tbidhardware[0]);
	2871	for (i = 1; i < lon; i++)
	2872	aux += sprintf(idhardwares + aux, ",%d", tbidhardware[i]);
	2873
	2874	if (!cuestionPerfilHardware(db, tbl, idc, ido, idperfilhard, idhardwares,
	2875	npc, tbidhardware, lon)) {
	2876	errorLog(modulo, 55, FALSE);
	2877	errorInfo(modulo, msglog);
[fc480f2]	2878	retval=FALSE;
[3ec149c]	2879	}
[fc480f2]	2880	else {
	2881	retval=TRUE;
	2882	}
[0a73ecf7]	2883	liberaMemoria(whard);
[fc480f2]	2884	liberaMemoria(idhardwares);
	2885	return (retval);
[3ec149c]	2886	}
	2887	// ________________________________________________________________________________________________________
	2888	// Función: cuestionPerfilHardware
	2889	//
	2890	// Descripción:
	2891	// Comprueba existencia de perfil hardware y actualización de éste para el ordenador
	2892	// Parámetros:
	2893	// - db: Objeto base de datos (ya operativo)
	2894	// - tbl: Objeto tabla
	2895	// - idc: Identificador de la Unidad organizativa donde se encuentra el cliente
	2896	// - ido: Identificador del ordenador
	2897	// - tbidhardware: Identificador del tipo de hardware
	2898	// - con: Número de componentes detectados para configurar un el perfil hardware
	2899	// - npc: Nombre del cliente
	2900	// ________________________________________________________________________________________________________
	2901	BOOLEAN cuestionPerfilHardware(Database db, Table tbl, char* idc, char* ido,
	2902	int idperfilhardware, charidhardwares, char npc, int *tbidhardware,
	2903	int lon)
	2904	{
	2905	char msglog[LONSTD], *sqlstr;
	2906	int i;
	2907	int nwidperfilhard;
	2908	char modulo[] = "cuestionPerfilHardware()";
	2909
	2910	sqlstr = reservaMemoria(strlen(idhardwares)+LONSQL); // Reserva para escribir sentencia SQL
	2911	if (sqlstr == NULL) {
	2912	errorLog(modulo, 3, FALSE);
	2913	return (FALSE);
	2914	}
	2915	// Busca perfil hard del ordenador que contenga todos los componentes hardware encontrados
	2916	sprintf(sqlstr, "SELECT idperfilhard FROM"
	2917	" (SELECT perfileshard_hardwares.idperfilhard as idperfilhard,"
	2918	" group_concat(cast(perfileshard_hardwares.idhardware AS char( 11) )"
	2919	" ORDER BY perfileshard_hardwares.idhardware SEPARATOR ',' ) AS idhardwares"
	2920	" FROM perfileshard_hardwares"
	2921	" GROUP BY perfileshard_hardwares.idperfilhard) AS temp"
	2922	" WHERE idhardwares LIKE '%s'", idhardwares);
	2923	// Ejecuta consulta
	2924	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2925	errorLog(modulo, 21, FALSE);
	2926	db.GetErrorErrStr(msglog);
	2927	errorInfo(modulo, msglog);
[fc480f2]	2928	liberaMemoria(sqlstr);
[3ec149c]	2929	return (false);
	2930	}
	2931	if (tbl.ISEOF()) { // No existe un perfil hardware con esos componentes de componentes hardware, lo crea
	2932	sprintf(sqlstr, "INSERT perfileshard (descripcion,idcentro,grupoid)"
[df052e1]	2933	" VALUES('Perfil hardware (%s) ',%s,0)", npc, idc);
[3ec149c]	2934	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	2935	db.GetErrorErrStr(msglog);
	2936	errorInfo(modulo, msglog);
[fc480f2]	2937	liberaMemoria(sqlstr);
[3ec149c]	2938	return (false);
	2939	}
	2940	// Recupera el identificador del nuevo perfil hardware
	2941	sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
	2942	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	2943	db.GetErrorErrStr(msglog);
	2944	errorInfo(modulo, msglog);
[fc480f2]	2945	liberaMemoria(sqlstr);
[3ec149c]	2946	return (false);
	2947	}
	2948	if (!tbl.ISEOF()) { // Si existe registro
	2949	if (!tbl.Get("identificador", nwidperfilhard)) {
	2950	tbl.GetErrorErrStr(msglog);
	2951	errorInfo(modulo, msglog);
[fc480f2]	2952	liberaMemoria(sqlstr);
[3ec149c]	2953	return (false);
	2954	}
	2955	}
	2956	// Crea la relación entre perfiles y componenetes hardware
	2957	for (i = 0; i < lon; i++) {
[df052e1]	2958	sprintf(sqlstr, "INSERT perfileshard_hardwares (idperfilhard,idhardware)"
[3ec149c]	2959	" VALUES(%d,%d)", nwidperfilhard, tbidhardware[i]);
	2960	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	2961	db.GetErrorErrStr(msglog);
	2962	errorInfo(modulo, msglog);
[fc480f2]	2963	liberaMemoria(sqlstr);
[3ec149c]	2964	return (false);
	2965	}
	2966	}
	2967	} else { // Existe un perfil con todos esos componentes
	2968	if (!tbl.Get("idperfilhard", nwidperfilhard)) {
	2969	tbl.GetErrorErrStr(msglog);
	2970	errorInfo(modulo, msglog);
[fc480f2]	2971	liberaMemoria(sqlstr);
[3ec149c]	2972	return (false);
	2973	}
	2974	}
	2975	if (idperfilhardware != nwidperfilhard) { // No coinciden los perfiles
	2976	// Actualiza el identificador del perfil hardware del ordenador
	2977	sprintf(sqlstr, "UPDATE ordenadores SET idperfilhard=%d"
	2978	" WHERE idordenador=%s", nwidperfilhard, ido);
	2979	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	2980	db.GetErrorErrStr(msglog);
	2981	errorInfo(modulo, msglog);
[fc480f2]	2982	liberaMemoria(sqlstr);
[3ec149c]	2983	return (false);
	2984	}
	2985	}
	2986	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
	2987	sprintf(sqlstr, "DELETE FROM perfileshard_hardwares WHERE idperfilhard IN "
	2988	" (SELECT idperfilhard FROM perfileshard WHERE idperfilhard NOT IN"
	2989	" (SELECT DISTINCT idperfilhard from ordenadores))");
	2990	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	2991	db.GetErrorErrStr(msglog);
	2992	errorInfo(modulo, msglog);
[fc480f2]	2993	liberaMemoria(sqlstr);
[3ec149c]	2994	return (false);
	2995	}
	2996
	2997	/* Eliminar Perfiles hardware que quedan húerfanos */
	2998	sprintf(sqlstr, "DELETE FROM perfileshard WHERE idperfilhard NOT IN"
[fc480f2]	2999	" (SELECT DISTINCT idperfilhard FROM ordenadores)");
[3ec149c]	3000	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3001	db.GetErrorErrStr(msglog);
	3002	errorInfo(modulo, msglog);
[fc480f2]	3003	liberaMemoria(sqlstr);
[3ec149c]	3004	return (false);
	3005	}
	3006	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
[fc480f2]	3007	sprintf(sqlstr, "DELETE FROM perfileshard_hardwares WHERE idperfilhard NOT IN"
	3008	" (SELECT idperfilhard FROM perfileshard)");
[3ec149c]	3009	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3010	db.GetErrorErrStr(msglog);
	3011	errorInfo(modulo, msglog);
[fc480f2]	3012	liberaMemoria(sqlstr);
[3ec149c]	3013	return (false);
	3014	}
[fc480f2]	3015	liberaMemoria(sqlstr);
[3ec149c]	3016	return (TRUE);
	3017	}
	3018	// ________________________________________________________________________________________________________
	3019	// Función: InventarioSoftware
	3020	//
	3021	// Descripción:
	3022	// Solicita al cliente un inventario de su software
	3023	// Parámetros:
	3024	// - socket_c: Socket de la consola al envió el mensaje
	3025	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	3026	// Devuelve:
	3027	// TRUE: Si el proceso es correcto
	3028	// FALSE: En caso de ocurrir algún error
	3029	// ________________________________________________________________________________________________________
	3030	BOOLEAN InventarioSoftware(SOCKET socket_c, TRAMA ptrTrama) {
	3031	char msglog[LONSTD];
	3032	char modulo[] = "InventarioSoftware()";
	3033
	3034	if (!enviaComando(ptrTrama, CLIENTE_OCUPADO)) {
	3035	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	3036	errorInfo(modulo, msglog);
	3037	respuestaConsola(socket_c, ptrTrama, FALSE);
	3038	return (FALSE);
	3039	}
	3040	respuestaConsola(socket_c, ptrTrama, TRUE);
	3041	return (TRUE);
	3042	}
	3043	// ________________________________________________________________________________________________________
	3044	// Función: RESPUESTA_InventarioSoftware
	3045	//
	3046	// Descripción:
	3047	// Respuesta del cliente al comando InventarioSoftware
	3048	// Parámetros:
	3049	// - socket_c: Socket del cliente que envió el mensaje
	3050	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	3051	// Devuelve:
	3052	// TRUE: Si el proceso es correcto
	3053	// FALSE: En caso de ocurrir algún error
	3054	// ________________________________________________________________________________________________________
	3055	BOOLEAN RESPUESTA_InventarioSoftware(SOCKET socket_c, TRAMA ptrTrama) {
	3056	char msglog[LONSTD];
	3057	Database db;
	3058	Table tbl;
[0a73ecf7]	3059	BOOLEAN res;
[3ec149c]	3060	char iph, ido, npc, idc, par, sft, *buffer;
	3061	char modulo[] = "RESPUESTA_InventarioSoftware()";
	3062
	3063	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	3064	errorLog(modulo, 20, FALSE);
	3065	db.GetErrorErrStr(msglog);
	3066	errorInfo(modulo, msglog);
	3067	return (FALSE);
	3068	}
	3069
	3070	iph = copiaParametro("iph",ptrTrama); // Toma dirección ip
	3071	ido = copiaParametro("ido",ptrTrama); // Toma identificador del ordenador
	3072
	3073	if (!respuestaEstandar(ptrTrama, iph, ido, db, tbl)) {
[0a73ecf7]	3074	liberaMemoria(iph);
	3075	liberaMemoria(ido);
[3ec149c]	3076	errorLog(modulo, 30, FALSE);
	3077	return (FALSE); // Error al registrar notificacion
	3078	}
[0a73ecf7]	3079
	3080	npc = copiaParametro("npc",ptrTrama);
	3081	idc = copiaParametro("idc",ptrTrama); // Toma identificador del Centro
[3ec149c]	3082	par = copiaParametro("par",ptrTrama);
	3083	sft = copiaParametro("sft",ptrTrama);
	3084
	3085	buffer = rTrim(leeArchivo(sft));
[0a73ecf7]	3086	if (buffer)
	3087	res=actualizaSoftware(db, tbl, buffer, par, ido, npc, idc);
	3088
	3089	liberaMemoria(iph);
	3090	liberaMemoria(ido);
	3091	liberaMemoria(npc);
	3092	liberaMemoria(idc);
	3093	liberaMemoria(par);
	3094	liberaMemoria(sft);
	3095
	3096	if(!res){
	3097	errorLog(modulo, 82, FALSE);
	3098	return (FALSE);
	3099	}
	3100
[3ec149c]	3101	db.Close(); // Cierra conexión
	3102	return (TRUE);
	3103	}
	3104	// ________________________________________________________________________________________________________
	3105	// Función: actualizaSoftware
	3106	//
	3107	// Descripción:
	3108	// Actualiza la base de datos con la configuración software del cliente
	3109	// Parámetros:
	3110	// - db: Objeto base de datos (ya operativo)
	3111	// - tbl: Objeto tabla
	3112	// - sft: cadena con el inventario software
	3113	// - par: Número de la partición
	3114	// - ido: Identificador del ordenador del cliente en la tabla
	3115	// - npc: Nombre del ordenador
	3116	// - idc: Identificador del centro o Unidad organizativa
	3117	// Devuelve:
	3118	// TRUE: Si el proceso es correcto
	3119	// FALSE: En caso de ocurrir algún error
[38e2328]	3120	//
	3121	// Versión 1.1.0: Se incluye el sistema operativo. Autora: Irina Gómez - ETSII Universidad Sevilla
[3ec149c]	3122	// ________________________________________________________________________________________________________
[0a73ecf7]	3123	BOOLEAN actualizaSoftware(Database db, Table tbl, char* sft, char* par,char* ido, char* npc, char* idc)
	3124	{
[38e2328]	3125	int i, j, lon, aux, idperfilsoft, idnombreso;
[fc480f2]	3126	bool retval;
[0a73ecf7]	3127	char *wsft;
[3ec149c]	3128	int tbidsoftware[MAXSOFTWARE];
[0a73ecf7]	3129	char tbSoftware[MAXSOFTWARE],msglog[LONSTD], sqlstr[LONSQL], strInt[LONINT], idsoftwares;
[3ec149c]	3130	char modulo[] = "actualizaSoftware()";
	3131
	3132	/* Toma Centro (Unidad Organizativa) y perfil software */
	3133	sprintf(sqlstr, "SELECT idperfilsoft,numpar"
	3134	" FROM ordenadores_particiones"
	3135	" WHERE idordenador=%s", ido);
	3136
	3137	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	3138	errorLog(modulo, 21, FALSE);
	3139	db.GetErrorErrStr(msglog);
	3140	errorInfo(modulo, msglog);
	3141	return (FALSE);
	3142	}
	3143	idperfilsoft = 0; // Por defecto se supone que el ordenador no tiene aún detectado el perfil software
	3144	while (!tbl.ISEOF()) { // Recorre particiones
	3145	if (!tbl.Get("numpar", aux)) {
	3146	tbl.GetErrorErrStr(msglog);
	3147	errorInfo(modulo, msglog);
	3148	return (FALSE);
	3149	}
	3150	if (aux == atoi(par)) { // Se encuentra la partición
	3151	if (!tbl.Get("idperfilsoft", idperfilsoft)) {
	3152	tbl.GetErrorErrStr(msglog);
	3153	errorInfo(modulo, msglog);
	3154	return (FALSE);
	3155	}
	3156	break;
	3157	}
	3158	tbl.MoveNext();
	3159	}
[0a73ecf7]	3160	wsft=escaparCadena(sft); // Codificar comillas simples
	3161	if(!wsft)
[3ec149c]	3162	return (FALSE);
	3163
	3164	/* Recorre componentes software*/
[0a73ecf7]	3165	lon = splitCadena(tbSoftware, wsft, '\n');
	3166
[3ec149c]	3167	if (lon == 0)
	3168	return (true); // No hay lineas que procesar
	3169	if (lon > MAXSOFTWARE)
	3170	lon = MAXSOFTWARE; // Limita el número de componentes software
	3171
	3172	for (i = 0; i < lon; i++) {
[38e2328]	3173	// Primera línea es el sistema operativo: se obtiene identificador
	3174	if (i == 0) {
	3175	idnombreso = checkDato(db, tbl, rTrim(tbSoftware[i]), "nombresos", "nombreso", "idnombreso");
	3176	continue;
	3177	}
	3178
[3ec149c]	3179	sprintf(sqlstr,
	3180	"SELECT idsoftware FROM softwares WHERE descripcion ='%s'",
	3181	rTrim(tbSoftware[i]));
	3182
	3183	// Ejecuta consulta
	3184	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	3185	errorLog(modulo, 21, FALSE);
	3186	db.GetErrorErrStr(msglog);
	3187	errorInfo(modulo, msglog);
	3188	return (FALSE);
	3189	}
	3190
	3191	if (tbl.ISEOF()) { // Software NO existente
[df052e1]	3192	sprintf(sqlstr, "INSERT INTO softwares (idtiposoftware,descripcion,idcentro,grupoid)"
[3ec149c]	3193	" VALUES(2,'%s',%s,0)", tbSoftware[i], idc);
	3194
	3195	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3196	db.GetErrorErrStr(msglog); // Error al acceder al registro
	3197	errorInfo(modulo, msglog);
	3198	return (FALSE);
	3199	}
	3200	// Recupera el identificador del software
	3201	sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
	3202	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	3203	db.GetErrorErrStr(msglog); // Error al acceder al registro
	3204	errorInfo(modulo, msglog);
	3205	return (FALSE);
	3206	}
	3207	if (!tbl.ISEOF()) { // Si existe registro
	3208	if (!tbl.Get("identificador", tbidsoftware[i])) {
	3209	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	3210	errorInfo(modulo, msglog);
	3211	return (FALSE);
	3212	}
	3213	}
	3214	} else {
	3215	if (!tbl.Get("idsoftware", tbidsoftware[i])) { // Toma dato
	3216	tbl.GetErrorErrStr(msglog); // Error al acceder al registro
	3217	errorInfo(modulo, msglog);
	3218	return (FALSE);
	3219	}
	3220	}
	3221	}
	3222
	3223	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
	3224
	3225	for (i = 0; i < lon - 1; i++) {
	3226	for (j = i + 1; j < lon; j++) {
	3227	if (tbidsoftware[i] > tbidsoftware[j]) {
	3228	aux = tbidsoftware[i];
	3229	tbidsoftware[i] = tbidsoftware[j];
	3230	tbidsoftware[j] = aux;
	3231	}
	3232	}
	3233	}
	3234	/* Crea cadena de identificadores de componentes software separados por coma */
	3235	sprintf(strInt, "%d", tbidsoftware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
	3236	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
	3237	idsoftwares = reservaMemoria((sizeof(aux)+1) * lon + lon);
	3238	if (idsoftwares == NULL) {
	3239	errorLog(modulo, 3, FALSE);
	3240	return (FALSE);
	3241	}
	3242	aux = sprintf(idsoftwares, "%d", tbidsoftware[0]);
	3243	for (i = 1; i < lon; i++)
	3244	aux += sprintf(idsoftwares + aux, ",%d", tbidsoftware[i]);
	3245
	3246	// Comprueba existencia de perfil software y actualización de éste para el ordenador
[38e2328]	3247	if (!cuestionPerfilSoftware(db, tbl, idc, ido, idperfilsoft, idnombreso, idsoftwares,
[3ec149c]	3248	npc, par, tbidsoftware, lon)) {
	3249	errorLog(modulo, 83, FALSE);
	3250	errorInfo(modulo, msglog);
[fc480f2]	3251	retval=FALSE;
[3ec149c]	3252	}
[fc480f2]	3253	else {
	3254	retval=TRUE;
	3255	}
[0a73ecf7]	3256	liberaMemoria(wsft);
[fc480f2]	3257	liberaMemoria(idsoftwares);
	3258	return (retval);
[3ec149c]	3259	}
	3260	// ________________________________________________________________________________________________________
	3261	// Función: CuestionPerfilSoftware
	3262	//
	3263	// Parámetros:
	3264	// - db: Objeto base de datos (ya operativo)
	3265	// - tbl: Objeto tabla
	3266	// - idcentro: Identificador del centro en la tabla
	3267	// - ido: Identificador del ordenador del cliente en la tabla
[38e2328]	3268	// - idnombreso: Identificador del sistema operativo
[3ec149c]	3269	// - idsoftwares: Cadena con los identificadores de componentes software separados por comas
	3270	// - npc: Nombre del ordenador del cliente
	3271	// - particion: Número de la partición
	3272	// - tbidsoftware: Array con los identificadores de componentes software
	3273	// - lon: Número de componentes
	3274	// Devuelve:
	3275	// TRUE: Si el proceso es correcto
	3276	// FALSE: En caso de ocurrir algún error
[38e2328]	3277	//
	3278	// Versión 1.1.0: Se incluye el sistema operativo. Autora: Irina Gómez - ETSII Universidad Sevilla
	3279	//_________________________________________________________________________________________________________
[3ec149c]	3280	BOOLEAN cuestionPerfilSoftware(Database db, Table tbl, char* idc, char* ido,
[38e2328]	3281	int idperfilsoftware, int idnombreso, char idsoftwares, char npc, char *par,
[3ec149c]	3282	int *tbidsoftware, int lon) {
	3283	char *sqlstr, msglog[LONSTD];
	3284	int i, nwidperfilsoft;
	3285	char modulo[] = "cuestionPerfilSoftware()";
	3286
	3287	sqlstr = reservaMemoria(strlen(idsoftwares)+LONSQL); // Reserva para escribir sentencia SQL
	3288	if (sqlstr == NULL) {
	3289	errorLog(modulo, 3, FALSE);
	3290	return (FALSE);
	3291	}
	3292	// Busca perfil soft del ordenador que contenga todos los componentes software encontrados
	3293	sprintf(sqlstr, "SELECT idperfilsoft FROM"
	3294	" (SELECT perfilessoft_softwares.idperfilsoft as idperfilsoft,"
	3295	" group_concat(cast(perfilessoft_softwares.idsoftware AS char( 11) )"
	3296	" ORDER BY perfilessoft_softwares.idsoftware SEPARATOR ',' ) AS idsoftwares"
	3297	" FROM perfilessoft_softwares"
	3298	" GROUP BY perfilessoft_softwares.idperfilsoft) AS temp"
	3299	" WHERE idsoftwares LIKE '%s'", idsoftwares);
	3300	// Ejecuta consulta
	3301	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	3302	errorLog(modulo, 21, FALSE);
	3303	db.GetErrorErrStr(msglog);
	3304	errorInfo(modulo, msglog);
[fc480f2]	3305	liberaMemoria(sqlstr);
[3ec149c]	3306	return (false);
	3307	}
	3308	if (tbl.ISEOF()) { // No existe un perfil software con esos componentes de componentes software, lo crea
[38e2328]	3309	sprintf(sqlstr, "INSERT perfilessoft (descripcion, idcentro, grupoid, idnombreso)"
	3310	" VALUES('Perfil Software (%s, Part:%s) ',%s,0,%i)", npc, par, idc,idnombreso);
[3ec149c]	3311	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3312	db.GetErrorErrStr(msglog);
	3313	errorInfo(modulo, msglog);
	3314	return (false);
	3315	}
	3316	// Recupera el identificador del nuevo perfil software
	3317	sprintf(sqlstr, "SELECT LAST_INSERT_ID() as identificador");
	3318	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	3319	tbl.GetErrorErrStr(msglog);
	3320	errorInfo(modulo, msglog);
[fc480f2]	3321	liberaMemoria(sqlstr);
[3ec149c]	3322	return (false);
	3323	}
	3324	if (!tbl.ISEOF()) { // Si existe registro
	3325	if (!tbl.Get("identificador", nwidperfilsoft)) {
	3326	tbl.GetErrorErrStr(msglog);
	3327	errorInfo(modulo, msglog);
[fc480f2]	3328	liberaMemoria(sqlstr);
[3ec149c]	3329	return (false);
	3330	}
	3331	}
	3332	// Crea la relación entre perfiles y componenetes software
	3333	for (i = 0; i < lon; i++) {
[fc480f2]	3334	sprintf(sqlstr, "INSERT perfilessoft_softwares (idperfilsoft,idsoftware)"
[3ec149c]	3335	" VALUES(%d,%d)", nwidperfilsoft, tbidsoftware[i]);
	3336	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3337	db.GetErrorErrStr(msglog);
	3338	errorInfo(modulo, msglog);
[fc480f2]	3339	liberaMemoria(sqlstr);
[3ec149c]	3340	return (false);
	3341	}
	3342	}
	3343	} else { // Existe un perfil con todos esos componentes
	3344	if (!tbl.Get("idperfilsoft", nwidperfilsoft)) {
	3345	tbl.GetErrorErrStr(msglog);
	3346	errorInfo(modulo, msglog);
[fc480f2]	3347	liberaMemoria(sqlstr);
[3ec149c]	3348	return (false);
	3349	}
	3350	}
	3351
	3352	if (idperfilsoftware != nwidperfilsoft) { // No coinciden los perfiles
	3353	// Actualiza el identificador del perfil software del ordenador
[fc480f2]	3354	sprintf(sqlstr, "UPDATE ordenadores_particiones SET idperfilsoft=%d,idimagen=0"
	3355	" WHERE idordenador=%s AND numpar=%s", nwidperfilsoft, ido, par);
[3ec149c]	3356	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3357	db.GetErrorErrStr(msglog);
	3358	errorInfo(modulo, msglog);
[fc480f2]	3359	liberaMemoria(sqlstr);
[3ec149c]	3360	return (false);
	3361	}
	3362	}
	3363
	3364	/* DEPURACIÓN DE PERFILES SOFTWARE */
	3365
	3366	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
	3367	sprintf(sqlstr, "DELETE FROM perfilessoft_softwares WHERE idperfilsoft IN "\
	3368	" (SELECT idperfilsoft FROM perfilessoft WHERE idperfilsoft NOT IN"\
	3369	" (SELECT DISTINCT idperfilsoft from ordenadores_particiones) AND idperfilsoft NOT IN"\
	3370	" (SELECT DISTINCT idperfilsoft from imagenes))");
	3371	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3372	db.GetErrorErrStr(msglog);
	3373	errorInfo(modulo, msglog);
[fc480f2]	3374	liberaMemoria(sqlstr);
[3ec149c]	3375	return (false);
	3376	}
	3377	/* Eliminar Perfiles software que quedan húerfanos */
	3378	sprintf(sqlstr, "DELETE FROM perfilessoft WHERE idperfilsoft NOT IN"
	3379	" (SELECT DISTINCT idperfilsoft from ordenadores_particiones)"\
	3380	" AND idperfilsoft NOT IN"\
	3381	" (SELECT DISTINCT idperfilsoft from imagenes)");
	3382	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3383	db.GetErrorErrStr(msglog);
	3384	errorInfo(modulo, msglog);
[fc480f2]	3385	liberaMemoria(sqlstr);
[3ec149c]	3386	return (false);
	3387	}
	3388	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
[fc480f2]	3389	sprintf(sqlstr, "DELETE FROM perfilessoft_softwares WHERE idperfilsoft NOT IN"
	3390	" (SELECT idperfilsoft from perfilessoft)");
[3ec149c]	3391	if (!db.Execute(sqlstr, tbl)) { // Error al insertar
	3392	db.GetErrorErrStr(msglog);
	3393	errorInfo(modulo, msglog);
[fc480f2]	3394	liberaMemoria(sqlstr);
[3ec149c]	3395	return (false);
	3396	}
[fc480f2]	3397	liberaMemoria(sqlstr);
[3ec149c]	3398	return (TRUE);
	3399	}
	3400	// ________________________________________________________________________________________________________
	3401	// Función: enviaArchivo
	3402	//
	3403	// Descripción:
	3404	// Envia un archivo por la red, por bloques
	3405	// Parámetros:
	3406	// - socket_c: Socket del cliente que envió el mensaje
	3407	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	3408	// Devuelve:
	3409	// TRUE: Si el proceso es correcto
	3410	// FALSE: En caso de ocurrir algún error
	3411	// ________________________________________________________________________________________________________
	3412	BOOLEAN enviaArchivo(SOCKET socket_c, TRAMA ptrTrama) {
	3413	char *nfl;
	3414	char modulo[] = "enviaArchivo()";
	3415
	3416	// Toma parámetros
	3417	nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo
	3418	if (!sendArchivo(socket_c, nfl)) {
[0a73ecf7]	3419	liberaMemoria(nfl);
[3ec149c]	3420	errorLog(modulo, 57, FALSE);
	3421	return (FALSE);
	3422	}
[0a73ecf7]	3423	liberaMemoria(nfl);
[3ec149c]	3424	return (TRUE);
	3425	}
	3426	// ________________________________________________________________________________________________________
	3427	// Función: enviaArchivo
	3428	//
	3429	// Descripción:
	3430	// Envia un archivo por la red, por bloques
	3431	// Parámetros:
	3432	// - socket_c: Socket del cliente que envió el mensaje
	3433	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	3434	// Devuelve:
	3435	// TRUE: Si el proceso es correcto
	3436	// FALSE: En caso de ocurrir algún error
	3437	// ________________________________________________________________________________________________________
	3438	BOOLEAN recibeArchivo(SOCKET socket_c, TRAMA ptrTrama) {
	3439	char *nfl;
	3440	char modulo[] = "recibeArchivo()";
	3441
	3442	// Toma parámetros
	3443	nfl = copiaParametro("nfl",ptrTrama); // Toma nombre completo del archivo
	3444	ptrTrama->tipo = MSG_NOTIFICACION;
	3445	enviaFlag(socket_c, ptrTrama);
	3446	if (!recArchivo(socket_c, nfl)) {
[0a73ecf7]	3447	liberaMemoria(nfl);
[3ec149c]	3448	errorLog(modulo, 58, FALSE);
	3449	return (FALSE);
	3450	}
[0a73ecf7]	3451	liberaMemoria(nfl);
[3ec149c]	3452	return (TRUE);
	3453	}
	3454	// ________________________________________________________________________________________________________
	3455	// Función: envioProgramacion
	3456	//
	3457	// Descripción:
	3458	// Envia un comando de actualización a todos los ordenadores que han sido programados con
	3459	// alguna acción para que entren en el bucle de comandos pendientes y las ejecuten
	3460	// Parámetros:
	3461	// - socket_c: Socket del cliente que envió el mensaje
	3462	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
	3463	// Devuelve:
	3464	// TRUE: Si el proceso es correcto
	3465	// FALSE: En caso de ocurrir algún error
	3466	// ________________________________________________________________________________________________________
	3467	BOOLEAN envioProgramacion(SOCKET socket_c, TRAMA ptrTrama)
	3468	{
	3469	char sqlstr[LONSQL], msglog[LONSTD];
[db4d467]	3470	char *idp,iph[LONIP],mac[LONMAC];
[3ec149c]	3471	Database db;
	3472	Table tbl;
	3473	int idx,idcomando;
	3474	char modulo[] = "envioProgramacion()";
	3475
	3476	if (!db.Open(usuario, pasguor, datasource, catalog)) { // Error de conexion
	3477	errorLog(modulo, 20, FALSE);
	3478	db.GetErrorErrStr(msglog);
	3479	errorInfo(modulo, msglog);
	3480	return (FALSE);
	3481	}
	3482
[0a73ecf7]	3483	idp = copiaParametro("idp",ptrTrama); // Toma identificador de la programación de la tabla acciones
[3ec149c]	3484
	3485	sprintf(sqlstr, "SELECT ordenadores.ip,ordenadores.mac,acciones.idcomando FROM acciones "\
	3486	" INNER JOIN ordenadores ON ordenadores.ip=acciones.ip"\
	3487	" WHERE acciones.idprogramacion=%s",idp);
[0a73ecf7]	3488
	3489	liberaMemoria(idp);
	3490
[3ec149c]	3491	if (!db.Execute(sqlstr, tbl)) { // Error al leer
	3492	errorLog(modulo, 21, FALSE);
	3493	db.GetErrorErrStr(msglog);
	3494	errorInfo(modulo, msglog);
	3495	return (FALSE);
	3496	}
[4d2cdae]	3497	db.Close();
[3ec149c]	3498	if(tbl.ISEOF())
	3499	return (TRUE); // No existen registros
	3500
	3501	/* Prepara la trama de actualizacion */
	3502
	3503	initParametros(ptrTrama,0);
	3504	ptrTrama->tipo=MSG_COMANDO;
	3505	sprintf(ptrTrama->parametros, "nfn=Actualizar\r");
	3506
	3507	while (!tbl.ISEOF()) { // Recorre particiones
	3508	if (!tbl.Get("ip", iph)) {
	3509	tbl.GetErrorErrStr(msglog);
	3510	errorInfo(modulo, msglog);
	3511	return (FALSE);
	3512	}
	3513	if (!tbl.Get("idcomando", idcomando)) {
	3514	tbl.GetErrorErrStr(msglog);
	3515	errorInfo(modulo, msglog);
	3516	return (FALSE);
	3517	}
	3518	if(idcomando==1){ // Arrancar
	3519	if (!tbl.Get("mac", mac)) {
	3520	tbl.GetErrorErrStr(msglog);
	3521	errorInfo(modulo, msglog);
	3522	return (FALSE);
	3523	}
[c916af9]	3524
[e70c867]	3525	// Se manda por broadcast y por unicast
[db4d467]	3526	if (!Levanta(iph, mac, (char*)"1")) {
[3ec149c]	3527	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	3528	errorInfo(modulo, msglog);
	3529	return (FALSE);
	3530	}
[e70c867]	3531
[db4d467]	3532	if (!Levanta(iph, mac, (char*)"2")) {
[e70c867]	3533	sprintf(msglog, "%s:%s", tbErrores[32], modulo);
	3534	errorInfo(modulo, msglog);
	3535	return (FALSE);
	3536	}
	3537
[3ec149c]	3538	}
	3539	if (clienteDisponible(iph, &idx)) { // Si el cliente puede recibir comandos
	3540	strcpy(tbsockets[idx].estado, CLIENTE_OCUPADO); // Actualiza el estado del cliente
	3541	if (!mandaTrama(&tbsockets[idx].sock, ptrTrama)) {
	3542	errorLog(modulo, 26, FALSE);
	3543	return (FALSE);
	3544	}
[eeeb98a]	3545	//close(tbsockets[idx].sock); // Cierra el socket del cliente hasta nueva disponibilidad
[3ec149c]	3546	}
	3547	tbl.MoveNext();
	3548	}
	3549	return (TRUE); // No existen registros
	3550	}
	3551	// ********************************************************************************************************
	3552	// PROGRAMA PRINCIPAL (SERVICIO)
	3553	// ********************************************************************************************************
	3554	int main(int argc, char *argv[]) {
	3555	int i;
	3556	SOCKET socket_s; // Socket donde escucha el servidor
	3557	SOCKET socket_c; // Socket de los clientes que se conectan
	3558	socklen_t iAddrSize;
	3559	struct sockaddr_in local, cliente;
	3560	char modulo[] = "main()";
	3561
	3562	/*--------------------------------------------------------------------------------------------------------
	3563	Validación de parámetros de ejecución y lectura del fichero de configuración del servicio
	3564	---------------------------------------------------------------------------------------------------------*/
	3565	if (!validacionParametros(argc, argv, 1)) // Valida parámetros de ejecución
	3566	exit(EXIT_FAILURE);
	3567
	3568	if (!tomaConfiguracion(szPathFileCfg)) { // Toma parametros de configuracion
	3569	exit(EXIT_FAILURE);
	3570	}
	3571	/*--------------------------------------------------------------------------------------------------------
	3572	Carga del catálogo de funciones que procesan las tramas (referencia directa por puntero a función)
	3573	---------------------------------------------------------------------------------------------------------*/
	3574	int cf = 0;
	3575
	3576	strcpy(tbfuncionesServer[cf].nf, "Sondeo");
	3577	tbfuncionesServer[cf++].fptr = &Sondeo;
	3578	strcpy(tbfuncionesServer[cf].nf, "respuestaSondeo");
	3579	tbfuncionesServer[cf++].fptr = &respuestaSondeo;
	3580
	3581	strcpy(tbfuncionesServer[cf].nf, "ConsolaRemota");
	3582	tbfuncionesServer[cf++].fptr = &ConsolaRemota;
	3583
	3584	strcpy(tbfuncionesServer[cf].nf, "EcoConsola");
	3585	tbfuncionesServer[cf++].fptr = &EcoConsola;
	3586
	3587	strcpy(tbfuncionesServer[cf].nf, "Actualizar");
	3588	tbfuncionesServer[cf++].fptr = &Actualizar;
	3589
	3590	strcpy(tbfuncionesServer[cf].nf, "Purgar");
	3591	tbfuncionesServer[cf++].fptr = &Purgar;
	3592
	3593	strcpy(tbfuncionesServer[cf].nf, "InclusionCliente");
	3594	tbfuncionesServer[cf++].fptr = &InclusionCliente;
	3595
[f679cf0]	3596	strcpy(tbfuncionesServer[cf].nf, "InclusionClienteWinLnx");
	3597	tbfuncionesServer[cf++].fptr = &InclusionClienteWinLnx;
	3598
[3ec149c]	3599	strcpy(tbfuncionesServer[cf].nf, "AutoexecCliente");
	3600	tbfuncionesServer[cf++].fptr = &AutoexecCliente;
	3601
	3602	strcpy(tbfuncionesServer[cf].nf, "ComandosPendientes");
	3603	tbfuncionesServer[cf++].fptr = &ComandosPendientes;
	3604
	3605	strcpy(tbfuncionesServer[cf].nf, "DisponibilidadComandos");
	3606	tbfuncionesServer[cf++].fptr = &DisponibilidadComandos;
	3607
	3608	strcpy(tbfuncionesServer[cf].nf, "Arrancar");
	3609	tbfuncionesServer[cf++].fptr = &Arrancar;
	3610	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Arrancar");
	3611	tbfuncionesServer[cf++].fptr = &RESPUESTA_Arrancar;
	3612
	3613	strcpy(tbfuncionesServer[cf].nf, "Apagar");
	3614	tbfuncionesServer[cf++].fptr = &Apagar;
	3615	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Apagar");
	3616	tbfuncionesServer[cf++].fptr = &RESPUESTA_Apagar;
	3617
	3618	strcpy(tbfuncionesServer[cf].nf, "Reiniciar");
	3619	tbfuncionesServer[cf++].fptr = &Reiniciar;
	3620	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Reiniciar");
	3621	tbfuncionesServer[cf++].fptr = &RESPUESTA_Reiniciar;
	3622
	3623	strcpy(tbfuncionesServer[cf].nf, "IniciarSesion");
	3624	tbfuncionesServer[cf++].fptr = &IniciarSesion;
	3625	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_IniciarSesion");
	3626	tbfuncionesServer[cf++].fptr = &RESPUESTA_IniciarSesion;
	3627
	3628	strcpy(tbfuncionesServer[cf].nf, "CrearImagen");
	3629	tbfuncionesServer[cf++].fptr = &CrearImagen;
	3630	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_CrearImagen");
	3631	tbfuncionesServer[cf++].fptr = &RESPUESTA_CrearImagen;
	3632
[0a73ecf7]	3633	strcpy(tbfuncionesServer[cf].nf, "CrearImagenBasica");
	3634	tbfuncionesServer[cf++].fptr = &CrearImagenBasica;
	3635	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_CrearImagenBasica");
	3636	tbfuncionesServer[cf++].fptr = &RESPUESTA_CrearImagenBasica;
	3637
	3638	strcpy(tbfuncionesServer[cf].nf, "CrearSoftIncremental");
	3639	tbfuncionesServer[cf++].fptr = &CrearSoftIncremental;
	3640	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_CrearSoftIncremental");
	3641	tbfuncionesServer[cf++].fptr = &RESPUESTA_CrearSoftIncremental;
	3642
[3ec149c]	3643	strcpy(tbfuncionesServer[cf].nf, "RestaurarImagen");
	3644	tbfuncionesServer[cf++].fptr = &RestaurarImagen;
	3645	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_RestaurarImagen");
	3646	tbfuncionesServer[cf++].fptr = &RESPUESTA_RestaurarImagen;
	3647
[0a73ecf7]	3648	strcpy(tbfuncionesServer[cf].nf, "RestaurarImagenBasica");
	3649	tbfuncionesServer[cf++].fptr = &RestaurarImagenBasica;
	3650	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_RestaurarImagenBasica");
	3651	tbfuncionesServer[cf++].fptr = &RESPUESTA_RestaurarImagenBasica;
	3652
	3653	strcpy(tbfuncionesServer[cf].nf, "RestaurarSoftIncremental");
	3654	tbfuncionesServer[cf++].fptr = &RestaurarSoftIncremental;
	3655	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_RestaurarSoftIncremental");
	3656	tbfuncionesServer[cf++].fptr = &RESPUESTA_RestaurarSoftIncremental;
	3657
[3ec149c]	3658	strcpy(tbfuncionesServer[cf].nf, "Configurar");
	3659	tbfuncionesServer[cf++].fptr = &Configurar;
	3660	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_Configurar");
	3661	tbfuncionesServer[cf++].fptr = &RESPUESTA_Configurar;
	3662
	3663	strcpy(tbfuncionesServer[cf].nf, "EjecutarScript");
	3664	tbfuncionesServer[cf++].fptr = &EjecutarScript;
	3665	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_EjecutarScript");
	3666	tbfuncionesServer[cf++].fptr = &RESPUESTA_EjecutarScript;
	3667
	3668	strcpy(tbfuncionesServer[cf].nf, "InventarioHardware");
	3669	tbfuncionesServer[cf++].fptr = &InventarioHardware;
	3670	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_InventarioHardware");
	3671	tbfuncionesServer[cf++].fptr = &RESPUESTA_InventarioHardware;
	3672
	3673	strcpy(tbfuncionesServer[cf].nf, "InventarioSoftware");
	3674	tbfuncionesServer[cf++].fptr = &InventarioSoftware;
	3675	strcpy(tbfuncionesServer[cf].nf, "RESPUESTA_InventarioSoftware");
	3676	tbfuncionesServer[cf++].fptr = &RESPUESTA_InventarioSoftware;
	3677
	3678	strcpy(tbfuncionesServer[cf].nf, "enviaArchivo");
	3679	tbfuncionesServer[cf++].fptr = &enviaArchivo;
	3680
	3681	strcpy(tbfuncionesServer[cf].nf, "recibeArchivo");
	3682	tbfuncionesServer[cf++].fptr = &recibeArchivo;
	3683
	3684	strcpy(tbfuncionesServer[cf].nf, "envioProgramacion");
	3685	tbfuncionesServer[cf++].fptr = &envioProgramacion;
	3686
	3687	/*--------------------------------------------------------------------------------------------------------
	3688	// Inicializa array de información de los clientes
	3689	---------------------------------------------------------------------------------------------------------*/
	3690	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
	3691	tbsockets[i].ip[0] = '\0';
	3692	tbsockets[i].sock = INVALID_SOCKET;
	3693	}
	3694	/*--------------------------------------------------------------------------------------------------------
	3695	Creación y configuración del socket del servicio
	3696	---------------------------------------------------------------------------------------------------------*/
	3697	socket_s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Crea socket del servicio
	3698	if (socket_s == SOCKET_ERROR) { // Error al crear el socket del servicio
	3699	errorLog(modulo, 13, TRUE);
	3700	exit(EXIT_FAILURE);
	3701	}
	3702
	3703	local.sin_addr.s_addr = htonl(INADDR_ANY); // Configura el socket del servicio
	3704	local.sin_family = AF_INET;
	3705	local.sin_port = htons(atoi(puerto));
	3706
	3707	if (bind(socket_s, (struct sockaddr *) &local, sizeof(local))
	3708	== SOCKET_ERROR) { // Enlaza socket
	3709	errorLog(modulo, 14, TRUE);
	3710	exit(EXIT_FAILURE);
	3711	}
	3712
	3713	listen(socket_s, 250); // Pone a escuchar al socket
	3714	iAddrSize = sizeof(cliente);
	3715	/*--------------------------------------------------------------------------------------------------------
	3716	Bucle para acceptar conexiones
	3717	---------------------------------------------------------------------------------------------------------*/
	3718	infoLog(1); // Inicio de sesión
	3719	while (TRUE) {
	3720	socket_c = accept(socket_s, (struct sockaddr *) &cliente, &iAddrSize);
	3721	if (socket_c == INVALID_SOCKET) {
	3722	errorLog(modulo, 15, TRUE);
	3723	exit(EXIT_FAILURE);
	3724	}
[2ef5645]	3725	swcSocket = FALSE; // Por defecto se cerrara el socket de cliente después del anális de la trama
[3ec149c]	3726	if (!gestionaTrama(&socket_c)) {
	3727	errorLog(modulo, 39, TRUE);
[0a73ecf7]	3728	//close(socket_c);/tmp/
[3ec149c]	3729	//break;
	3730	}
	3731	if (!swcSocket) // Sólo se cierra cuando el cliente NO espera comandos ineractivos
	3732	close(socket_c);
	3733	}
	3734	/*--------------------------------------------------------------------------------------------------------
	3735	Fin del servicio
	3736	---------------------------------------------------------------------------------------------------------*/
	3737	close(socket_s);
	3738	exit(EXIT_SUCCESS);
	3739	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ 6777e3e

Download in other formats: