Context Navigation

ogAdmServer.cpp @ e0314d93

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 e0314d93 was bbd1290, checked in by ramon <ramongomez@…>, 9 years ago

#738: integrar cambios del ticket:738 en versión 1.1

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

Property mode set to 100644

File size: 126.9 KB

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

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

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ e0314d93

Download in other formats: