Context Navigation

source: ogServer-Git/sources/ogAdmServer.c @ 8fa9ec6

Last change on this file since 8fa9ec6 was 8fa9ec6, checked in by OpenGnSys Support Team <soporte-og@…>, 4 years ago

#942 add type to POST /schedule/create

Moreover, add og_task_schedule_create() function.

Property mode set to 100644

File size: 154.1 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	og_cmd_legacy(task->params, cmd);
3401
3402	if (og_dbi_add_action(dbi, task, cmd)) {
3403	dbi_result_free(result);
3404	return -1;
3405	}
3406
3407	list_add_tail(&cmd->list, &cmd_list);
3408	}
3409
3410	dbi_result_free(result);
3411
3412	return 0;
3413	}
3414
3415	static int og_queue_task_group_clients(struct og_dbi dbi, struct og_task task,
3416	char *query)
3417	{
3418
3419	const char *msglog;
3420	dbi_result result;
3421
3422	result = dbi_conn_queryf(dbi->conn, query);
3423	if (!result) {
3424	dbi_conn_error(dbi->conn, &msglog);
3425	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3426	__func__, __LINE__, msglog);
3427	return -1;
3428	}
3429
3430	while (dbi_result_next_row(result)) {
3431	uint32_t group_id = dbi_result_get_uint(result, "idgrupo");
3432
3433	sprintf(query, "SELECT idgrupo FROM gruposordenadores "
3434	"WHERE grupoid=%d", group_id);
3435	if (og_queue_task_group_clients(dbi, task, query)) {
3436	dbi_result_free(result);
3437	return -1;
3438	}
3439
3440	sprintf(query,"SELECT ip, mac, idordenador FROM ordenadores "
3441	"WHERE grupoid=%d", group_id);
3442	if (og_queue_task_command(dbi, task, query)) {
3443	dbi_result_free(result);
3444	return -1;
3445	}
3446
3447	}
3448
3449	dbi_result_free(result);
3450
3451	return 0;
3452	}
3453
3454	static int og_queue_task_group_classrooms(struct og_dbi *dbi,
3455	struct og_task task, char query)
3456	{
3457
3458	const char *msglog;
3459	dbi_result result;
3460
3461	result = dbi_conn_queryf(dbi->conn, query);
3462	if (!result) {
3463	dbi_conn_error(dbi->conn, &msglog);
3464	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3465	__func__, __LINE__, msglog);
3466	return -1;
3467	}
3468
3469	while (dbi_result_next_row(result)) {
3470	uint32_t group_id = dbi_result_get_uint(result, "idgrupo");
3471
3472	sprintf(query, "SELECT idgrupo FROM grupos "
3473	"WHERE grupoid=%d AND tipo=%d", group_id, AMBITO_GRUPOSAULAS);
3474	if (og_queue_task_group_classrooms(dbi, task, query)) {
3475	dbi_result_free(result);
3476	return -1;
3477	}
3478
3479	sprintf(query,
3480	"SELECT ip,mac,idordenador "
3481	"FROM ordenadores INNER JOIN aulas "
3482	"WHERE ordenadores.idaula=aulas.idaula "
3483	"AND aulas.grupoid=%d",
3484	group_id);
3485	if (og_queue_task_command(dbi, task, query)) {
3486	dbi_result_free(result);
3487	return -1;
3488	}
3489
3490	}
3491
3492	dbi_result_free(result);
3493
3494	return 0;
3495	}
3496
3497	static int og_queue_task_clients(struct og_dbi dbi, struct og_task task)
3498	{
3499	char query[4096];
3500
3501	switch (task->type_scope) {
3502	case AMBITO_CENTROS:
3503	sprintf(query,
3504	"SELECT ip,mac,idordenador "
3505	"FROM ordenadores INNER JOIN aulas "
3506	"WHERE ordenadores.idaula=aulas.idaula "
3507	"AND idcentro=%d",
3508	task->scope);
3509	return og_queue_task_command(dbi, task, query);
3510	case AMBITO_GRUPOSAULAS:
3511	sprintf(query,
3512	"SELECT idgrupo FROM grupos "
3513	"WHERE idgrupo=%i AND tipo=%d",
3514	task->scope, AMBITO_GRUPOSAULAS);
3515	return og_queue_task_group_classrooms(dbi, task, query);
3516	case AMBITO_AULAS:
3517	sprintf(query,
3518	"SELECT ip,mac,idordenador FROM ordenadores "
3519	"WHERE idaula=%d",
3520	task->scope);
3521	return og_queue_task_command(dbi, task, query);
3522	case AMBITO_GRUPOSORDENADORES:
3523	sprintf(query,
3524	"SELECT idgrupo FROM gruposordenadores "
3525	"WHERE idgrupo = %d",
3526	task->scope);
3527	return og_queue_task_group_clients(dbi, task, query);
3528	case AMBITO_ORDENADORES:
3529	sprintf(query,
3530	"SELECT ip, mac, idordenador FROM ordenadores "
3531	"WHERE idordenador = %d",
3532	task->scope);
3533	return og_queue_task_command(dbi, task, query);
3534	}
3535	return 0;
3536	}
3537
3538	static int og_dbi_queue_procedure(struct og_dbi dbi, struct og_task task)
3539	{
3540	uint32_t procedure_id;
3541	const char *msglog;
3542	dbi_result result;
3543
3544	result = dbi_conn_queryf(dbi->conn,
3545	"SELECT parametros, procedimientoid, idcomando "
3546	"FROM procedimientos_acciones "
3547	"WHERE idprocedimiento=%d ORDER BY orden", task->procedure_id);
3548	if (!result) {
3549	dbi_conn_error(dbi->conn, &msglog);
3550	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3551	__func__, __LINE__, msglog);
3552	return -1;
3553	}
3554
3555	while (dbi_result_next_row(result)) {
3556	procedure_id = dbi_result_get_uint(result, "procedimientoid");
3557	if (procedure_id > 0) {
3558	task->procedure_id = procedure_id;
3559	if (og_dbi_queue_procedure(dbi, task))
3560	return -1;
3561	continue;
3562	}
3563
3564	task->params = strdup(dbi_result_get_string(result, "parametros"));
3565	task->command_id = dbi_result_get_uint(result, "idcomando");
3566	if (og_queue_task_clients(dbi, task))
3567	return -1;
3568	}
3569
3570	dbi_result_free(result);
3571
3572	return 0;
3573	}
3574
3575	static int og_dbi_queue_task(struct og_dbi *dbi, uint32_t task_id,
3576	uint32_t schedule_id)
3577	{
3578	struct og_task task = {};
3579	uint32_t task_id_next;
3580	struct og_cmd *cmd;
3581	const char *msglog;
3582	dbi_result result;
3583
3584	task.schedule_id = schedule_id;
3585
3586	result = dbi_conn_queryf(dbi->conn,
3587	"SELECT tareas_acciones.orden, "
3588	"tareas_acciones.idprocedimiento, "
3589	"tareas_acciones.tareaid, "
3590	"tareas.idtarea, "
3591	"tareas.idcentro, "
3592	"tareas.ambito, "
3593	"tareas.idambito, "
3594	"tareas.restrambito "
3595	" FROM tareas"
3596	" INNER JOIN tareas_acciones ON tareas_acciones.idtarea=tareas.idtarea"
3597	" WHERE tareas_acciones.idtarea=%u ORDER BY tareas_acciones.orden ASC", task_id);
3598	if (!result) {
3599	dbi_conn_error(dbi->conn, &msglog);
3600	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3601	__func__, __LINE__, msglog);
3602	return -1;
3603	}
3604
3605	while (dbi_result_next_row(result)) {
3606	task_id_next = dbi_result_get_uint(result, "tareaid");
3607
3608	if (task_id_next > 0) {
3609	if (og_dbi_queue_task(dbi, task_id_next, schedule_id))
3610	return -1;
3611
3612	continue;
3613	}
3614	task.task_id = dbi_result_get_uint(result, "idtarea");
3615	task.center_id = dbi_result_get_uint(result, "idcentro");
3616	task.procedure_id = dbi_result_get_uint(result, "idprocedimiento");
3617	task.type_scope = dbi_result_get_uint(result, "ambito");
3618	task.scope = dbi_result_get_uint(result, "idambito");
3619	task.filtered_scope = dbi_result_get_string(result, "restrambito");
3620
3621	og_dbi_queue_procedure(dbi, &task);
3622	}
3623
3624	dbi_result_free(result);
3625
3626	list_for_each_entry(cmd, &cmd_list, list) {
3627	if (cmd->type != OG_CMD_WOL)
3628	continue;
3629
3630	if (!Levanta((char **)cmd->params.ips_array,
3631	(char **)cmd->params.mac_array,
3632	cmd->params.ips_array_len,
3633	(char *)cmd->params.wol_type))
3634	return -1;
3635	}
3636
3637	return 0;
3638	}
3639
3640	void og_dbi_schedule_task(unsigned int task_id, unsigned int schedule_id)
3641	{
3642	struct og_msg_params params = {};
3643	bool duplicated = false;
3644	struct og_cmd *cmd;
3645	struct og_dbi *dbi;
3646	unsigned int i;
3647
3648	dbi = og_dbi_open(&dbi_config);
3649	if (!dbi) {
3650	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3651	__func__, __LINE__);
3652	return;
3653	}
3654	og_dbi_queue_task(dbi, task_id, schedule_id);
3655	og_dbi_close(dbi);
3656
3657	list_for_each_entry(cmd, &cmd_list, list) {
3658	for (i = 0; i < params.ips_array_len; i++) {
3659	if (!strncmp(cmd->ip, params.ips_array[i],
3660	OG_DB_IP_MAXLEN)) {
3661	duplicated = true;
3662	break;
3663	}
3664	}
3665
3666	if (!duplicated)
3667	params.ips_array[params.ips_array_len++] = cmd->ip;
3668	else
3669	duplicated = false;
3670	}
3671
3672	og_send_request(OG_METHOD_GET, OG_CMD_RUN_SCHEDULE, &params, NULL);
3673	}
3674
3675	static int og_cmd_task_post(json_t element, struct og_msg_params params)
3676	{
3677	struct og_cmd *cmd;
3678	struct og_dbi *dbi;
3679	const char *key;
3680	json_t *value;
3681	int err;
3682
3683	if (json_typeof(element) != JSON_OBJECT)
3684	return -1;
3685
3686	json_object_foreach(element, key, value) {
3687	if (!strcmp(key, "task")) {
3688	err = og_json_parse_string(value, &params->task_id);
3689	params->flags \|= OG_REST_PARAM_TASK;
3690	}
3691
3692	if (err < 0)
3693	break;
3694	}
3695
3696	if (!og_msg_params_validate(params, OG_REST_PARAM_TASK))
3697	return -1;
3698
3699	dbi = og_dbi_open(&dbi_config);
3700	if (!dbi) {
3701	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3702	__func__, __LINE__);
3703	return -1;
3704	}
3705
3706	og_dbi_queue_task(dbi, atoi(params->task_id), 0);
3707	og_dbi_close(dbi);
3708
3709	list_for_each_entry(cmd, &cmd_list, list)
3710	params->ips_array[params->ips_array_len++] = cmd->ip;
3711
3712	return og_send_request(OG_METHOD_GET, OG_CMD_RUN_SCHEDULE, params,
3713	NULL);
3714	}
3715
3716	static int og_dbi_schedule_get(void)
3717	{
3718	uint32_t schedule_id, task_id;
3719	struct og_schedule_time time;
3720	struct og_dbi *dbi;
3721	const char *msglog;
3722	dbi_result result;
3723
3724	dbi = og_dbi_open(&dbi_config);
3725	if (!dbi) {
3726	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3727	__func__, __LINE__);
3728	return -1;
3729	}
3730
3731	result = dbi_conn_queryf(dbi->conn,
3732	"SELECT idprogramacion, tipoaccion, identificador, "
3733	"sesion, annos, meses, diario, dias, semanas, horas, "
3734	"ampm, minutos FROM programaciones "
3735	"WHERE suspendida = 0");
3736	if (!result) {
3737	dbi_conn_error(dbi->conn, &msglog);
3738	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3739	__func__, __LINE__, msglog);
3740	og_dbi_close(dbi);
3741	return -1;
3742	}
3743
3744	while (dbi_result_next_row(result)) {
3745	memset(&time, 0, sizeof(time));
3746	schedule_id = dbi_result_get_uint(result, "idprogramacion");
3747	task_id = dbi_result_get_uint(result, "identificador");
3748	time.years = dbi_result_get_uint(result, "annos");
3749	time.months = dbi_result_get_uint(result, "meses");
3750	time.weeks = dbi_result_get_uint(result, "semanas");
3751	time.week_days = dbi_result_get_uint(result, "dias");
3752	time.days = dbi_result_get_uint(result, "diario");
3753	time.hours = dbi_result_get_uint(result, "horas");
3754	time.am_pm = dbi_result_get_uint(result, "ampm");
3755	time.minutes = dbi_result_get_uint(result, "minutos");
3756
3757	og_schedule_create(schedule_id, task_id, &time);
3758	}
3759
3760	dbi_result_free(result);
3761	og_dbi_close(dbi);
3762
3763	return 0;
3764	}
3765
3766	static int og_dbi_schedule_create(struct og_dbi *dbi,
3767	struct og_msg_params *params,
3768	uint32_t *schedule_id)
3769	{
3770	const char *msglog;
3771	dbi_result result;
3772	uint8_t suspended = 0;
3773	uint8_t type = 3;
3774
3775	result = dbi_conn_queryf(dbi->conn,
3776	"INSERT INTO programaciones (tipoaccion,"
3777	" identificador, nombrebloque, annos, meses,"
3778	" semanas, dias, diario, horas, ampm, minutos,"
3779	" suspendida) VALUES (%d, %s, '%s', %d, %d,"
3780	" %d, %d, %d, %d, %d, %d, %d)", type,
3781	params->task_id, params->name,
3782	params->time.years, params->time.months,
3783	params->time.weeks, params->time.week_days,
3784	params->time.days, params->time.hours,
3785	params->time.am_pm, params->time.minutes,
3786	suspended);
3787	if (!result) {
3788	dbi_conn_error(dbi->conn, &msglog);
3789	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3790	__func__, __LINE__, msglog);
3791	return -1;
3792	}
3793	dbi_result_free(result);
3794
3795	*schedule_id = dbi_conn_sequence_last(dbi->conn, NULL);
3796
3797	return 0;
3798	}
3799
3800	static int og_dbi_schedule_update(struct og_dbi *dbi,
3801	struct og_msg_params *params)
3802	{
3803	const char *msglog;
3804	dbi_result result;
3805	uint8_t type = 3;
3806
3807	result = dbi_conn_queryf(dbi->conn,
3808	"UPDATE programaciones SET tipoaccion=%d, "
3809	"identificador='%s', nombrebloque='%s', "
3810	"annos=%d, meses=%d, "
3811	"diario=%d, horas=%d, ampm=%d, minutos=%d "
3812	"WHERE idprogramacion='%s'",
3813	type, params->task_id, params->name,
3814	params->time.years, params->time.months,
3815	params->time.days, params->time.hours,
3816	params->time.am_pm, params->time.minutes,
3817	params->id);
3818
3819	if (!result) {
3820	dbi_conn_error(dbi->conn, &msglog);
3821	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3822	__func__, __LINE__, msglog);
3823	return -1;
3824	}
3825	dbi_result_free(result);
3826
3827	return 0;
3828	}
3829
3830	static int og_dbi_schedule_delete(struct og_dbi *dbi, uint32_t id)
3831	{
3832	const char *msglog;
3833	dbi_result result;
3834
3835	result = dbi_conn_queryf(dbi->conn,
3836	"DELETE FROM programaciones WHERE idprogramacion=%d",
3837	id);
3838	if (!result) {
3839	dbi_conn_error(dbi->conn, &msglog);
3840	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3841	__func__, __LINE__, msglog);
3842	return -1;
3843	}
3844	dbi_result_free(result);
3845
3846	return 0;
3847	}
3848
3849	struct og_db_schedule {
3850	uint32_t id;
3851	uint32_t task_id;
3852	const char *name;
3853	struct og_schedule_time time;
3854	uint32_t week_days;
3855	uint32_t weeks;
3856	uint32_t suspended;
3857	uint32_t session;
3858	};
3859
3860	static int og_dbi_schedule_get_json(struct og_dbi dbi, json_t root,
3861	const char task_id, const char schedule_id)
3862	{
3863	struct og_db_schedule schedule;
3864	json_t obj, array;
3865	const char *msglog;
3866	dbi_result result;
3867	int err = 0;
3868
3869	if (task_id) {
3870	result = dbi_conn_queryf(dbi->conn,
3871	"SELECT idprogramacion,"
3872	" identificador, nombrebloque,"
3873	" annos, meses, diario, dias,"
3874	" semanas, horas, ampm,"
3875	" minutos,suspendida, sesion "
3876	"FROM programaciones "
3877	"WHERE identificador=%d",
3878	atoi(task_id));
3879	} else if (schedule_id) {
3880	result = dbi_conn_queryf(dbi->conn,
3881	"SELECT idprogramacion,"
3882	" identificador, nombrebloque,"
3883	" annos, meses, diario, dias,"
3884	" semanas, horas, ampm,"
3885	" minutos,suspendida, sesion "
3886	"FROM programaciones "
3887	"WHERE idprogramacion=%d",
3888	atoi(schedule_id));
3889	} else {
3890	result = dbi_conn_queryf(dbi->conn,
3891	"SELECT idprogramacion,"
3892	" identificador, nombrebloque,"
3893	" annos, meses, diario, dias,"
3894	" semanas, horas, ampm,"
3895	" minutos,suspendida, sesion "
3896	"FROM programaciones");
3897	}
3898
3899	if (!result) {
3900	dbi_conn_error(dbi->conn, &msglog);
3901	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
3902	__func__, __LINE__, msglog);
3903	return -1;
3904	}
3905
3906	array = json_array();
3907	if (!array)
3908	return -1;
3909
3910	while (dbi_result_next_row(result)) {
3911	schedule.id = dbi_result_get_uint(result, "idprogramacion");
3912	schedule.task_id = dbi_result_get_uint(result, "identificador");
3913	schedule.name = dbi_result_get_string(result, "nombrebloque");
3914	schedule.time.years = dbi_result_get_uint(result, "annos");
3915	schedule.time.months = dbi_result_get_uint(result, "meses");
3916	schedule.time.days = dbi_result_get_uint(result, "diario");
3917	schedule.time.hours = dbi_result_get_uint(result, "horas");
3918	schedule.time.am_pm = dbi_result_get_uint(result, "ampm");
3919	schedule.time.minutes = dbi_result_get_uint(result, "minutos");
3920	schedule.week_days = dbi_result_get_uint(result, "dias");
3921	schedule.weeks = dbi_result_get_uint(result, "semanas");
3922	schedule.suspended = dbi_result_get_uint(result, "suspendida");
3923	schedule.session = dbi_result_get_uint(result, "sesion");
3924
3925	obj = json_object();
3926	if (!obj) {
3927	err = -1;
3928	break;
3929	}
3930	json_object_set_new(obj, "id", json_integer(schedule.id));
3931	json_object_set_new(obj, "task", json_integer(schedule.task_id));
3932	json_object_set_new(obj, "name", json_string(schedule.name));
3933	json_object_set_new(obj, "years", json_integer(schedule.time.years));
3934	json_object_set_new(obj, "months", json_integer(schedule.time.months));
3935	json_object_set_new(obj, "days", json_integer(schedule.time.days));
3936	json_object_set_new(obj, "hours", json_integer(schedule.time.hours));
3937	json_object_set_new(obj, "am_pm", json_integer(schedule.time.am_pm));
3938	json_object_set_new(obj, "minutes", json_integer(schedule.time.minutes));
3939	json_object_set_new(obj, "week_days", json_integer(schedule.week_days));
3940	json_object_set_new(obj, "weeks", json_integer(schedule.weeks));
3941	json_object_set_new(obj, "suspended", json_integer(schedule.suspended));
3942	json_object_set_new(obj, "session", json_integer(schedule.session));
3943
3944	json_array_append_new(array, obj);
3945	}
3946
3947	json_object_set_new(root, "schedule", array);
3948
3949	dbi_result_free(result);
3950
3951	return err;
3952	}
3953
3954	static struct ev_loop *og_loop;
3955
3956	static int og_task_schedule_create(struct og_msg_params *params)
3957	{
3958	uint32_t schedule_id;
3959	struct og_dbi *dbi;
3960	int err;
3961
3962	dbi = og_dbi_open(&dbi_config);
3963	if (!dbi) {
3964	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
3965	__func__, __LINE__);
3966	return -1;
3967	}
3968
3969	err = og_dbi_schedule_create(dbi, params, &schedule_id);
3970	if (err < 0) {
3971	og_dbi_close(dbi);
3972	return -1;
3973	}
3974	og_schedule_create(schedule_id, atoi(params->task_id), &params->time);
3975	og_schedule_refresh(og_loop);
3976	og_dbi_close(dbi);
3977
3978	return 0;
3979	}
3980
3981	static int og_cmd_schedule_create(json_t element, struct og_msg_params params)
3982	{
3983	const char *key;
3984	json_t *value;
3985	int err;
3986
3987	if (json_typeof(element) != JSON_OBJECT)
3988	return -1;
3989
3990	json_object_foreach(element, key, value) {
3991	if (!strcmp(key, "task")) {
3992	err = og_json_parse_string(value, &params->task_id);
3993	params->flags \|= OG_REST_PARAM_TASK;
3994	} else if (!strcmp(key, "name")) {
3995	err = og_json_parse_string(value, &params->name);
3996	params->flags \|= OG_REST_PARAM_NAME;
3997	} else if (!strcmp(key, "when")) {
3998	err = og_json_parse_time_params(value, params);
3999	} else if (!strcmp(key, "type")) {
4000	err = og_json_parse_string(value, &params->type);
4001	params->flags \|= OG_REST_PARAM_TYPE;
4002	}
4003
4004	if (err < 0)
4005	break;
4006	}
4007
4008	if (!og_msg_params_validate(params, OG_REST_PARAM_TASK \|
4009	OG_REST_PARAM_NAME \|
4010	OG_REST_PARAM_TIME_YEARS \|
4011	OG_REST_PARAM_TIME_MONTHS \|
4012	OG_REST_PARAM_TIME_WEEKS \|
4013	OG_REST_PARAM_TIME_WEEK_DAYS \|
4014	OG_REST_PARAM_TIME_DAYS \|
4015	OG_REST_PARAM_TIME_HOURS \|
4016	OG_REST_PARAM_TIME_MINUTES \|
4017	OG_REST_PARAM_TIME_AM_PM))
4018	return -1;
4019
4020	return og_task_schedule_create(params);
4021	}
4022
4023	static int og_cmd_schedule_update(json_t element, struct og_msg_params params)
4024	{
4025	struct og_dbi *dbi;
4026	const char *key;
4027	json_t *value;
4028	int err;
4029
4030	if (json_typeof(element) != JSON_OBJECT)
4031	return -1;
4032
4033	json_object_foreach(element, key, value) {
4034	if (!strcmp(key, "id")) {
4035	err = og_json_parse_string(value, &params->id);
4036	params->flags \|= OG_REST_PARAM_ID;
4037	} else if (!strcmp(key, "task")) {
4038	err = og_json_parse_string(value, &params->task_id);
4039	params->flags \|= OG_REST_PARAM_TASK;
4040	} else if (!strcmp(key, "name")) {
4041	err = og_json_parse_string(value, &params->name);
4042	params->flags \|= OG_REST_PARAM_NAME;
4043	} else if (!strcmp(key, "when"))
4044	err = og_json_parse_time_params(value, params);
4045
4046	if (err < 0)
4047	break;
4048	}
4049
4050	if (!og_msg_params_validate(params, OG_REST_PARAM_ID \|
4051	OG_REST_PARAM_TASK \|
4052	OG_REST_PARAM_NAME \|
4053	OG_REST_PARAM_TIME_YEARS \|
4054	OG_REST_PARAM_TIME_MONTHS \|
4055	OG_REST_PARAM_TIME_DAYS \|
4056	OG_REST_PARAM_TIME_HOURS \|
4057	OG_REST_PARAM_TIME_MINUTES \|
4058	OG_REST_PARAM_TIME_AM_PM))
4059	return -1;
4060
4061	dbi = og_dbi_open(&dbi_config);
4062	if (!dbi) {
4063	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4064	__func__, __LINE__);
4065	return -1;
4066	}
4067
4068	err = og_dbi_schedule_update(dbi, params);
4069	og_dbi_close(dbi);
4070
4071	if (err < 0)
4072	return err;
4073
4074	og_schedule_update(og_loop, atoi(params->id), atoi(params->task_id),
4075	&params->time);
4076	og_schedule_refresh(og_loop);
4077
4078	return err;
4079	}
4080
4081	static int og_cmd_schedule_delete(json_t element, struct og_msg_params params)
4082	{
4083	struct og_dbi *dbi;
4084	const char *key;
4085	json_t *value;
4086	int err;
4087
4088	if (json_typeof(element) != JSON_OBJECT)
4089	return -1;
4090
4091	json_object_foreach(element, key, value) {
4092	if (!strcmp(key, "id")) {
4093	err = og_json_parse_string(value, &params->id);
4094	params->flags \|= OG_REST_PARAM_ID;
4095	} else {
4096	return -1;
4097	}
4098
4099	if (err < 0)
4100	break;
4101	}
4102
4103	if (!og_msg_params_validate(params, OG_REST_PARAM_ID))
4104	return -1;
4105
4106	dbi = og_dbi_open(&dbi_config);
4107	if (!dbi) {
4108	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4109	__func__, __LINE__);
4110	return -1;
4111	}
4112
4113	err = og_dbi_schedule_delete(dbi, atoi(params->id));
4114	og_dbi_close(dbi);
4115
4116	og_schedule_delete(og_loop, atoi(params->id));
4117
4118	return err;
4119	}
4120
4121	static int og_cmd_schedule_get(json_t element, struct og_msg_params params,
4122	char *buffer_reply)
4123	{
4124	struct og_buffer og_buffer = {
4125	.data = buffer_reply,
4126	};
4127	json_t *schedule_root;
4128	struct og_dbi *dbi;
4129	const char *key;
4130	json_t *value;
4131	int err;
4132
4133	if (element) {
4134	if (json_typeof(element) != JSON_OBJECT)
4135	return -1;
4136
4137	json_object_foreach(element, key, value) {
4138	if (!strcmp(key, "task")) {
4139	err = og_json_parse_string(value,
4140	&params->task_id);
4141	} else if (!strcmp(key, "id")) {
4142	err = og_json_parse_string(value, &params->id);
4143	} else {
4144	return -1;
4145	}
4146
4147	if (err < 0)
4148	break;
4149	}
4150	}
4151
4152	dbi = og_dbi_open(&dbi_config);
4153	if (!dbi) {
4154	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4155	__func__, __LINE__);
4156	return -1;
4157	}
4158
4159	schedule_root = json_object();
4160	if (!schedule_root) {
4161	og_dbi_close(dbi);
4162	return -1;
4163	}
4164
4165	err = og_dbi_schedule_get_json(dbi, schedule_root,
4166	params->task_id, params->id);
4167	og_dbi_close(dbi);
4168
4169	if (err >= 0)
4170	json_dump_callback(schedule_root, og_json_dump_clients, &og_buffer, 0);
4171
4172	json_decref(schedule_root);
4173
4174	return err;
4175	}
4176
4177	static int og_client_method_not_found(struct og_client *cli)
4178	{
4179	/* To meet RFC 7231, this function MUST generate an Allow header field
4180	* containing the correct methods. For example: "Allow: POST\r\n"
4181	*/
4182	char buf[] = "HTTP/1.1 405 Method Not Allowed\r\n"
4183	"Content-Length: 0\r\n\r\n";
4184
4185	send(og_client_socket(cli), buf, strlen(buf), 0);
4186
4187	return -1;
4188	}
4189
4190	static int og_client_bad_request(struct og_client *cli)
4191	{
4192	char buf[] = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n";
4193
4194	send(og_client_socket(cli), buf, strlen(buf), 0);
4195
4196	return -1;
4197	}
4198
4199	static int og_client_not_found(struct og_client *cli)
4200	{
4201	char buf[] = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n";
4202
4203	send(og_client_socket(cli), buf, strlen(buf), 0);
4204
4205	return -1;
4206	}
4207
4208	static int og_client_not_authorized(struct og_client *cli)
4209	{
4210	char buf[] = "HTTP/1.1 401 Unauthorized\r\n"
4211	"WWW-Authenticate: Basic\r\n"
4212	"Content-Length: 0\r\n\r\n";
4213
4214	send(og_client_socket(cli), buf, strlen(buf), 0);
4215
4216	return -1;
4217	}
4218
4219	static int og_server_internal_error(struct og_client *cli)
4220	{
4221	char buf[] = "HTTP/1.1 500 Internal Server Error\r\n"
4222	"Content-Length: 0\r\n\r\n";
4223
4224	send(og_client_socket(cli), buf, strlen(buf), 0);
4225
4226	return -1;
4227	}
4228
4229	static int og_client_payload_too_large(struct og_client *cli)
4230	{
4231	char buf[] = "HTTP/1.1 413 Payload Too Large\r\n"
4232	"Content-Length: 0\r\n\r\n";
4233
4234	send(og_client_socket(cli), buf, strlen(buf), 0);
4235
4236	return -1;
4237	}
4238
4239	#define OG_MSG_RESPONSE_MAXLEN 65536
4240
4241	static int og_client_ok(struct og_client cli, char buf_reply)
4242	{
4243	char buf[OG_MSG_RESPONSE_MAXLEN] = {};
4244	int err = 0, len;
4245
4246	len = snprintf(buf, sizeof(buf),
4247	"HTTP/1.1 200 OK\r\nContent-Length: %ld\r\n\r\n%s",
4248	strlen(buf_reply), buf_reply);
4249	if (len >= (int)sizeof(buf))
4250	err = og_server_internal_error(cli);
4251
4252	send(og_client_socket(cli), buf, strlen(buf), 0);
4253
4254	return err;
4255	}
4256
4257	static int og_client_state_process_payload_rest(struct og_client *cli)
4258	{
4259	char buf_reply[OG_MSG_RESPONSE_MAXLEN] = {};
4260	struct og_msg_params params = {};
4261	enum og_rest_method method;
4262	const char cmd, body;
4263	json_error_t json_err;
4264	json_t *root = NULL;
4265	int err = 0;
4266
4267	syslog(LOG_DEBUG, "%s:%hu %.32s ...\n",
4268	inet_ntoa(cli->addr.sin_addr),
4269	ntohs(cli->addr.sin_port), cli->buf);
4270
4271	if (!strncmp(cli->buf, "GET", strlen("GET"))) {
4272	method = OG_METHOD_GET;
4273	cmd = cli->buf + strlen("GET") + 2;
4274	} else if (!strncmp(cli->buf, "POST", strlen("POST"))) {
4275	method = OG_METHOD_POST;
4276	cmd = cli->buf + strlen("POST") + 2;
4277	} else
4278	return og_client_method_not_found(cli);
4279
4280	body = strstr(cli->buf, "\r\n\r\n") + 4;
4281
4282	if (strcmp(cli->auth_token, auth_token)) {
4283	syslog(LOG_ERR, "wrong Authentication key\n");
4284	return og_client_not_authorized(cli);
4285	}
4286
4287	if (cli->content_length) {
4288	root = json_loads(body, 0, &json_err);
4289	if (!root) {
4290	syslog(LOG_ERR, "malformed json line %d: %s\n",
4291	json_err.line, json_err.text);
4292	return og_client_not_found(cli);
4293	}
4294	}
4295
4296	if (!strncmp(cmd, "clients", strlen("clients"))) {
4297	if (method != OG_METHOD_POST &&
4298	method != OG_METHOD_GET)
4299	return og_client_method_not_found(cli);
4300
4301	if (method == OG_METHOD_POST && !root) {
4302	syslog(LOG_ERR, "command clients with no payload\n");
4303	return og_client_bad_request(cli);
4304	}
4305	switch (method) {
4306	case OG_METHOD_POST:
4307	err = og_cmd_post_clients(root, &params);
4308	break;
4309	case OG_METHOD_GET:
4310	err = og_cmd_get_clients(root, &params, buf_reply);
4311	break;
4312	default:
4313	return og_client_bad_request(cli);
4314	}
4315	} else if (!strncmp(cmd, "wol", strlen("wol"))) {
4316	if (method != OG_METHOD_POST)
4317	return og_client_method_not_found(cli);
4318
4319	if (!root) {
4320	syslog(LOG_ERR, "command wol with no payload\n");
4321	return og_client_bad_request(cli);
4322	}
4323	err = og_cmd_wol(root, &params);
4324	} else if (!strncmp(cmd, "shell/run", strlen("shell/run"))) {
4325	if (method != OG_METHOD_POST)
4326	return og_client_method_not_found(cli);
4327
4328	if (!root) {
4329	syslog(LOG_ERR, "command run with no payload\n");
4330	return og_client_bad_request(cli);
4331	}
4332	err = og_cmd_run_post(root, &params);
4333	} else if (!strncmp(cmd, "shell/output", strlen("shell/output"))) {
4334	if (method != OG_METHOD_POST)
4335	return og_client_method_not_found(cli);
4336
4337	if (!root) {
4338	syslog(LOG_ERR, "command output with no payload\n");
4339	return og_client_bad_request(cli);
4340	}
4341
4342	err = og_cmd_run_get(root, &params, buf_reply);
4343	} else if (!strncmp(cmd, "session", strlen("session"))) {
4344	if (method != OG_METHOD_POST)
4345	return og_client_method_not_found(cli);
4346
4347	if (!root) {
4348	syslog(LOG_ERR, "command session with no payload\n");
4349	return og_client_bad_request(cli);
4350	}
4351	err = og_cmd_session(root, &params);
4352	} else if (!strncmp(cmd, "poweroff", strlen("poweroff"))) {
4353	if (method != OG_METHOD_POST)
4354	return og_client_method_not_found(cli);
4355
4356	if (!root) {
4357	syslog(LOG_ERR, "command poweroff with no payload\n");
4358	return og_client_bad_request(cli);
4359	}
4360	err = og_cmd_poweroff(root, &params);
4361	} else if (!strncmp(cmd, "reboot", strlen("reboot"))) {
4362	if (method != OG_METHOD_POST)
4363	return og_client_method_not_found(cli);
4364
4365	if (!root) {
4366	syslog(LOG_ERR, "command reboot with no payload\n");
4367	return og_client_bad_request(cli);
4368	}
4369	err = og_cmd_reboot(root, &params);
4370	} else if (!strncmp(cmd, "stop", strlen("stop"))) {
4371	if (method != OG_METHOD_POST)
4372	return og_client_method_not_found(cli);
4373
4374	if (!root) {
4375	syslog(LOG_ERR, "command stop with no payload\n");
4376	return og_client_bad_request(cli);
4377	}
4378	err = og_cmd_stop(root, &params);
4379	} else if (!strncmp(cmd, "refresh", strlen("refresh"))) {
4380	if (method != OG_METHOD_POST)
4381	return og_client_method_not_found(cli);
4382
4383	if (!root) {
4384	syslog(LOG_ERR, "command refresh with no payload\n");
4385	return og_client_bad_request(cli);
4386	}
4387	err = og_cmd_refresh(root, &params);
4388	} else if (!strncmp(cmd, "hardware", strlen("hardware"))) {
4389	if (method != OG_METHOD_POST)
4390	return og_client_method_not_found(cli);
4391
4392	if (!root) {
4393	syslog(LOG_ERR, "command hardware with no payload\n");
4394	return og_client_bad_request(cli);
4395	}
4396	err = og_cmd_hardware(root, &params);
4397	} else if (!strncmp(cmd, "software", strlen("software"))) {
4398	if (method != OG_METHOD_POST)
4399	return og_client_method_not_found(cli);
4400
4401	if (!root) {
4402	syslog(LOG_ERR, "command software with no payload\n");
4403	return og_client_bad_request(cli);
4404	}
4405	err = og_cmd_software(root, &params);
4406	} else if (!strncmp(cmd, "image/create/basic",
4407	strlen("image/create/basic"))) {
4408	if (method != OG_METHOD_POST)
4409	return og_client_method_not_found(cli);
4410
4411	if (!root) {
4412	syslog(LOG_ERR, "command create with no payload\n");
4413	return og_client_bad_request(cli);
4414	}
4415	err = og_cmd_create_basic_image(root, &params);
4416	} else if (!strncmp(cmd, "image/create/incremental",
4417	strlen("image/create/incremental"))) {
4418	if (method != OG_METHOD_POST)
4419	return og_client_method_not_found(cli);
4420
4421	if (!root) {
4422	syslog(LOG_ERR, "command create with no payload\n");
4423	return og_client_bad_request(cli);
4424	}
4425	err = og_cmd_create_incremental_image(root, &params);
4426	} else if (!strncmp(cmd, "image/create", strlen("image/create"))) {
4427	if (method != OG_METHOD_POST)
4428	return og_client_method_not_found(cli);
4429
4430	if (!root) {
4431	syslog(LOG_ERR, "command create with no payload\n");
4432	return og_client_bad_request(cli);
4433	}
4434	err = og_cmd_create_image(root, &params);
4435	} else if (!strncmp(cmd, "image/restore/basic",
4436	strlen("image/restore/basic"))) {
4437	if (method != OG_METHOD_POST)
4438	return og_client_method_not_found(cli);
4439
4440	if (!root) {
4441	syslog(LOG_ERR, "command create with no payload\n");
4442	return og_client_bad_request(cli);
4443	}
4444	err = og_cmd_restore_basic_image(root, &params);
4445	} else if (!strncmp(cmd, "image/restore/incremental",
4446	strlen("image/restore/incremental"))) {
4447	if (method != OG_METHOD_POST)
4448	return og_client_method_not_found(cli);
4449
4450	if (!root) {
4451	syslog(LOG_ERR, "command create with no payload\n");
4452	return og_client_bad_request(cli);
4453	}
4454	err = og_cmd_restore_incremental_image(root, &params);
4455	} else if (!strncmp(cmd, "image/restore", strlen("image/restore"))) {
4456	if (method != OG_METHOD_POST)
4457	return og_client_method_not_found(cli);
4458
4459	if (!root) {
4460	syslog(LOG_ERR, "command create with no payload\n");
4461	return og_client_bad_request(cli);
4462	}
4463	err = og_cmd_restore_image(root, &params);
4464	} else if (!strncmp(cmd, "setup", strlen("setup"))) {
4465	if (method != OG_METHOD_POST)
4466	return og_client_method_not_found(cli);
4467
4468	if (!root) {
4469	syslog(LOG_ERR, "command create with no payload\n");
4470	return og_client_bad_request(cli);
4471	}
4472	err = og_cmd_setup(root, &params);
4473	} else if (!strncmp(cmd, "run/schedule", strlen("run/schedule"))) {
4474	if (method != OG_METHOD_POST)
4475	return og_client_method_not_found(cli);
4476
4477	if (!root) {
4478	syslog(LOG_ERR, "command create with no payload\n");
4479	return og_client_bad_request(cli);
4480	}
4481
4482	err = og_cmd_run_schedule(root, &params);
4483	} else if (!strncmp(cmd, "task/run", strlen("task/run"))) {
4484	if (method != OG_METHOD_POST)
4485	return og_client_method_not_found(cli);
4486
4487	if (!root) {
4488	syslog(LOG_ERR, "command task with no payload\n");
4489	return og_client_bad_request(cli);
4490	}
4491	err = og_cmd_task_post(root, &params);
4492	} else if (!strncmp(cmd, "schedule/create",
4493	strlen("schedule/create"))) {
4494	if (method != OG_METHOD_POST)
4495	return og_client_method_not_found(cli);
4496
4497	if (!root) {
4498	syslog(LOG_ERR, "command task with no payload\n");
4499	return og_client_bad_request(cli);
4500	}
4501	err = og_cmd_schedule_create(root, &params);
4502	} else if (!strncmp(cmd, "schedule/delete",
4503	strlen("schedule/delete"))) {
4504	if (method != OG_METHOD_POST)
4505	return og_client_method_not_found(cli);
4506
4507	if (!root) {
4508	syslog(LOG_ERR, "command task with no payload\n");
4509	return og_client_bad_request(cli);
4510	}
4511	err = og_cmd_schedule_delete(root, &params);
4512	} else if (!strncmp(cmd, "schedule/update",
4513	strlen("schedule/update"))) {
4514	if (method != OG_METHOD_POST)
4515	return og_client_method_not_found(cli);
4516
4517	if (!root) {
4518	syslog(LOG_ERR, "command task with no payload\n");
4519	return og_client_bad_request(cli);
4520	}
4521	err = og_cmd_schedule_update(root, &params);
4522	} else if (!strncmp(cmd, "schedule/get",
4523	strlen("schedule/get"))) {
4524	if (method != OG_METHOD_POST)
4525	return og_client_method_not_found(cli);
4526
4527	err = og_cmd_schedule_get(root, &params, buf_reply);
4528	} else {
4529	syslog(LOG_ERR, "unknown command: %.32s ...\n", cmd);
4530	err = og_client_not_found(cli);
4531	}
4532
4533	if (root)
4534	json_decref(root);
4535
4536	if (err < 0)
4537	return og_client_bad_request(cli);
4538
4539	err = og_client_ok(cli, buf_reply);
4540	if (err < 0) {
4541	syslog(LOG_ERR, "HTTP response to %s:%hu is too large\n",
4542	inet_ntoa(cli->addr.sin_addr),
4543	ntohs(cli->addr.sin_port));
4544	}
4545
4546	return err;
4547	}
4548
4549	static int og_client_state_recv_hdr_rest(struct og_client *cli)
4550	{
4551	char *ptr;
4552
4553	ptr = strstr(cli->buf, "\r\n\r\n");
4554	if (!ptr)
4555	return 0;
4556
4557	cli->msg_len = ptr - cli->buf + 4;
4558
4559	ptr = strstr(cli->buf, "Content-Length: ");
4560	if (ptr) {
4561	sscanf(ptr, "Content-Length: %i[^\r\n]", &cli->content_length);
4562	if (cli->content_length < 0)
4563	return -1;
4564	cli->msg_len += cli->content_length;
4565	}
4566
4567	ptr = strstr(cli->buf, "Authorization: ");
4568	if (ptr)
4569	sscanf(ptr, "Authorization: %63[^\r\n]", cli->auth_token);
4570
4571	return 1;
4572	}
4573
4574	static int og_client_recv(struct og_client *cli, int events)
4575	{
4576	struct ev_io *io = &cli->io;
4577	int ret;
4578
4579	if (events & EV_ERROR) {
4580	syslog(LOG_ERR, "unexpected error event from client %s:%hu\n",
4581	inet_ntoa(cli->addr.sin_addr),
4582	ntohs(cli->addr.sin_port));
4583	return 0;
4584	}
4585
4586	ret = recv(io->fd, cli->buf + cli->buf_len,
4587	sizeof(cli->buf) - cli->buf_len, 0);
4588	if (ret <= 0) {
4589	if (ret < 0) {
4590	syslog(LOG_ERR, "error reading from client %s:%hu (%s)\n",
4591	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port),
4592	strerror(errno));
4593	} else {
4594	syslog(LOG_DEBUG, "closed connection by %s:%hu\n",
4595	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
4596	}
4597	return ret;
4598	}
4599
4600	return ret;
4601	}
4602
4603	static void og_client_read_cb(struct ev_loop loop, struct ev_io io, int events)
4604	{
4605	struct og_client *cli;
4606	int ret;
4607
4608	cli = container_of(io, struct og_client, io);
4609
4610	ret = og_client_recv(cli, events);
4611	if (ret <= 0)
4612	goto close;
4613
4614	if (cli->keepalive_idx >= 0)
4615	return;
4616
4617	ev_timer_again(loop, &cli->timer);
4618
4619	cli->buf_len += ret;
4620	if (cli->buf_len >= sizeof(cli->buf)) {
4621	syslog(LOG_ERR, "client request from %s:%hu is too long\n",
4622	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
4623	og_client_payload_too_large(cli);
4624	goto close;
4625	}
4626
4627	switch (cli->state) {
4628	case OG_CLIENT_RECEIVING_HEADER:
4629	ret = og_client_state_recv_hdr_rest(cli);
4630	if (ret < 0)
4631	goto close;
4632	if (!ret)
4633	return;
4634
4635	cli->state = OG_CLIENT_RECEIVING_PAYLOAD;
4636	/* Fall through. */
4637	case OG_CLIENT_RECEIVING_PAYLOAD:
4638	/* Still not enough data to process request. */
4639	if (cli->buf_len < cli->msg_len)
4640	return;
4641
4642	cli->state = OG_CLIENT_PROCESSING_REQUEST;
4643	/* fall through. */
4644	case OG_CLIENT_PROCESSING_REQUEST:
4645	ret = og_client_state_process_payload_rest(cli);
4646	if (ret < 0) {
4647	syslog(LOG_ERR, "Failed to process HTTP request from %s:%hu\n",
4648	inet_ntoa(cli->addr.sin_addr),
4649	ntohs(cli->addr.sin_port));
4650	}
4651	if (ret < 0)
4652	goto close;
4653
4654	if (cli->keepalive_idx < 0) {
4655	syslog(LOG_DEBUG, "server closing connection to %s:%hu\n",
4656	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
4657	goto close;
4658	} else {
4659	syslog(LOG_DEBUG, "leaving client %s:%hu in keepalive mode\n",
4660	inet_ntoa(cli->addr.sin_addr),
4661	ntohs(cli->addr.sin_port));
4662	og_client_keepalive(loop, cli);
4663	og_client_reset_state(cli);
4664	}
4665	break;
4666	default:
4667	syslog(LOG_ERR, "unknown state, critical internal error\n");
4668	goto close;
4669	}
4670	return;
4671	close:
4672	ev_timer_stop(loop, &cli->timer);
4673	og_client_release(loop, cli);
4674	}
4675
4676	enum og_agent_state {
4677	OG_AGENT_RECEIVING_HEADER = 0,
4678	OG_AGENT_RECEIVING_PAYLOAD,
4679	OG_AGENT_PROCESSING_RESPONSE,
4680	};
4681
4682	static int og_agent_state_recv_hdr_rest(struct og_client *cli)
4683	{
4684	char *ptr;
4685
4686	ptr = strstr(cli->buf, "\r\n\r\n");
4687	if (!ptr)
4688	return 0;
4689
4690	cli->msg_len = ptr - cli->buf + 4;
4691
4692	ptr = strstr(cli->buf, "Content-Length: ");
4693	if (ptr) {
4694	sscanf(ptr, "Content-Length: %i[^\r\n]", &cli->content_length);
4695	if (cli->content_length < 0)
4696	return -1;
4697	cli->msg_len += cli->content_length;
4698	}
4699
4700	return 1;
4701	}
4702
4703	static void og_agent_reset_state(struct og_client *cli)
4704	{
4705	cli->state = OG_AGENT_RECEIVING_HEADER;
4706	cli->buf_len = 0;
4707	cli->content_length = 0;
4708	memset(cli->buf, 0, sizeof(cli->buf));
4709	}
4710
4711	static int og_dbi_get_computer_info(struct og_computer *computer,
4712	struct in_addr addr)
4713	{
4714	const char *msglog;
4715	struct og_dbi *dbi;
4716	dbi_result result;
4717
4718	dbi = og_dbi_open(&dbi_config);
4719	if (!dbi) {
4720	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4721	__func__, __LINE__);
4722	return -1;
4723	}
4724	result = dbi_conn_queryf(dbi->conn,
4725	"SELECT ordenadores.idordenador,"
4726	" ordenadores.nombreordenador,"
4727	" ordenadores.idaula,"
4728	" centros.idcentro FROM ordenadores "
4729	"INNER JOIN aulas ON aulas.idaula=ordenadores.idaula "
4730	"INNER JOIN centros ON centros.idcentro=aulas.idcentro "
4731	"WHERE ordenadores.ip='%s'", inet_ntoa(addr));
4732	if (!result) {
4733	dbi_conn_error(dbi->conn, &msglog);
4734	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
4735	__func__, __LINE__, msglog);
4736	og_dbi_close(dbi);
4737	return -1;
4738	}
4739	if (!dbi_result_next_row(result)) {
4740	syslog(LOG_ERR, "client does not exist in database (%s:%d)\n",
4741	__func__, __LINE__);
4742	dbi_result_free(result);
4743	og_dbi_close(dbi);
4744	return -1;
4745	}
4746
4747	computer->id = dbi_result_get_uint(result, "idordenador");
4748	computer->center = dbi_result_get_uint(result, "idcentro");
4749	computer->room = dbi_result_get_uint(result, "idaula");
4750	strncpy(computer->name,
4751	dbi_result_get_string(result, "nombreordenador"),
4752	OG_COMPUTER_NAME_MAXLEN);
4753
4754	dbi_result_free(result);
4755	og_dbi_close(dbi);
4756
4757	return 0;
4758	}
4759
4760	static int og_resp_probe(struct og_client cli, json_t data)
4761	{
4762	const char *status = NULL;
4763	const char *key;
4764	json_t *value;
4765	int err = 0;
4766
4767	if (json_typeof(data) != JSON_OBJECT)
4768	return -1;
4769
4770	json_object_foreach(data, key, value) {
4771	if (!strcmp(key, "status")) {
4772	err = og_json_parse_string(value, &status);
4773	if (err < 0)
4774	return err;
4775	} else {
4776	return -1;
4777	}
4778	}
4779
4780	if (!strcmp(status, "BSY"))
4781	cli->status = OG_CLIENT_STATUS_BUSY;
4782	else if (!strcmp(status, "OPG"))
4783	cli->status = OG_CLIENT_STATUS_OGLIVE;
4784
4785	return status ? 0 : -1;
4786	}
4787
4788	static int og_resp_shell_run(struct og_client cli, json_t data)
4789	{
4790	const char *output = NULL;
4791	char filename[4096];
4792	const char *key;
4793	json_t *value;
4794	int err = -1;
4795	FILE *file;
4796
4797	if (json_typeof(data) != JSON_OBJECT)
4798	return -1;
4799
4800	json_object_foreach(data, key, value) {
4801	if (!strcmp(key, "out")) {
4802	err = og_json_parse_string(value, &output);
4803	if (err < 0)
4804	return err;
4805	} else {
4806	return -1;
4807	}
4808	}
4809
4810	if (!output) {
4811	syslog(LOG_ERR, "%s:%d: malformed json response\n",
4812	__FILE__, __LINE__);
4813	return -1;
4814	}
4815
4816	sprintf(filename, "/tmp/_Seconsola_%s", inet_ntoa(cli->addr.sin_addr));
4817	file = fopen(filename, "wt");
4818	if (!file) {
4819	syslog(LOG_ERR, "cannot open file %s: %s\n",
4820	filename, strerror(errno));
4821	return -1;
4822	}
4823
4824	fprintf(file, "%s", output);
4825	fclose(file);
4826
4827	return 0;
4828	}
4829
4830	struct og_computer_legacy {
4831	char center[OG_DB_INT_MAXLEN + 1];
4832	char id[OG_DB_INT_MAXLEN + 1];
4833	char hardware[8192];
4834	};
4835
4836	static int og_resp_hardware(json_t data, struct og_client cli)
4837	{
4838	struct og_computer_legacy legacy = {};
4839	const char *hardware = NULL;
4840	struct og_computer computer;
4841	struct og_dbi *dbi;
4842	const char *key;
4843	json_t *value;
4844	int err = 0;
4845	bool res;
4846
4847	if (json_typeof(data) != JSON_OBJECT)
4848	return -1;
4849
4850	json_object_foreach(data, key, value) {
4851	if (!strcmp(key, "hardware")) {
4852	err = og_json_parse_string(value, &hardware);
4853	if (err < 0)
4854	return -1;
4855	} else {
4856	return -1;
4857	}
4858	}
4859
4860	if (!hardware) {
4861	syslog(LOG_ERR, "malformed response json\n");
4862	return -1;
4863	}
4864
4865	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
4866	if (err < 0)
4867	return -1;
4868
4869	snprintf(legacy.center, sizeof(legacy.center), "%d", computer.center);
4870	snprintf(legacy.id, sizeof(legacy.id), "%d", computer.id);
4871	snprintf(legacy.hardware, sizeof(legacy.hardware), "%s", hardware);
4872
4873	dbi = og_dbi_open(&dbi_config);
4874	if (!dbi) {
4875	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4876	__func__, __LINE__);
4877	return -1;
4878	}
4879
4880	res = actualizaHardware(dbi, legacy.hardware, legacy.id, computer.name,
4881	legacy.center);
4882	og_dbi_close(dbi);
4883
4884	if (!res) {
4885	syslog(LOG_ERR, "Problem updating client configuration\n");
4886	return -1;
4887	}
4888
4889	return 0;
4890	}
4891
4892	struct og_software_legacy {
4893	char software[8192];
4894	char center[OG_DB_INT_MAXLEN + 1];
4895	char part[OG_DB_SMALLINT_MAXLEN + 1];
4896	char id[OG_DB_INT_MAXLEN + 1];
4897	};
4898
4899	static int og_resp_software(json_t data, struct og_client cli)
4900	{
4901	struct og_software_legacy legacy = {};
4902	const char *partition = NULL;
4903	const char *software = NULL;
4904	struct og_computer computer;
4905	struct og_dbi *dbi;
4906	const char *key;
4907	json_t *value;
4908	int err = 0;
4909	bool res;
4910
4911	if (json_typeof(data) != JSON_OBJECT)
4912	return -1;
4913
4914	json_object_foreach(data, key, value) {
4915	if (!strcmp(key, "software"))
4916	err = og_json_parse_string(value, &software);
4917	else if (!strcmp(key, "partition"))
4918	err = og_json_parse_string(value, &partition);
4919	else
4920	return -1;
4921
4922	if (err < 0)
4923	return -1;
4924	}
4925
4926	if (!software \|\| !partition) {
4927	syslog(LOG_ERR, "malformed response json\n");
4928	return -1;
4929	}
4930
4931	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
4932	if (err < 0)
4933	return -1;
4934
4935	snprintf(legacy.software, sizeof(legacy.software), "%s", software);
4936	snprintf(legacy.part, sizeof(legacy.part), "%s", partition);
4937	snprintf(legacy.id, sizeof(legacy.id), "%d", computer.id);
4938	snprintf(legacy.center, sizeof(legacy.center), "%d", computer.center);
4939
4940	dbi = og_dbi_open(&dbi_config);
4941	if (!dbi) {
4942	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
4943	__func__, __LINE__);
4944	return -1;
4945	}
4946
4947	res = actualizaSoftware(dbi, legacy.software, legacy.part, legacy.id,
4948	computer.name, legacy.center);
4949	og_dbi_close(dbi);
4950
4951	if (!res) {
4952	syslog(LOG_ERR, "Problem updating client configuration\n");
4953	return -1;
4954	}
4955
4956	return 0;
4957	}
4958
4959	#define OG_PARAMS_RESP_REFRESH (OG_PARAM_PART_DISK \| \
4960	OG_PARAM_PART_NUMBER \| \
4961	OG_PARAM_PART_CODE \| \
4962	OG_PARAM_PART_FILESYSTEM \| \
4963	OG_PARAM_PART_OS \| \
4964	OG_PARAM_PART_SIZE \| \
4965	OG_PARAM_PART_USED_SIZE)
4966
4967	static int og_json_parse_partition_array(json_t *value,
4968	struct og_partition *partitions)
4969	{
4970	json_t *element;
4971	int i, err;
4972
4973	if (json_typeof(value) != JSON_ARRAY)
4974	return -1;
4975
4976	for (i = 0; i < json_array_size(value) && i < OG_PARTITION_MAX; i++) {
4977	element = json_array_get(value, i);
4978
4979	err = og_json_parse_partition(element, &partitions[i],
4980	OG_PARAMS_RESP_REFRESH);
4981	if (err < 0)
4982	return err;
4983	}
4984
4985	return 0;
4986	}
4987
4988	static int og_resp_refresh(json_t data, struct og_client cli)
4989	{
4990	struct og_partition partitions[OG_PARTITION_MAX] = {};
4991	const char *serial_number = NULL;
4992	struct og_partition disk_setup;
4993	struct og_computer computer;
4994	char cfg[1024] = {};
4995	struct og_dbi *dbi;
4996	const char *key;
4997	unsigned int i;
4998	json_t *value;
4999	int err = 0;
5000	bool res;
5001
5002	if (json_typeof(data) != JSON_OBJECT)
5003	return -1;
5004
5005	json_object_foreach(data, key, value) {
5006	if (!strcmp(key, "disk_setup")) {
5007	err = og_json_parse_partition(value,
5008	&disk_setup,
5009	OG_PARAMS_RESP_REFRESH);
5010	} else if (!strcmp(key, "partition_setup")) {
5011	err = og_json_parse_partition_array(value, partitions);
5012	} else if (!strcmp(key, "serial_number")) {
5013	err = og_json_parse_string(value, &serial_number);
5014	} else {
5015	return -1;
5016	}
5017
5018	if (err < 0)
5019	return err;
5020	}
5021
5022	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5023	if (err < 0)
5024	return -1;
5025
5026	if (strlen(serial_number) > 0)
5027	snprintf(cfg, sizeof(cfg), "ser=%s\n", serial_number);
5028
5029	if (!disk_setup.disk \|\| !disk_setup.number \|\| !disk_setup.code \|\|
5030	!disk_setup.filesystem \|\| !disk_setup.os \|\| !disk_setup.size \|\|
5031	!disk_setup.used_size)
5032	return -1;
5033
5034	snprintf(cfg + strlen(cfg), sizeof(cfg) - strlen(cfg),
5035	"disk=%s\tpar=%s\tcpt=%s\tfsi=%s\tsoi=%s\ttam=%s\tuso=%s\n",
5036	disk_setup.disk, disk_setup.number, disk_setup.code,
5037	disk_setup.filesystem, disk_setup.os, disk_setup.size,
5038	disk_setup.used_size);
5039
5040	for (i = 0; i < OG_PARTITION_MAX; i++) {
5041	if (!partitions[i].disk \|\| !partitions[i].number \|\|
5042	!partitions[i].code \|\| !partitions[i].filesystem \|\|
5043	!partitions[i].os \|\| !partitions[i].size \|\|
5044	!partitions[i].used_size)
5045	continue;
5046
5047	snprintf(cfg + strlen(cfg), sizeof(cfg) - strlen(cfg),
5048	"disk=%s\tpar=%s\tcpt=%s\tfsi=%s\tsoi=%s\ttam=%s\tuso=%s\n",
5049	partitions[i].disk, partitions[i].number,
5050	partitions[i].code, partitions[i].filesystem,
5051	partitions[i].os, partitions[i].size,
5052	partitions[i].used_size);
5053	}
5054
5055	dbi = og_dbi_open(&dbi_config);
5056	if (!dbi) {
5057	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5058	__func__, __LINE__);
5059	return -1;
5060	}
5061	res = actualizaConfiguracion(dbi, cfg, computer.id);
5062	og_dbi_close(dbi);
5063
5064	if (!res) {
5065	syslog(LOG_ERR, "Problem updating client configuration\n");
5066	return -1;
5067	}
5068
5069	return 0;
5070	}
5071
5072	static int og_resp_image_create(json_t data, struct og_client cli)
5073	{
5074	struct og_software_legacy soft_legacy;
5075	struct og_image_legacy img_legacy;
5076	const char *partition = NULL;
5077	const char *software = NULL;
5078	const char *image_id = NULL;
5079	struct og_computer computer;
5080	const char *disk = NULL;
5081	const char *code = NULL;
5082	const char *name = NULL;
5083	const char *repo = NULL;
5084	struct og_dbi *dbi;
5085	const char *key;
5086	json_t *value;
5087	int err = 0;
5088	bool res;
5089
5090	if (json_typeof(data) != JSON_OBJECT)
5091	return -1;
5092
5093	json_object_foreach(data, key, value) {
5094	if (!strcmp(key, "software"))
5095	err = og_json_parse_string(value, &software);
5096	else if (!strcmp(key, "partition"))
5097	err = og_json_parse_string(value, &partition);
5098	else if (!strcmp(key, "disk"))
5099	err = og_json_parse_string(value, &disk);
5100	else if (!strcmp(key, "code"))
5101	err = og_json_parse_string(value, &code);
5102	else if (!strcmp(key, "id"))
5103	err = og_json_parse_string(value, &image_id);
5104	else if (!strcmp(key, "name"))
5105	err = og_json_parse_string(value, &name);
5106	else if (!strcmp(key, "repository"))
5107	err = og_json_parse_string(value, &repo);
5108	else
5109	return -1;
5110
5111	if (err < 0)
5112	return err;
5113	}
5114
5115	if (!software \|\| !partition \|\| !disk \|\| !code \|\| !image_id \|\| !name \|\|
5116	!repo) {
5117	syslog(LOG_ERR, "malformed response json\n");
5118	return -1;
5119	}
5120
5121	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5122	if (err < 0)
5123	return -1;
5124
5125	snprintf(soft_legacy.center, sizeof(soft_legacy.center), "%d",
5126	computer.center);
5127	snprintf(soft_legacy.software, sizeof(soft_legacy.software), "%s",
5128	software);
5129	snprintf(img_legacy.image_id, sizeof(img_legacy.image_id), "%s",
5130	image_id);
5131	snprintf(soft_legacy.id, sizeof(soft_legacy.id), "%d", computer.id);
5132	snprintf(img_legacy.part, sizeof(img_legacy.part), "%s", partition);
5133	snprintf(img_legacy.disk, sizeof(img_legacy.disk), "%s", disk);
5134	snprintf(img_legacy.code, sizeof(img_legacy.code), "%s", code);
5135	snprintf(img_legacy.name, sizeof(img_legacy.name), "%s", name);
5136	snprintf(img_legacy.repo, sizeof(img_legacy.repo), "%s", repo);
5137
5138	dbi = og_dbi_open(&dbi_config);
5139	if (!dbi) {
5140	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5141	__func__, __LINE__);
5142	return -1;
5143	}
5144
5145	res = actualizaSoftware(dbi,
5146	soft_legacy.software,
5147	img_legacy.part,
5148	soft_legacy.id,
5149	computer.name,
5150	soft_legacy.center);
5151	if (!res) {
5152	og_dbi_close(dbi);
5153	syslog(LOG_ERR, "Problem updating client configuration\n");
5154	return -1;
5155	}
5156
5157	res = actualizaCreacionImagen(dbi,
5158	img_legacy.image_id,
5159	img_legacy.disk,
5160	img_legacy.part,
5161	img_legacy.code,
5162	img_legacy.repo,
5163	soft_legacy.id);
5164	og_dbi_close(dbi);
5165
5166	if (!res) {
5167	syslog(LOG_ERR, "Problem updating client configuration\n");
5168	return -1;
5169	}
5170
5171	return 0;
5172	}
5173
5174	static int og_resp_image_restore(json_t data, struct og_client cli)
5175	{
5176	struct og_software_legacy soft_legacy;
5177	struct og_image_legacy img_legacy;
5178	const char *partition = NULL;
5179	const char *image_id = NULL;
5180	struct og_computer computer;
5181	const char *disk = NULL;
5182	dbi_result query_result;
5183	struct og_dbi *dbi;
5184	const char *key;
5185	json_t *value;
5186	int err = 0;
5187	bool res;
5188
5189	if (json_typeof(data) != JSON_OBJECT)
5190	return -1;
5191
5192	json_object_foreach(data, key, value) {
5193	if (!strcmp(key, "partition"))
5194	err = og_json_parse_string(value, &partition);
5195	else if (!strcmp(key, "disk"))
5196	err = og_json_parse_string(value, &disk);
5197	else if (!strcmp(key, "image_id"))
5198	err = og_json_parse_string(value, &image_id);
5199	else
5200	return -1;
5201
5202	if (err < 0)
5203	return err;
5204	}
5205
5206	if (!partition \|\| !disk \|\| !image_id) {
5207	syslog(LOG_ERR, "malformed response json\n");
5208	return -1;
5209	}
5210
5211	err = og_dbi_get_computer_info(&computer, cli->addr.sin_addr);
5212	if (err < 0)
5213	return -1;
5214
5215	snprintf(img_legacy.image_id, sizeof(img_legacy.image_id), "%s",
5216	image_id);
5217	snprintf(img_legacy.part, sizeof(img_legacy.part), "%s", partition);
5218	snprintf(img_legacy.disk, sizeof(img_legacy.disk), "%s", disk);
5219	snprintf(soft_legacy.id, sizeof(soft_legacy.id), "%d", computer.id);
5220
5221	dbi = og_dbi_open(&dbi_config);
5222	if (!dbi) {
5223	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5224	__func__, __LINE__);
5225	return -1;
5226	}
5227
5228	query_result = dbi_conn_queryf(dbi->conn,
5229	"SELECT idperfilsoft FROM imagenes "
5230	" WHERE idimagen='%s'",
5231	image_id);
5232	if (!query_result) {
5233	og_dbi_close(dbi);
5234	syslog(LOG_ERR, "failed to query database\n");
5235	return -1;
5236	}
5237	if (!dbi_result_next_row(query_result)) {
5238	dbi_result_free(query_result);
5239	og_dbi_close(dbi);
5240	syslog(LOG_ERR, "software profile does not exist in database\n");
5241	return -1;
5242	}
5243	snprintf(img_legacy.software_id, sizeof(img_legacy.software_id),
5244	"%d", dbi_result_get_uint(query_result, "idperfilsoft"));
5245	dbi_result_free(query_result);
5246
5247	res = actualizaRestauracionImagen(dbi,
5248	img_legacy.image_id,
5249	img_legacy.disk,
5250	img_legacy.part,
5251	soft_legacy.id,
5252	img_legacy.software_id);
5253	og_dbi_close(dbi);
5254
5255	if (!res) {
5256	syslog(LOG_ERR, "Problem updating client configuration\n");
5257	return -1;
5258	}
5259
5260	return 0;
5261	}
5262
5263	static int og_dbi_update_action(struct og_client *cli, bool success)
5264	{
5265	char end_date_string[24];
5266	struct tm *end_date;
5267	const char *msglog;
5268	struct og_dbi *dbi;
5269	uint8_t status = 2;
5270	dbi_result result;
5271	time_t now;
5272
5273	if (!cli->last_cmd_id)
5274	return 0;
5275
5276	dbi = og_dbi_open(&dbi_config);
5277	if (!dbi) {
5278	syslog(LOG_ERR, "cannot open connection database (%s:%d)\n",
5279	__func__, __LINE__);
5280	return -1;
5281	}
5282
5283	time(&now);
5284	end_date = localtime(&now);
5285
5286	sprintf(end_date_string, "%hu/%hhu/%hhu %hhu:%hhu:%hhu",
5287	end_date->tm_year + 1900, end_date->tm_mon + 1,
5288	end_date->tm_mday, end_date->tm_hour, end_date->tm_min,
5289	end_date->tm_sec);
5290	result = dbi_conn_queryf(dbi->conn,
5291	"UPDATE acciones SET fechahorafin='%s', "
5292	"estado=%d, resultado=%d WHERE idaccion=%d",
5293	end_date_string, ACCION_FINALIZADA,
5294	status - success, cli->last_cmd_id);
5295
5296	if (!result) {
5297	dbi_conn_error(dbi->conn, &msglog);
5298	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
5299	__func__, __LINE__, msglog);
5300	og_dbi_close(dbi);
5301	return -1;
5302	}
5303	cli->last_cmd_id = 0;
5304	dbi_result_free(result);
5305	og_dbi_close(dbi);
5306
5307	return 0;
5308	}
5309
5310	static int og_agent_state_process_response(struct og_client *cli)
5311	{
5312	json_error_t json_err;
5313	json_t *root;
5314	int err = -1;
5315	char *body;
5316
5317	if (!strncmp(cli->buf, "HTTP/1.0 202 Accepted",
5318	strlen("HTTP/1.0 202 Accepted"))) {
5319	og_dbi_update_action(cli, true);
5320	return 1;
5321	}
5322
5323	if (strncmp(cli->buf, "HTTP/1.0 200 OK", strlen("HTTP/1.0 200 OK"))) {
5324	og_dbi_update_action(cli, false);
5325	return -1;
5326	}
5327	og_dbi_update_action(cli, true);
5328
5329	if (!cli->content_length) {
5330	cli->last_cmd = OG_CMD_UNSPEC;
5331	return 0;
5332	}
5333
5334	body = strstr(cli->buf, "\r\n\r\n") + 4;
5335
5336	root = json_loads(body, 0, &json_err);
5337	if (!root) {
5338	syslog(LOG_ERR, "%s:%d: malformed json line %d: %s\n",
5339	__FILE__, __LINE__, json_err.line, json_err.text);
5340	return -1;
5341	}
5342
5343	switch (cli->last_cmd) {
5344	case OG_CMD_PROBE:
5345	err = og_resp_probe(cli, root);
5346	break;
5347	case OG_CMD_SHELL_RUN:
5348	err = og_resp_shell_run(cli, root);
5349	break;
5350	case OG_CMD_HARDWARE:
5351	err = og_resp_hardware(root, cli);
5352	break;
5353	case OG_CMD_SOFTWARE:
5354	err = og_resp_software(root, cli);
5355	break;
5356	case OG_CMD_REFRESH:
5357	err = og_resp_refresh(root, cli);
5358	break;
5359	case OG_CMD_SETUP:
5360	err = og_resp_refresh(root, cli);
5361	break;
5362	case OG_CMD_IMAGE_CREATE:
5363	err = og_resp_image_create(root, cli);
5364	break;
5365	case OG_CMD_IMAGE_RESTORE:
5366	err = og_resp_image_restore(root, cli);
5367	break;
5368	default:
5369	err = -1;
5370	break;
5371	}
5372
5373	cli->last_cmd = OG_CMD_UNSPEC;
5374
5375	return err;
5376	}
5377
5378	static void og_agent_deliver_pending_cmd(struct og_client *cli)
5379	{
5380	const struct og_cmd *cmd;
5381
5382	cmd = og_cmd_find(inet_ntoa(cli->addr.sin_addr));
5383	if (!cmd)
5384	return;
5385
5386	og_send_request(cmd->method, cmd->type, &cmd->params, cmd->json);
5387	cli->last_cmd_id = cmd->id;
5388
5389	og_cmd_free(cmd);
5390	}
5391
5392	static void og_agent_read_cb(struct ev_loop loop, struct ev_io io, int events)
5393	{
5394	struct og_client *cli;
5395	int ret;
5396
5397	cli = container_of(io, struct og_client, io);
5398
5399	ret = og_client_recv(cli, events);
5400	if (ret <= 0)
5401	goto close;
5402
5403	ev_timer_again(loop, &cli->timer);
5404
5405	cli->buf_len += ret;
5406	if (cli->buf_len >= sizeof(cli->buf)) {
5407	syslog(LOG_ERR, "client request from %s:%hu is too long\n",
5408	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
5409	goto close;
5410	}
5411
5412	switch (cli->state) {
5413	case OG_AGENT_RECEIVING_HEADER:
5414	ret = og_agent_state_recv_hdr_rest(cli);
5415	if (ret < 0)
5416	goto close;
5417	if (!ret)
5418	return;
5419
5420	cli->state = OG_AGENT_RECEIVING_PAYLOAD;
5421	/* Fall through. */
5422	case OG_AGENT_RECEIVING_PAYLOAD:
5423	/* Still not enough data to process request. */
5424	if (cli->buf_len < cli->msg_len)
5425	return;
5426
5427	cli->state = OG_AGENT_PROCESSING_RESPONSE;
5428	/* fall through. */
5429	case OG_AGENT_PROCESSING_RESPONSE:
5430	ret = og_agent_state_process_response(cli);
5431	if (ret < 0) {
5432	syslog(LOG_ERR, "Failed to process HTTP request from %s:%hu\n",
5433	inet_ntoa(cli->addr.sin_addr),
5434	ntohs(cli->addr.sin_port));
5435	goto close;
5436	} else if (ret == 0) {
5437	og_agent_deliver_pending_cmd(cli);
5438	}
5439
5440	syslog(LOG_DEBUG, "leaving client %s:%hu in keepalive mode\n",
5441	inet_ntoa(cli->addr.sin_addr),
5442	ntohs(cli->addr.sin_port));
5443	og_agent_reset_state(cli);
5444	break;
5445	default:
5446	syslog(LOG_ERR, "unknown state, critical internal error\n");
5447	goto close;
5448	}
5449	return;
5450	close:
5451	ev_timer_stop(loop, &cli->timer);
5452	og_client_release(loop, cli);
5453	}
5454
5455	static void og_client_timer_cb(struct ev_loop loop, ev_timer timer, int events)
5456	{
5457	struct og_client *cli;
5458
5459	cli = container_of(timer, struct og_client, timer);
5460	if (cli->keepalive_idx >= 0) {
5461	ev_timer_again(loop, &cli->timer);
5462	return;
5463	}
5464	syslog(LOG_ERR, "timeout request for client %s:%hu\n",
5465	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
5466
5467	og_client_release(loop, cli);
5468	}
5469
5470	static void og_agent_send_refresh(struct og_client *cli)
5471	{
5472	struct og_msg_params params;
5473	int err;
5474
5475	params.ips_array[0] = inet_ntoa(cli->addr.sin_addr);
5476	params.ips_array_len = 1;
5477
5478	err = og_send_request(OG_METHOD_GET, OG_CMD_REFRESH, &params, NULL);
5479	if (err < 0) {
5480	syslog(LOG_ERR, "Can't send refresh to: %s\n",
5481	params.ips_array[0]);
5482	} else {
5483	syslog(LOG_INFO, "Sent refresh to: %s\n",
5484	params.ips_array[0]);
5485	}
5486	}
5487
5488	static int socket_rest, socket_agent_rest;
5489
5490	static void og_server_accept_cb(struct ev_loop loop, struct ev_io io,
5491	int events)
5492	{
5493	struct sockaddr_in client_addr;
5494	socklen_t addrlen = sizeof(client_addr);
5495	struct og_client *cli;
5496	int client_sd;
5497
5498	if (events & EV_ERROR)
5499	return;
5500
5501	client_sd = accept(io->fd, (struct sockaddr *)&client_addr, &addrlen);
5502	if (client_sd < 0) {
5503	syslog(LOG_ERR, "cannot accept client connection\n");
5504	return;
5505	}
5506
5507	cli = (struct og_client *)calloc(1, sizeof(struct og_client));
5508	if (!cli) {
5509	close(client_sd);
5510	return;
5511	}
5512	memcpy(&cli->addr, &client_addr, sizeof(client_addr));
5513	if (io->fd == socket_agent_rest)
5514	cli->keepalive_idx = 0;
5515	else
5516	cli->keepalive_idx = -1;
5517
5518	if (io->fd == socket_rest)
5519	cli->rest = true;
5520	else if (io->fd == socket_agent_rest)
5521	cli->agent = true;
5522
5523	syslog(LOG_DEBUG, "connection from client %s:%hu\n",
5524	inet_ntoa(cli->addr.sin_addr), ntohs(cli->addr.sin_port));
5525
5526	if (io->fd == socket_agent_rest)
5527	ev_io_init(&cli->io, og_agent_read_cb, client_sd, EV_READ);
5528	else
5529	ev_io_init(&cli->io, og_client_read_cb, client_sd, EV_READ);
5530
5531	ev_io_start(loop, &cli->io);
5532	if (io->fd == socket_agent_rest) {
5533	ev_timer_init(&cli->timer, og_client_timer_cb,
5534	OG_AGENT_CLIENT_TIMEOUT, 0.);
5535	} else {
5536	ev_timer_init(&cli->timer, og_client_timer_cb,
5537	OG_CLIENT_TIMEOUT, 0.);
5538	}
5539	ev_timer_start(loop, &cli->timer);
5540	list_add(&cli->list, &client_list);
5541
5542	if (io->fd == socket_agent_rest) {
5543	og_agent_send_refresh(cli);
5544	}
5545	}
5546
5547	static int og_socket_server_init(const char *port)
5548	{
5549	struct sockaddr_in local;
5550	int sd, on = 1;
5551
5552	sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5553	if (sd < 0) {
5554	syslog(LOG_ERR, "cannot create main socket\n");
5555	return -1;
5556	}
5557	setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(int));
5558
5559	local.sin_addr.s_addr = htonl(INADDR_ANY);
5560	local.sin_family = AF_INET;
5561	local.sin_port = htons(atoi(port));
5562
5563	if (bind(sd, (struct sockaddr *) &local, sizeof(local)) < 0) {
5564	close(sd);
5565	syslog(LOG_ERR, "cannot bind socket\n");
5566	return -1;
5567	}
5568
5569	listen(sd, 250);
5570
5571	return sd;
5572	}
5573
5574	int main(int argc, char *argv[])
5575	{
5576	struct ev_io ev_io_server_rest, ev_io_agent_rest;
5577	int i;
5578
5579	og_loop = ev_default_loop(0);
5580
5581	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
5582	exit(EXIT_FAILURE);
5583
5584	openlog("ogAdmServer", LOG_PID, LOG_DAEMON);
5585
5586	/*--------------------------------------------------------------------------------------------------------
5587	Validación de parámetros de ejecución y lectura del fichero de configuración del servicio
5588	---------------------------------------------------------------------------------------------------------*/
5589	if (!validacionParametros(argc, argv, 1)) // Valida parámetros de ejecución
5590	exit(EXIT_FAILURE);
5591
5592	if (!tomaConfiguracion(szPathFileCfg)) { // Toma parametros de configuracion
5593	exit(EXIT_FAILURE);
5594	}
5595
5596	/*--------------------------------------------------------------------------------------------------------
5597	// Inicializa array de información de los clientes
5598	---------------------------------------------------------------------------------------------------------*/
5599	for (i = 0; i < MAXIMOS_CLIENTES; i++) {
5600	tbsockets[i].ip[0] = '\0';
5601	tbsockets[i].cli = NULL;
5602	}
5603	/*--------------------------------------------------------------------------------------------------------
5604	Creación y configuración del socket del servicio
5605	---------------------------------------------------------------------------------------------------------*/
5606
5607	socket_rest = og_socket_server_init("8888");
5608	if (socket_rest < 0)
5609	exit(EXIT_FAILURE);
5610
5611	ev_io_init(&ev_io_server_rest, og_server_accept_cb, socket_rest, EV_READ);
5612	ev_io_start(og_loop, &ev_io_server_rest);
5613
5614	socket_agent_rest = og_socket_server_init("8889");
5615	if (socket_agent_rest < 0)
5616	exit(EXIT_FAILURE);
5617
5618	ev_io_init(&ev_io_agent_rest, og_server_accept_cb, socket_agent_rest, EV_READ);
5619	ev_io_start(og_loop, &ev_io_agent_rest);
5620
5621	if (og_dbi_schedule_get() < 0)
5622	exit(EXIT_FAILURE);
5623
5624	og_schedule_next(og_loop);
5625
5626	infoLog(1); // Inicio de sesión
5627
5628	/* old log file has been deprecated. */
5629	og_log(97, false);
5630
5631	syslog(LOG_INFO, "Waiting for connections\n");
5632
5633	while (1)
5634	ev_loop(og_loop, 0);
5635
5636	exit(EXIT_SUCCESS);
5637	}

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

Download in other formats: