Context Navigation

source: ogServer-Git/sources/ogAdmServer.c @ 6c7d827

Last change on this file since 6c7d827 was 6c7d827, checked in by OpenGnSys Support Team <soporte-og@…>, 4 years ago
#942 ignore stale schedules on start
Property mode set to `100644`
File size: 155.9 KB

Line
1	// *******************************************************************************************************
2	// Servicio: ogAdmServer
3	// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
4	// Fecha Creación: Marzo-2010
5	// Fecha Última modificación: Marzo-2010
6	// Nombre del fichero: ogAdmServer.cpp
7	// Descripción :Este fichero implementa el servicio de administración general del sistema
8	// *******************************************************************************************************
9	#include "ogAdmServer.h"
10	#include "ogAdmLib.c"
11	#include "dbi.h"
12	#include "list.h"
13	#include "schedule.h"
14	#include <ev.h>
15	#include <syslog.h>
16	#include <sys/ioctl.h>
17	#include <ifaddrs.h>
18	#include <sys/types.h>
19	#include <sys/stat.h>
20	#include <fcntl.h>
21	#include <jansson.h>
22	#include <time.h>
23
24	static char usuario[LONPRM]; // Usuario de acceso a la base de datos
25	static char pasguor[LONPRM]; // Password del usuario
26	static char datasource[LONPRM]; // Dirección IP del gestor de base de datos
27	static char catalog[LONPRM]; // Nombre de la base de datos
28	static char interface[LONPRM]; // Interface name
29	static char auth_token[LONPRM]; // API token
30
31	static struct og_dbi_config dbi_config = {
32	.user = usuario,
33	.passwd = pasguor,
34	.host = datasource,
35	.database = catalog,
36	};
37
38	//________________________________________________________________________________________________________
39	// Función: tomaConfiguracion
40	//
41	// Descripción:
42	// Lee el fichero de configuración del servicio
43	// Parámetros:
44	// filecfg : Ruta completa al fichero de configuración
45	// Devuelve:
46	// true: Si el proceso es correcto
47	// false: En caso de ocurrir algún error
48	//________________________________________________________________________________________________________
49	static bool tomaConfiguracion(const char *filecfg)
50	{
51	char buf[1024], *line;
52	char key, value;
53	FILE *fcfg;
54
55	if (filecfg == NULL \|\| strlen(filecfg) == 0) {
56	syslog(LOG_ERR, "No configuration file has been specified\n");
57	return false;
58	}
59
60	fcfg = fopen(filecfg, "rt");
61	if (fcfg == NULL) {
62	syslog(LOG_ERR, "Cannot open configuration file `%s'\n",
63	filecfg);
64	return false;
65	}
66
67	servidoradm[0] = '\0'; //inicializar variables globales
68
69	line = fgets(buf, sizeof(buf), fcfg);
70	while (line != NULL) {
71	const char *delim = "=";
72
73	line[strlen(line) - 1] = '\0';
74
75	key = strtok(line, delim);
76	value = strtok(NULL, delim);
77
78	if (!strcmp(StrToUpper(key), "SERVIDORADM"))
79	snprintf(servidoradm, sizeof(servidoradm), "%s", value);
80	else if (!strcmp(StrToUpper(key), "PUERTO"))
81	snprintf(puerto, sizeof(puerto), "%s", value);
82	else if (!strcmp(StrToUpper(key), "USUARIO"))
83	snprintf(usuario, sizeof(usuario), "%s", value);
84	else if (!strcmp(StrToUpper(key), "PASSWORD"))
85	snprintf(pasguor, sizeof(pasguor), "%s", value);
86	else if (!strcmp(StrToUpper(key), "DATASOURCE"))
87	snprintf(datasource, sizeof(datasource), "%s", value);
88	else if (!strcmp(StrToUpper(key), "CATALOG"))
89	snprintf(catalog, sizeof(catalog), "%s", value);
90	else if (!strcmp(StrToUpper(key), "INTERFACE"))
91	snprintf(interface, sizeof(interface), "%s", value);
92	else if (!strcmp(StrToUpper(key), "APITOKEN"))
93	snprintf(auth_token, sizeof(auth_token), "%s", value);
94
95	line = fgets(buf, sizeof(buf), fcfg);
96	}
97
98	fclose(fcfg);
99
100	if (!servidoradm[0]) {
101	syslog(LOG_ERR, "Missing SERVIDORADM in configuration file\n");
102	return false;
103	}
104	if (!puerto[0]) {
105	syslog(LOG_ERR, "Missing PUERTO in configuration file\n");
106	return false;
107	}
108	if (!usuario[0]) {
109	syslog(LOG_ERR, "Missing USUARIO in configuration file\n");
110	return false;
111	}
112	if (!pasguor[0]) {
113	syslog(LOG_ERR, "Missing PASSWORD in configuration file\n");
114	return false;
115	}
116	if (!datasource[0]) {
117	syslog(LOG_ERR, "Missing DATASOURCE in configuration file\n");
118	return false;
119	}
120	if (!catalog[0]) {
121	syslog(LOG_ERR, "Missing CATALOG in configuration file\n");
122	return false;
123	}
124	if (!interface[0])
125	syslog(LOG_ERR, "Missing INTERFACE in configuration file\n");
126
127	return true;
128	}
129
130	enum og_client_state {
131	OG_CLIENT_RECEIVING_HEADER = 0,
132	OG_CLIENT_RECEIVING_PAYLOAD,
133	OG_CLIENT_PROCESSING_REQUEST,
134	};
135
136	#define OG_MSG_REQUEST_MAXLEN 65536
137	#define OG_CMD_MAXLEN 64
138
139	/* Shut down connection if there is no complete message after 10 seconds. */
140	#define OG_CLIENT_TIMEOUT 10
141
142	/* Agent client operation might take longer, shut down after 30 seconds. */
143	#define OG_AGENT_CLIENT_TIMEOUT 30
144
145	enum og_cmd_type {
146	OG_CMD_UNSPEC,
147	OG_CMD_WOL,
148	OG_CMD_PROBE,
149	OG_CMD_SHELL_RUN,
150	OG_CMD_SESSION,
151	OG_CMD_POWEROFF,
152	OG_CMD_REFRESH,
153	OG_CMD_REBOOT,
154	OG_CMD_STOP,
155	OG_CMD_HARDWARE,
156	OG_CMD_SOFTWARE,
157	OG_CMD_IMAGE_CREATE,
158	OG_CMD_IMAGE_RESTORE,
159	OG_CMD_SETUP,
160	OG_CMD_RUN_SCHEDULE,
161	OG_CMD_MAX
162	};
163
164	static LIST_HEAD(client_list);
165
166	enum og_client_status {
167	OG_CLIENT_STATUS_OGLIVE,
168	OG_CLIENT_STATUS_BUSY,
169	};
170
171	struct og_client {
172	struct list_head list;
173	struct ev_io io;
174	struct ev_timer timer;
175	struct sockaddr_in addr;
176	enum og_client_state state;
177	char buf[OG_MSG_REQUEST_MAXLEN];
178	unsigned int buf_len;
179	unsigned int msg_len;
180	int keepalive_idx;
181	bool rest;
182	bool agent;
183	int content_length;
184	char auth_token[64];
185	enum og_client_status status;
186	enum og_cmd_type last_cmd;
187	unsigned int last_cmd_id;
188	};
189
190	static inline int og_client_socket(const struct og_client *cli)
191	{
192	return cli->io.fd;
193	}
194
195	static inline const char og_client_status(const struct og_client cli)
196	{
197	if (cli->last_cmd != OG_CMD_UNSPEC)
198	return "BSY";
199
200	switch (cli->status) {
201	case OG_CLIENT_STATUS_BUSY:
202	return "BSY";
203	case OG_CLIENT_STATUS_OGLIVE:
204	return "OPG";
205	default:
206	return "OFF";
207	}
208	}
209
210	// ________________________________________________________________________________________________________
211	// Función: clienteDisponible
212	//
213	// Descripción:
214	// Comprueba la disponibilidad del cliente para recibir comandos interactivos
215	// Parametros:
216	// - ip : La ip del cliente a buscar
217	// - idx: (Salida) Indice que ocupa el cliente, de estar ya registrado
218	// Devuelve:
219	// true: Si el cliente está disponible
220	// false: En caso contrario
221	// ________________________________________________________________________________________________________
222	bool clienteDisponible(char ip, int idx)
223	{
224	int estado;
225
226	if (clienteExistente(ip, idx)) {
227	estado = strcmp(tbsockets[*idx].estado, CLIENTE_OCUPADO); // Cliente ocupado
228	if (estado == 0)
229	return false;
230
231	estado = strcmp(tbsockets[*idx].estado, CLIENTE_APAGADO); // Cliente apagado
232	if (estado == 0)
233	return false;
234
235	estado = strcmp(tbsockets[*idx].estado, CLIENTE_INICIANDO); // Cliente en proceso de inclusión
236	if (estado == 0)
237	return false;
238
239	return true; // En caso contrario el cliente está disponible
240	}
241	return false; // Cliente no está registrado en el sistema
242	}
243	// ________________________________________________________________________________________________________
244	// Función: clienteExistente
245	//
246	// Descripción:
247	// Comprueba si el cliente está registrado en la tabla de socket del sistema
248	// Parametros:
249	// - ip : La ip del cliente a buscar
250	// - idx:(Salida) Indice que ocupa el cliente, de estar ya registrado
251	// Devuelve:
252	// true: Si el cliente está registrado
253	// false: En caso contrario
254	// ________________________________________________________________________________________________________
255	bool clienteExistente(char ip, int idx)
256	{
257	int i;
258	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
259	if (contieneIP(ip, tbsockets[i].ip)) { // Si existe la IP en la cadena
260	*idx = i;
261	return true;
262	}
263	}
264	return false;
265	}
266	// ________________________________________________________________________________________________________
267	// Función: actualizaConfiguracion
268	//
269	// Descripción:
270	// Esta función actualiza la base de datos con la configuracion de particiones de un cliente
271	// Parámetros:
272	// - db: Objeto base de datos (ya operativo)
273	// - tbl: Objeto tabla
274	// - cfg: cadena con una Configuración
275	// - ido: Identificador del ordenador cliente
276	// Devuelve:
277	// true: Si el proceso es correcto
278	// false: En caso de ocurrir algún error
279	// Especificaciones:
280	// Los parametros de la configuración son:
281	// par= Número de partición
282	// cpt= Codigo o tipo de partición
283	// sfi= Sistema de ficheros que está implementado en la partición
284	// soi= Nombre del sistema de ficheros instalado en la partición
285	// tam= Tamaño de la partición
286	// ________________________________________________________________________________________________________
287	bool actualizaConfiguracion(struct og_dbi dbi, char cfg, int ido)
288	{
289	int lon, p, c,i, dato, swu, idsoi, idsfi,k;
290	char ptrPar[MAXPAR], ptrCfg[7], *ptrDual[2], tbPar[LONSTD];
291	char ser, disk, par, cpt, sfi, soi, tam, uso; // Parametros de configuración.
292	dbi_result result, result_update;
293	const char *msglog;
294
295	lon = 0;
296	p = splitCadena(ptrPar, cfg, '\n');
297	for (i = 0; i < p; i++) {
298	c = splitCadena(ptrCfg, ptrPar[i], '\t');
299
300	// Si la 1ª línea solo incluye el número de serie del equipo; actualizar BD.
301	if (i == 0 && c == 1) {
302	splitCadena(ptrDual, ptrCfg[0], '=');
303	ser = ptrDual[1];
304	if (strlen(ser) > 0) {
305	// Solo actualizar si número de serie no existía.
306	result = dbi_conn_queryf(dbi->conn,
307	"UPDATE ordenadores SET numserie='%s'"
308	" WHERE idordenador=%d AND numserie IS NULL",
309	ser, ido);
310	if (!result) {
311	dbi_conn_error(dbi->conn, &msglog);
312	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
313	__func__, __LINE__, msglog);
314	return false;
315	}
316	dbi_result_free(result);
317	}
318	continue;
319	}
320
321	// Distribución de particionado.
322	disk = par = cpt = sfi = soi = tam = uso = NULL;
323
324	splitCadena(ptrDual, ptrCfg[0], '=');
325	disk = ptrDual[1]; // Número de disco
326
327	splitCadena(ptrDual, ptrCfg[1], '=');
328	par = ptrDual[1]; // Número de partición
329
330	k=splitCadena(ptrDual, ptrCfg[2], '=');
331	if(k==2){
332	cpt = ptrDual[1]; // Código de partición
333	}else{
334	cpt = (char*)"0";
335	}
336
337	k=splitCadena(ptrDual, ptrCfg[3], '=');
338	if(k==2){
339	sfi = ptrDual[1]; // Sistema de ficheros
340	/* Comprueba existencia del s0xistema de ficheros instalado */
341	idsfi = checkDato(dbi, sfi, "sistemasficheros", "descripcion","idsistemafichero");
342	}
343	else
344	idsfi=0;
345
346	k=splitCadena(ptrDual, ptrCfg[4], '=');
347	if(k==2){ // Sistema operativo detecdtado
348	soi = ptrDual[1]; // Nombre del S.O. instalado
349	/* Comprueba existencia del sistema operativo instalado */
350	idsoi = checkDato(dbi, soi, "nombresos", "nombreso", "idnombreso");
351	}
352	else
353	idsoi=0;
354
355	splitCadena(ptrDual, ptrCfg[5], '=');
356	tam = ptrDual[1]; // Tamaño de la partición
357
358	splitCadena(ptrDual, ptrCfg[6], '=');
359	uso = ptrDual[1]; // Porcentaje de uso del S.F.
360
361	lon += sprintf(tbPar + lon, "(%s, %s),", disk, par);
362
363	result = dbi_conn_queryf(dbi->conn,
364	"SELECT numdisk, numpar, tamano, uso, idsistemafichero, idnombreso"
365	" FROM ordenadores_particiones"
366	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
367	ido, disk, par);
368	if (!result) {
369	dbi_conn_error(dbi->conn, &msglog);
370	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
371	__func__, __LINE__, msglog);
372	return false;
373	}
374	if (!dbi_result_next_row(result)) {
375	result_update = dbi_conn_queryf(dbi->conn,
376	"INSERT INTO ordenadores_particiones(idordenador,numdisk,numpar,codpar,tamano,uso,idsistemafichero,idnombreso,idimagen)"
377	" VALUES(%d,%s,%s,0x%s,%s,%s,%d,%d,0)",
378	ido, disk, par, cpt, tam, uso, idsfi, idsoi);
379	if (!result_update) {
380	dbi_conn_error(dbi->conn, &msglog);
381	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
382	__func__, __LINE__, msglog);
383	return false;
384	}
385	dbi_result_free(result_update);
386
387	} else { // Existe el registro
388	swu = true; // Se supone que algún dato ha cambiado
389
390	dato = dbi_result_get_uint(result, "tamano");
391	if (atoi(tam) == dato) {// Parámetro tamaño igual al almacenado
392	dato = dbi_result_get_uint(result, "idsistemafichero");
393	if (idsfi == dato) {// Parámetro sistema de fichero igual al almacenado
394	dato = dbi_result_get_uint(result, "idnombreso");
395	if (idsoi == dato) {// Parámetro sistema de fichero distinto al almacenado
396	swu = false; // Todos los parámetros de la partición son iguales, no se actualiza
397	}
398	}
399	}
400	if (swu) { // Hay que actualizar los parámetros de la partición
401	result_update = dbi_conn_queryf(dbi->conn,
402	"UPDATE ordenadores_particiones SET "
403	" codpar=0x%s,"
404	" tamano=%s,"
405	" uso=%s,"
406	" idsistemafichero=%d,"
407	" idnombreso=%d,"
408	" idimagen=0,"
409	" idperfilsoft=0,"
410	" fechadespliegue=NULL"
411	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
412	cpt, tam, uso, idsfi, idsoi, ido, disk, par);
413	} else { // Actualizar porcentaje de uso.
414	result_update = dbi_conn_queryf(dbi->conn,
415	"UPDATE ordenadores_particiones SET "
416	" codpar=0x%s,"
417	" uso=%s"
418	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
419	cpt, uso, ido, disk, par);
420	}
421	if (!result_update) {
422	dbi_conn_error(dbi->conn, &msglog);
423	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
424	__func__, __LINE__, msglog);
425	return false;
426	}
427
428	dbi_result_free(result_update);
429	}
430	dbi_result_free(result);
431	}
432	lon += sprintf(tbPar + lon, "(0,0)");
433	// Eliminar particiones almacenadas que ya no existen
434	result_update = dbi_conn_queryf(dbi->conn,
435	"DELETE FROM ordenadores_particiones WHERE idordenador=%d AND (numdisk, numpar) NOT IN (%s)",
436	ido, tbPar);
437	if (!result_update) {
438	dbi_conn_error(dbi->conn, &msglog);
439	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
440	__func__, __LINE__, msglog);
441	return false;
442	}
443	dbi_result_free(result_update);
444
445	return true;
446	}
447	// ________________________________________________________________________________________________________
448	// Función: checkDato
449	//
450	// Descripción:
451	// Esta función comprueba si existe un dato en una tabla y si no es así lo incluye. devuelve en
452	// cualquier caso el identificador del registro existenet o del insertado
453	// Parámetros:
454	// - db: Objeto base de datos (ya operativo)
455	// - tbl: Objeto tabla
456	// - dato: Dato
457	// - tabla: Nombre de la tabla
458	// - nomdato: Nombre del dato en la tabla
459	// - nomidentificador: Nombre del identificador en la tabla
460	// Devuelve:
461	// El identificador del registro existente o el del insertado
462	//
463	// Especificaciones:
464	// En caso de producirse algún error se devuelve el valor 0
465	// ________________________________________________________________________________________________________
466
467	int checkDato(struct og_dbi dbi, char dato, const char *tabla,
468	const char nomdato, const char nomidentificador)
469	{
470	const char *msglog;
471	int identificador;
472	dbi_result result;
473
474	if (strlen(dato) == 0)
475	return (0); // EL dato no tiene valor
476	result = dbi_conn_queryf(dbi->conn,
477	"SELECT %s FROM %s WHERE %s ='%s'", nomidentificador,
478	tabla, nomdato, dato);
479
480	// Ejecuta consulta
481	if (!result) {
482	dbi_conn_error(dbi->conn, &msglog);
483	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
484	__func__, __LINE__, msglog);
485	return (0);
486	}
487	if (!dbi_result_next_row(result)) { // Software NO existente
488	dbi_result_free(result);
489
490	result = dbi_conn_queryf(dbi->conn,
491	"INSERT INTO %s (%s) VALUES('%s')", tabla, nomdato, dato);
492	if (!result) {
493	dbi_conn_error(dbi->conn, &msglog);
494	og_info((char *)msglog);
495	return (0);
496	}
497	// Recupera el identificador del software
498	identificador = dbi_conn_sequence_last(dbi->conn, NULL);
499	} else {
500	identificador = dbi_result_get_uint(result, nomidentificador);
501	}
502	dbi_result_free(result);
503
504	return (identificador);
505	}
506
507	struct og_task {
508	uint32_t task_id;
509	uint32_t procedure_id;
510	uint32_t command_id;
511	uint32_t center_id;
512	uint32_t schedule_id;
513	uint32_t type_scope;
514	uint32_t scope;
515	const char *filtered_scope;
516	const char *params;
517	};
518
519	static TRAMA og_msg_alloc(char data, unsigned int len);
520	static void og_msg_free(TRAMA *ptrTrama);
521
522	static bool og_send_cmd(char *ips_array[], int ips_array_len,
523	const char state, TRAMA ptrTrama)
524	{
525	int i, idx;
526
527	for (i = 0; i < ips_array_len; i++) {
528	if (clienteDisponible(ips_array[i], &idx)) { // Si el cliente puede recibir comandos
529	int sock = tbsockets[idx].cli ? tbsockets[idx].cli->io.fd : -1;
530
531	strcpy(tbsockets[idx].estado, state); // Actualiza el estado del cliente
532	if (sock >= 0 && !mandaTrama(&sock, ptrTrama)) {
533	syslog(LOG_ERR, "failed to send response to %s:%s\n",
534	ips_array[i], strerror(errno));
535	}
536	}
537	}
538	return true;
539	}
540
541	// ________________________________________________________________________________________________________
542	// Función: Levanta
543	//
544	// Descripción:
545	// Enciende ordenadores a través de la red cuyas macs se pasan como parámetro
546	// Parámetros:
547	// - iph: Cadena de direcciones ip separadas por ";"
548	// - mac: Cadena de direcciones mac separadas por ";"
549	// - mar: Método de arranque (1=Broadcast, 2=Unicast)
550	// Devuelve:
551	// true: Si el proceso es correcto
552	// false: En caso de ocurrir algún error
553	// ________________________________________________________________________________________________________
554
555	bool Levanta(char ptrIP[], char ptrMacs[], int lon, char *mar)
556	{
557	unsigned int on = 1;
558	struct sockaddr_in local;
559	int i, res;
560	int s;
561
562	/* Creación de socket para envío de magig packet */
563	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
564	if (s < 0) {
565	syslog(LOG_ERR, "cannot create socket for magic packet\n");
566	return false;
567	}
568	res = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (unsigned int *) &on,
569	sizeof(on));
570	if (res < 0) {
571	syslog(LOG_ERR, "cannot set broadcast socket\n");
572	return false;
573	}
574	memset(&local, 0, sizeof(local));
575	local.sin_family = AF_INET;
576	local.sin_port = htons(PUERTO_WAKEUP);
577	local.sin_addr.s_addr = htonl(INADDR_ANY);
578
579	for (i = 0; i < lon; i++) {
580	if (!WakeUp(s, ptrIP[i], ptrMacs[i], mar)) {
581	syslog(LOG_ERR, "problem sending magic packet\n");
582	close(s);
583	return false;
584	}
585	}
586	close(s);
587	return true;
588	}
589
590	#define OG_WOL_SEQUENCE 6
591	#define OG_WOL_MACADDR_LEN 6
592	#define OG_WOL_REPEAT 16
593
594	struct wol_msg {
595	char secuencia_FF[OG_WOL_SEQUENCE];
596	char macbin[OG_WOL_REPEAT][OG_WOL_MACADDR_LEN];
597	};
598
599	static bool wake_up_broadcast(int sd, struct sockaddr_in *client,
600	const struct wol_msg *msg)
601	{
602	struct sockaddr_in *broadcast_addr;
603	struct ifaddrs ifaddr, ifa;
604	int ret;
605
606	if (getifaddrs(&ifaddr) < 0) {
607	syslog(LOG_ERR, "cannot get list of addresses\n");
608	return false;
609	}
610
611	client->sin_addr.s_addr = htonl(INADDR_BROADCAST);
612
613	for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
614	if (ifa->ifa_addr == NULL \|\|
615	ifa->ifa_addr->sa_family != AF_INET \|\|
616	strcmp(ifa->ifa_name, interface) != 0)
617	continue;
618
619	broadcast_addr =
620	(struct sockaddr_in *)ifa->ifa_ifu.ifu_broadaddr;
621	client->sin_addr.s_addr = broadcast_addr->sin_addr.s_addr;
622	break;
623	}
624	freeifaddrs(ifaddr);
625
626	ret = sendto(sd, msg, sizeof(*msg), 0,
627	(struct sockaddr )client, sizeof(client));
628	if (ret < 0) {
629	syslog(LOG_ERR, "failed to send broadcast wol\n");
630	return false;
631	}
632
633	return true;
634	}
635
636	static bool wake_up_unicast(int sd, struct sockaddr_in *client,
637	const struct wol_msg *msg,
638	const struct in_addr *addr)
639	{
640	int ret;
641
642	client->sin_addr.s_addr = addr->s_addr;
643
644	ret = sendto(sd, msg, sizeof(*msg), 0,
645	(struct sockaddr )client, sizeof(client));
646	if (ret < 0) {
647	syslog(LOG_ERR, "failed to send unicast wol\n");
648	return false;
649	}
650
651	return true;
652	}
653
654	enum wol_delivery_type {
655	OG_WOL_BROADCAST = 1,
656	OG_WOL_UNICAST = 2
657	};
658
659	//_____________________________________________________________________________________________________________
660	// Función: WakeUp
661	//
662	// Descripción:
663	// Enciende el ordenador cuya MAC se pasa como parámetro
664	// Parámetros:
665	// - s : Socket para enviar trama magic packet
666	// - iph : Cadena con la dirección ip
667	// - mac : Cadena con la dirección mac en formato XXXXXXXXXXXX
668	// - mar: Método de arranque (1=Broadcast, 2=Unicast)
669	// Devuelve:
670	// true: Si el proceso es correcto
671	// false: En caso de ocurrir algún error
672	//_____________________________________________________________________________________________________________
673	//
674	bool WakeUp(int s, char* iph, char mac, char mar)
675	{
676	unsigned int macaddr[OG_WOL_MACADDR_LEN];
677	char HDaddress_bin[OG_WOL_MACADDR_LEN];
678	struct sockaddr_in WakeUpCliente;
679	struct wol_msg Trama_WakeUp;
680	struct in_addr addr;
681	bool ret;
682	int i;
683
684	for (i = 0; i < 6; i++) // Primera secuencia de la trama Wake Up (0xFFFFFFFFFFFF)
685	Trama_WakeUp.secuencia_FF[i] = 0xFF;
686
687	sscanf(mac, "%02x%02x%02x%02x%02x%02x",
688	&macaddr[0], &macaddr[1], &macaddr[2],
689	&macaddr[3], &macaddr[4], &macaddr[5]);
690
691	for (i = 0; i < 6; i++)
692	HDaddress_bin[i] = (uint8_t)macaddr[i];
693
694	for (i = 0; i < 16; i++) // Segunda secuencia de la trama Wake Up , repetir 16 veces su la MAC
695	memcpy(&Trama_WakeUp.macbin[i][0], &HDaddress_bin, 6);
696
697	/* Creación de socket del cliente que recibe la trama magic packet */
698	WakeUpCliente.sin_family = AF_INET;
699	WakeUpCliente.sin_port = htons((short) PUERTO_WAKEUP);
700
701	switch (atoi(mar)) {
702	case OG_WOL_BROADCAST:
703	ret = wake_up_broadcast(s, &WakeUpCliente, &Trama_WakeUp);
704	break;
705	case OG_WOL_UNICAST:
706	if (inet_aton(iph, &addr) < 0) {
707	syslog(LOG_ERR, "bad IP address for unicast wol\n");
708	ret = false;
709	break;
710	}
711	ret = wake_up_unicast(s, &WakeUpCliente, &Trama_WakeUp, &addr);
712	break;
713	default:
714	syslog(LOG_ERR, "unknown wol type\n");
715	ret = false;
716	break;
717	}
718	return ret;
719	}
720
721	// ________________________________________________________________________________________________________
722	// Función: actualizaCreacionImagen
723	//
724	// Descripción:
725	// Esta función actualiza la base de datos con el resultado de la creación de una imagen
726	// Parámetros:
727	// - db: Objeto base de datos (ya operativo)
728	// - tbl: Objeto tabla
729	// - idi: Identificador de la imagen
730	// - dsk: Disco de donde se creó
731	// - par: Partición de donde se creó
732	// - cpt: Código de partición
733	// - ipr: Ip del repositorio
734	// - ido: Identificador del ordenador modelo
735	// Devuelve:
736	// true: Si el proceso es correcto
737	// false: En caso de ocurrir algún error
738	// ________________________________________________________________________________________________________
739	bool actualizaCreacionImagen(struct og_dbi dbi, char idi, char *dsk,
740	char par, char cpt, char ipr, char ido)
741	{
742	const char *msglog;
743	dbi_result result;
744	int idr,ifs;
745
746	/* Toma identificador del repositorio correspondiente al ordenador modelo */
747	result = dbi_conn_queryf(dbi->conn,
748	"SELECT repositorios.idrepositorio"
749	" FROM repositorios"
750	" LEFT JOIN ordenadores USING (idrepositorio)"
751	" WHERE repositorios.ip='%s' AND ordenadores.idordenador=%s", ipr, ido);
752
753	if (!result) {
754	dbi_conn_error(dbi->conn, &msglog);
755	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
756	__func__, __LINE__, msglog);
757	return false;
758	}
759	if (!dbi_result_next_row(result)) {
760	syslog(LOG_ERR,
761	"repository does not exist in database (%s:%d)\n",
762	__func__, __LINE__);
763	dbi_result_free(result);
764	return false;
765	}
766	idr = dbi_result_get_uint(result, "idrepositorio");
767	dbi_result_free(result);
768
769	/* Toma identificador del perfilsoftware */
770	result = dbi_conn_queryf(dbi->conn,
771	"SELECT idperfilsoft"
772	" FROM ordenadores_particiones"
773	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s", ido, dsk, par);
774
775	if (!result) {
776	dbi_conn_error(dbi->conn, &msglog);
777	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
778	__func__, __LINE__, msglog);
779	return false;
780	}
781	if (!dbi_result_next_row(result)) {
782	syslog(LOG_ERR,
783	"software profile does not exist in database (%s:%d)\n",
784	__func__, __LINE__);
785	dbi_result_free(result);
786	return false;
787	}
788	ifs = dbi_result_get_uint(result, "idperfilsoft");
789	dbi_result_free(result);
790
791	/* Actualizar los datos de la imagen */
792	result = dbi_conn_queryf(dbi->conn,
793	"UPDATE imagenes"
794	" SET idordenador=%s, numdisk=%s, numpar=%s, codpar=%s,"
795	" idperfilsoft=%d, idrepositorio=%d,"
796	" fechacreacion=NOW(), revision=revision+1"
797	" WHERE idimagen=%s", ido, dsk, par, cpt, ifs, idr, idi);
798
799	if (!result) {
800	dbi_conn_error(dbi->conn, &msglog);
801	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
802	__func__, __LINE__, msglog);
803	return false;
804	}
805	dbi_result_free(result);
806
807	/* Actualizar los datos en el cliente */
808	result = dbi_conn_queryf(dbi->conn,
809	"UPDATE ordenadores_particiones"
810	" SET idimagen=%s, revision=(SELECT revision FROM imagenes WHERE idimagen=%s),"
811	" fechadespliegue=NOW()"
812	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s",
813	idi, idi, ido, dsk, par);
814	if (!result) {
815	dbi_conn_error(dbi->conn, &msglog);
816	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
817	__func__, __LINE__, msglog);
818	return false;
819	}
820	dbi_result_free(result);
821
822	return true;
823	}
824
825	// ________________________________________________________________________________________________________
826	// Función: actualizaRestauracionImagen
827	//
828	// Descripción:
829	// Esta función actualiza la base de datos con el resultado de la restauración de una imagen
830	// Parámetros:
831	// - db: Objeto base de datos (ya operativo)
832	// - tbl: Objeto tabla
833	// - idi: Identificador de la imagen
834	// - dsk: Disco de donde se restauró
835	// - par: Partición de donde se restauró
836	// - ido: Identificador del cliente donde se restauró
837	// - ifs: Identificador del perfil software contenido en la imagen
838	// Devuelve:
839	// true: Si el proceso es correcto
840	// false: En caso de ocurrir algún error
841	// ________________________________________________________________________________________________________
842	bool actualizaRestauracionImagen(struct og_dbi dbi, char idi,
843	char dsk, char par, char ido, char ifs)
844	{
845	const char *msglog;
846	dbi_result result;
847
848	/* Actualizar los datos de la imagen */
849	result = dbi_conn_queryf(dbi->conn,
850	"UPDATE ordenadores_particiones"
851	" SET idimagen=%s, idperfilsoft=%s, fechadespliegue=NOW(),"
852	" revision=(SELECT revision FROM imagenes WHERE idimagen=%s),"
853	" idnombreso=IFNULL((SELECT idnombreso FROM perfilessoft WHERE idperfilsoft=%s),0)"
854	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s", idi, ifs, idi, ifs, ido, dsk, par);
855
856	if (!result) {
857	dbi_conn_error(dbi->conn, &msglog);
858	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
859	__func__, __LINE__, msglog);
860	return false;
861	}
862	dbi_result_free(result);
863
864	return true;
865	}
866	// ________________________________________________________________________________________________________
867	// Función: actualizaHardware
868	//
869	// Descripción:
870	// Actualiza la base de datos con la configuracion hardware del cliente
871	// Parámetros:
872	// - db: Objeto base de datos (ya operativo)
873	// - tbl: Objeto tabla
874	// - hrd: cadena con el inventario hardware
875	// - ido: Identificador del ordenador
876	// - npc: Nombre del ordenador
877	// - idc: Identificador del centro o Unidad organizativa
878	// ________________________________________________________________________________________________________
879	//
880	bool actualizaHardware(struct og_dbi dbi, char hrd, char ido, char npc,
881	char *idc)
882	{
883	const char *msglog;
884	int idtipohardware, idperfilhard;
885	int lon, i, j, aux;
886	bool retval;
887	char *whard;
888	int tbidhardware[MAXHARDWARE];
889	char tbHardware[MAXHARDWARE],dualHardware[2], strInt[LONINT], *idhardwares;
890	dbi_result result;
891
892	/* Toma Centro (Unidad Organizativa) */
893	result = dbi_conn_queryf(dbi->conn,
894	"SELECT idperfilhard FROM ordenadores WHERE idordenador=%s",
895	ido);
896	if (!result) {
897	dbi_conn_error(dbi->conn, &msglog);
898	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
899	__func__, __LINE__, msglog);
900	return false;
901	}
902	if (!dbi_result_next_row(result)) {
903	syslog(LOG_ERR, "client does not exist in database (%s:%d)\n",
904	__func__, __LINE__);
905	dbi_result_free(result);
906	return false;
907	}
908	idperfilhard = dbi_result_get_uint(result, "idperfilhard");
909	dbi_result_free(result);
910
911	whard=escaparCadena(hrd); // Codificar comillas simples
912	if(!whard)
913	return false;
914	/* Recorre componentes hardware*/
915	lon = splitCadena(tbHardware, whard, '\n');
916	if (lon > MAXHARDWARE)
917	lon = MAXHARDWARE; // Limita el número de componentes hardware
918	/*
919	for (i=0;i<lon;i++){
920	sprintf(msglog,"Linea de inventario: %s",tbHardware[i]);
921	RegistraLog(msglog,false);
922	}
923	*/
924	for (i = 0; i < lon; i++) {
925	splitCadena(dualHardware, rTrim(tbHardware[i]), '=');
926	//sprintf(msglog,"nemonico: %s",dualHardware[0]);
927	//RegistraLog(msglog,false);
928	//sprintf(msglog,"valor: %s",dualHardware[1]);
929	//RegistraLog(msglog,false);
930	result = dbi_conn_queryf(dbi->conn,
931	"SELECT idtipohardware,descripcion FROM tipohardwares WHERE nemonico='%s'",
932	dualHardware[0]);
933	if (!result) {
934	dbi_conn_error(dbi->conn, &msglog);
935	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
936	__func__, __LINE__, msglog);
937	return false;
938	}
939	if (!dbi_result_next_row(result)) { // Tipo de Hardware NO existente
940	dbi_result_free(result);
941	return false;
942	} else { // Tipo de Hardware Existe
943	idtipohardware = dbi_result_get_uint(result, "idtipohardware");
944	dbi_result_free(result);
945
946	result = dbi_conn_queryf(dbi->conn,
947	"SELECT idhardware FROM hardwares WHERE idtipohardware=%d AND descripcion='%s'",
948	idtipohardware, dualHardware[1]);
949
950	if (!result) {
951	dbi_conn_error(dbi->conn, &msglog);
952	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
953	__func__, __LINE__, msglog);
954	return false;
955	}
956
957	if (!dbi_result_next_row(result)) { // Hardware NO existente
958	dbi_result_free(result);
959	result = dbi_conn_queryf(dbi->conn,
960	"INSERT hardwares (idtipohardware,descripcion,idcentro,grupoid) "
961	" VALUES(%d,'%s',%s,0)", idtipohardware,
962	dualHardware[1], idc);
963	if (!result) {
964	dbi_conn_error(dbi->conn, &msglog);
965	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
966	__func__, __LINE__, msglog);
967	return false;
968	}
969
970	// Recupera el identificador del hardware
971	tbidhardware[i] = dbi_conn_sequence_last(dbi->conn, NULL);
972	} else {
973	tbidhardware[i] = dbi_result_get_uint(result, "idhardware");
974	}
975	dbi_result_free(result);
976	}
977	}
978	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
979
980	for (i = 0; i < lon - 1; i++) {
981	for (j = i + 1; j < lon; j++) {
982	if (tbidhardware[i] > tbidhardware[j]) {
983	aux = tbidhardware[i];
984	tbidhardware[i] = tbidhardware[j];
985	tbidhardware[j] = aux;
986	}
987	}
988	}
989	/* Crea cadena de identificadores de componentes hardware separados por coma */
990	sprintf(strInt, "%d", tbidhardware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
991	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
992	idhardwares = reservaMemoria(sizeof(aux) * lon + lon);
993	if (idhardwares == NULL) {
994	syslog(LOG_ERR, "%s:%d OOM\n", __FILE__, __LINE__);
995	return false;
996	}
997	aux = sprintf(idhardwares, "%d", tbidhardware[0]);
998	for (i = 1; i < lon; i++)
999	aux += sprintf(idhardwares + aux, ",%d", tbidhardware[i]);
1000
1001	if (!cuestionPerfilHardware(dbi, idc, ido, idperfilhard, idhardwares,
1002	npc, tbidhardware, lon)) {
1003	syslog(LOG_ERR, "Problem updating client hardware\n");
1004	retval=false;
1005	}
1006	else {
1007	retval=true;
1008	}
1009	liberaMemoria(whard);
1010	liberaMemoria(idhardwares);
1011	return (retval);
1012	}
1013	// ________________________________________________________________________________________________________
1014	// Función: cuestionPerfilHardware
1015	//
1016	// Descripción:
1017	// Comprueba existencia de perfil hardware y actualización de éste para el ordenador
1018	// Parámetros:
1019	// - db: Objeto base de datos (ya operativo)
1020	// - tbl: Objeto tabla
1021	// - idc: Identificador de la Unidad organizativa donde se encuentra el cliente
1022	// - ido: Identificador del ordenador
1023	// - tbidhardware: Identificador del tipo de hardware
1024	// - con: Número de componentes detectados para configurar un el perfil hardware
1025	// - npc: Nombre del cliente
1026	// ________________________________________________________________________________________________________
1027	bool cuestionPerfilHardware(struct og_dbi dbi, char idc, char *ido,
1028	int idperfilhardware, char idhardwares, char npc, int *tbidhardware,
1029	int lon)
1030	{
1031	const char *msglog;
1032	dbi_result result;
1033	int i;
1034	int nwidperfilhard;
1035
1036	// Busca perfil hard del ordenador que contenga todos los componentes hardware encontrados
1037	result = dbi_conn_queryf(dbi->conn,
1038	"SELECT idperfilhard FROM"
1039	" (SELECT perfileshard_hardwares.idperfilhard as idperfilhard,"
1040	" group_concat(cast(perfileshard_hardwares.idhardware AS char( 11) )"
1041	" ORDER BY perfileshard_hardwares.idhardware SEPARATOR ',' ) AS idhardwares"
1042	" FROM perfileshard_hardwares"
1043	" GROUP BY perfileshard_hardwares.idperfilhard) AS temp"
1044	" WHERE idhardwares LIKE '%s'", idhardwares);
1045
1046	if (!result) {
1047	dbi_conn_error(dbi->conn, &msglog);
1048	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1049	__func__, __LINE__, msglog);
1050	return false;
1051	}
1052	if (!dbi_result_next_row(result)) {
1053	// No existe un perfil hardware con esos componentes de componentes hardware, lo crea
1054	dbi_result_free(result);
1055	result = dbi_conn_queryf(dbi->conn,
1056	"INSERT perfileshard (descripcion,idcentro,grupoid)"
1057	" VALUES('Perfil hardware (%s) ',%s,0)", npc, idc);
1058	if (!result) {
1059	dbi_conn_error(dbi->conn, &msglog);
1060	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1061	__func__, __LINE__, msglog);
1062	return false;
1063	}
1064	dbi_result_free(result);
1065
1066	// Recupera el identificador del nuevo perfil hardware
1067	nwidperfilhard = dbi_conn_sequence_last(dbi->conn, NULL);
1068
1069	// Crea la relación entre perfiles y componenetes hardware
1070	for (i = 0; i < lon; i++) {
1071	result = dbi_conn_queryf(dbi->conn,
1072	"INSERT perfileshard_hardwares (idperfilhard,idhardware)"
1073	" VALUES(%d,%d)", nwidperfilhard, tbidhardware[i]);
1074	if (!result) {
1075	dbi_conn_error(dbi->conn, &msglog);
1076	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1077	__func__, __LINE__, msglog);
1078	return false;
1079	}
1080	dbi_result_free(result);
1081	}
1082	} else { // Existe un perfil con todos esos componentes
1083	nwidperfilhard = dbi_result_get_uint(result, "idperfilhard");
1084	dbi_result_free(result);
1085	}
1086	if (idperfilhardware != nwidperfilhard) { // No coinciden los perfiles
1087	// Actualiza el identificador del perfil hardware del ordenador
1088	result = dbi_conn_queryf(dbi->conn,
1089	"UPDATE ordenadores SET idperfilhard=%d"
1090	" WHERE idordenador=%s", nwidperfilhard, ido);
1091	if (!result) {
1092	dbi_conn_error(dbi->conn, &msglog);
1093	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1094	__func__, __LINE__, msglog);
1095	return false;
1096	}
1097	dbi_result_free(result);
1098	}
1099	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
1100	result = dbi_conn_queryf(dbi->conn,
1101	"DELETE FROM perfileshard_hardwares WHERE idperfilhard IN "
1102	" (SELECT idperfilhard FROM perfileshard WHERE idperfilhard NOT IN"
1103	" (SELECT DISTINCT idperfilhard from ordenadores))");
1104	if (!result) {
1105	dbi_conn_error(dbi->conn, &msglog);
1106	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1107	__func__, __LINE__, msglog);
1108	return false;
1109	}
1110	dbi_result_free(result);
1111
1112	/* Eliminar Perfiles hardware que quedan húerfanos */
1113	result = dbi_conn_queryf(dbi->conn,
1114	"DELETE FROM perfileshard WHERE idperfilhard NOT IN"
1115	" (SELECT DISTINCT idperfilhard FROM ordenadores)");
1116	if (!result) {
1117	dbi_conn_error(dbi->conn, &msglog);
1118	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1119	__func__, __LINE__, msglog);
1120	return false;
1121	}
1122	dbi_result_free(result);
1123
1124	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
1125	result = dbi_conn_queryf(dbi->conn,
1126	"DELETE FROM perfileshard_hardwares WHERE idperfilhard NOT IN"
1127	" (SELECT idperfilhard FROM perfileshard)");
1128	if (!result) {
1129	dbi_conn_error(dbi->conn, &msglog);
1130	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1131	__func__, __LINE__, msglog);
1132	return false;
1133	}
1134	dbi_result_free(result);
1135
1136	return true;
1137	}
1138	// ________________________________________________________________________________________________________
1139	// Función: actualizaSoftware
1140	//
1141	// Descripción:
1142	// Actualiza la base de datos con la configuración software del cliente
1143	// Parámetros:
1144	// - db: Objeto base de datos (ya operativo)
1145	// - tbl: Objeto tabla
1146	// - sft: cadena con el inventario software
1147	// - par: Número de la partición
1148	// - ido: Identificador del ordenador del cliente en la tabla
1149	// - npc: Nombre del ordenador
1150	// - idc: Identificador del centro o Unidad organizativa
1151	// Devuelve:
1152	// true: Si el proceso es correcto
1153	// false: En caso de ocurrir algún error
1154	//
1155	// Versión 1.1.0: Se incluye el sistema operativo. Autora: Irina Gómez - ETSII Universidad Sevilla
1156	// ________________________________________________________________________________________________________
1157	bool actualizaSoftware(struct og_dbi dbi, char sft, char par,char ido,
1158	char npc, char idc)
1159	{
1160	int i, j, lon, aux, idperfilsoft, idnombreso;
1161	bool retval;
1162	char *wsft;
1163	int tbidsoftware[MAXSOFTWARE];
1164	char tbSoftware[MAXSOFTWARE], strInt[LONINT], idsoftwares;
1165	const char *msglog;
1166	dbi_result result;
1167
1168	/* Toma Centro (Unidad Organizativa) y perfil software */
1169	result = dbi_conn_queryf(dbi->conn,
1170	"SELECT idperfilsoft,numpar"
1171	" FROM ordenadores_particiones"
1172	" WHERE idordenador=%s", ido);
1173	if (!result) {
1174	dbi_conn_error(dbi->conn, &msglog);
1175	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1176	__func__, __LINE__, msglog);
1177	return false;
1178	}
1179	idperfilsoft = 0; // Por defecto se supone que el ordenador no tiene aún detectado el perfil software
1180	while (dbi_result_next_row(result)) {
1181	aux = dbi_result_get_uint(result, "numpar");
1182	if (aux == atoi(par)) { // Se encuentra la partición
1183	idperfilsoft = dbi_result_get_uint(result, "idperfilsoft");
1184	break;
1185	}
1186	}
1187	dbi_result_free(result);
1188	wsft=escaparCadena(sft); // Codificar comillas simples
1189	if(!wsft)
1190	return false;
1191
1192	/* Recorre componentes software*/
1193	lon = splitCadena(tbSoftware, wsft, '\n');
1194
1195	if (lon == 0)
1196	return true; // No hay lineas que procesar
1197	if (lon > MAXSOFTWARE)
1198	lon = MAXSOFTWARE; // Limita el número de componentes software
1199
1200	idnombreso = 0;
1201	for (i = 0; i < lon; i++) {
1202	// Primera línea es el sistema operativo: se obtiene identificador
1203	if (i == 0) {
1204	idnombreso = checkDato(dbi, rTrim(tbSoftware[i]), "nombresos", "nombreso", "idnombreso");
1205	continue;
1206	}
1207
1208	result = dbi_conn_queryf(dbi->conn,
1209	"SELECT idsoftware FROM softwares WHERE descripcion ='%s'",
1210	rTrim(tbSoftware[i]));
1211	if (!result) {
1212	dbi_conn_error(dbi->conn, &msglog);
1213	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1214	__func__, __LINE__, msglog);
1215	return false;
1216	}
1217
1218	if (!dbi_result_next_row(result)) {
1219	dbi_result_free(result);
1220	result = dbi_conn_queryf(dbi->conn,
1221	"INSERT INTO softwares (idtiposoftware,descripcion,idcentro,grupoid)"
1222	" VALUES(2,'%s',%s,0)", tbSoftware[i], idc);
1223	if (!result) { // Error al insertar
1224	dbi_conn_error(dbi->conn, &msglog);
1225	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1226	__func__, __LINE__, msglog);
1227	return false;
1228	}
1229
1230	// Recupera el identificador del software
1231	tbidsoftware[i] = dbi_conn_sequence_last(dbi->conn, NULL);
1232	} else {
1233	tbidsoftware[i] = dbi_result_get_uint(result, "idsoftware");
1234	}
1235	dbi_result_free(result);
1236	}
1237
1238	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
1239
1240	for (i = 0; i < lon - 1; i++) {
1241	for (j = i + 1; j < lon; j++) {
1242	if (tbidsoftware[i] > tbidsoftware[j]) {
1243	aux = tbidsoftware[i];
1244	tbidsoftware[i] = tbidsoftware[j];
1245	tbidsoftware[j] = aux;
1246	}
1247	}
1248	}
1249	/* Crea cadena de identificadores de componentes software separados por coma */
1250	sprintf(strInt, "%d", tbidsoftware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
1251	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
1252	idsoftwares = reservaMemoria((sizeof(aux)+1) * lon + lon);
1253	if (idsoftwares == NULL) {
1254	syslog(LOG_ERR, "%s:%d OOM\n", __FILE__, __LINE__);
1255	return false;
1256	}
1257	aux = sprintf(idsoftwares, "%d", tbidsoftware[0]);
1258	for (i = 1; i < lon; i++)
1259	aux += sprintf(idsoftwares + aux, ",%d", tbidsoftware[i]);
1260
1261	// Comprueba existencia de perfil software y actualización de éste para el ordenador
1262	if (!cuestionPerfilSoftware(dbi, idc, ido, idperfilsoft, idnombreso, idsoftwares,
1263	npc, par, tbidsoftware, lon)) {
1264	syslog(LOG_ERR, "cannot update software\n");
1265	og_info((char *)msglog);
1266	retval=false;
1267	}
1268	else {
1269	retval=true;
1270	}
1271	liberaMemoria(wsft);
1272	liberaMemoria(idsoftwares);
1273	return (retval);
1274	}
1275	// ________________________________________________________________________________________________________
1276	// Función: CuestionPerfilSoftware
1277	//
1278	// Parámetros:
1279	// - db: Objeto base de datos (ya operativo)
1280	// - tbl: Objeto tabla
1281	// - idcentro: Identificador del centro en la tabla
1282	// - ido: Identificador del ordenador del cliente en la tabla
1283	// - idnombreso: Identificador del sistema operativo
1284	// - idsoftwares: Cadena con los identificadores de componentes software separados por comas
1285	// - npc: Nombre del ordenador del cliente
1286	// - particion: Número de la partición
1287	// - tbidsoftware: Array con los identificadores de componentes software
1288	// - lon: Número de componentes
1289	// Devuelve:
1290	// true: Si el proceso es correcto
1291	// false: En caso de ocurrir algún error
1292	//
1293	// Versión 1.1.0: Se incluye el sistema operativo. Autora: Irina Gómez - ETSII Universidad Sevilla
1294	//_________________________________________________________________________________________________________
1295	bool cuestionPerfilSoftware(struct og_dbi dbi, char idc, char *ido,
1296	int idperfilsoftware, int idnombreso,
1297	char idsoftwares, char npc, char *par,
1298	int *tbidsoftware, int lon)
1299	{
1300	int i, nwidperfilsoft;
1301	const char *msglog;
1302	dbi_result result;
1303
1304	// Busca perfil soft del ordenador que contenga todos los componentes software encontrados
1305	result = dbi_conn_queryf(dbi->conn,
1306	"SELECT idperfilsoft FROM"
1307	" (SELECT perfilessoft_softwares.idperfilsoft as idperfilsoft,"
1308	" group_concat(cast(perfilessoft_softwares.idsoftware AS char( 11) )"
1309	" ORDER BY perfilessoft_softwares.idsoftware SEPARATOR ',' ) AS idsoftwares"
1310	" FROM perfilessoft_softwares"
1311	" GROUP BY perfilessoft_softwares.idperfilsoft) AS temp"
1312	" WHERE idsoftwares LIKE '%s'", idsoftwares);
1313
1314	if (!result) {
1315	dbi_conn_error(dbi->conn, &msglog);
1316	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
1317	__func__, __LINE__, msglog);
1318	return false;
1319	}
1320	if (!dbi_result_next_row(result)) { // No existe un perfil software con esos componentes de componentes software, lo crea
1321	dbi_result_free(result);
1322	result = dbi_conn_queryf(dbi->conn,
1323	"INSERT perfilessoft (descripcion, idcentro, grupoid, idnombreso)"
1324	" VALUES('Perfil Software (%s, Part:%s) ',%s,0,%i)", npc, par, idc,idnombreso);
1325	if (!result) {
1326	dbi_conn_error(dbi->conn, &msglog);
1327	og_info((char *)msglog);
1328	return false;
1329	}
1330
1331	dbi_result_free(result);
1332	// Recupera el identificador del nuevo perfil software
1333	nwidperfilsoft = dbi_conn_sequence_last(dbi->conn, NULL);
1334
1335	// Crea la relación entre perfiles y componenetes software
1336	for (i = 0; i < lon; i++) {
1337	result = dbi_conn_queryf(dbi->conn,
1338	"INSERT perfilessoft_softwares (idperfilsoft,idsoftware)"
1339	" VALUES(%d,%d)", nwidperfilsoft, tbidsoftware[i]);
1340	if (!result) {
1341	dbi_conn_error(dbi->conn, &msglog);
1342	og_info((char *)msglog);
1343	return false;
1344	}
1345	dbi_result_free(result);
1346	}
1347	} else { // Existe un perfil con todos esos componentes
1348	nwidperfilsoft = dbi_result_get_uint(result, "idperfilsoft");
1349	dbi_result_free(result);
1350	}
1351
1352	if (idperfilsoftware != nwidperfilsoft) { // No coinciden los perfiles
1353	// Actualiza el identificador del perfil software del ordenador
1354	result = dbi_conn_queryf(dbi->conn,
1355	"UPDATE ordenadores_particiones SET idperfilsoft=%d,idimagen=0"
1356	" WHERE idordenador=%s AND numpar=%s", nwidperfilsoft, ido, par);
1357	if (!result) { // Error al insertar
1358	dbi_conn_error(dbi->conn, &msglog);
1359	og_info((char *)msglog);
1360	return false;
1361	}
1362	dbi_result_free(result);
1363	}
1364
1365	/* DEPURACIÓN DE PERFILES SOFTWARE */
1366
1367	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
1368	result = dbi_conn_queryf(dbi->conn,
1369	"DELETE FROM perfilessoft_softwares WHERE idperfilsoft IN "\
1370	" (SELECT idperfilsoft FROM perfilessoft WHERE idperfilsoft NOT IN"\
1371	" (SELECT DISTINCT idperfilsoft from ordenadores_particiones) AND idperfilsoft NOT IN"\
1372	" (SELECT DISTINCT idperfilsoft from imagenes))");
1373	if (!result) {
1374	dbi_conn_error(dbi->conn, &msglog);
1375	og_info((char *)msglog);
1376	return false;
1377	}
1378	dbi_result_free(result),
1379	/* Eliminar Perfiles software que quedan húerfanos */
1380	result = dbi_conn_queryf(dbi->conn,
1381	"DELETE FROM perfilessoft WHERE idperfilsoft NOT IN"
1382	" (SELECT DISTINCT idperfilsoft from ordenadores_particiones)"\
1383	" AND idperfilsoft NOT IN"\
1384	" (SELECT DISTINCT idperfilsoft from imagenes)");
1385	if (!result) {
1386	dbi_conn_error(dbi->conn, &msglog);
1387	og_info((char *)msglog);
1388	return false;
1389	}
1390	dbi_result_free(result),
1391
1392	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
1393	result = dbi_conn_queryf(dbi->conn,
1394	"DELETE FROM perfilessoft_softwares WHERE idperfilsoft NOT IN"
1395	" (SELECT idperfilsoft from perfilessoft)");
1396	if (!result) {
1397	dbi_conn_error(dbi->conn, &msglog);
1398	og_info((char *)msglog);
1399	return false;
1400	}
1401	dbi_result_free(result);
1402
1403	return true;
1404	}
1405
1406	static void og_client_release(struct ev_loop loop, struct og_client cli)
1407	{
1408	if (cli->keepalive_idx >= 0) {
1409	syslog(LOG_DEBUG, "closing keepalive connection for %s:%hu in slot %d\n",
1410	inet_ntoa(cli->addr.sin_addr),
1411	ntohs(cli->addr.sin_port), cli->keepalive_idx);
1412	tbsockets[cli->keepalive_idx].cli = NULL;
1413	}
1414
1415	list_del(&cli->list);
1416	ev_io_stop(loop, &cli->io);
1417	close(cli->io.fd);
1418	free(cli);
1419	}
1420
1421	static void og_client_keepalive(struct ev_loop loop, struct og_client cli)
1422	{
1423	struct og_client *old_cli;
1424
1425	old_cli = tbsockets[cli->keepalive_idx].cli;
1426	if (old_cli && old_cli != cli) {
1427	syslog(LOG_DEBUG, "closing old keepalive connection for %s:%hu\n",
1428	inet_ntoa(old_cli->addr.sin_addr),
1429	ntohs(old_cli->addr.sin_port));
1430
1431	og_client_release(loop, old_cli);
1432	}
1433	tbsockets[cli->keepalive_idx].cli = cli;
1434	}
1435
1436	static void og_client_reset_state(struct og_client *cli)
1437	{
1438	cli->state = OG_CLIENT_RECEIVING_HEADER;
1439	cli->buf_len = 0;
1440	}
1441
1442	static TRAMA og_msg_alloc(char data, unsigned int len)
1443	{
1444	TRAMA *ptrTrama;
1445
1446	ptrTrama = (TRAMA *)reservaMemoria(sizeof(TRAMA));
1447	if (!ptrTrama) {
1448	syslog(LOG_ERR, "OOM\n");
1449	return NULL;
1450	}
1451
1452	initParametros(ptrTrama, len);
1453	memcpy(ptrTrama, "@JMMLCAMDJ_MCDJ", LONGITUD_CABECERATRAMA);
1454	memcpy(ptrTrama->parametros, data, len);
1455	ptrTrama->lonprm = len;
1456
1457	return ptrTrama;
1458	}
1459
1460	static void og_msg_free(TRAMA *ptrTrama)
1461	{
1462	liberaMemoria(ptrTrama->parametros);
1463	liberaMemoria(ptrTrama);
1464	}
1465
1466	#define OG_CLIENTS_MAX 4096
1467	#define OG_PARTITION_MAX 4
1468
1469	struct og_partition {
1470	const char *disk;
1471	const char *number;
1472	const char *code;
1473	const char *size;
1474	const char *filesystem;
1475	const char *format;
1476	const char *os;
1477	const char *used_size;
1478	};
1479
1480	struct og_sync_params {
1481	const char *sync;
1482	const char *diff;
1483	const char *remove;
1484	const char *compress;
1485	const char *cleanup;
1486	const char *cache;
1487	const char *cleanup_cache;
1488	const char *remove_dst;
1489	const char *diff_id;
1490	const char *diff_name;
1491	const char *path;
1492	const char *method;
1493	};
1494
1495	struct og_msg_params {
1496	const char *ips_array[OG_CLIENTS_MAX];
1497	const char *mac_array[OG_CLIENTS_MAX];
1498	unsigned int ips_array_len;
1499	const char *wol_type;
1500	char run_cmd[4096];
1501	const char *disk;
1502	const char *partition;
1503	const char *repository;
1504	const char *name;
1505	const char *id;
1506	const char *code;
1507	const char *type;
1508	const char *profile;
1509	const char *cache;
1510	const char *cache_size;
1511	bool echo;
1512	struct og_partition partition_setup[OG_PARTITION_MAX];
1513	struct og_sync_params sync_setup;
1514	struct og_schedule_time time;
1515	const char *task_id;
1516	uint64_t flags;
1517	};
1518
1519	#define OG_COMPUTER_NAME_MAXLEN 100
1520
1521	struct og_computer {
1522	unsigned int id;
1523	unsigned int center;
1524	unsigned int room;
1525	char name[OG_COMPUTER_NAME_MAXLEN + 1];
1526	};
1527
1528	#define OG_REST_PARAM_ADDR (1UL << 0)
1529	#define OG_REST_PARAM_MAC (1UL << 1)
1530	#define OG_REST_PARAM_WOL_TYPE (1UL << 2)
1531	#define OG_REST_PARAM_RUN_CMD (1UL << 3)
1532	#define OG_REST_PARAM_DISK (1UL << 4)
1533	#define OG_REST_PARAM_PARTITION (1UL << 5)
1534	#define OG_REST_PARAM_REPO (1UL << 6)
1535	#define OG_REST_PARAM_NAME (1UL << 7)
1536	#define OG_REST_PARAM_ID (1UL << 8)
1537	#define OG_REST_PARAM_CODE (1UL << 9)
1538	#define OG_REST_PARAM_TYPE (1UL << 10)
1539	#define OG_REST_PARAM_PROFILE (1UL << 11)
1540	#define OG_REST_PARAM_CACHE (1UL << 12)
1541	#define OG_REST_PARAM_CACHE_SIZE (1UL << 13)
1542	#define OG_REST_PARAM_PART_0 (1UL << 14)
1543	#define OG_REST_PARAM_PART_1 (1UL << 15)
1544	#define OG_REST_PARAM_PART_2 (1UL << 16)
1545	#define OG_REST_PARAM_PART_3 (1UL << 17)
1546	#define OG_REST_PARAM_SYNC_SYNC (1UL << 18)
1547	#define OG_REST_PARAM_SYNC_DIFF (1UL << 19)
1548	#define OG_REST_PARAM_SYNC_REMOVE (1UL << 20)
1549	#define OG_REST_PARAM_SYNC_COMPRESS (1UL << 21)
1550	#define OG_REST_PARAM_SYNC_CLEANUP (1UL << 22)
1551	#define OG_REST_PARAM_SYNC_CACHE (1UL << 23)
1552	#define OG_REST_PARAM_SYNC_CLEANUP_CACHE (1UL << 24)
1553	#define OG_REST_PARAM_SYNC_REMOVE_DST (1UL << 25)
1554	#define OG_REST_PARAM_SYNC_DIFF_ID (1UL << 26)
1555	#define OG_REST_PARAM_SYNC_DIFF_NAME (1UL << 27)
1556	#define OG_REST_PARAM_SYNC_PATH (1UL << 28)
1557	#define OG_REST_PARAM_SYNC_METHOD (1UL << 29)
1558	#define OG_REST_PARAM_ECHO (1UL << 30)
1559	#define OG_REST_PARAM_TASK (1UL << 31)
1560	#define OG_REST_PARAM_TIME_YEARS (1UL << 32)
1561	#define OG_REST_PARAM_TIME_MONTHS (1UL << 33)
1562	#define OG_REST_PARAM_TIME_WEEKS (1UL << 34)
1563	#define OG_REST_PARAM_TIME_WEEK_DAYS (1UL << 35)
1564	#define OG_REST_PARAM_TIME_DAYS (1UL << 36)
1565	#define OG_REST_PARAM_TIME_HOURS (1UL << 37)
1566	#define OG_REST_PARAM_TIME_AM_PM (1UL << 38)
1567	#define OG_REST_PARAM_TIME_MINUTES (1UL << 39)
1568
1569	enum og_rest_method {
1570	OG_METHOD_GET = 0,
1571	OG_METHOD_POST,
1572	OG_METHOD_NO_HTTP
1573	};
1574
1575	static struct og_client og_client_find(const char ip)
1576	{
1577	struct og_client *client;
1578	struct in_addr addr;
1579	int res;
1580
1581	res = inet_aton(ip, &addr);
1582	if (!res) {
1583	syslog(LOG_ERR, "Invalid IP string: %s\n", ip);
1584	return NULL;
1585	}
1586
1587	list_for_each_entry(client, &client_list, list) {
1588	if (client->addr.sin_addr.s_addr == addr.s_addr && client->agent) {
1589	return client;
1590	}
1591	}
1592
1593	return NULL;
1594	}
1595
1596	static bool og_msg_params_validate(const struct og_msg_params *params,
1597	const uint64_t flags)
1598	{
1599	return (params->flags & flags) == flags;
1600	}
1601
1602	static int og_json_parse_clients(json_t element, struct og_msg_params params)
1603	{
1604	unsigned int i;
1605	json_t *k;
1606
1607	if (json_typeof(element) != JSON_ARRAY)
1608	return -1;
1609
1610	for (i = 0; i < json_array_size(element); i++) {
1611	k = json_array_get(element, i);
1612	if (json_typeof(k) != JSON_STRING)
1613	return -1;
1614
1615	params->ips_array[params->ips_array_len++] =
1616	json_string_value(k);
1617
1618	params->flags \|= OG_REST_PARAM_ADDR;
1619	}
1620
1621	return 0;
1622	}
1623
1624	static int og_json_parse_string(json_t element, const char *str)
1625	{
1626	if (json_typeof(element) != JSON_STRING)
1627	return -1;
1628
1629	*str = json_string_value(element);
1630	return 0;
1631	}
1632
1633	static int og_json_parse_uint(json_t element, uint32_t integer)
1634	{
1635	if (json_typeof(element) != JSON_INTEGER)
1636	return -1;
1637
1638	*integer = json_integer_value(element);
1639	return 0;
1640	}
1641
1642	static int og_json_parse_bool(json_t element, bool value)
1643	{
1644	if (json_typeof(element) == JSON_TRUE)
1645	*value = true;
1646	else if (json_typeof(element) == JSON_FALSE)
1647	*value = false;
1648	else
1649	return -1;
1650
1651	return 0;
1652	}
1653
1654	static int og_json_parse_sync_params(json_t *element,
1655	struct og_msg_params *params)
1656	{
1657	const char *key;
1658	json_t *value;
1659	int err = 0;
1660
1661	json_object_foreach(element, key, value) {
1662	if (!strcmp(key, "sync")) {
1663	err = og_json_parse_string(value, &params->sync_setup.sync);
1664	params->flags \|= OG_REST_PARAM_SYNC_SYNC;
1665	} else if (!strcmp(key, "diff")) {
1666	err = og_json_parse_string(value, &params->sync_setup.diff);
1667	params->flags \|= OG_REST_PARAM_SYNC_DIFF;
1668	} else if (!strcmp(key, "remove")) {
1669	err = og_json_parse_string(value, &params->sync_setup.remove);
1670	params->flags \|= OG_REST_PARAM_SYNC_REMOVE;
1671	} else if (!strcmp(key, "compress")) {
1672	err = og_json_parse_string(value, &params->sync_setup.compress);
1673	params->flags \|= OG_REST_PARAM_SYNC_COMPRESS;
1674	} else if (!strcmp(key, "cleanup")) {
1675	err = og_json_parse_string(value, &params->sync_setup.cleanup);
1676	params->flags \|= OG_REST_PARAM_SYNC_CLEANUP;
1677	} else if (!strcmp(key, "cache")) {
1678	err = og_json_parse_string(value, &params->sync_setup.cache);
1679	params->flags \|= OG_REST_PARAM_SYNC_CACHE;
1680	} else if (!strcmp(key, "cleanup_cache")) {
1681	err = og_json_parse_string(value, &params->sync_setup.cleanup_cache);
1682	params->flags \|= OG_REST_PARAM_SYNC_CLEANUP_CACHE;
1683	} else if (!strcmp(key, "remove_dst")) {
1684	err = og_json_parse_string(value, &params->sync_setup.remove_dst);
1685	params->flags \|= OG_REST_PARAM_SYNC_REMOVE_DST;
1686	} else if (!strcmp(key, "diff_id")) {
1687	err = og_json_parse_string(value, &params->sync_setup.diff_id);
1688	params->flags \|= OG_REST_PARAM_SYNC_DIFF_ID;
1689	} else if (!strcmp(key, "diff_name")) {
1690	err = og_json_parse_string(value, &params->sync_setup.diff_name);
1691	params->flags \|= OG_REST_PARAM_SYNC_DIFF_NAME;
1692	} else if (!strcmp(key, "path")) {
1693	err = og_json_parse_string(value, &params->sync_setup.path);
1694	params->flags \|= OG_REST_PARAM_SYNC_PATH;
1695	} else if (!strcmp(key, "method")) {
1696	err = og_json_parse_string(value, &params->sync_setup.method);
1697	params->flags \|= OG_REST_PARAM_SYNC_METHOD;
1698	}
1699
1700	if (err != 0)
1701	return err;
1702	}
1703	return err;
1704	}
1705
1706	#define OG_PARAM_PART_NUMBER (1UL << 0)
1707	#define OG_PARAM_PART_CODE (1UL << 1)
1708	#define OG_PARAM_PART_FILESYSTEM (1UL << 2)
1709	#define OG_PARAM_PART_SIZE (1UL << 3)
1710	#define OG_PARAM_PART_FORMAT (1UL << 4)
1711	#define OG_PARAM_PART_DISK (1UL << 5)
1712	#define OG_PARAM_PART_OS (1UL << 6)
1713	#define OG_PARAM_PART_USED_SIZE (1UL << 7)
1714
1715	static int og_json_parse_partition(json_t *element,
1716	struct og_partition *part,
1717	uint64_t required_flags)
1718	{
1719	uint64_t flags = 0UL;
1720	const char *key;
1721	json_t *value;
1722	int err = 0;
1723
1724	json_object_foreach(element, key, value) {
1725	if (!strcmp(key, "partition")) {
1726	err = og_json_parse_string(value, &part->number);
1727	flags \|= OG_PARAM_PART_NUMBER;
1728	} else if (!strcmp(key, "code")) {
1729	err = og_json_parse_string(value, &part->code);
1730	flags \|= OG_PARAM_PART_CODE;
1731	} else if (!strcmp(key, "filesystem")) {
1732	err = og_json_parse_string(value, &part->filesystem);
1733	flags \|= OG_PARAM_PART_FILESYSTEM;
1734	} else if (!strcmp(key, "size")) {
1735	err = og_json_parse_string(value, &part->size);
1736	flags \|= OG_PARAM_PART_SIZE;
1737	} else if (!strcmp(key, "format")) {
1738	err = og_json_parse_string(value, &part->format);
1739	flags \|= OG_PARAM_PART_FORMAT;
1740	} else if (!strcmp(key, "disk")) {
1741	err = og_json_parse_string(value, &part->disk);
1742	flags \|= OG_PARAM_PART_DISK;
1743	} else if (!strcmp(key, "os")) {
1744	err = og_json_parse_string(value, &part->os);
1745	flags \|= OG_PARAM_PART_OS;
1746	} else if (!strcmp(key, "used_size")) {
1747	err = og_json_parse_string(value, &part->used_size);
1748	flags \|= OG_PARAM_PART_USED_SIZE;
1749	}
1750
1751	if (err < 0)
1752	return err;
1753	}
1754
1755	if (flags != required_flags)
1756	return -1;
1757
1758	return err;
1759	}
1760
1761	static int og_json_parse_partition_setup(json_t *element,
1762	struct og_msg_params *params)
1763	{
1764	unsigned int i;
1765	json_t *k;
1766
1767	if (json_typeof(element) != JSON_ARRAY)
1768	return -1;
1769
1770	for (i = 0; i < json_array_size(element) && i < OG_PARTITION_MAX; ++i) {
1771	k = json_array_get(element, i);
1772
1773	if (json_typeof(k) != JSON_OBJECT)
1774	return -1;
1775
1776	if (og_json_parse_partition(k, &params->partition_setup[i],
1777	OG_PARAM_PART_NUMBER \|
1778	OG_PARAM_PART_CODE \|
1779	OG_PARAM_PART_FILESYSTEM \|
1780	OG_PARAM_PART_SIZE \|
1781	OG_PARAM_PART_FORMAT) < 0)
1782	return -1;
1783
1784	params->flags \|= (OG_REST_PARAM_PART_0 << i);
1785	}
1786	return 0;
1787	}
1788
1789	static int og_json_parse_time_params(json_t *element,
1790	struct og_msg_params *params)
1791	{
1792	const char *key;
1793	json_t *value;
1794	int err = 0;
1795
1796	json_object_foreach(element, key, value) {
1797	if (!strcmp(key, "years")) {
1798	err = og_json_parse_uint(value, &params->time.years);
1799	params->flags \|= OG_REST_PARAM_TIME_YEARS;
1800	} else if (!strcmp(key, "months")) {
1801	err = og_json_parse_uint(value, &params->time.months);
1802	params->flags \|= OG_REST_PARAM_TIME_MONTHS;
1803	} else if (!strcmp(key, "weeks")) {
1804	err = og_json_parse_uint(value, &params->time.weeks);
1805	params->flags \|= OG_REST_PARAM_TIME_WEEKS;
1806	} else if (!strcmp(key, "week_days")) {
1807	err = og_json_parse_uint(value, &params->time.week_days);
1808	params->flags \|= OG_REST_PARAM_TIME_WEEK_DAYS;
1809	} else if (!strcmp(key, "days")) {
1810	err = og_json_parse_uint(value, &params->time.days);
1811	params->flags \|= OG_REST_PARAM_TIME_DAYS;
1812	} else if (!strcmp(key, "hours")) {
1813	err = og_json_parse_uint(value, &params->time.hours);
1814	params->flags \|= OG_REST_PARAM_TIME_HOURS;
1815	} else if (!strcmp(key, "am_pm")) {
1816	err = og_json_parse_uint(value, &params->time.am_pm);
1817	params->flags \|= OG_REST_PARAM_TIME_AM_PM;
1818	} else if (!strcmp(key, "minutes")) {
1819	err = og_json_parse_uint(value, &params->time.minutes);
1820	params->flags \|= OG_REST_PARAM_TIME_MINUTES;
1821	}
1822	if (err != 0)
1823	return err;
1824	}
1825
1826	return err;
1827	}
1828
1829	static const char *og_cmd_to_uri[OG_CMD_MAX] = {
1830	[OG_CMD_WOL] = "wol",
1831	[OG_CMD_PROBE] = "probe",
1832	[OG_CMD_SHELL_RUN] = "shell/run",
1833	[OG_CMD_SESSION] = "session",
1834	[OG_CMD_POWEROFF] = "poweroff",
1835	[OG_CMD_REFRESH] = "refresh",
1836	[OG_CMD_REBOOT] = "reboot",
1837	[OG_CMD_STOP] = "stop",
1838	[OG_CMD_HARDWARE] = "hardware",
1839	[OG_CMD_SOFTWARE] = "software",
1840	[OG_CMD_IMAGE_CREATE] = "image/create",
1841	[OG_CMD_IMAGE_RESTORE] = "image/restore",
1842	[OG_CMD_SETUP] = "setup",
1843	[OG_CMD_RUN_SCHEDULE] = "run/schedule",
1844	};
1845
1846	static bool og_client_is_busy(const struct og_client *cli,
1847	enum og_cmd_type type)
1848	{
1849	switch (type) {
1850	case OG_CMD_REBOOT:
1851	case OG_CMD_POWEROFF:
1852	case OG_CMD_STOP:
1853	break;
1854	default:
1855	if (cli->last_cmd != OG_CMD_UNSPEC)
1856	return true;
1857	break;
1858	}
1859
1860	return false;
1861	}
1862
1863	static int og_send_request(enum og_rest_method method, enum og_cmd_type type,
1864	const struct og_msg_params *params,
1865	const json_t *data)
1866	{
1867	const char *content_type = "Content-Type: application/json";
1868	char content [OG_MSG_REQUEST_MAXLEN - 700] = {};
1869	char buf[OG_MSG_REQUEST_MAXLEN] = {};
1870	unsigned int content_length;
1871	char method_str[5] = {};
1872	struct og_client *cli;
1873	const char *uri;
1874	unsigned int i;
1875	int client_sd;
1876
1877	if (method == OG_METHOD_GET)
1878	snprintf(method_str, 5, "GET");
1879	else if (method == OG_METHOD_POST)
1880	snprintf(method_str, 5, "POST");
1881	else
1882	return -1;
1883
1884	if (!data)
1885	content_length = 0;
1886	else
1887	content_length = json_dumpb(data, content,
1888	OG_MSG_REQUEST_MAXLEN - 700,
1889	JSON_COMPACT);
1890
1891	uri = og_cmd_to_uri[type];
1892	snprintf(buf, OG_MSG_REQUEST_MAXLEN,
1893	"%s /%s HTTP/1.1\r\nContent-Length: %d\r\n%s\r\n\r\n%s",
1894	method_str, uri, content_length, content_type, content);
1895
1896	for (i = 0; i < params->ips_array_len; i++) {
1897	cli = og_client_find(params->ips_array[i]);
1898	if (!cli)
1899	continue;
1900
1901	if (og_client_is_busy(cli, type))
1902	continue;
1903
1904	client_sd = cli->io.fd;
1905	if (client_sd < 0) {
1906	syslog(LOG_INFO, "Client %s not conected\n",
1907	params->ips_array[i]);
1908	continue;
1909	}
1910
1911	if (send(client_sd, buf, strlen(buf), 0) < 0)
1912	continue;
1913
1914	cli->last_cmd = type;
1915	}
1916
1917	return 0;
1918	}
1919
1920	static int og_cmd_post_clients(json_t element, struct og_msg_params params)
1921	{
1922	const char *key;
1923	json_t *value;
1924	int err = 0;
1925
1926	if (json_typeof(element) != JSON_OBJECT)
1927	return -1;
1928
1929	json_object_foreach(element, key, value) {
1930	if (!strcmp(key, "clients"))
1931	err = og_json_parse_clients(value, params);
1932
1933	if (err < 0)
1934	break;
1935	}
1936
1937	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
1938	return -1;
1939
1940	return og_send_request(OG_METHOD_POST, OG_CMD_PROBE, params, NULL);
1941	}
1942
1943	struct og_buffer {
1944	char *data;
1945	int len;
1946	};
1947
1948	static int og_json_dump_clients(const char buffer, size_t size, void data)
1949	{
1950	struct og_buffer og_buffer = (struct og_buffer )data;
1951
1952	memcpy(og_buffer->data + og_buffer->len, buffer, size);
1953	og_buffer->len += size;
1954
1955	return 0;
1956	}
1957
1958	static int og_cmd_get_clients(json_t element, struct og_msg_params params,
1959	char *buffer_reply)
1960	{
1961	json_t root, array, addr, state, *object;
1962	struct og_client *client;
1963	struct og_buffer og_buffer = {
1964	.data = buffer_reply,
1965	};
1966
1967	array = json_array();
1968	if (!array)
1969	return -1;
1970
1971	list_for_each_entry(client, &client_list, list) {
1972	if (!client->agent)
1973	continue;
1974
1975	object = json_object();
1976	if (!object) {
1977	json_decref(array);
1978	return -1;
1979	}
1980	addr = json_string(inet_ntoa(client->addr.sin_addr));
1981	if (!addr) {
1982	json_decref(object);
1983	json_decref(array);
1984	return -1;
1985	}
1986	json_object_set_new(object, "addr", addr);
1987	state = json_string(og_client_status(client));
1988	if (!state) {
1989	json_decref(object);
1990	json_decref(array);
1991	return -1;
1992	}
1993	json_object_set_new(object, "state", state);
1994	json_array_append_new(array, object);
1995	}
1996	root = json_pack("{s:o}", "clients", array);
1997	if (!root) {
1998	json_decref(array);
1999	return -1;
2000	}
2001
2002	json_dump_callback(root, og_json_dump_clients, &og_buffer, 0);
2003	json_decref(root);
2004
2005	return 0;
2006	}
2007
2008	static int og_json_parse_target(json_t element, struct og_msg_params params)
2009	{
2010	const char *key;
2011	json_t *value;
2012
2013	if (json_typeof(element) != JSON_OBJECT) {
2014	return -1;
2015	}
2016
2017	json_object_foreach(element, key, value) {
2018	if (!strcmp(key, "addr")) {
2019	if (json_typeof(value) != JSON_STRING)
2020	return -1;
2021
2022	params->ips_array[params->ips_array_len] =
2023	json_string_value(value);
2024
2025	params->flags \|= OG_REST_PARAM_ADDR;
2026	} else if (!strcmp(key, "mac")) {
2027	if (json_typeof(value) != JSON_STRING)
2028	return -1;
2029
2030	params->mac_array[params->ips_array_len] =
2031	json_string_value(value);
2032
2033	params->flags \|= OG_REST_PARAM_MAC;
2034	}
2035	}
2036
2037	return 0;
2038	}
2039
2040	static int og_json_parse_targets(json_t element, struct og_msg_params params)
2041	{
2042	unsigned int i;
2043	json_t *k;
2044	int err;
2045
2046	if (json_typeof(element) != JSON_ARRAY)
2047	return -1;
2048
2049	for (i = 0; i < json_array_size(element); i++) {
2050	k = json_array_get(element, i);
2051
2052	if (json_typeof(k) != JSON_OBJECT)
2053	return -1;
2054
2055	err = og_json_parse_target(k, params);
2056	if (err < 0)
2057	return err;
2058
2059	params->ips_array_len++;
2060	}
2061	return 0;
2062	}
2063
2064	static int og_json_parse_type(json_t element, struct og_msg_params params)
2065	{
2066	const char *type;
2067
2068	if (json_typeof(element) != JSON_STRING)
2069	return -1;
2070
2071	params->wol_type = json_string_value(element);
2072
2073	type = json_string_value(element);
2074	if (!strcmp(type, "unicast"))
2075	params->wol_type = "2";
2076	else if (!strcmp(type, "broadcast"))
2077	params->wol_type = "1";
2078
2079	params->flags \|= OG_REST_PARAM_WOL_TYPE;
2080
2081	return 0;
2082	}
2083
2084	static int og_cmd_wol(json_t element, struct og_msg_params params)
2085	{
2086	const char *key;
2087	json_t *value;
2088	int err = 0;
2089
2090	if (json_typeof(element) != JSON_OBJECT)
2091	return -1;
2092
2093	json_object_foreach(element, key, value) {
2094	if (!strcmp(key, "clients")) {
2095	err = og_json_parse_targets(value, params);
2096	} else if (!strcmp(key, "type")) {
2097	err = og_json_parse_type(value, params);
2098	}
2099
2100	if (err < 0)
2101	break;
2102	}
2103
2104	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2105	OG_REST_PARAM_MAC \|
2106	OG_REST_PARAM_WOL_TYPE))
2107	return -1;
2108
2109	if (!Levanta((char )params->ips_array, (char )params->mac_array,
2110	params->ips_array_len, (char *)params->wol_type))
2111	return -1;
2112
2113	return 0;
2114	}
2115
2116	static int og_json_parse_run(json_t element, struct og_msg_params params)
2117	{
2118	if (json_typeof(element) != JSON_STRING)
2119	return -1;
2120
2121	snprintf(params->run_cmd, sizeof(params->run_cmd), "%s",
2122	json_string_value(element));
2123
2124	params->flags \|= OG_REST_PARAM_RUN_CMD;
2125
2126	return 0;
2127	}
2128
2129	static int og_cmd_run_post(json_t element, struct og_msg_params params)
2130	{
2131	json_t value, clients;
2132	const char *key;
2133	unsigned int i;
2134	int err = 0;
2135
2136	if (json_typeof(element) != JSON_OBJECT)
2137	return -1;
2138
2139	json_object_foreach(element, key, value) {
2140	if (!strcmp(key, "clients"))
2141	err = og_json_parse_clients(value, params);
2142	else if (!strcmp(key, "run"))
2143	err = og_json_parse_run(value, params);
2144	else if (!strcmp(key, "echo")) {
2145	err = og_json_parse_bool(value, &params->echo);
2146	params->flags \|= OG_REST_PARAM_ECHO;
2147	}
2148
2149	if (err < 0)
2150	break;
2151	}
2152
2153	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2154	OG_REST_PARAM_RUN_CMD \|
2155	OG_REST_PARAM_ECHO))
2156	return -1;
2157
2158	clients = json_copy(element);
2159	json_object_del(clients, "clients");
2160
2161	err = og_send_request(OG_METHOD_POST, OG_CMD_SHELL_RUN, params, clients);
2162	if (err < 0)
2163	return err;
2164
2165	for (i = 0; i < params->ips_array_len; i++) {
2166	char filename[4096];
2167	FILE *f;
2168
2169	sprintf(filename, "/tmp/_Seconsola_%s", params->ips_array[i]);
2170	f = fopen(filename, "wt");
2171	fclose(f);
2172	}
2173
2174	return 0;
2175	}
2176
2177	static int og_cmd_run_get(json_t element, struct og_msg_params params,
2178	char *buffer_reply)
2179	{
2180	struct og_buffer og_buffer = {
2181	.data = buffer_reply,
2182	};
2183	json_t root, value, *array;
2184	const char *key;
2185	unsigned int i;
2186	int err = 0;
2187
2188	if (json_typeof(element) != JSON_OBJECT)
2189	return -1;
2190
2191	json_object_foreach(element, key, value) {
2192	if (!strcmp(key, "clients"))
2193	err = og_json_parse_clients(value, params);
2194
2195	if (err < 0)
2196	return err;
2197	}
2198
2199	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2200	return -1;
2201
2202	array = json_array();
2203	if (!array)
2204	return -1;
2205
2206	for (i = 0; i < params->ips_array_len; i++) {
2207	json_t object, output, *addr;
2208	char data[4096] = {};
2209	char filename[4096];
2210	int fd, numbytes;
2211
2212	sprintf(filename, "/tmp/_Seconsola_%s", params->ips_array[i]);
2213
2214	fd = open(filename, O_RDONLY);
2215	if (!fd)
2216	return -1;
2217
2218	numbytes = read(fd, data, sizeof(data));
2219	if (numbytes < 0) {
2220	close(fd);
2221	return -1;
2222	}
2223	data[sizeof(data) - 1] = '\0';
2224	close(fd);
2225
2226	object = json_object();
2227	if (!object) {
2228	json_decref(array);
2229	return -1;
2230	}
2231	addr = json_string(params->ips_array[i]);
2232	if (!addr) {
2233	json_decref(object);
2234	json_decref(array);
2235	return -1;
2236	}
2237	json_object_set_new(object, "addr", addr);
2238
2239	output = json_string(data);
2240	if (!output) {
2241	json_decref(object);
2242	json_decref(array);
2243	return -1;
2244	}
2245	json_object_set_new(object, "output", output);
2246
2247	json_array_append_new(array, object);
2248	}
2249
2250	root = json_pack("{s:o}", "clients", array);
2251	if (!root)
2252	return -1;
2253
2254	json_dump_callback(root, og_json_dump_clients, &og_buffer, 0);
2255	json_decref(root);
2256
2257	return 0;
2258	}
2259
2260	static int og_cmd_session(json_t element, struct og_msg_params params)
2261	{
2262	json_t clients, value;
2263	const char *key;
2264	int err = 0;
2265
2266	if (json_typeof(element) != JSON_OBJECT)
2267	return -1;
2268
2269	json_object_foreach(element, key, value) {
2270	if (!strcmp(key, "clients")) {
2271	err = og_json_parse_clients(value, params);
2272	} else if (!strcmp(key, "disk")) {
2273	err = og_json_parse_string(value, &params->disk);
2274	params->flags \|= OG_REST_PARAM_DISK;
2275	} else if (!strcmp(key, "partition")) {
2276	err = og_json_parse_string(value, &params->partition);
2277	params->flags \|= OG_REST_PARAM_PARTITION;
2278	}
2279
2280	if (err < 0)
2281	return err;
2282	}
2283
2284	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2285	OG_REST_PARAM_DISK \|
2286	OG_REST_PARAM_PARTITION))
2287	return -1;
2288
2289	clients = json_copy(element);
2290	json_object_del(clients, "clients");
2291
2292	return og_send_request(OG_METHOD_POST, OG_CMD_SESSION, params, clients);
2293	}
2294
2295	static int og_cmd_poweroff(json_t element, struct og_msg_params params)
2296	{
2297	const char *key;
2298	json_t *value;
2299	int err = 0;
2300
2301	if (json_typeof(element) != JSON_OBJECT)
2302	return -1;
2303
2304	json_object_foreach(element, key, value) {
2305	if (!strcmp(key, "clients"))
2306	err = og_json_parse_clients(value, params);
2307
2308	if (err < 0)
2309	break;
2310	}
2311
2312	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2313	return -1;
2314
2315	return og_send_request(OG_METHOD_POST, OG_CMD_POWEROFF, params, NULL);
2316	}
2317
2318	static int og_cmd_refresh(json_t element, struct og_msg_params params)
2319	{
2320	const char *key;
2321	json_t *value;
2322	int err = 0;
2323
2324	if (json_typeof(element) != JSON_OBJECT)
2325	return -1;
2326
2327	json_object_foreach(element, key, value) {
2328	if (!strcmp(key, "clients"))
2329	err = og_json_parse_clients(value, params);
2330
2331	if (err < 0)
2332	break;
2333	}
2334
2335	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2336	return -1;
2337
2338	return og_send_request(OG_METHOD_GET, OG_CMD_REFRESH, params, NULL);
2339	}
2340
2341	static int og_cmd_reboot(json_t element, struct og_msg_params params)
2342	{
2343	const char *key;
2344	json_t *value;
2345	int err = 0;
2346
2347	if (json_typeof(element) != JSON_OBJECT)
2348	return -1;
2349
2350	json_object_foreach(element, key, value) {
2351	if (!strcmp(key, "clients"))
2352	err = og_json_parse_clients(value, params);
2353
2354	if (err < 0)
2355	break;
2356	}
2357
2358	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2359	return -1;
2360
2361	return og_send_request(OG_METHOD_POST, OG_CMD_REBOOT, params, NULL);
2362	}
2363
2364	static int og_cmd_stop(json_t element, struct og_msg_params params)
2365	{
2366	const char *key;
2367	json_t *value;
2368	int err = 0;
2369
2370	if (json_typeof(element) != JSON_OBJECT)
2371	return -1;
2372
2373	json_object_foreach(element, key, value) {
2374	if (!strcmp(key, "clients"))
2375	err = og_json_parse_clients(value, params);
2376
2377	if (err < 0)
2378	break;
2379	}
2380
2381	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2382	return -1;
2383
2384	return og_send_request(OG_METHOD_POST, OG_CMD_STOP, params, NULL);
2385	}
2386
2387	static int og_cmd_hardware(json_t element, struct og_msg_params params)
2388	{
2389	const char *key;
2390	json_t *value;
2391	int err = 0;
2392
2393	if (json_typeof(element) != JSON_OBJECT)
2394	return -1;
2395
2396	json_object_foreach(element, key, value) {
2397	if (!strcmp(key, "clients"))
2398	err = og_json_parse_clients(value, params);
2399
2400	if (err < 0)
2401	break;
2402	}
2403
2404	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2405	return -1;
2406
2407	return og_send_request(OG_METHOD_GET, OG_CMD_HARDWARE, params, NULL);
2408	}
2409
2410	static int og_cmd_software(json_t element, struct og_msg_params params)
2411	{
2412	json_t clients, value;
2413	const char *key;
2414	int err = 0;
2415
2416	if (json_typeof(element) != JSON_OBJECT)
2417	return -1;
2418
2419	json_object_foreach(element, key, value) {
2420	if (!strcmp(key, "clients"))
2421	err = og_json_parse_clients(value, params);
2422	else if (!strcmp(key, "disk")) {
2423	err = og_json_parse_string(value, &params->disk);
2424	params->flags \|= OG_REST_PARAM_DISK;
2425	}
2426	else if (!strcmp(key, "partition")) {
2427	err = og_json_parse_string(value, &params->partition);
2428	params->flags \|= OG_REST_PARAM_PARTITION;
2429	}
2430
2431	if (err < 0)
2432	break;
2433	}
2434
2435	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2436	OG_REST_PARAM_DISK \|
2437	OG_REST_PARAM_PARTITION))
2438	return -1;
2439
2440	clients = json_copy(element);
2441	json_object_del(clients, "clients");
2442
2443	return og_send_request(OG_METHOD_POST, OG_CMD_SOFTWARE, params, clients);
2444	}
2445
2446	static int og_cmd_create_image(json_t element, struct og_msg_params params)
2447	{
2448	json_t value, clients;
2449	const char *key;
2450	int err = 0;
2451
2452	if (json_typeof(element) != JSON_OBJECT)
2453	return -1;
2454
2455	json_object_foreach(element, key, value) {
2456	if (!strcmp(key, "disk")) {
2457	err = og_json_parse_string(value, &params->disk);
2458	params->flags \|= OG_REST_PARAM_DISK;
2459	} else if (!strcmp(key, "partition")) {
2460	err = og_json_parse_string(value, &params->partition);
2461	params->flags \|= OG_REST_PARAM_PARTITION;
2462	} else if (!strcmp(key, "name")) {
2463	err = og_json_parse_string(value, &params->name);
2464	params->flags \|= OG_REST_PARAM_NAME;
2465	} else if (!strcmp(key, "repository")) {
2466	err = og_json_parse_string(value, &params->repository);
2467	params->flags \|= OG_REST_PARAM_REPO;
2468	} else if (!strcmp(key, "clients")) {
2469	err = og_json_parse_clients(value, params);
2470	} else if (!strcmp(key, "id")) {
2471	err = og_json_parse_string(value, &params->id);
2472	params->flags \|= OG_REST_PARAM_ID;
2473	} else if (!strcmp(key, "code")) {
2474	err = og_json_parse_string(value, &params->code);
2475	params->flags \|= OG_REST_PARAM_CODE;
2476	}
2477
2478	if (err < 0)
2479	break;
2480	}
2481
2482	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2483	OG_REST_PARAM_DISK \|
2484	OG_REST_PARAM_PARTITION \|
2485	OG_REST_PARAM_CODE \|
2486	OG_REST_PARAM_ID \|
2487	OG_REST_PARAM_NAME \|
2488	OG_REST_PARAM_REPO))
2489	return -1;
2490
2491	clients = json_copy(element);
2492	json_object_del(clients, "clients");
2493
2494	return og_send_request(OG_METHOD_POST, OG_CMD_IMAGE_CREATE, params,
2495	clients);
2496	}
2497
2498	static int og_cmd_restore_image(json_t element, struct og_msg_params params)
2499	{
2500	json_t clients, value;
2501	const char *key;
2502	int err = 0;
2503
2504	if (json_typeof(element) != JSON_OBJECT)
2505	return -1;
2506
2507	json_object_foreach(element, key, value) {
2508	if (!strcmp(key, "disk")) {
2509	err = og_json_parse_string(value, &params->disk);
2510	params->flags \|= OG_REST_PARAM_DISK;
2511	} else if (!strcmp(key, "partition")) {
2512	err = og_json_parse_string(value, &params->partition);
2513	params->flags \|= OG_REST_PARAM_PARTITION;
2514	} else if (!strcmp(key, "name")) {
2515	err = og_json_parse_string(value, &params->name);
2516	params->flags \|= OG_REST_PARAM_NAME;
2517	} else if (!strcmp(key, "repository")) {
2518	err = og_json_parse_string(value, &params->repository);
2519	params->flags \|= OG_REST_PARAM_REPO;
2520	} else if (!strcmp(key, "clients")) {
2521	err = og_json_parse_clients(value, params);
2522	} else if (!strcmp(key, "type")) {
2523	err = og_json_parse_string(value, &params->type);
2524	params->flags \|= OG_REST_PARAM_TYPE;
2525	} else if (!strcmp(key, "profile")) {
2526	err = og_json_parse_string(value, &params->profile);
2527	params->flags \|= OG_REST_PARAM_PROFILE;
2528	} else if (!strcmp(key, "id")) {
2529	err = og_json_parse_string(value, &params->id);
2530	params->flags \|= OG_REST_PARAM_ID;
2531	}
2532
2533	if (err < 0)
2534	break;
2535	}
2536
2537	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2538	OG_REST_PARAM_DISK \|
2539	OG_REST_PARAM_PARTITION \|
2540	OG_REST_PARAM_NAME \|
2541	OG_REST_PARAM_REPO \|
2542	OG_REST_PARAM_TYPE \|
2543	OG_REST_PARAM_PROFILE \|
2544	OG_REST_PARAM_ID))
2545	return -1;
2546
2547	clients = json_copy(element);
2548	json_object_del(clients, "clients");
2549
2550	return og_send_request(OG_METHOD_POST, OG_CMD_IMAGE_RESTORE, params,
2551	clients);
2552	}
2553
2554	static int og_cmd_setup(json_t element, struct og_msg_params params)
2555	{
2556	json_t value, clients;
2557	const char *key;
2558	int err = 0;
2559
2560	if (json_typeof(element) != JSON_OBJECT)
2561	return -1;
2562
2563	json_object_foreach(element, key, value) {
2564	if (!strcmp(key, "clients")) {
2565	err = og_json_parse_clients(value, params);
2566	} else if (!strcmp(key, "disk")) {
2567	err = og_json_parse_string(value, &params->disk);
2568	params->flags \|= OG_REST_PARAM_DISK;
2569	} else if (!strcmp(key, "cache")) {
2570	err = og_json_parse_string(value, &params->cache);
2571	params->flags \|= OG_REST_PARAM_CACHE;
2572	} else if (!strcmp(key, "cache_size")) {
2573	err = og_json_parse_string(value, &params->cache_size);
2574	params->flags \|= OG_REST_PARAM_CACHE_SIZE;
2575	} else if (!strcmp(key, "partition_setup")) {
2576	err = og_json_parse_partition_setup(value, params);
2577	}
2578
2579	if (err < 0)
2580	break;
2581	}
2582
2583	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2584	OG_REST_PARAM_DISK \|
2585	OG_REST_PARAM_CACHE \|
2586	OG_REST_PARAM_CACHE_SIZE \|
2587	OG_REST_PARAM_PART_0 \|
2588	OG_REST_PARAM_PART_1 \|
2589	OG_REST_PARAM_PART_2 \|
2590	OG_REST_PARAM_PART_3))
2591	return -1;
2592
2593	clients = json_copy(element);
2594	json_object_del(clients, "clients");
2595
2596	return og_send_request(OG_METHOD_POST, OG_CMD_SETUP, params, clients);
2597	}
2598
2599	static int og_cmd_run_schedule(json_t element, struct og_msg_params params)
2600	{
2601	const char *key;
2602	json_t *value;
2603	int err = 0;
2604
2605	json_object_foreach(element, key, value) {
2606	if (!strcmp(key, "clients"))
2607	err = og_json_parse_clients(value, params);
2608
2609	if (err < 0)
2610	break;
2611	}
2612
2613	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR))
2614	return -1;
2615
2616	return og_send_request(OG_METHOD_GET, OG_CMD_RUN_SCHEDULE, params,
2617	NULL);
2618	}
2619
2620	static int og_cmd_create_basic_image(json_t element, struct og_msg_params params)
2621	{
2622	char buf[4096] = {};
2623	int err = 0, len;
2624	const char *key;
2625	json_t *value;
2626	TRAMA *msg;
2627
2628	if (json_typeof(element) != JSON_OBJECT)
2629	return -1;
2630
2631	json_object_foreach(element, key, value) {
2632	if (!strcmp(key, "clients")) {
2633	err = og_json_parse_clients(value, params);
2634	} else if (!strcmp(key, "disk")) {
2635	err = og_json_parse_string(value, &params->disk);
2636	params->flags \|= OG_REST_PARAM_DISK;
2637	} else if (!strcmp(key, "partition")) {
2638	err = og_json_parse_string(value, &params->partition);
2639	params->flags \|= OG_REST_PARAM_PARTITION;
2640	} else if (!strcmp(key, "code")) {
2641	err = og_json_parse_string(value, &params->code);
2642	params->flags \|= OG_REST_PARAM_CODE;
2643	} else if (!strcmp(key, "id")) {
2644	err = og_json_parse_string(value, &params->id);
2645	params->flags \|= OG_REST_PARAM_ID;
2646	} else if (!strcmp(key, "name")) {
2647	err = og_json_parse_string(value, &params->name);
2648	params->flags \|= OG_REST_PARAM_NAME;
2649	} else if (!strcmp(key, "repository")) {
2650	err = og_json_parse_string(value, &params->repository);
2651	params->flags \|= OG_REST_PARAM_REPO;
2652	} else if (!strcmp(key, "sync_params")) {
2653	err = og_json_parse_sync_params(value, params);
2654	}
2655
2656	if (err < 0)
2657	break;
2658	}
2659
2660	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2661	OG_REST_PARAM_DISK \|
2662	OG_REST_PARAM_PARTITION \|
2663	OG_REST_PARAM_CODE \|
2664	OG_REST_PARAM_ID \|
2665	OG_REST_PARAM_NAME \|
2666	OG_REST_PARAM_REPO \|
2667	OG_REST_PARAM_SYNC_SYNC \|
2668	OG_REST_PARAM_SYNC_DIFF \|
2669	OG_REST_PARAM_SYNC_REMOVE \|
2670	OG_REST_PARAM_SYNC_COMPRESS \|
2671	OG_REST_PARAM_SYNC_CLEANUP \|
2672	OG_REST_PARAM_SYNC_CACHE \|
2673	OG_REST_PARAM_SYNC_CLEANUP_CACHE \|
2674	OG_REST_PARAM_SYNC_REMOVE_DST))
2675	return -1;
2676
2677	len = snprintf(buf, sizeof(buf),
2678	"nfn=CrearImagenBasica\rdsk=%s\rpar=%s\rcpt=%s\ridi=%s\r"
2679	"nci=%s\ripr=%s\rrti=\rmsy=%s\rwhl=%s\reli=%s\rcmp=%s\rbpi=%s\r"
2680	"cpc=%s\rbpc=%s\rnba=%s\r",
2681	params->disk, params->partition, params->code, params->id,
2682	params->name, params->repository, params->sync_setup.sync,
2683	params->sync_setup.diff, params->sync_setup.remove,
2684	params->sync_setup.compress, params->sync_setup.cleanup,
2685	params->sync_setup.cache, params->sync_setup.cleanup_cache,
2686	params->sync_setup.remove_dst);
2687
2688	msg = og_msg_alloc(buf, len);
2689	if (!msg)
2690	return -1;
2691
2692	og_send_cmd((char **)params->ips_array, params->ips_array_len,
2693	CLIENTE_OCUPADO, msg);
2694
2695	og_msg_free(msg);
2696
2697	return 0;
2698	}
2699
2700	static int og_cmd_create_incremental_image(json_t element, struct og_msg_params params)
2701	{
2702	char buf[4096] = {};
2703	int err = 0, len;
2704	const char *key;
2705	json_t *value;
2706	TRAMA *msg;
2707
2708	if (json_typeof(element) != JSON_OBJECT)
2709	return -1;
2710
2711	json_object_foreach(element, key, value) {
2712	if (!strcmp(key, "clients"))
2713	err = og_json_parse_clients(value, params);
2714	else if (!strcmp(key, "disk")) {
2715	err = og_json_parse_string(value, &params->disk);
2716	params->flags \|= OG_REST_PARAM_DISK;
2717	} else if (!strcmp(key, "partition")) {
2718	err = og_json_parse_string(value, &params->partition);
2719	params->flags \|= OG_REST_PARAM_PARTITION;
2720	} else if (!strcmp(key, "id")) {
2721	err = og_json_parse_string(value, &params->id);
2722	params->flags \|= OG_REST_PARAM_ID;
2723	} else if (!strcmp(key, "name")) {
2724	err = og_json_parse_string(value, &params->name);
2725	params->flags \|= OG_REST_PARAM_NAME;
2726	} else if (!strcmp(key, "repository")) {
2727	err = og_json_parse_string(value, &params->repository);
2728	params->flags \|= OG_REST_PARAM_REPO;
2729	} else if (!strcmp(key, "sync_params")) {
2730	err = og_json_parse_sync_params(value, params);
2731	}
2732
2733	if (err < 0)
2734	break;
2735	}
2736
2737	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2738	OG_REST_PARAM_DISK \|
2739	OG_REST_PARAM_PARTITION \|
2740	OG_REST_PARAM_ID \|
2741	OG_REST_PARAM_NAME \|
2742	OG_REST_PARAM_REPO \|
2743	OG_REST_PARAM_SYNC_SYNC \|
2744	OG_REST_PARAM_SYNC_PATH \|
2745	OG_REST_PARAM_SYNC_DIFF \|
2746	OG_REST_PARAM_SYNC_DIFF_ID \|
2747	OG_REST_PARAM_SYNC_DIFF_NAME \|
2748	OG_REST_PARAM_SYNC_REMOVE \|
2749	OG_REST_PARAM_SYNC_COMPRESS \|
2750	OG_REST_PARAM_SYNC_CLEANUP \|
2751	OG_REST_PARAM_SYNC_CACHE \|
2752	OG_REST_PARAM_SYNC_CLEANUP_CACHE \|
2753	OG_REST_PARAM_SYNC_REMOVE_DST))
2754	return -1;
2755
2756	len = snprintf(buf, sizeof(buf),
2757	"nfn=CrearSoftIncremental\rdsk=%s\rpar=%s\ridi=%s\rnci=%s\r"
2758	"rti=%s\ripr=%s\ridf=%s\rncf=%s\rmsy=%s\rwhl=%s\reli=%s\rcmp=%s\r"
2759	"bpi=%s\rcpc=%s\rbpc=%s\rnba=%s\r",
2760	params->disk, params->partition, params->id, params->name,
2761	params->sync_setup.path, params->repository, params->sync_setup.diff_id,
2762	params->sync_setup.diff_name, params->sync_setup.sync,
2763	params->sync_setup.diff, params->sync_setup.remove_dst,
2764	params->sync_setup.compress, params->sync_setup.cleanup,
2765	params->sync_setup.cache, params->sync_setup.cleanup_cache,
2766	params->sync_setup.remove_dst);
2767
2768	msg = og_msg_alloc(buf, len);
2769	if (!msg)
2770	return -1;
2771
2772	og_send_cmd((char **)params->ips_array, params->ips_array_len,
2773	CLIENTE_OCUPADO, msg);
2774
2775	og_msg_free(msg);
2776
2777	return 0;
2778	}
2779
2780	static int og_cmd_restore_basic_image(json_t element, struct og_msg_params params)
2781	{
2782	char buf[4096] = {};
2783	int err = 0, len;
2784	const char *key;
2785	json_t *value;
2786	TRAMA *msg;
2787
2788	if (json_typeof(element) != JSON_OBJECT)
2789	return -1;
2790
2791	json_object_foreach(element, key, value) {
2792	if (!strcmp(key, "clients")) {
2793	err = og_json_parse_clients(value, params);
2794	} else if (!strcmp(key, "disk")) {
2795	err = og_json_parse_string(value, &params->disk);
2796	params->flags \|= OG_REST_PARAM_DISK;
2797	} else if (!strcmp(key, "partition")) {
2798	err = og_json_parse_string(value, &params->partition);
2799	params->flags \|= OG_REST_PARAM_PARTITION;
2800	} else if (!strcmp(key, "id")) {
2801	err = og_json_parse_string(value, &params->id);
2802	params->flags \|= OG_REST_PARAM_ID;
2803	} else if (!strcmp(key, "name")) {
2804	err = og_json_parse_string(value, &params->name);
2805	params->flags \|= OG_REST_PARAM_NAME;
2806	} else if (!strcmp(key, "repository")) {
2807	err = og_json_parse_string(value, &params->repository);
2808	params->flags \|= OG_REST_PARAM_REPO;
2809	} else if (!strcmp(key, "profile")) {
2810	err = og_json_parse_string(value, &params->profile);
2811	params->flags \|= OG_REST_PARAM_PROFILE;
2812	} else if (!strcmp(key, "type")) {
2813	err = og_json_parse_string(value, &params->type);
2814	params->flags \|= OG_REST_PARAM_TYPE;
2815	} else if (!strcmp(key, "sync_params")) {
2816	err = og_json_parse_sync_params(value, params);
2817	}
2818
2819	if (err < 0)
2820	break;
2821	}
2822
2823	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2824	OG_REST_PARAM_DISK \|
2825	OG_REST_PARAM_PARTITION \|
2826	OG_REST_PARAM_ID \|
2827	OG_REST_PARAM_NAME \|
2828	OG_REST_PARAM_REPO \|
2829	OG_REST_PARAM_PROFILE \|
2830	OG_REST_PARAM_TYPE \|
2831	OG_REST_PARAM_SYNC_PATH \|
2832	OG_REST_PARAM_SYNC_METHOD \|
2833	OG_REST_PARAM_SYNC_SYNC \|
2834	OG_REST_PARAM_SYNC_DIFF \|
2835	OG_REST_PARAM_SYNC_REMOVE \|
2836	OG_REST_PARAM_SYNC_COMPRESS \|
2837	OG_REST_PARAM_SYNC_CLEANUP \|
2838	OG_REST_PARAM_SYNC_CACHE \|
2839	OG_REST_PARAM_SYNC_CLEANUP_CACHE \|
2840	OG_REST_PARAM_SYNC_REMOVE_DST))
2841	return -1;
2842
2843	len = snprintf(buf, sizeof(buf),
2844	"nfn=RestaurarImagenBasica\rdsk=%s\rpar=%s\ridi=%s\rnci=%s\r"
2845	"ipr=%s\rifs=%s\rrti=%s\rmet=%s\rmsy=%s\rtpt=%s\rwhl=%s\r"
2846	"eli=%s\rcmp=%s\rbpi=%s\rcpc=%s\rbpc=%s\rnba=%s\r",
2847	params->disk, params->partition, params->id, params->name,
2848	params->repository, params->profile, params->sync_setup.path,
2849	params->sync_setup.method, params->sync_setup.sync, params->type,
2850	params->sync_setup.diff, params->sync_setup.remove,
2851	params->sync_setup.compress, params->sync_setup.cleanup,
2852	params->sync_setup.cache, params->sync_setup.cleanup_cache,
2853	params->sync_setup.remove_dst);
2854
2855	msg = og_msg_alloc(buf, len);
2856	if (!msg)
2857	return -1;
2858
2859	og_send_cmd((char **)params->ips_array, params->ips_array_len,
2860	CLIENTE_OCUPADO, msg);
2861
2862	og_msg_free(msg);
2863
2864	return 0;
2865	}
2866
2867	static int og_cmd_restore_incremental_image(json_t element, struct og_msg_params params)
2868	{
2869	char buf[4096] = {};
2870	int err = 0, len;
2871	const char *key;
2872	json_t *value;
2873	TRAMA *msg;
2874
2875	if (json_typeof(element) != JSON_OBJECT)
2876	return -1;
2877
2878	json_object_foreach(element, key, value) {
2879	if (!strcmp(key, "clients")) {
2880	err = og_json_parse_clients(value, params);
2881	} else if (!strcmp(key, "disk")) {
2882	err = og_json_parse_string(value, &params->disk);
2883	params->flags \|= OG_REST_PARAM_DISK;
2884	} else if (!strcmp(key, "partition")) {
2885	err = og_json_parse_string(value, &params->partition);
2886	params->flags \|= OG_REST_PARAM_PARTITION;
2887	} else if (!strcmp(key, "id")) {
2888	err = og_json_parse_string(value, &params->id);
2889	params->flags \|= OG_REST_PARAM_ID;
2890	} else if (!strcmp(key, "name")) {
2891	err = og_json_parse_string(value, &params->name);
2892	params->flags \|= OG_REST_PARAM_NAME;
2893	} else if (!strcmp(key, "repository")) {
2894	err = og_json_parse_string(value, &params->repository);
2895	params->flags \|= OG_REST_PARAM_REPO;
2896	} else if (!strcmp(key, "profile")) {
2897	err = og_json_parse_string(value, &params->profile);
2898	params->flags \|= OG_REST_PARAM_PROFILE;
2899	} else if (!strcmp(key, "type")) {
2900	err = og_json_parse_string(value, &params->type);
2901	params->flags \|= OG_REST_PARAM_TYPE;
2902	} else if (!strcmp(key, "sync_params")) {
2903	err = og_json_parse_sync_params(value, params);
2904	}
2905
2906	if (err < 0)
2907	break;
2908	}
2909
2910	if (!og_msg_params_validate(params, OG_REST_PARAM_ADDR \|
2911	OG_REST_PARAM_DISK \|
2912	OG_REST_PARAM_PARTITION \|
2913	OG_REST_PARAM_ID \|
2914	OG_REST_PARAM_NAME \|
2915	OG_REST_PARAM_REPO \|
2916	OG_REST_PARAM_PROFILE \|
2917	OG_REST_PARAM_TYPE \|
2918	OG_REST_PARAM_SYNC_DIFF_ID \|
2919	OG_REST_PARAM_SYNC_DIFF_NAME \|
2920	OG_REST_PARAM_SYNC_PATH \|
2921	OG_REST_PARAM_SYNC_METHOD \|
2922	OG_REST_PARAM_SYNC_SYNC \|
2923	OG_REST_PARAM_SYNC_DIFF \|
2924	OG_REST_PARAM_SYNC_REMOVE \|
2925	OG_REST_PARAM_SYNC_COMPRESS \|
2926	OG_REST_PARAM_SYNC_CLEANUP \|
2927	OG_REST_PARAM_SYNC_CACHE \|
2928	OG_REST_PARAM_SYNC_CLEANUP_CACHE \|
2929	OG_REST_PARAM_SYNC_REMOVE_DST))
2930	return -1;
2931
2932	len = snprintf(buf, sizeof(buf),
2933	"nfn=RestaurarSoftIncremental\rdsk=%s\rpar=%s\ridi=%s\rnci=%s\r"
2934	"ipr=%s\rifs=%s\ridf=%s\rncf=%s\rrti=%s\rmet=%s\rmsy=%s\r"
2935	"tpt=%s\rwhl=%s\reli=%s\rcmp=%s\rbpi=%s\rcpc=%s\rbpc=%s\r"
2936	"nba=%s\r",
2937	params->disk, params->partition, params->id, params->name,
2938	params->repository, params->profile, params->sync_setup.diff_id,
2939	params->sync_setup.diff_name, params->sync_setup.path,
2940	params->sync_setup.method, params->sync_setup.sync, params->type,
2941	params->sync_setup.diff, params->sync_setup.remove,
2942	params->sync_setup.compress, params->sync_setup.cleanup,
2943	params->sync_setup.cache, params->sync_setup.cleanup_cache,
2944	params->sync_setup.remove_dst);
2945
2946	msg = og_msg_alloc(buf, len);
2947	if (!msg)
2948	return -1;
2949
2950	og_send_cmd((char **)params->ips_array, params->ips_array_len,
2951	CLIENTE_OCUPADO, msg);
2952
2953	og_msg_free(msg);
2954
2955	return 0;
2956	}
2957
2958	struct og_cmd {
2959	uint32_t id;
2960	struct list_head list;
2961	uint32_t client_id;
2962	const char *ip;
2963	const char *mac;
2964	enum og_cmd_type type;
2965	enum og_rest_method method;
2966	struct og_msg_params params;
2967	json_t *json;
2968	};
2969
2970	static LIST_HEAD(cmd_list);
2971
2972	static const struct og_cmd og_cmd_find(const char client_ip)
2973	{
2974	struct og_cmd cmd, next;
2975
2976	list_for_each_entry_safe(cmd, next, &cmd_list, list) {
2977	if (strcmp(cmd->ip, client_ip))
2978	continue;
2979
2980	list_del(&cmd->list);
2981	return cmd;
2982	}
2983
2984	return NULL;
2985	}
2986
2987	static void og_cmd_free(const struct og_cmd *cmd)
2988	{
2989	struct og_msg_params params = (struct og_msg_params )&cmd->params;
2990	int i;
2991
2992	for (i = 0; i < params->ips_array_len; i++) {
2993	free((void *)params->ips_array[i]);
2994	free((void *)params->mac_array[i]);
2995	}
2996	free((void *)params->wol_type);
2997
2998	if (cmd->json)
2999	json_decref(cmd->json);
3000
3001	free((void *)cmd->ip);
3002	free((void *)cmd->mac);
3003	free((void *)cmd);
3004	}
3005
3006	static void og_cmd_init(struct og_cmd *cmd, enum og_rest_method method,
3007	enum og_cmd_type type, json_t *root)
3008	{
3009	cmd->type = type;
3010	cmd->method = method;
3011	cmd->params.ips_array[0] = strdup(cmd->ip);
3012	cmd->params.ips_array_len = 1;
3013	cmd->json = root;
3014	}
3015
3016	static int og_cmd_legacy_wol(const char input, struct og_cmd cmd)
3017	{
3018	char wol_type[2] = {};
3019
3020	if (sscanf(input, "mar=%s", wol_type) != 1) {
3021	syslog(LOG_ERR, "malformed database legacy input\n");
3022	return -1;
3023	}
3024
3025	og_cmd_init(cmd, OG_METHOD_NO_HTTP, OG_CMD_WOL, NULL);
3026	cmd->params.mac_array[0] = strdup(cmd->mac);
3027	cmd->params.wol_type = strdup(wol_type);
3028
3029	return 0;
3030	}
3031
3032	static int og_cmd_legacy_shell_run(const char input, struct og_cmd cmd)
3033	{
3034	json_t root, script, *echo;
3035
3036	script = json_string(input + 4);
3037	echo = json_boolean(false);
3038
3039	root = json_object();
3040	if (!root)
3041	return -1;
3042	json_object_set_new(root, "run", script);
3043	json_object_set_new(root, "echo", echo);
3044
3045	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_SHELL_RUN, root);
3046
3047	return 0;
3048	}
3049
3050	#define OG_DB_SMALLINT_MAXLEN 6
3051
3052	static int og_cmd_legacy_session(const char input, struct og_cmd cmd)
3053	{
3054	char part_str[OG_DB_SMALLINT_MAXLEN + 1];
3055	char disk_str[OG_DB_SMALLINT_MAXLEN + 1];
3056	json_t root, disk, *partition;
3057
3058	if (sscanf(input, "dsk=%s\rpar=%s\r", disk_str, part_str) != 2)
3059	return -1;
3060	partition = json_string(part_str);
3061	disk = json_string(disk_str);
3062
3063	root = json_object();
3064	if (!root)
3065	return -1;
3066	json_object_set_new(root, "partition", partition);
3067	json_object_set_new(root, "disk", disk);
3068
3069	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_SESSION, root);
3070
3071	return 0;
3072	}
3073
3074	static int og_cmd_legacy_poweroff(const char input, struct og_cmd cmd)
3075	{
3076	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_POWEROFF, NULL);
3077
3078	return 0;
3079	}
3080
3081	static int og_cmd_legacy_refresh(const char input, struct og_cmd cmd)
3082	{
3083	og_cmd_init(cmd, OG_METHOD_GET, OG_CMD_REFRESH, NULL);
3084
3085	return 0;
3086	}
3087
3088	static int og_cmd_legacy_reboot(const char input, struct og_cmd cmd)
3089	{
3090	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_REBOOT, NULL);
3091
3092	return 0;
3093	}
3094
3095	static int og_cmd_legacy_stop(const char input, struct og_cmd cmd)
3096	{
3097	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_STOP, NULL);
3098
3099	return 0;
3100	}
3101
3102	static int og_cmd_legacy_hardware(const char input, struct og_cmd cmd)
3103	{
3104	og_cmd_init(cmd, OG_METHOD_GET, OG_CMD_HARDWARE, NULL);
3105
3106	return 0;
3107	}
3108
3109	static int og_cmd_legacy_software(const char input, struct og_cmd cmd)
3110	{
3111	og_cmd_init(cmd, OG_METHOD_GET, OG_CMD_SOFTWARE, NULL);
3112
3113	return 0;
3114	}
3115
3116	#define OG_DB_IMAGE_NAME_MAXLEN 50
3117	#define OG_DB_FILESYSTEM_MAXLEN 16
3118	#define OG_DB_INT8_MAXLEN 8
3119	#define OG_DB_INT_MAXLEN 11
3120	#define OG_DB_IP_MAXLEN 15
3121
3122	struct og_image_legacy {
3123	char software_id[OG_DB_INT_MAXLEN + 1];
3124	char image_id[OG_DB_INT_MAXLEN + 1];
3125	char name[OG_DB_IMAGE_NAME_MAXLEN + 1];
3126	char repo[OG_DB_IP_MAXLEN + 1];
3127	char part[OG_DB_SMALLINT_MAXLEN + 1];
3128	char disk[OG_DB_SMALLINT_MAXLEN + 1];
3129	char code[OG_DB_INT8_MAXLEN + 1];
3130	};
3131
3132	struct og_legacy_partition {
3133	char partition[OG_DB_SMALLINT_MAXLEN + 1];
3134	char code[OG_DB_INT8_MAXLEN + 1];
3135	char size[OG_DB_INT_MAXLEN + 1];
3136	char filesystem[OG_DB_FILESYSTEM_MAXLEN + 1];
3137	char format[2]; /* Format is a boolean 0 or 1 => length is 2 */
3138	};
3139
3140	static int og_cmd_legacy_image_create(const char input, struct og_cmd cmd)
3141	{
3142	json_t root, disk, partition, code, image_id, name, *repo;
3143	struct og_image_legacy img = {};
3144
3145	if (sscanf(input, "dsk=%s\rpar=%s\rcpt=%s\ridi=%s\rnci=%s\ripr=%s\r",
3146	img.disk, img.part, img.code, img.image_id, img.name,
3147	img.repo) != 6)
3148	return -1;
3149	image_id = json_string(img.image_id);
3150	partition = json_string(img.part);
3151	code = json_string(img.code);
3152	name = json_string(img.name);
3153	repo = json_string(img.repo);
3154	disk = json_string(img.disk);
3155
3156	root = json_object();
3157	if (!root)
3158	return -1;
3159	json_object_set_new(root, "partition", partition);
3160	json_object_set_new(root, "repository", repo);
3161	json_object_set_new(root, "id", image_id);
3162	json_object_set_new(root, "code", code);
3163	json_object_set_new(root, "name", name);
3164	json_object_set_new(root, "disk", disk);
3165
3166	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_IMAGE_CREATE, root);
3167
3168	return 0;
3169	}
3170
3171	#define OG_DB_RESTORE_TYPE_MAXLEN 64
3172
3173	static int og_cmd_legacy_image_restore(const char input, struct og_cmd cmd)
3174	{
3175	json_t root, disk, partition, image_id, name, repo;
3176	char restore_type_str[OG_DB_RESTORE_TYPE_MAXLEN + 1] = {};
3177	char software_id_str[OG_DB_INT_MAXLEN + 1] = {};
3178	json_t software_id, restore_type;
3179	struct og_image_legacy img = {};
3180
3181	if (sscanf(input,
3182	"dsk=%s\rpar=%s\ridi=%s\rnci=%s\ripr=%s\rifs=%s\rptc=%s\r",
3183	img.disk, img.part, img.image_id, img.name, img.repo,
3184	software_id_str, restore_type_str) != 7)
3185	return -1;
3186
3187	restore_type = json_string(restore_type_str);
3188	software_id = json_string(software_id_str);
3189	image_id = json_string(img.image_id);
3190	partition = json_string(img.part);
3191	name = json_string(img.name);
3192	repo = json_string(img.repo);
3193	disk = json_string(img.disk);
3194
3195	root = json_object();
3196	if (!root)
3197	return -1;
3198	json_object_set_new(root, "profile", software_id);
3199	json_object_set_new(root, "partition", partition);
3200	json_object_set_new(root, "type", restore_type);
3201	json_object_set_new(root, "repository", repo);
3202	json_object_set_new(root, "id", image_id);
3203	json_object_set_new(root, "name", name);
3204	json_object_set_new(root, "disk", disk);
3205
3206	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_IMAGE_RESTORE, root);
3207
3208	return 0;
3209	}
3210
3211	static int og_cmd_legacy_setup(const char input, struct og_cmd cmd)
3212	{
3213	json_t root, disk, cache, cache_size, partition_setup, object;
3214	struct og_legacy_partition part_cfg[OG_PARTITION_MAX] = {};
3215	char cache_size_str [OG_DB_INT_MAXLEN + 1];
3216	char disk_str [OG_DB_SMALLINT_MAXLEN + 1];
3217	json_t part, code, fs, size, *format;
3218	unsigned int partition_len = 0;
3219	const char *in_ptr;
3220	char cache_str[2];
3221
3222	if (sscanf(input, "dsk=%s\rcfg=dis=%[^]che=%[^]*tch=%[^!]!",
3223	disk_str, cache_str, cache_size_str) != 3)
3224	return -1;
3225
3226	in_ptr = strstr(input, "!") + 1;
3227	while (strlen(in_ptr) > 0) {
3228	if(sscanf(in_ptr,
3229	"par=%[^]cpt=%[^]sfi=%[^]tam=%[^]ope=%[^%%]%%",
3230	part_cfg[partition_len].partition,
3231	part_cfg[partition_len].code,
3232	part_cfg[partition_len].filesystem,
3233	part_cfg[partition_len].size,
3234	part_cfg[partition_len].format) != 5)
3235	return -1;
3236	in_ptr = strstr(in_ptr, "%") + 1;
3237	partition_len++;
3238	}
3239
3240	root = json_object();
3241	if (!root)
3242	return -1;
3243
3244	cache_size = json_string(cache_size_str);
3245	cache = json_string(cache_str);
3246	partition_setup = json_array();
3247	disk = json_string(disk_str);
3248
3249	for (unsigned int i = 0; i < partition_len; ++i) {
3250	object = json_object();
3251	if (!object) {
3252	json_decref(root);
3253	return -1;
3254	}
3255
3256	part = json_string(part_cfg[i].partition);
3257	fs = json_string(part_cfg[i].filesystem);
3258	format = json_string(part_cfg[i].format);
3259	code = json_string(part_cfg[i].code);
3260	size = json_string(part_cfg[i].size);
3261
3262	json_object_set_new(object, "partition", part);
3263	json_object_set_new(object, "filesystem", fs);
3264	json_object_set_new(object, "format", format);
3265	json_object_set_new(object, "code", code);
3266	json_object_set_new(object, "size", size);
3267
3268	json_array_append_new(partition_setup, object);
3269	}
3270
3271	json_object_set_new(root, "partition_setup", partition_setup);
3272	json_object_set_new(root, "cache_size", cache_size);
3273	json_object_set_new(root, "cache", cache);
3274	json_object_set_new(root, "disk", disk);
3275
3276	og_cmd_init(cmd, OG_METHOD_POST, OG_CMD_SETUP, root);
3277
3278	return 0;
3279	}
3280
3281	static int og_cmd_legacy_run_schedule(const char input, struct og_cmd cmd)
3282	{
3283	og_cmd_init(cmd, OG_METHOD_GET, OG_CMD_RUN_SCHEDULE, NULL);
3284
3285	return 0;
3286	}
3287
3288	static int og_cmd_legacy(const char input, struct og_cmd cmd)
3289	{
3290	char legacy_cmd[32] = {};
3291	int err = -1;
3292
3293	if (sscanf(input, "nfn=%31s\r", legacy_cmd) != 1) {
3294	syslog(LOG_ERR, "malformed database legacy input\n");
3295	return -1;
3296	}
3297	input = strchr(input, '\r') + 1;
3298
3299	if (!strcmp(legacy_cmd, "Arrancar")) {
3300	err = og_cmd_legacy_wol(input, cmd);
3301	} else if (!strcmp(legacy_cmd, "EjecutarScript")) {
3302	err = og_cmd_legacy_shell_run(input, cmd);
3303	} else if (!strcmp(legacy_cmd, "IniciarSesion")) {
3304	err = og_cmd_legacy_session(input, cmd);
3305	} else if (!strcmp(legacy_cmd, "Apagar")) {
3306	err = og_cmd_legacy_poweroff(input, cmd);
3307	} else if (!strcmp(legacy_cmd, "Actualizar")) {
3308	err = og_cmd_legacy_refresh(input, cmd);
3309	} else if (!strcmp(legacy_cmd, "Reiniciar")) {
3310	err = og_cmd_legacy_reboot(input, cmd);
3311	} else if (!strcmp(legacy_cmd, "Purgar")) {
3312	err = og_cmd_legacy_stop(input, cmd);
3313	} else if (!strcmp(legacy_cmd, "InventarioHardware")) {
3314	err = og_cmd_legacy_hardware(input, cmd);
3315	} else if (!strcmp(legacy_cmd, "InventarioSoftware")) {
3316	err = og_cmd_legacy_software(input, cmd);
3317	} else if (!strcmp(legacy_cmd, "CrearImagen")) {
3318	err = og_cmd_legacy_image_create(input, cmd);
3319	} else if (!strcmp(legacy_cmd, "RestaurarImagen")) {
3320	err = og_cmd_legacy_image_restore(input, cmd);
3321	} else if (!strcmp(legacy_cmd, "Configurar")) {
3322	err = og_cmd_legacy_setup(input, cmd);
3323	} else if (!strcmp(legacy_cmd, "EjecutaComandosPendientes") \|\|
3324	!strcmp(legacy_cmd, "Actualizar")) {
3325	err = og_cmd_legacy_run_schedule(input, cmd);
3326	}
3327
3328	return err;
3329	}
3330
3331	static int og_dbi_add_action(const struct og_dbi dbi, const struct og_task task,
3332	struct og_cmd *cmd)
3333	{
3334	char start_date_string[24];
3335	struct tm *start_date;
3336	const char *msglog;
3337	dbi_result result;
3338	time_t now;
3339
3340	time(&now);
3341	start_date = localtime(&now);
3342
3343	sprintf(start_date_string, "%hu/%hhu/%hhu %hhu:%hhu:%hhu",
3344	start_date->tm_year + 1900, start_date->tm_mon + 1,
3345	start_date->tm_mday, start_date->tm_hour, start_date->tm_min,
3346	start_date->tm_sec);
3347	result = dbi_conn_queryf(dbi->conn,
3348	"INSERT INTO acciones (idordenador, "
3349	"tipoaccion, idtipoaccion, descriaccion, ip, "
3350	"sesion, idcomando, parametros, fechahorareg, "
3351	"estado, resultado, ambito, idambito, "
3352	"restrambito, idprocedimiento, idcentro, "
3353	"idprogramacion) "
3354	"VALUES (%d, %d, %d, '%s', '%s', %d, %d, '%s', "
3355	"'%s', %d, %d, %d, %d, '%s', %d, %d, %d)",
3356	cmd->client_id, EJECUCION_TAREA, task->task_id,
3357	"", cmd->ip, 0, task->command_id,
3358	task->params, start_date_string,
3359	ACCION_INICIADA, ACCION_SINRESULTADO,
3360	task->type_scope, task->scope, "",
3361	task->procedure_id, task->center_id,
3362	task->schedule_id);
3363	if (!result) {
3364	dbi_conn_error(dbi->conn, &msglog);
3365	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3366	__func__, __LINE__, msglog);
3367	return -1;
3368	}
3369	cmd->id = dbi_conn_sequence_last(dbi->conn, NULL);
3370	dbi_result_free(result);
3371
3372	return 0;
3373	}
3374
3375	static int og_queue_task_command(struct og_dbi dbi, const struct og_task task,
3376	char *query)
3377	{
3378	struct og_cmd *cmd;
3379	const char *msglog;
3380	dbi_result result;
3381
3382	result = dbi_conn_queryf(dbi->conn, query);
3383	if (!result) {
3384	dbi_conn_error(dbi->conn, &msglog);
3385	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3386	__func__, __LINE__, msglog);
3387	return -1;
3388	}
3389
3390	while (dbi_result_next_row(result)) {
3391	cmd = (struct og_cmd *)calloc(1, sizeof(struct og_cmd));
3392	if (!cmd) {
3393	dbi_result_free(result);
3394	return -1;
3395	}
3396
3397	cmd->client_id = dbi_result_get_uint(result, "idordenador");
3398	cmd->ip = strdup(dbi_result_get_string(result, "ip"));
3399	cmd->mac = strdup(dbi_result_get_string(result, "mac"));
3400
3401	og_cmd_legacy(task->params, cmd);
3402
3403	if (task->procedure_id) {
3404	if (og_dbi_add_action(dbi, task, cmd)) {
3405	dbi_result_free(result);
3406	return -1;
3407	}
3408	} else {
3409	cmd->id = task->task_id;
3410	}
3411
3412	list_add_tail(&cmd->list, &cmd_list);
3413	}
3414
3415	dbi_result_free(result);
3416
3417	return 0;
3418	}
3419
3420	static int og_queue_task_group_clients(struct og_dbi dbi, struct og_task task,
3421	char *query)
3422	{
3423
3424	const char *msglog;
3425	dbi_result result;
3426
3427	result = dbi_conn_queryf(dbi->conn, query);
3428	if (!result) {
3429	dbi_conn_error(dbi->conn, &msglog);
3430	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3431	__func__, __LINE__, msglog);
3432	return -1;
3433	}
3434
3435	while (dbi_result_next_row(result)) {
3436	uint32_t group_id = dbi_result_get_uint(result, "idgrupo");
3437
3438	sprintf(query, "SELECT idgrupo FROM gruposordenadores "
3439	"WHERE grupoid=%d", group_id);
3440	if (og_queue_task_group_clients(dbi, task, query)) {
3441	dbi_result_free(result);
3442	return -1;
3443	}
3444
3445	sprintf(query,"SELECT ip, mac, idordenador FROM ordenadores "
3446	"WHERE grupoid=%d", group_id);
3447	if (og_queue_task_command(dbi, task, query)) {
3448	dbi_result_free(result);
3449	return -1;
3450	}
3451
3452	}
3453
3454	dbi_result_free(result);
3455
3456	return 0;
3457	}
3458
3459	static int og_queue_task_group_classrooms(struct og_dbi *dbi,
3460	struct og_task task, char query)
3461	{
3462
3463	const char *msglog;
3464	dbi_result result;
3465
3466	result = dbi_conn_queryf(dbi->conn, query);
3467	if (!result) {
3468	dbi_conn_error(dbi->conn, &msglog);
3469	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3470	__func__, __LINE__, msglog);
3471	return -1;
3472	}
3473
3474	while (dbi_result_next_row(result)) {
3475	uint32_t group_id = dbi_result_get_uint(result, "idgrupo");
3476
3477	sprintf(query, "SELECT idgrupo FROM grupos "
3478	"WHERE grupoid=%d AND tipo=%d", group_id, AMBITO_GRUPOSAULAS);
3479	if (og_queue_task_group_classrooms(dbi, task, query)) {
3480	dbi_result_free(result);
3481	return -1;
3482	}
3483
3484	sprintf(query,
3485	"SELECT ip,mac,idordenador "
3486	"FROM ordenadores INNER JOIN aulas "
3487	"WHERE ordenadores.idaula=aulas.idaula "
3488	"AND aulas.grupoid=%d",
3489	group_id);
3490	if (og_queue_task_command(dbi, task, query)) {
3491	dbi_result_free(result);
3492	return -1;
3493	}
3494
3495	}
3496
3497	dbi_result_free(result);
3498
3499	return 0;
3500	}
3501
3502	static int og_queue_task_clients(struct og_dbi dbi, struct og_task task)
3503	{
3504	char query[4096];
3505
3506	switch (task->type_scope) {
3507	case AMBITO_CENTROS:
3508	sprintf(query,
3509	"SELECT ip,mac,idordenador "
3510	"FROM ordenadores INNER JOIN aulas "
3511	"WHERE ordenadores.idaula=aulas.idaula "
3512	"AND idcentro=%d",
3513	task->scope);
3514	return og_queue_task_command(dbi, task, query);
3515	case AMBITO_GRUPOSAULAS:
3516	sprintf(query,
3517	"SELECT idgrupo FROM grupos "
3518	"WHERE idgrupo=%i AND tipo=%d",
3519	task->scope, AMBITO_GRUPOSAULAS);
3520	return og_queue_task_group_classrooms(dbi, task, query);
3521	case AMBITO_AULAS:
3522	sprintf(query,
3523	"SELECT ip,mac,idordenador FROM ordenadores "
3524	"WHERE idaula=%d",
3525	task->scope);
3526	return og_queue_task_command(dbi, task, query);
3527	case AMBITO_GRUPOSORDENADORES:
3528	sprintf(query,
3529	"SELECT idgrupo FROM gruposordenadores "
3530	"WHERE idgrupo = %d",
3531	task->scope);
3532	return og_queue_task_group_clients(dbi, task, query);
3533	case AMBITO_ORDENADORES:
3534	sprintf(query,
3535	"SELECT ip, mac, idordenador FROM ordenadores "
3536	"WHERE idordenador = %d",
3537	task->scope);
3538	return og_queue_task_command(dbi, task, query);
3539	}
3540	return 0;
3541	}
3542
3543	static int og_dbi_queue_procedure(struct og_dbi dbi, struct og_task task)
3544	{
3545	uint32_t procedure_id;
3546	const char *msglog;
3547	dbi_result result;
3548
3549	result = dbi_conn_queryf(dbi->conn,
3550	"SELECT parametros, procedimientoid, idcomando "
3551	"FROM procedimientos_acciones "
3552	"WHERE idprocedimiento=%d ORDER BY orden", task->procedure_id);
3553	if (!result) {
3554	dbi_conn_error(dbi->conn, &msglog);
3555	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3556	__func__, __LINE__, msglog);
3557	return -1;
3558	}
3559
3560	while (dbi_result_next_row(result)) {
3561	procedure_id = dbi_result_get_uint(result, "procedimientoid");
3562	if (procedure_id > 0) {
3563	task->procedure_id = procedure_id;
3564	if (og_dbi_queue_procedure(dbi, task))
3565	return -1;
3566	continue;
3567	}
3568
3569	task->params = strdup(dbi_result_get_string(result, "parametros"));
3570	task->command_id = dbi_result_get_uint(result, "idcomando");
3571	if (og_queue_task_clients(dbi, task))
3572	return -1;
3573	}
3574
3575	dbi_result_free(result);
3576
3577	return 0;
3578	}
3579
3580	static int og_dbi_queue_task(struct og_dbi *dbi, uint32_t task_id,
3581	uint32_t schedule_id)
3582	{
3583	struct og_task task = {};
3584	uint32_t task_id_next;
3585	struct og_cmd *cmd;
3586	const char *msglog;
3587	dbi_result result;
3588
3589	task.schedule_id = schedule_id;
3590
3591	result = dbi_conn_queryf(dbi->conn,
3592	"SELECT tareas_acciones.orden, "
3593	"tareas_acciones.idprocedimiento, "
3594	"tareas_acciones.tareaid, "
3595	"tareas.idtarea, "
3596	"tareas.idcentro, "
3597	"tareas.ambito, "
3598	"tareas.idambito, "
3599	"tareas.restrambito "
3600	" FROM tareas"
3601	" INNER JOIN tareas_acciones ON tareas_acciones.idtarea=tareas.idtarea"
3602	" WHERE tareas_acciones.idtarea=%u ORDER BY tareas_acciones.orden ASC", task_id);
3603	if (!result) {
3604	dbi_conn_error(dbi->conn, &msglog);
3605	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3606	__func__, __LINE__, msglog);
3607	return -1;
3608	}
3609
3610	while (dbi_result_next_row(result)) {
3611	task_id_next = dbi_result_get_uint(result, "tareaid");
3612
3613	if (task_id_next > 0) {
3614	if (og_dbi_queue_task(dbi, task_id_next, schedule_id))
3615	return -1;
3616
3617	continue;
3618	}
3619	task.task_id = dbi_result_get_uint(result, "idtarea");
3620	task.center_id = dbi_result_get_uint(result, "idcentro");
3621	task.procedure_id = dbi_result_get_uint(result, "idprocedimiento");
3622	task.type_scope = dbi_result_get_uint(result, "ambito");
3623	task.scope = dbi_result_get_uint(result, "idambito");
3624	task.filtered_scope = dbi_result_get_string(result, "restrambito");
3625
3626	og_dbi_queue_procedure(dbi, &task);
3627	}
3628
3629	dbi_result_free(result);
3630
3631	list_for_each_entry(cmd, &cmd_list, list) {
3632	if (cmd->type != OG_CMD_WOL)
3633	continue;
3634
3635	if (!Levanta((char **)cmd->params.ips_array,
3636	(char **)cmd->params.mac_array,
3637	cmd->params.ips_array_len,
3638	(char *)cmd->params.wol_type))
3639	return -1;
3640	}
3641
3642	return 0;
3643	}
3644
3645	static int og_dbi_queue_command(struct og_dbi *dbi, uint32_t task_id,
3646	uint32_t schedule_id)
3647	{
3648	struct og_task task = {};
3649	const char *msglog;
3650	dbi_result result;
3651	char query[4096];
3652
3653	result = dbi_conn_queryf(dbi->conn,
3654	"SELECT idaccion, idcentro, idordenador, parametros "
3655	"FROM acciones "
3656	"WHERE sesion = %u", task_id);
3657	if (!result) {
3658	dbi_conn_error(dbi->conn, &msglog);
3659	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3660	__func__, __LINE__, msglog);
3661	return -1;
3662	}
3663
3664	while (dbi_result_next_row(result)) {
3665	task.task_id = dbi_result_get_uint(result, "idaccion");
3666	task.center_id = dbi_result_get_uint(result, "idcentro");
3667	task.scope = dbi_result_get_uint(result, "idordenador");
3668	task.params = strdup(dbi_result_get_string(result, "parametros"));
3669
3670	sprintf(query,
3671	"SELECT ip, mac, idordenador FROM ordenadores "
3672	"WHERE idordenador = %d",
3673	task.scope);
3674	if (og_queue_task_command(dbi, &task, query)) {
3675	dbi_result_free(result);
3676	return -1;
3677	}
3678	}
3679
3680	dbi_result_free(result);
3681
3682	return 0;
3683	}
3684
3685	void og_schedule_run(unsigned int task_id, unsigned int schedule_id,
3686	enum og_schedule_type type)
3687	{
3688	struct og_msg_params params = {};
3689	bool duplicated = false;
3690	struct og_cmd *cmd;
3691	struct og_dbi *dbi;
3692	unsigned int i;
3693
3694	dbi = og_dbi_open(&dbi_config);
3695	if (!dbi) {
3696	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3697	__func__, __LINE__);
3698	return;
3699	}
3700
3701	switch (type) {
3702	case OG_SCHEDULE_TASK:
3703	og_dbi_queue_task(dbi, task_id, schedule_id);
3704	break;
3705	case OG_SCHEDULE_COMMAND:
3706	og_dbi_queue_command(dbi, task_id, schedule_id);
3707	break;
3708	}
3709	og_dbi_close(dbi);
3710
3711	list_for_each_entry(cmd, &cmd_list, list) {
3712	for (i = 0; i < params.ips_array_len; i++) {
3713	if (!strncmp(cmd->ip, params.ips_array[i],
3714	OG_DB_IP_MAXLEN)) {
3715	duplicated = true;
3716	break;
3717	}
3718	}
3719
3720	if (!duplicated)
3721	params.ips_array[params.ips_array_len++] = cmd->ip;
3722	else
3723	duplicated = false;
3724	}
3725
3726	og_send_request(OG_METHOD_GET, OG_CMD_RUN_SCHEDULE, &params, NULL);
3727	}
3728
3729	static int og_cmd_task_post(json_t element, struct og_msg_params params)
3730	{
3731	struct og_cmd *cmd;
3732	struct og_dbi *dbi;
3733	const char *key;
3734	json_t *value;
3735	int err;
3736
3737	if (json_typeof(element) != JSON_OBJECT)
3738	return -1;
3739
3740	json_object_foreach(element, key, value) {
3741	if (!strcmp(key, "task")) {
3742	err = og_json_parse_string(value, &params->task_id);
3743	params->flags \|= OG_REST_PARAM_TASK;
3744	}
3745
3746	if (err < 0)
3747	break;
3748	}
3749
3750	if (!og_msg_params_validate(params, OG_REST_PARAM_TASK))
3751	return -1;
3752
3753	dbi = og_dbi_open(&dbi_config);
3754	if (!dbi) {
3755	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3756	__func__, __LINE__);
3757	return -1;
3758	}
3759
3760	og_dbi_queue_task(dbi, atoi(params->task_id), 0);
3761	og_dbi_close(dbi);
3762
3763	list_for_each_entry(cmd, &cmd_list, list)
3764	params->ips_array[params->ips_array_len++] = cmd->ip;
3765
3766	return og_send_request(OG_METHOD_GET, OG_CMD_RUN_SCHEDULE, params,
3767	NULL);
3768	}
3769
3770	static int og_dbi_schedule_get(void)
3771	{
3772	uint32_t schedule_id, task_id;
3773	struct og_schedule_time time;
3774	struct og_dbi *dbi;
3775	const char *msglog;
3776	dbi_result result;
3777
3778	dbi = og_dbi_open(&dbi_config);
3779	if (!dbi) {
3780	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3781	__func__, __LINE__);
3782	return -1;
3783	}
3784
3785	result = dbi_conn_queryf(dbi->conn,
3786	"SELECT idprogramacion, tipoaccion, identificador, "
3787	"sesion, annos, meses, diario, dias, semanas, horas, "
3788	"ampm, minutos FROM programaciones "
3789	"WHERE suspendida = 0");
3790	if (!result) {
3791	dbi_conn_error(dbi->conn, &msglog);
3792	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3793	__func__, __LINE__, msglog);
3794	og_dbi_close(dbi);
3795	return -1;
3796	}
3797
3798	while (dbi_result_next_row(result)) {
3799	memset(&time, 0, sizeof(time));
3800	schedule_id = dbi_result_get_uint(result, "idprogramacion");
3801	task_id = dbi_result_get_uint(result, "identificador");
3802	time.years = dbi_result_get_uint(result, "annos");
3803	time.months = dbi_result_get_uint(result, "meses");
3804	time.weeks = dbi_result_get_uint(result, "semanas");
3805	time.week_days = dbi_result_get_uint(result, "dias");
3806	time.days = dbi_result_get_uint(result, "diario");
3807	time.hours = dbi_result_get_uint(result, "horas");
3808	time.am_pm = dbi_result_get_uint(result, "ampm");
3809	time.minutes = dbi_result_get_uint(result, "minutos");
3810	time.on_start = true;
3811
3812	og_schedule_create(schedule_id, task_id, OG_SCHEDULE_TASK,
3813	&time);
3814	}
3815
3816	dbi_result_free(result);
3817	og_dbi_close(dbi);
3818
3819	return 0;
3820	}
3821
3822	static int og_dbi_schedule_create(struct og_dbi *dbi,
3823	struct og_msg_params *params,
3824	uint32_t *schedule_id,
3825	enum og_schedule_type schedule_type)
3826	{
3827	uint8_t suspended = 0;
3828	uint32_t session = 0;
3829	const char *msglog;
3830	dbi_result result;
3831	uint8_t type;
3832
3833	switch (schedule_type) {
3834	case OG_SCHEDULE_TASK:
3835	type = 3;
3836	break;
3837	case OG_SCHEDULE_COMMAND:
3838	session = atoi(params->task_id);
3839	type = 1;
3840	break;
3841	}
3842
3843	result = dbi_conn_queryf(dbi->conn,
3844	"INSERT INTO programaciones (tipoaccion,"
3845	" identificador, nombrebloque, annos, meses,"
3846	" semanas, dias, diario, horas, ampm, minutos,"
3847	" suspendida, sesion) VALUES (%d, %s, '%s',"
3848	" %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)",
3849	type, params->task_id, params->name,
3850	params->time.years, params->time.months,
3851	params->time.weeks, params->time.week_days,
3852	params->time.days, params->time.hours,
3853	params->time.am_pm, params->time.minutes,
3854	suspended, session);
3855	if (!result) {
3856	dbi_conn_error(dbi->conn, &msglog);
3857	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3858	__func__, __LINE__, msglog);
3859	return -1;
3860	}
3861	dbi_result_free(result);
3862
3863	*schedule_id = dbi_conn_sequence_last(dbi->conn, NULL);
3864
3865	return 0;
3866	}
3867
3868	static int og_dbi_schedule_update(struct og_dbi *dbi,
3869	struct og_msg_params *params)
3870	{
3871	const char *msglog;
3872	dbi_result result;
3873	uint8_t type = 3;
3874
3875	result = dbi_conn_queryf(dbi->conn,
3876	"UPDATE programaciones SET tipoaccion=%d, "
3877	"identificador='%s', nombrebloque='%s', "
3878	"annos=%d, meses=%d, "
3879	"diario=%d, horas=%d, ampm=%d, minutos=%d "
3880	"WHERE idprogramacion='%s'",
3881	type, params->task_id, params->name,
3882	params->time.years, params->time.months,
3883	params->time.days, params->time.hours,
3884	params->time.am_pm, params->time.minutes,
3885	params->id);
3886
3887	if (!result) {
3888	dbi_conn_error(dbi->conn, &msglog);
3889	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3890	__func__, __LINE__, msglog);
3891	return -1;
3892	}
3893	dbi_result_free(result);
3894
3895	return 0;
3896	}
3897
3898	static int og_dbi_schedule_delete(struct og_dbi *dbi, uint32_t id)
3899	{
3900	const char *msglog;
3901	dbi_result result;
3902
3903	result = dbi_conn_queryf(dbi->conn,
3904	"DELETE FROM programaciones WHERE idprogramacion=%d",
3905	id);
3906	if (!result) {
3907	dbi_conn_error(dbi->conn, &msglog);
3908	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3909	__func__, __LINE__, msglog);
3910	return -1;
3911	}
3912	dbi_result_free(result);
3913
3914	return 0;
3915	}
3916
3917	struct og_db_schedule {
3918	uint32_t id;
3919	uint32_t task_id;
3920	const char *name;
3921	struct og_schedule_time time;
3922	uint32_t week_days;
3923	uint32_t weeks;
3924	uint32_t suspended;
3925	uint32_t session;
3926	};
3927
3928	static int og_dbi_schedule_get_json(struct og_dbi dbi, json_t root,
3929	const char task_id, const char schedule_id)
3930	{
3931	struct og_db_schedule schedule;
3932	json_t obj, array;
3933	const char *msglog;
3934	dbi_result result;
3935	int err = 0;
3936
3937	if (task_id) {
3938	result = dbi_conn_queryf(dbi->conn,
3939	"SELECT idprogramacion,"
3940	" identificador, nombrebloque,"
3941	" annos, meses, diario, dias,"
3942	" semanas, horas, ampm,"
3943	" minutos,suspendida, sesion "
3944	"FROM programaciones "
3945	"WHERE identificador=%d",
3946	atoi(task_id));
3947	} else if (schedule_id) {
3948	result = dbi_conn_queryf(dbi->conn,
3949	"SELECT idprogramacion,"
3950	" identificador, nombrebloque,"
3951	" annos, meses, diario, dias,"
3952	" semanas, horas, ampm,"
3953	" minutos,suspendida, sesion "
3954	"FROM programaciones "
3955	"WHERE idprogramacion=%d",
3956	atoi(schedule_id));
3957	} else {
3958	result = dbi_conn_queryf(dbi->conn,
3959	"SELECT idprogramacion,"
3960	" identificador, nombrebloque,"
3961	" annos, meses, diario, dias,"
3962	" semanas, horas, ampm,"
3963	" minutos,suspendida, sesion "
3964	"FROM programaciones");
3965	}
3966
3967	if (!result) {
3968	dbi_conn_error(dbi->conn, &msglog);
3969	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3970	__func__, __LINE__, msglog);
3971	return -1;
3972	}
3973
3974	array = json_array();
3975	if (!array)
3976	return -1;
3977
3978	while (dbi_result_next_row(result)) {
3979	schedule.id = dbi_result_get_uint(result, "idprogramacion");
3980	schedule.task_id = dbi_result_get_uint(result, "identificador");
3981	schedule.name = dbi_result_get_string(result, "nombrebloque");
3982	schedule.time.years = dbi_result_get_uint(result, "annos");
3983	schedule.time.months = dbi_result_get_uint(result, "meses");
3984	schedule.time.days = dbi_result_get_uint(result, "diario");
3985	schedule.time.hours = dbi_result_get_uint(result, "horas");
3986	schedule.time.am_pm = dbi_result_get_uint(result, "ampm");
3987	schedule.time.minutes = dbi_result_get_uint(result, "minutos");
3988	schedule.week_days = dbi_result_get_uint(result, "dias");
3989	schedule.weeks = dbi_result_get_uint(result, "semanas");
3990	schedule.suspended = dbi_result_get_uint(result, "suspendida");
3991	schedule.session = dbi_result_get_uint(result, "sesion");
3992
3993	obj = json_object();
3994	if (!obj) {
3995	err = -1;
3996	break;
3997	}
3998	json_object_set_new(obj, "id", json_integer(schedule.id));
3999	json_object_set_new(obj, "task", json_integer(schedule.task_id));
4000	json_object_set_new(obj, "name", json_string(schedule.name));
4001	json_object_set_new(obj, "years", json_integer(schedule.time.years));
4002	json_object_set_new(obj, "months", json_integer(schedule.time.months));
4003	json_object_set_new(obj, "days", json_integer(schedule.time.days));
4004	json_object_set_new(obj, "hours", json_integer(schedule.time.hours));
4005	json_object_set_new(obj, "am_pm", json_integer(schedule.time.am_pm));
4006	json_object_set_new(obj, "minutes", json_integer(schedule.time.minutes));
4007	json_object_set_new(obj, "week_days", json_integer(schedule.week_days));
4008	json_object_set_new(obj, "weeks", json_integer(schedule.weeks));
4009	json_object_set_new(obj, "suspended", json_integer(schedule.suspended));
4010	json_object_set_new(obj, "session", json_integer(schedule.session));
4011
4012	json_array_append_new(array, obj);
4013	}
4014
4015	json_object_set_new(root, "schedule", array);
4016
4017	dbi_result_free(result);
4018
4019	return err;
4020	}
4021
4022	static struct ev_loop *og_loop;
4023
4024	static int og_task_schedule_create(struct og_msg_params *params)
4025	{
4026	enum og_schedule_type type;
4027	uint32_t schedule_id;
4028	struct og_dbi *dbi;
4029	int err;
4030
4031	if (!strcmp(params->type, "task"))
4032	type = OG_SCHEDULE_TASK;
4033	else if (!strcmp(params->type, "command"))
4034	type = OG_SCHEDULE_COMMAND;
4035	else
4036	return -1;
4037
4038	dbi = og_dbi_open(&dbi_config);
4039	if (!dbi) {
4040	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4041	__func__, __LINE__);
4042	return -1;
4043	}
4044
4045	err = og_dbi_schedule_create(dbi, params, &schedule_id, type);
4046	if (err < 0) {
4047	og_dbi_close(dbi);
4048	return -1;
4049	}
4050	og_schedule_create(schedule_id, atoi(params->task_id), type,
4051	&params->time);
4052	og_schedule_refresh(og_loop);
4053	og_dbi_close(dbi);
4054
4055	return 0;
4056	}
4057
4058	static int og_cmd_schedule_create(json_t element, struct og_msg_params params)
4059	{
4060	const char *key;
4061	json_t *value;
4062	int err;
4063
4064	if (json_typeof(element) != JSON_OBJECT)
4065	return -1;
4066
4067	json_object_foreach(element, key, value) {
4068	if (!strcmp(key, "task")) {
4069	err = og_json_parse_string(value, &params->task_id);
4070	params->flags \|= OG_REST_PARAM_TASK;
4071	} else if (!strcmp(key, "name")) {
4072	err = og_json_parse_string(value, &params->name);
4073	params->flags \|= OG_REST_PARAM_NAME;
4074	} else if (!strcmp(key, "when")) {
4075	err = og_json_parse_time_params(value, params);
4076	} else if (!strcmp(key, "type")) {
4077	err = og_json_parse_string(value, &params->type);
4078	params->flags \|= OG_REST_PARAM_TYPE;
4079	}
4080
4081	if (err < 0)
4082	break;
4083	}
4084
4085	if (!og_msg_params_validate(params, OG_REST_PARAM_TASK \|
4086	OG_REST_PARAM_NAME \|
4087	OG_REST_PARAM_TIME_YEARS \|
4088	OG_REST_PARAM_TIME_MONTHS \|
4089	OG_REST_PARAM_TIME_WEEKS \|
4090	OG_REST_PARAM_TIME_WEEK_DAYS \|
4091	OG_REST_PARAM_TIME_DAYS \|
4092	OG_REST_PARAM_TIME_HOURS \|
4093	OG_REST_PARAM_TIME_MINUTES \|
4094	OG_REST_PARAM_TIME_AM_PM \|
4095	OG_REST_PARAM_TYPE))
4096	return -1;
4097
4098	return og_task_schedule_create(params);
4099	}
4100
4101	static int og_cmd_schedule_update(json_t element, struct og_msg_params params)
4102	{
4103	struct og_dbi *dbi;
4104	const char *key;
4105	json_t *value;
4106	int err;
4107
4108	if (json_typeof(element) != JSON_OBJECT)
4109	return -1;
4110
4111	json_object_foreach(element, key, value) {
4112	if (!strcmp(key, "id")) {
4113	err = og_json_parse_string(value, &params->id);
4114	params->flags \|= OG_REST_PARAM_ID;
4115	} else if (!strcmp(key, "task")) {
4116	err = og_json_parse_string(value, &params->task_id);
4117	params->flags \|= OG_REST_PARAM_TASK;
4118	} else if (!strcmp(key, "name")) {
4119	err = og_json_parse_string(value, &params->name);
4120	params->flags \|= OG_REST_PARAM_NAME;
4121	} else if (!strcmp(key, "when"))
4122	err = og_json_parse_time_params(value, params);
4123
4124	if (err < 0)
4125	break;
4126	}
4127
4128	if (!og_msg_params_validate(params, OG_REST_PARAM_ID \|
4129	OG_REST_PARAM_TASK \|
4130	OG_REST_PARAM_NAME \|
4131	OG_REST_PARAM_TIME_YEARS \|
4132	OG_REST_PARAM_TIME_MONTHS \|
4133	OG_REST_PARAM_TIME_DAYS \|
4134	OG_REST_PARAM_TIME_HOURS \|
4135	OG_REST_PARAM_TIME_MINUTES \|
4136	OG_REST_PARAM_TIME_AM_PM))
4137	return -1;
4138
4139	dbi = og_dbi_open(&dbi_config);
4140	if (!dbi) {
4141	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4142	__func__, __LINE__);
4143	return -1;
4144	}
4145
4146	err = og_dbi_schedule_update(dbi, params);
4147	og_dbi_close(dbi);
4148
4149	if (err < 0)
4150	return err;
4151
4152	og_schedule_update(og_loop, atoi(params->id), atoi(params->task_id),
4153	&params->time);
4154	og_schedule_refresh(og_loop);
4155
4156	return err;
4157	}
4158
4159	static int og_cmd_schedule_delete(json_t element, struct og_msg_params params)
4160	{
4161	struct og_dbi *dbi;
4162	const char *key;
4163	json_t *value;
4164	int err;
4165
4166	if (json_typeof(element) != JSON_OBJECT)
4167	return -1;
4168
4169	json_object_foreach(element, key, value) {
4170	if (!strcmp(key, "id")) {
4171	err = og_json_parse_string(value, &params->id);
4172	params->flags \|= OG_REST_PARAM_ID;
4173	} else {
4174	return -1;
4175	}
4176
4177	if (err < 0)
4178	break;
4179	}
4180
4181	if (!og_msg_params_validate(params, OG_REST_PARAM_ID))
4182	return -1;
4183
4184	dbi = og_dbi_open(&dbi_config);
4185	if (!dbi) {
4186	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4187	__func__, __LINE__);
4188	return -1;
4189	}
4190
4191	err = og_dbi_schedule_delete(dbi, atoi(params->id));
4192	og_dbi_close(dbi);
4193
4194	og_schedule_delete(og_loop, atoi(params->id));
4195
4196	return err;
4197	}
4198
4199	static int og_cmd_schedule_get(json_t element, struct og_msg_params params,
4200	char *buffer_reply)
4201	{
4202	struct og_buffer og_buffer = {
4203	.data = buffer_reply,
4204	};
4205	json_t *schedule_root;
4206	struct og_dbi *dbi;
4207	const char *key;
4208	json_t *value;
4209	int err;
4210
4211	if (element) {
4212	if (json_typeof(element) != JSON_OBJECT)
4213	return -1;
4214
4215	json_object_foreach(element, key, value) {
4216	if (!strcmp(key, "task")) {
4217	err = og_json_parse_string(value,
4218	&params->task_id);
4219	} else if (!strcmp(key, "id")) {
4220	err = og_json_parse_string(value, &params->id);
4221	} else {
4222	return -1;
4223	}
4224
4225	if (err < 0)
4226	break;
4227	}
4228	}
4229
4230	dbi = og_dbi_open(&dbi_config);
4231	if (!dbi) {
4232	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4233	__func__, __LINE__);
4234	return -1;
4235	}
4236
4237	schedule_root = json_object();
4238	if (!schedule_root) {
4239	og_dbi_close(dbi);
4240	return -1;
4241	}
4242
4243	err = og_dbi_schedule_get_json(dbi, schedule_root,
4244	params->task_id, params->id);
4245	og_dbi_close(dbi);
4246
4247	if (err >= 0)
4248	json_dump_callback(schedule_root, og_json_dump_clients, &og_buffer, 0);
4249
4250	json_decref(schedule_root);
4251
4252	return err;
4253	}
4254
4255	static int og_client_method_not_found(struct og_client *cli)
4256	{
4257	/* To meet RFC 7231, this function MUST generate an Allow header field
4258	* containing the correct methods. For example: "Allow: POST\r\n"
4259	*/
4260	char buf[] = "HTTP/1.1 405 Method Not Allowed\r\n"
4261	"Content-Length: 0\r\n\r\n";
4262
4263	send(og_client_socket(cli), buf, strlen(buf), 0);
4264
4265	return -1;
4266	}
4267
4268	static int og_client_bad_request(struct og_client *cli)
4269	{
4270	char buf[] = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n";
4271
4272	send(og_client_socket(cli), buf, strlen(buf), 0);
4273
4274	return -1;
4275	}
4276
4277	static int og_client_not_found(struct og_client *cli)
4278	{
4279	char buf[] = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n";
4280
4281	send(og_client_socket(cli), buf, strlen(buf), 0);
4282
4283	return -1;
4284	}
4285
4286	static int og_client_not_authorized(struct og_client *cli)
4287	{
4288	char buf[] = "HTTP/1.1 401 Unauthorized\r\n"
4289	"WWW-Authenticate: Basic\r\n"
4290	"Content-Length: 0\r\n\r\n";
4291
4292	send(og_client_socket(cli), buf, strlen(buf), 0);
4293
4294	return -1;
4295	}
4296
4297	static int og_server_internal_error(struct og_client *cli)
4298	{
4299	char buf[] = "HTTP/1.1 500 Internal Server Error\r\n"
4300	"Content-Length: 0\r\n\r\n";
4301
4302	send(og_client_socket(cli), buf, strlen(buf), 0);
4303
4304	return -1;
4305	}
4306
4307	static int og_client_payload_too_large(struct og_client *cli)
4308	{
4309	char buf[] = "HTTP/1.1 413 Payload Too Large\r\n"
4310	"Content-Length: 0\r\n\r\n";
4311
4312	send(og_client_socket(cli), buf, strlen(buf), 0);
4313
4314	return -1;
4315	}
4316
4317	#define OG_MSG_RESPONSE_MAXLEN 65536
4318
4319	static int og_client_ok(struct og_client cli, char buf_reply)
4320	{
4321	char buf[OG_MSG_RESPONSE_MAXLEN] = {};
4322	int err = 0, len;
4323
4324	len = snprintf(buf, sizeof(buf),
4325	"HTTP/1.1 200 OK\r\nContent-Length: %ld\r\n\r\n%s",
4326	strlen(buf_reply), buf_reply);
4327	if (len >= (int)sizeof(buf))
4328	err = og_server_internal_error(cli);
4329
4330	send(og_client_socket(cli), buf, strlen(buf), 0);
4331
4332	return err;
4333	}
4334
4335	static int og_client_state_process_payload_rest(struct og_client *cli)
4336	{
4337	char buf_reply[OG_MSG_RESPONSE_MAXLEN] = {};
4338	struct og_msg_params params = {};
4339	enum og_rest_method method;
4340	const char cmd, body;
4341	json_error_t json_err;
4342	json_t *root = NULL;
4343	int err = 0;
4344
4345	syslog(LOG_DEBUG, "%s:%hu %.32s ...\n",
4346	inet_ntoa(cli->addr.sin_addr),
4347	ntohs(cli->addr.sin_port), cli->buf);
4348
4349	if (!strncmp(cli->buf, "GET", strlen("GET"))) {
4350	method = OG_METHOD_GET;
4351	cmd = cli->buf + strlen("GET") + 2;
4352	} else if (!strncmp(cli->buf, "POST", strlen("POST"))) {
4353	method = OG_METHOD_POST;
4354	cmd = cli->buf + strlen("POST") + 2;
4355	} else
4356	return og_client_method_not_found(cli);
4357
4358	body = strstr(cli->buf, "\r\n\r\n") + 4;
4359
4360	if (strcmp(cli->auth_token, auth_token)) {
4361	syslog(LOG_ERR, "wrong Authentication key\n");
4362	return og_client_not_authorized(cli);
4363	}
4364
4365	if (cli->content_length) {
4366	root = json_loads(body, 0, &json_err);
4367	if (!root) {
4368	syslog(LOG_ERR, "malformed json line %d: %s\n",
4369	json_err.line, json_err.text);
4370	return og_client_not_found(cli);
4371	}
4372	}
4373
4374	if (!strncmp(cmd, "clients", strlen("clients"))) {
4375	if (method != OG_METHOD_POST &&
4376	method != OG_METHOD_GET)
4377	return og_client_method_not_found(cli);
4378
4379	if (method == OG_METHOD_POST && !root) {
4380	syslog(LOG_ERR, "command clients with no payload\n");
4381	return og_client_bad_request(cli);
4382	}
4383	switch (method) {
4384	case OG_METHOD_POST:
4385	err = og_cmd_post_clients(root, &params);
4386	break;
4387	case OG_METHOD_GET:
4388	err = og_cmd_get_clients(root, &params, buf_reply);
4389	break;
4390	default:
4391	return og_client_bad_request(cli);
4392	}
4393	} else if (!strncmp(cmd, "wol", strlen("wol"))) {
4394	if (method != OG_METHOD_POST)
4395	return og_client_method_not_found(cli);
4396
4397	if (!root) {
4398	syslog(LOG_ERR, "command wol with no payload\n");
4399	return og_client_bad_request(cli);
4400	}
4401	err = og_cmd_wol(root, &params);
4402	} else if (!strncmp(cmd, "shell/run", strlen("shell/run"))) {
4403	if (method != OG_METHOD_POST)
4404	return og_client_method_not_found(cli);
4405
4406	if (!root) {
4407	syslog(LOG_ERR, "command run with no payload\n");
4408	return og_client_bad_request(cli);
4409	}
4410	err = og_cmd_run_post(root, &params);
4411	} else if (!strncmp(cmd, "shell/output", strlen("shell/output"))) {
4412	if (method != OG_METHOD_POST)
4413	return og_client_method_not_found(cli);
4414
4415	if (!root) {
4416	syslog(LOG_ERR, "command output with no payload\n");
4417	return og_client_bad_request(cli);
4418	}
4419
4420	err = og_cmd_run_get(root, &params, buf_reply);
4421	} else if (!strncmp(cmd, "session", strlen("session"))) {
4422	if (method != OG_METHOD_POST)
4423	return og_client_method_not_found(cli);
4424
4425	if (!root) {
4426	syslog(LOG_ERR, "command session with no payload\n");
4427	return og_client_bad_request(cli);
4428	}
4429	err = og_cmd_session(root, &params);
4430	} else if (!strncmp(cmd, "poweroff", strlen("poweroff"))) {
4431	if (method != OG_METHOD_POST)
4432	return og_client_method_not_found(cli);
4433
4434	if (!root) {
4435	syslog(LOG_ERR, "command poweroff with no payload\n");
4436	return og_client_bad_request(cli);
4437	}
4438	err = og_cmd_poweroff(root, &params);
4439	} else if (!strncmp(cmd, "reboot", strlen("reboot"))) {
4440	if (method != OG_METHOD_POST)
4441	return og_client_method_not_found(cli);
4442
4443	if (!root) {
4444	syslog(LOG_ERR, "command reboot with no payload\n");
4445	return og_client_bad_request(cli);
4446	}
4447	err = og_cmd_reboot(root, &params);
4448	} else if (!strncmp(cmd, "stop", strlen("stop"))) {
4449	if (method != OG_METHOD_POST)
4450	return og_client_method_not_found(cli);
4451
4452	if (!root) {
4453	syslog(LOG_ERR, "command stop with no payload\n");
4454	return og_client_bad_request(cli);
4455	}
4456	err = og_cmd_stop(root, &params);
4457	} else if (!strncmp(cmd, "refresh", strlen("refresh"))) {
4458	if (method != OG_METHOD_POST)
4459	return og_client_method_not_found(cli);
4460
4461	if (!root) {
4462	syslog(LOG_ERR, "command refresh with no payload\n");
4463	return og_client_bad_request(cli);
4464	}
4465	err = og_cmd_refresh(root, &params);
4466	} else if (!strncmp(cmd, "hardware", strlen("hardware"))) {
4467	if (method != OG_METHOD_POST)
4468	return og_client_method_not_found(cli);
4469
4470	if (!root) {
4471	syslog(LOG_ERR, "command hardware with no payload\n");
4472	return og_client_bad_request(cli);
4473	}
4474	err = og_cmd_hardware(root, &params);
4475	} else if (!strncmp(cmd, "software", strlen("software"))) {
4476	if (method != OG_METHOD_POST)
4477	return og_client_method_not_found(cli);
4478
4479	if (!root) {
4480	syslog(LOG_ERR, "command software with no payload\n");
4481	return og_client_bad_request(cli);
4482	}
4483	err = og_cmd_software(root, &params);
4484	} else if (!strncmp(cmd, "image/create/basic",
4485	strlen("image/create/basic"))) {
4486	if (method != OG_METHOD_POST)
4487	return og_client_method_not_found(cli);
4488
4489	if (!root) {
4490	syslog(LOG_ERR, "command create with no payload\n");
4491	return og_client_bad_request(cli);
4492	}
4493	err = og_cmd_create_basic_image(root, &params);
4494	} else if (!strncmp(cmd, "image/create/incremental",
4495	strlen("image/create/incremental"))) {
4496	if (method != OG_METHOD_POST)
4497	return og_client_method_not_found(cli);
4498
4499	if (!root) {
4500	syslog(LOG_ERR, "command create with no payload\n");
4501	return og_client_bad_request(cli);
4502	}
4503	err = og_cmd_create_incremental_image(root, &params);
4504	} else if (!strncmp(cmd, "image/create", strlen("image/create"))) {
4505	if (method != OG_METHOD_POST)
4506	return og_client_method_not_found(cli);
4507
4508	if (!root) {
4509	syslog(LOG_ERR, "command create with no payload\n");
4510	return og_client_bad_request(cli);
4511	}
4512	err = og_cmd_create_image(root, &params);
4513	} else if (!strncmp(cmd, "image/restore/basic",
4514	strlen("image/restore/basic"))) {
4515	if (method != OG_METHOD_POST)
4516	return og_client_method_not_found(cli);
4517
4518	if (!root) {
4519	syslog(LOG_ERR, "command create with no payload\n");
4520	return og_client_bad_request(cli);
4521	}
4522	err = og_cmd_restore_basic_image(root, &params);
4523	} else if (!strncmp(cmd, "image/restore/incremental",
4524	strlen("image/restore/incremental"))) {
4525	if (method != OG_METHOD_POST)
4526	return og_client_method_not_found(cli);
4527
4528	if (!root) {
4529	syslog(LOG_ERR, "command create with no payload\n");
4530	return og_client_bad_request(cli);
4531	}
4532	err = og_cmd_restore_incremental_image(root, &params);
4533	} else if (!strncmp(cmd, "image/restore", strlen("image/restore"))) {
4534	if (method != OG_METHOD_POST)
4535	return og_client_method_not_found(cli);
4536
4537	if (!root) {
4538	syslog(LOG_ERR, "command create with no payload\n");
4539	return og_client_bad_request(cli);
4540	}
4541	err = og_cmd_restore_image(root, &params);
4542	} else if (!strncmp(cmd, "setup", strlen("setup"))) {
4543	if (method != OG_METHOD_POST)
4544	return og_client_method_not_found(cli);
4545
4546	if (!root) {
4547	syslog(LOG_ERR, "command create with no payload\n");
4548	return og_client_bad_request(cli);
4549	}
4550	err = og_cmd_setup(root, &params);
4551	} else if (!strncmp(cmd, "run/schedule", strlen("run/schedule"))) {
4552	if (method != OG_METHOD_POST)
4553	return og_client_method_not_found(cli);
4554
4555	if (!root) {
4556	syslog(LOG_ERR, "command create with no payload\n");
4557	return og_client_bad_request(cli);
4558	}
4559
4560	err = og_cmd_run_schedule(root, &params);
4561	} else if (!strncmp(cmd, "task/run", strlen("task/run"))) {
4562	if (method != OG_METHOD_POST)
4563	return og_client_method_not_found(cli);
4564
4565	if (!root) {
4566	syslog(LOG_ERR, "command task with no payload\n");
4567	return og_client_bad_request(cli);
4568	}
4569	err = og_cmd_task_post(root, &params);
4570	} else if (!strncmp(cmd, "schedule/create",
4571	strlen("schedule/create"))) {
4572	if (method != OG_METHOD_POST)
4573	return og_client_method_not_found(cli);
4574
4575	if (!root) {
4576	syslog(LOG_ERR, "command task with no payload\n");
4577	return og_client_bad_request(cli);
4578	}
4579	err = og_cmd_schedule_create(root, &params);
4580	} else if (!strncmp(cmd, "schedule/delete",
4581	strlen("schedule/delete"))) {
4582	if (method != OG_METHOD_POST)
4583	return og_client_method_not_found(cli);
4584
4585	if (!root) {
4586	syslog(LOG_ERR, "command task with no payload\n");
4587	return og_client_bad_request(cli);
4588	}
4589	err = og_cmd_schedule_delete(root, &params);
4590	} else if (!strncmp(cmd, "schedule/update",
4591	strlen("schedule/update"))) {
4592	if (method != OG_METHOD_POST)
4593	return og_client_method_not_found(cli);
4594
4595	if (!root) {
4596	syslog(LOG_ERR, "command task with no payload\n");
4597	return og_client_bad_request(cli);
4598	}
4599	err = og_cmd_schedule_update(root, &params);
4600	} else if (!strncmp(cmd, "schedule/get",
4601	strlen("schedule/get"))) {
4602	if (method != OG_METHOD_POST)
4603	return og_client_method_not_found(cli);
4604
4605	err = og_cmd_schedule_get(root, &params, buf_reply);
4606	} else {
4607	syslog(LOG_ERR, "unknown command: %.32s ...\n", cmd);
4608	err = og_client_not_found(cli);
4609	}
4610
4611	if (root)
4612	json_decref(root);
4613
4614	if (err < 0)
4615	return og_client_bad_request(cli);
4616
4617	err = og_client_ok(cli, buf_reply);
4618	if (err < 0) {
4619	syslog(LOG_ERR, "HTTP response to %s:%hu is too large\n",
4620	inet_ntoa(cli->addr.sin_addr),
4621	ntohs(cli->addr.sin_port));
4622	}
4623
4624	return err;
4625	}
4626
4627	static int og_client_state_recv_hdr_rest(struct og_client *cli)
4628	{
4629	char *ptr;
4630
4631	ptr = strstr(cli->buf, "\r\n\r\n");
4632	if (!ptr)
4633	return 0;
4634
4635	cli->msg_len = ptr - cli->buf + 4;
4636
4637	ptr = strstr(cli->buf, "Content-Length: ");
4638	if (ptr) {
4639	sscanf(ptr, "Content-Length: %i[^\r\n]", &cli->content_length);
4640	if (cli->content_length < 0)
4641	return -1;
4642	cli->msg_len += cli->content_length;
4643	}
4644
4645	ptr = strstr(cli->buf, "Authorization: ");
4646	if (ptr)
4647	sscanf(ptr, "Authorization: %63[^\r\n]", cli->auth_token);
4648
4649	return 1;
4650	}
4651
4652	static int og_client_recv(struct og_client *cli, int events)
4653	{
4654	struct ev_io *io = &cli->io;
4655	int ret;
4656
4657	if (events & EV_ERROR) {
4658	syslog(LOG_ERR, "unexpected error event from client %s:%hu\n",
4659	inet_ntoa(cli->addr.sin_addr),
4660	ntohs(cli->addr.sin_port));
4661	return 0;
4662	}
4663
4664	ret = recv(io->fd, cli->buf + cli->buf_len,
4665	sizeof(cli->buf) - cli->buf_len, 0);
4666	if (ret <= 0) {
4667	if (ret < 0) {
4668	syslog(LOG_ERR, "error reading from client %s:%hu (%s)\n",
4669	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
4670	strerror(errno));
4671	} else {
4672	syslog(LOG_DEBUG, "closed connection by %s:%hu\n",
4673	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
4674	}
4675	return ret;
4676	}
4677
4678	return ret;
4679	}
4680
4681	static void og_client_read_cb(struct ev_loop loop, struct ev_io io, int events)
4682	{
4683	struct og_client *cli;
4684	int ret;
4685
4686	cli = container_of(io, struct og_client, io);
4687
4688	ret = og_client_recv(cli, events);
4689	if (ret <= 0)
4690	goto close;
4691
4692	if (cli->keepalive_idx >= 0)
4693	return;
4694
4695	ev_timer_again(loop, &cli->timer);
4696
4697	cli->buf_len += ret;
4698	if (cli->buf_len >= sizeof(cli->buf)) {
4699	syslog(LOG_ERR, "client request from %s:%hu is too long\n",
4700	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
4701	og_client_payload_too_large(cli);
4702	goto close;
4703	}
4704
4705	switch (cli->state) {
4706	case OG_CLIENT_RECEIVING_HEADER:
4707	ret = og_client_state_recv_hdr_rest(cli);
4708	if (ret < 0)
4709	goto close;
4710	if (!ret)
4711	return;
4712
4713	cli->state = OG_CLIENT_RECEIVING_PAYLOAD;
4714	/* Fall through. */
4715	case OG_CLIENT_RECEIVING_PAYLOAD:
4716	/* Still not enough data to process request. */
4717	if (cli->buf_len < cli->msg_len)
4718	return;
4719
4720	cli->state = OG_CLIENT_PROCESSING_REQUEST;
4721	/* fall through. */
4722	case OG_CLIENT_PROCESSING_REQUEST:
4723	ret = og_client_state_process_payload_rest(cli);
4724	if (ret < 0) {
4725	syslog(LOG_ERR, "Failed to process HTTP request from %s:%hu\n",
4726	inet_ntoa(cli->addr.sin_addr),
4727	ntohs(cli->addr.sin_port));
4728	}
4729	if (ret < 0)
4730	goto close;
4731
4732	if (cli->keepalive_idx < 0) {
4733	syslog(LOG_DEBUG, "server closing connection to %s:%hu\n",
4734	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
4735	goto close;
4736	} else {
4737	syslog(LOG_DEBUG, "leaving client %s:%hu in keepalive mode\n",
4738	inet_ntoa(cli->addr.sin_addr),
4739	ntohs(cli->addr.sin_port));
4740	og_client_keepalive(loop, cli);
4741	og_client_reset_state(cli);
4742	}
4743	break;
4744	default:
4745	syslog(LOG_ERR, "unknown state, critical internal error\n");
4746	goto close;
4747	}
4748	return;
4749	close:
4750	ev_timer_stop(loop, &cli->timer);
4751	og_client_release(loop, cli);
4752	}
4753
4754	enum og_agent_state {
4755	OG_AGENT_RECEIVING_HEADER = 0,
4756	OG_AGENT_RECEIVING_PAYLOAD,
4757	OG_AGENT_PROCESSING_RESPONSE,
4758	};
4759
4760	static int og_agent_state_recv_hdr_rest(struct og_client *cli)
4761	{
4762	char *ptr;
4763
4764	ptr = strstr(cli->buf, "\r\n\r\n");
4765	if (!ptr)
4766	return 0;
4767
4768	cli->msg_len = ptr - cli->buf + 4;
4769
4770	ptr = strstr(cli->buf, "Content-Length: ");
4771	if (ptr) {
4772	sscanf(ptr, "Content-Length: %i[^\r\n]", &cli->content_length);
4773	if (cli->content_length < 0)
4774	return -1;
4775	cli->msg_len += cli->content_length;
4776	}
4777
4778	return 1;
4779	}
4780
4781	static void og_agent_reset_state(struct og_client *cli)
4782	{
4783	cli->state = OG_AGENT_RECEIVING_HEADER;
4784	cli->buf_len = 0;
4785	cli->content_length = 0;
4786	memset(cli->buf, 0, sizeof(cli->buf));
4787	}
4788
4789	static int og_dbi_get_computer_info(struct og_computer *computer,
4790	struct in_addr addr)
4791	{
4792	const char *msglog;
4793	struct og_dbi *dbi;
4794	dbi_result result;
4795
4796	dbi = og_dbi_open(&dbi_config);
4797	if (!dbi) {
4798	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4799	__func__, __LINE__);
4800	return -1;
4801	}
4802	result = dbi_conn_queryf(dbi->conn,
4803	"SELECT ordenadores.idordenador,"
4804	" ordenadores.nombreordenador,"
4805	" ordenadores.idaula,"
4806	" centros.idcentro FROM ordenadores "
4807	"INNER JOIN aulas ON aulas.idaula=ordenadores.idaula "
4808	"INNER JOIN centros ON centros.idcentro=aulas.idcentro "
4809	"WHERE ordenadores.ip='%s'", inet_ntoa(addr));
4810	if (!result) {
4811	dbi_conn_error(dbi->conn, &msglog);
4812	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
4813	__func__, __LINE__, msglog);
4814	og_dbi_close(dbi);
4815	return -1;
4816	}
4817	if (!dbi_result_next_row(result)) {
4818	syslog(LOG_ERR, "client does not exist in database (%s:%d)\n",
4819	__func__, __LINE__);
4820	dbi_result_free(result);
4821	og_dbi_close(dbi);
4822	return -1;
4823	}
4824
4825	computer->id = dbi_result_get_uint(result, "idordenador");
4826	computer->center = dbi_result_get_uint(result, "idcentro");
4827	computer->room = dbi_result_get_uint(result, "idaula");
4828	strncpy(computer->name,
4829	dbi_result_get_string(result, "nombreordenador"),
4830	OG_COMPUTER_NAME_MAXLEN);
4831
4832	dbi_result_free(result);
4833	og_dbi_close(dbi);
4834
4835	return 0;
4836	}
4837
4838	static int og_resp_probe(struct og_client cli, json_t data)
4839	{
4840	const char *status = NULL;
4841	const char *key;
4842	json_t *value;
4843	int err = 0;
4844
4845	if (json_typeof(data) != JSON_OBJECT)
4846	return -1;
4847
4848	json_object_foreach(data, key, value) {
4849	if (!strcmp(key, "status")) {
4850	err = og_json_parse_string(value, &status);
4851	if (err < 0)
4852	return err;
4853	} else {
4854	return -1;
4855	}
4856	}
4857
4858	if (!strcmp(status, "BSY"))
4859	cli->status = OG_CLIENT_STATUS_BUSY;
4860	else if (!strcmp(status, "OPG"))
4861	cli->status = OG_CLIENT_STATUS_OGLIVE;
4862
4863	return status ? 0 : -1;
4864	}
4865
4866	static int og_resp_shell_run(struct og_client cli, json_t data)
4867	{
4868	const char *output = NULL;
4869	char filename[4096];
4870	const char *key;
4871	json_t *value;
4872	int err = -1;
4873	FILE *file;
4874
4875	if (json_typeof(data) != JSON_OBJECT)
4876	return -1;
4877
4878	json_object_foreach(data, key, value) {
4879	if (!strcmp(key, "out")) {
4880	err = og_json_parse_string(value, &output);
4881	if (err < 0)
4882	return err;
4883	} else {
4884	return -1;
4885	}
4886	}
4887
4888	if (!output) {
4889	syslog(LOG_ERR, "%s:%d: malformed json response\n",
4890	__FILE__, __LINE__);
4891	return -1;
4892	}
4893
4894	sprintf(filename, "/tmp/_Seconsola_%s", inet_ntoa(cli->addr.sin_addr));
4895	file = fopen(filename, "wt");
4896	if (!file) {
4897	syslog(LOG_ERR, "cannot open file %s: %s\n",
4898	filename, strerror(errno));
4899	return -1;
4900	}
4901
4902	fprintf(file, "%s", output);
4903	fclose(file);
4904
4905	return 0;
4906	}
4907
4908	struct og_computer_legacy {
4909	char center[OG_DB_INT_MAXLEN + 1];
4910	char id[OG_DB_INT_MAXLEN + 1];
4911	char hardware[8192];
4912	};
4913
4914	static int og_resp_hardware(json_t data, struct og_client cli)
4915	{
4916	struct og_computer_legacy legacy = {};
4917	const char *hardware = NULL;
4918	struct og_computer computer;
4919	struct og_dbi *dbi;
4920	const char *key;
4921	json_t *value;
4922	int err = 0;
4923	bool res;
4924
4925	if (json_typeof(data) != JSON_OBJECT)
4926	return -1;
4927
4928	json_object_foreach(data, key, value) {
4929	if (!strcmp(key, "hardware")) {
4930	err = og_json_parse_string(value, &hardware);
4931	if (err < 0)
4932	return -1;
4933	} else {
4934	return -1;
4935	}
4936	}
4937
4938	if (!hardware) {
4939	syslog(LOG_ERR, "malformed response json\n");
4940	return -1;
4941	}
4942
4943	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
4944	if (err < 0)
4945	return -1;
4946
4947	snprintf(legacy.center, sizeof(legacy.center), "%d", computer.center);
4948	snprintf(legacy.id, sizeof(legacy.id), "%d", computer.id);
4949	snprintf(legacy.hardware, sizeof(legacy.hardware), "%s", hardware);
4950
4951	dbi = og_dbi_open(&dbi_config);
4952	if (!dbi) {
4953	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4954	__func__, __LINE__);
4955	return -1;
4956	}
4957
4958	res = actualizaHardware(dbi, legacy.hardware, legacy.id, computer.name,
4959	legacy.center);
4960	og_dbi_close(dbi);
4961
4962	if (!res) {
4963	syslog(LOG_ERR, "Problem updating client configuration\n");
4964	return -1;
4965	}
4966
4967	return 0;
4968	}
4969
4970	struct og_software_legacy {
4971	char software[8192];
4972	char center[OG_DB_INT_MAXLEN + 1];
4973	char part[OG_DB_SMALLINT_MAXLEN + 1];
4974	char id[OG_DB_INT_MAXLEN + 1];
4975	};
4976
4977	static int og_resp_software(json_t data, struct og_client cli)
4978	{
4979	struct og_software_legacy legacy = {};
4980	const char *partition = NULL;
4981	const char *software = NULL;
4982	struct og_computer computer;
4983	struct og_dbi *dbi;
4984	const char *key;
4985	json_t *value;
4986	int err = 0;
4987	bool res;
4988
4989	if (json_typeof(data) != JSON_OBJECT)
4990	return -1;
4991
4992	json_object_foreach(data, key, value) {
4993	if (!strcmp(key, "software"))
4994	err = og_json_parse_string(value, &software);
4995	else if (!strcmp(key, "partition"))
4996	err = og_json_parse_string(value, &partition);
4997	else
4998	return -1;
4999
5000	if (err < 0)
5001	return -1;
5002	}
5003
5004	if (!software \|\| !partition) {
5005	syslog(LOG_ERR, "malformed response json\n");
5006	return -1;
5007	}
5008
5009	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5010	if (err < 0)
5011	return -1;
5012
5013	snprintf(legacy.software, sizeof(legacy.software), "%s", software);
5014	snprintf(legacy.part, sizeof(legacy.part), "%s", partition);
5015	snprintf(legacy.id, sizeof(legacy.id), "%d", computer.id);
5016	snprintf(legacy.center, sizeof(legacy.center), "%d", computer.center);
5017
5018	dbi = og_dbi_open(&dbi_config);
5019	if (!dbi) {
5020	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5021	__func__, __LINE__);
5022	return -1;
5023	}
5024
5025	res = actualizaSoftware(dbi, legacy.software, legacy.part, legacy.id,
5026	computer.name, legacy.center);
5027	og_dbi_close(dbi);
5028
5029	if (!res) {
5030	syslog(LOG_ERR, "Problem updating client configuration\n");
5031	return -1;
5032	}
5033
5034	return 0;
5035	}
5036
5037	#define OG_PARAMS_RESP_REFRESH (OG_PARAM_PART_DISK \| \
5038	OG_PARAM_PART_NUMBER \| \
5039	OG_PARAM_PART_CODE \| \
5040	OG_PARAM_PART_FILESYSTEM \| \
5041	OG_PARAM_PART_OS \| \
5042	OG_PARAM_PART_SIZE \| \
5043	OG_PARAM_PART_USED_SIZE)
5044
5045	static int og_json_parse_partition_array(json_t *value,
5046	struct og_partition *partitions)
5047	{
5048	json_t *element;
5049	int i, err;
5050
5051	if (json_typeof(value) != JSON_ARRAY)
5052	return -1;
5053
5054	for (i = 0; i < json_array_size(value) && i < OG_PARTITION_MAX; i++) {
5055	element = json_array_get(value, i);
5056
5057	err = og_json_parse_partition(element, &partitions[i],
5058	OG_PARAMS_RESP_REFRESH);
5059	if (err < 0)
5060	return err;
5061	}
5062
5063	return 0;
5064	}
5065
5066	static int og_resp_refresh(json_t data, struct og_client cli)
5067	{
5068	struct og_partition partitions[OG_PARTITION_MAX] = {};
5069	const char *serial_number = NULL;
5070	struct og_partition disk_setup;
5071	struct og_computer computer;
5072	char cfg[1024] = {};
5073	struct og_dbi *dbi;
5074	const char *key;
5075	unsigned int i;
5076	json_t *value;
5077	int err = 0;
5078	bool res;
5079
5080	if (json_typeof(data) != JSON_OBJECT)
5081	return -1;
5082
5083	json_object_foreach(data, key, value) {
5084	if (!strcmp(key, "disk_setup")) {
5085	err = og_json_parse_partition(value,
5086	&disk_setup,
5087	OG_PARAMS_RESP_REFRESH);
5088	} else if (!strcmp(key, "partition_setup")) {
5089	err = og_json_parse_partition_array(value, partitions);
5090	} else if (!strcmp(key, "serial_number")) {
5091	err = og_json_parse_string(value, &serial_number);
5092	} else {
5093	return -1;
5094	}
5095
5096	if (err < 0)
5097	return err;
5098	}
5099
5100	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5101	if (err < 0)
5102	return -1;
5103
5104	if (strlen(serial_number) > 0)
5105	snprintf(cfg, sizeof(cfg), "ser=%s\n", serial_number);
5106
5107	if (!disk_setup.disk \|\| !disk_setup.number \|\| !disk_setup.code \|\|
5108	!disk_setup.filesystem \|\| !disk_setup.os \|\| !disk_setup.size \|\|
5109	!disk_setup.used_size)
5110	return -1;
5111
5112	snprintf(cfg + strlen(cfg), sizeof(cfg) - strlen(cfg),
5113	"disk=%s\tpar=%s\tcpt=%s\tfsi=%s\tsoi=%s\ttam=%s\tuso=%s\n",
5114	disk_setup.disk, disk_setup.number, disk_setup.code,
5115	disk_setup.filesystem, disk_setup.os, disk_setup.size,
5116	disk_setup.used_size);
5117
5118	for (i = 0; i < OG_PARTITION_MAX; i++) {
5119	if (!partitions[i].disk \|\| !partitions[i].number \|\|
5120	!partitions[i].code \|\| !partitions[i].filesystem \|\|
5121	!partitions[i].os \|\| !partitions[i].size \|\|
5122	!partitions[i].used_size)
5123	continue;
5124
5125	snprintf(cfg + strlen(cfg), sizeof(cfg) - strlen(cfg),
5126	"disk=%s\tpar=%s\tcpt=%s\tfsi=%s\tsoi=%s\ttam=%s\tuso=%s\n",
5127	partitions[i].disk, partitions[i].number,
5128	partitions[i].code, partitions[i].filesystem,
5129	partitions[i].os, partitions[i].size,
5130	partitions[i].used_size);
5131	}
5132
5133	dbi = og_dbi_open(&dbi_config);
5134	if (!dbi) {
5135	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5136	__func__, __LINE__);
5137	return -1;
5138	}
5139	res = actualizaConfiguracion(dbi, cfg, computer.id);
5140	og_dbi_close(dbi);
5141
5142	if (!res) {
5143	syslog(LOG_ERR, "Problem updating client configuration\n");
5144	return -1;
5145	}
5146
5147	return 0;
5148	}
5149
5150	static int og_resp_image_create(json_t data, struct og_client cli)
5151	{
5152	struct og_software_legacy soft_legacy;
5153	struct og_image_legacy img_legacy;
5154	const char *partition = NULL;
5155	const char *software = NULL;
5156	const char *image_id = NULL;
5157	struct og_computer computer;
5158	const char *disk = NULL;
5159	const char *code = NULL;
5160	const char *name = NULL;
5161	const char *repo = NULL;
5162	struct og_dbi *dbi;
5163	const char *key;
5164	json_t *value;
5165	int err = 0;
5166	bool res;
5167
5168	if (json_typeof(data) != JSON_OBJECT)
5169	return -1;
5170
5171	json_object_foreach(data, key, value) {
5172	if (!strcmp(key, "software"))
5173	err = og_json_parse_string(value, &software);
5174	else if (!strcmp(key, "partition"))
5175	err = og_json_parse_string(value, &partition);
5176	else if (!strcmp(key, "disk"))
5177	err = og_json_parse_string(value, &disk);
5178	else if (!strcmp(key, "code"))
5179	err = og_json_parse_string(value, &code);
5180	else if (!strcmp(key, "id"))
5181	err = og_json_parse_string(value, &image_id);
5182	else if (!strcmp(key, "name"))
5183	err = og_json_parse_string(value, &name);
5184	else if (!strcmp(key, "repository"))
5185	err = og_json_parse_string(value, &repo);
5186	else
5187	return -1;
5188
5189	if (err < 0)
5190	return err;
5191	}
5192
5193	if (!software \|\| !partition \|\| !disk \|\| !code \|\| !image_id \|\| !name \|\|
5194	!repo) {
5195	syslog(LOG_ERR, "malformed response json\n");
5196	return -1;
5197	}
5198
5199	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5200	if (err < 0)
5201	return -1;
5202
5203	snprintf(soft_legacy.center, sizeof(soft_legacy.center), "%d",
5204	computer.center);
5205	snprintf(soft_legacy.software, sizeof(soft_legacy.software), "%s",
5206	software);
5207	snprintf(img_legacy.image_id, sizeof(img_legacy.image_id), "%s",
5208	image_id);
5209	snprintf(soft_legacy.id, sizeof(soft_legacy.id), "%d", computer.id);
5210	snprintf(img_legacy.part, sizeof(img_legacy.part), "%s", partition);
5211	snprintf(img_legacy.disk, sizeof(img_legacy.disk), "%s", disk);
5212	snprintf(img_legacy.code, sizeof(img_legacy.code), "%s", code);
5213	snprintf(img_legacy.name, sizeof(img_legacy.name), "%s", name);
5214	snprintf(img_legacy.repo, sizeof(img_legacy.repo), "%s", repo);
5215
5216	dbi = og_dbi_open(&dbi_config);
5217	if (!dbi) {
5218	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5219	__func__, __LINE__);
5220	return -1;
5221	}
5222
5223	res = actualizaSoftware(dbi,
5224	soft_legacy.software,
5225	img_legacy.part,
5226	soft_legacy.id,
5227	computer.name,
5228	soft_legacy.center);
5229	if (!res) {
5230	og_dbi_close(dbi);
5231	syslog(LOG_ERR, "Problem updating client configuration\n");
5232	return -1;
5233	}
5234
5235	res = actualizaCreacionImagen(dbi,
5236	img_legacy.image_id,
5237	img_legacy.disk,
5238	img_legacy.part,
5239	img_legacy.code,
5240	img_legacy.repo,
5241	soft_legacy.id);
5242	og_dbi_close(dbi);
5243
5244	if (!res) {
5245	syslog(LOG_ERR, "Problem updating client configuration\n");
5246	return -1;
5247	}
5248
5249	return 0;
5250	}
5251
5252	static int og_resp_image_restore(json_t data, struct og_client cli)
5253	{
5254	struct og_software_legacy soft_legacy;
5255	struct og_image_legacy img_legacy;
5256	const char *partition = NULL;
5257	const char *image_id = NULL;
5258	struct og_computer computer;
5259	const char *disk = NULL;
5260	dbi_result query_result;
5261	struct og_dbi *dbi;
5262	const char *key;
5263	json_t *value;
5264	int err = 0;
5265	bool res;
5266
5267	if (json_typeof(data) != JSON_OBJECT)
5268	return -1;
5269
5270	json_object_foreach(data, key, value) {
5271	if (!strcmp(key, "partition"))
5272	err = og_json_parse_string(value, &partition);
5273	else if (!strcmp(key, "disk"))
5274	err = og_json_parse_string(value, &disk);
5275	else if (!strcmp(key, "image_id"))
5276	err = og_json_parse_string(value, &image_id);
5277	else
5278	return -1;
5279
5280	if (err < 0)
5281	return err;
5282	}
5283
5284	if (!partition \|\| !disk \|\| !image_id) {
5285	syslog(LOG_ERR, "malformed response json\n");
5286	return -1;
5287	}
5288
5289	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5290	if (err < 0)
5291	return -1;
5292
5293	snprintf(img_legacy.image_id, sizeof(img_legacy.image_id), "%s",
5294	image_id);
5295	snprintf(img_legacy.part, sizeof(img_legacy.part), "%s", partition);
5296	snprintf(img_legacy.disk, sizeof(img_legacy.disk), "%s", disk);
5297	snprintf(soft_legacy.id, sizeof(soft_legacy.id), "%d", computer.id);
5298
5299	dbi = og_dbi_open(&dbi_config);
5300	if (!dbi) {
5301	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5302	__func__, __LINE__);
5303	return -1;
5304	}
5305
5306	query_result = dbi_conn_queryf(dbi->conn,
5307	"SELECT idperfilsoft FROM imagenes "
5308	" WHERE idimagen='%s'",
5309	image_id);
5310	if (!query_result) {
5311	og_dbi_close(dbi);
5312	syslog(LOG_ERR, "failed to query database\n");
5313	return -1;
5314	}
5315	if (!dbi_result_next_row(query_result)) {
5316	dbi_result_free(query_result);
5317	og_dbi_close(dbi);
5318	syslog(LOG_ERR, "software profile does not exist in database\n");
5319	return -1;
5320	}
5321	snprintf(img_legacy.software_id, sizeof(img_legacy.software_id),
5322	"%d", dbi_result_get_uint(query_result, "idperfilsoft"));
5323	dbi_result_free(query_result);
5324
5325	res = actualizaRestauracionImagen(dbi,
5326	img_legacy.image_id,
5327	img_legacy.disk,
5328	img_legacy.part,
5329	soft_legacy.id,
5330	img_legacy.software_id);
5331	og_dbi_close(dbi);
5332
5333	if (!res) {
5334	syslog(LOG_ERR, "Problem updating client configuration\n");
5335	return -1;
5336	}
5337
5338	return 0;
5339	}
5340
5341	static int og_dbi_update_action(struct og_client *cli, bool success)
5342	{
5343	char end_date_string[24];
5344	struct tm *end_date;
5345	const char *msglog;
5346	struct og_dbi *dbi;
5347	uint8_t status = 2;
5348	dbi_result result;
5349	time_t now;
5350
5351	if (!cli->last_cmd_id)
5352	return 0;
5353
5354	dbi = og_dbi_open(&dbi_config);
5355	if (!dbi) {
5356	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5357	__func__, __LINE__);
5358	return -1;
5359	}
5360
5361	time(&now);
5362	end_date = localtime(&now);
5363
5364	sprintf(end_date_string, "%hu/%hhu/%hhu %hhu:%hhu:%hhu",
5365	end_date->tm_year + 1900, end_date->tm_mon + 1,
5366	end_date->tm_mday, end_date->tm_hour, end_date->tm_min,
5367	end_date->tm_sec);
5368	result = dbi_conn_queryf(dbi->conn,
5369	"UPDATE acciones SET fechahorafin='%s', "
5370	"estado=%d, resultado=%d WHERE idaccion=%d",
5371	end_date_string, ACCION_FINALIZADA,
5372	status - success, cli->last_cmd_id);
5373
5374	if (!result) {
5375	dbi_conn_error(dbi->conn, &msglog);
5376	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
5377	__func__, __LINE__, msglog);
5378	og_dbi_close(dbi);
5379	return -1;
5380	}
5381	cli->last_cmd_id = 0;
5382	dbi_result_free(result);
5383	og_dbi_close(dbi);
5384
5385	return 0;
5386	}
5387
5388	static int og_agent_state_process_response(struct og_client *cli)
5389	{
5390	json_error_t json_err;
5391	json_t *root;
5392	int err = -1;
5393	char *body;
5394
5395	if (!strncmp(cli->buf, "HTTP/1.0 202 Accepted",
5396	strlen("HTTP/1.0 202 Accepted"))) {
5397	og_dbi_update_action(cli, true);
5398	return 1;
5399	}
5400
5401	if (strncmp(cli->buf, "HTTP/1.0 200 OK", strlen("HTTP/1.0 200 OK"))) {
5402	og_dbi_update_action(cli, false);
5403	return -1;
5404	}
5405	og_dbi_update_action(cli, true);
5406
5407	if (!cli->content_length) {
5408	cli->last_cmd = OG_CMD_UNSPEC;
5409	return 0;
5410	}
5411
5412	body = strstr(cli->buf, "\r\n\r\n") + 4;
5413
5414	root = json_loads(body, 0, &json_err);
5415	if (!root) {
5416	syslog(LOG_ERR, "%s:%d: malformed json line %d: %s\n",
5417	__FILE__, __LINE__, json_err.line, json_err.text);
5418	return -1;
5419	}
5420
5421	switch (cli->last_cmd) {
5422	case OG_CMD_PROBE:
5423	err = og_resp_probe(cli, root);
5424	break;
5425	case OG_CMD_SHELL_RUN:
5426	err = og_resp_shell_run(cli, root);
5427	break;
5428	case OG_CMD_HARDWARE:
5429	err = og_resp_hardware(root, cli);
5430	break;
5431	case OG_CMD_SOFTWARE:
5432	err = og_resp_software(root, cli);
5433	break;
5434	case OG_CMD_REFRESH:
5435	err = og_resp_refresh(root, cli);
5436	break;
5437	case OG_CMD_SETUP:
5438	err = og_resp_refresh(root, cli);
5439	break;
5440	case OG_CMD_IMAGE_CREATE:
5441	err = og_resp_image_create(root, cli);
5442	break;
5443	case OG_CMD_IMAGE_RESTORE:
5444	err = og_resp_image_restore(root, cli);
5445	break;
5446	default:
5447	err = -1;
5448	break;
5449	}
5450
5451	cli->last_cmd = OG_CMD_UNSPEC;
5452
5453	return err;
5454	}
5455
5456	static void og_agent_deliver_pending_cmd(struct og_client *cli)
5457	{
5458	const struct og_cmd *cmd;
5459
5460	cmd = og_cmd_find(inet_ntoa(cli->addr.sin_addr));
5461	if (!cmd)
5462	return;
5463
5464	og_send_request(cmd->method, cmd->type, &cmd->params, cmd->json);
5465	cli->last_cmd_id = cmd->id;
5466
5467	og_cmd_free(cmd);
5468	}
5469
5470	static void og_agent_read_cb(struct ev_loop loop, struct ev_io io, int events)
5471	{
5472	struct og_client *cli;
5473	int ret;
5474
5475	cli = container_of(io, struct og_client, io);
5476
5477	ret = og_client_recv(cli, events);
5478	if (ret <= 0)
5479	goto close;
5480
5481	ev_timer_again(loop, &cli->timer);
5482
5483	cli->buf_len += ret;
5484	if (cli->buf_len >= sizeof(cli->buf)) {
5485	syslog(LOG_ERR, "client request from %s:%hu is too long\n",
5486	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
5487	goto close;
5488	}
5489
5490	switch (cli->state) {
5491	case OG_AGENT_RECEIVING_HEADER:
5492	ret = og_agent_state_recv_hdr_rest(cli);
5493	if (ret < 0)
5494	goto close;
5495	if (!ret)
5496	return;
5497
5498	cli->state = OG_AGENT_RECEIVING_PAYLOAD;
5499	/* Fall through. */
5500	case OG_AGENT_RECEIVING_PAYLOAD:
5501	/* Still not enough data to process request. */
5502	if (cli->buf_len < cli->msg_len)
5503	return;
5504
5505	cli->state = OG_AGENT_PROCESSING_RESPONSE;
5506	/* fall through. */
5507	case OG_AGENT_PROCESSING_RESPONSE:
5508	ret = og_agent_state_process_response(cli);
5509	if (ret < 0) {
5510	syslog(LOG_ERR, "Failed to process HTTP request from %s:%hu\n",
5511	inet_ntoa(cli->addr.sin_addr),
5512	ntohs(cli->addr.sin_port));
5513	goto close;
5514	} else if (ret == 0) {
5515	og_agent_deliver_pending_cmd(cli);
5516	}
5517
5518	syslog(LOG_DEBUG, "leaving client %s:%hu in keepalive mode\n",
5519	inet_ntoa(cli->addr.sin_addr),
5520	ntohs(cli->addr.sin_port));
5521	og_agent_reset_state(cli);
5522	break;
5523	default:
5524	syslog(LOG_ERR, "unknown state, critical internal error\n");
5525	goto close;
5526	}
5527	return;
5528	close:
5529	ev_timer_stop(loop, &cli->timer);
5530	og_client_release(loop, cli);
5531	}
5532
5533	static void og_client_timer_cb(struct ev_loop loop, ev_timer timer, int events)
5534	{
5535	struct og_client *cli;
5536
5537	cli = container_of(timer, struct og_client, timer);
5538	if (cli->keepalive_idx >= 0) {
5539	ev_timer_again(loop, &cli->timer);
5540	return;
5541	}
5542	syslog(LOG_ERR, "timeout request for client %s:%hu\n",
5543	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
5544
5545	og_client_release(loop, cli);
5546	}
5547
5548	static void og_agent_send_refresh(struct og_client *cli)
5549	{
5550	struct og_msg_params params;
5551	int err;
5552
5553	params.ips_array[0] = inet_ntoa(cli->addr.sin_addr);
5554	params.ips_array_len = 1;
5555
5556	err = og_send_request(OG_METHOD_GET, OG_CMD_REFRESH, &params, NULL);
5557	if (err < 0) {
5558	syslog(LOG_ERR, "Can't send refresh to: %s\n",
5559	params.ips_array[0]);
5560	} else {
5561	syslog(LOG_INFO, "Sent refresh to: %s\n",
5562	params.ips_array[0]);
5563	}
5564	}
5565
5566	static int socket_rest, socket_agent_rest;
5567
5568	static void og_server_accept_cb(struct ev_loop loop, struct ev_io io,
5569	int events)
5570	{
5571	struct sockaddr_in client_addr;
5572	socklen_t addrlen = sizeof(client_addr);
5573	struct og_client *cli;
5574	int client_sd;
5575
5576	if (events & EV_ERROR)
5577	return;
5578
5579	client_sd = accept(io->fd, (struct sockaddr *)&client_addr, &addrlen);
5580	if (client_sd < 0) {
5581	syslog(LOG_ERR, "cannot accept client connection\n");
5582	return;
5583	}
5584
5585	cli = (struct og_client *)calloc(1, sizeof(struct og_client));
5586	if (!cli) {
5587	close(client_sd);
5588	return;
5589	}
5590	memcpy(&cli->addr, &client_addr, sizeof(client_addr));
5591	if (io->fd == socket_agent_rest)
5592	cli->keepalive_idx = 0;
5593	else
5594	cli->keepalive_idx = -1;
5595
5596	if (io->fd == socket_rest)
5597	cli->rest = true;
5598	else if (io->fd == socket_agent_rest)
5599	cli->agent = true;
5600
5601	syslog(LOG_DEBUG, "connection from client %s:%hu\n",
5602	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
5603
5604	if (io->fd == socket_agent_rest)
5605	ev_io_init(&cli->io, og_agent_read_cb, client_sd, EV_READ);
5606	else
5607	ev_io_init(&cli->io, og_client_read_cb, client_sd, EV_READ);
5608
5609	ev_io_start(loop, &cli->io);
5610	if (io->fd == socket_agent_rest) {
5611	ev_timer_init(&cli->timer, og_client_timer_cb,
5612	OG_AGENT_CLIENT_TIMEOUT, 0.);
5613	} else {
5614	ev_timer_init(&cli->timer, og_client_timer_cb,
5615	OG_CLIENT_TIMEOUT, 0.);
5616	}
5617	ev_timer_start(loop, &cli->timer);
5618	list_add(&cli->list, &client_list);
5619
5620	if (io->fd == socket_agent_rest) {
5621	og_agent_send_refresh(cli);
5622	}
5623	}
5624
5625	static int og_socket_server_init(const char *port)
5626	{
5627	struct sockaddr_in local;
5628	int sd, on = 1;
5629
5630	sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5631	if (sd < 0) {
5632	syslog(LOG_ERR, "cannot create main socket\n");
5633	return -1;
5634	}
5635	setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(int));
5636
5637	local.sin_addr.s_addr = htonl(INADDR_ANY);
5638	local.sin_family = AF_INET;
5639	local.sin_port = htons(atoi(port));
5640
5641	if (bind(sd, (struct sockaddr *) &local, sizeof(local)) < 0) {
5642	close(sd);
5643	syslog(LOG_ERR, "cannot bind socket\n");
5644	return -1;
5645	}
5646
5647	listen(sd, 250);
5648
5649	return sd;
5650	}
5651
5652	int main(int argc, char *argv[])
5653	{
5654	struct ev_io ev_io_server_rest, ev_io_agent_rest;
5655	int i;
5656
5657	og_loop = ev_default_loop(0);
5658
5659	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
5660	exit(EXIT_FAILURE);
5661
5662	openlog("ogAdmServer", LOG_PID, LOG_DAEMON);
5663
5664	/*--------------------------------------------------------------------------------------------------------
5665	Validación de parámetros de ejecución y lectura del fichero de configuración del servicio
5666	---------------------------------------------------------------------------------------------------------*/
5667	if (!validacionParametros(argc, argv, 1)) // Valida parámetros de ejecución
5668	exit(EXIT_FAILURE);
5669
5670	if (!tomaConfiguracion(szPathFileCfg)) { // Toma parametros de configuracion
5671	exit(EXIT_FAILURE);
5672	}
5673
5674	/*--------------------------------------------------------------------------------------------------------
5675	// Inicializa array de información de los clientes
5676	---------------------------------------------------------------------------------------------------------*/
5677	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
5678	tbsockets[i].ip[0] = '\0';
5679	tbsockets[i].cli = NULL;
5680	}
5681	/*--------------------------------------------------------------------------------------------------------
5682	Creación y configuración del socket del servicio
5683	---------------------------------------------------------------------------------------------------------*/
5684
5685	socket_rest = og_socket_server_init("8888");
5686	if (socket_rest < 0)
5687	exit(EXIT_FAILURE);
5688
5689	ev_io_init(&ev_io_server_rest, og_server_accept_cb, socket_rest, EV_READ);
5690	ev_io_start(og_loop, &ev_io_server_rest);
5691
5692	socket_agent_rest = og_socket_server_init("8889");
5693	if (socket_agent_rest < 0)
5694	exit(EXIT_FAILURE);
5695
5696	ev_io_init(&ev_io_agent_rest, og_server_accept_cb, socket_agent_rest, EV_READ);
5697	ev_io_start(og_loop, &ev_io_agent_rest);
5698
5699	if (og_dbi_schedule_get() < 0)
5700	exit(EXIT_FAILURE);
5701
5702	og_schedule_next(og_loop);
5703
5704	infoLog(1); // Inicio de sesión
5705
5706	/* old log file has been deprecated. */
5707	og_log(97, false);
5708
5709	syslog(LOG_INFO, "Waiting for connections\n");
5710
5711	while (1)
5712	ev_loop(og_loop, 0);
5713
5714	exit(EXIT_SUCCESS);
5715	}

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

Download in other formats: