Context Navigation

source: ogServer-Git/sources/ogAdmServer.c @ 894d833

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

#942 add command type to POST /schedule/create

Pass idcomando as task_id.

Property mode set to 100644

File size: 155.9 KB

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

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

Download in other formats: