Context Navigation

ogAdmServer.cpp @ a0da76f

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 a0da76f was 0a73ecf7, checked in by ramon <ramongomez@…>, 12 years ago

Versión 1.0.5, #565 @567: Integrar código del ticket:567 para corregir ejecución duplicada de comandos, incluyendo código del ogAdmServer con soporte para el ticket:565 (imágenes incrementales).

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

Property mode set to 100644

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

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

Context Navigation

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

Download in other formats: