Context Navigation

ogAdmServer.cpp @ 5797e0b

Last change on this file since 5797e0b was 5797e0b, checked in by OpenGnSys Support Team <soporte-og@…>, 5 years ago

#915 add wol command to REST API in ogAdmServer

Send Wake-On-Lan to clients (through POST method):

Request:

curl -X POST http://127.0.0.1:8888/wol
{ "type" : "unicast", "clients" : [ { "addr" : "192.168.2.1", "mac" : "00AABBCCDD01" } ] }

Reply:

200 OK

Property mode set to 100644

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

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

Context Navigation

source: ogServer-Git/sources/ogAdmServer.cpp @ 5797e0b

Download in other formats: