Context Navigation

ogAdmServer.cpp @ b9a6500

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 b9a6500 was 3ec149c, checked in by alonso <alonso@…>, 15 years ago
git-svn-id: https://opengnsys.es/svn/trunk@1314 a21b9725-9963-47de-94b9-378ad31fedc9
Property mode set to `100644`
File size: 106.4 KB

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

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

Context Navigation

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

Download in other formats: