Context Navigation

ogAdmServer.cpp @ 1e8645b

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 1e8645b was ab4ab39, checked in by irina <irinagomez@…>, 9 years ago

#737 Comando crear imagen de la consola: actualiza en la base de datos las propiedades de la particion: imagen, revisión y fecha de despliegue.

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

Property mode set to 100644

File size: 128.9 KB

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

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

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ 1e8645b

Download in other formats: