Context Navigation

source: ogServer-Git/src/ogAdmServer.c @ d89d6c6

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

#988 remove legacy configuration file

Add getopt parser and use json configuration file instead.

Property mode set to 100644

File size: 36.8 KB

Rev	Line
[6fc28cd]	1	// *******************************************************************************************************
[b9eb98b]	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
[6fc28cd]	8	// *******************************************************************************************************
[b9eb98b]	9	#include "ogAdmServer.h"
[0fbdcf2]	10	#include "dbi.h"
[f4e7832]	11	#include "utils.h"
[96b9bb8]	12	#include "list.h"
[04ca20e]	13	#include "rest.h"
	14	#include "client.h"
	15	#include "json.h"
[83b242c]	16	#include "schedule.h"
[96b02b5]	17	#include "wol.h"
[ef6e3d2]	18	#include <syslog.h>
[2baf362]	19	#include <sys/ioctl.h>
[c6020f2]	20	#include <sys/types.h>
	21	#include <sys/stat.h>
	22	#include <fcntl.h>
[95e6520]	23	#include <jansson.h>
[83b242c]	24	#include <time.h>
[2427e9d]	25
[d6789f1]	26	char usuario[4096]; // Usuario de acceso a la base de datos
	27	char pasguor[4096]; // Password del usuario
	28	char datasource[4096]; // Dirección IP del gestor de base de datos
	29	char catalog[4096]; // Nombre de la base de datos
	30	char interface[4096]; // Interface name
	31	char auth_token[4096]; // API token
	32	char servidoradm[4096]; // Dirección IP del servidor de administración
	33	char puerto[4096]; // Puerto de comunicación
[0631b0e]	34	char db_port[4096];
[d6789f1]	35
[04ca20e]	36	struct og_dbi_config dbi_config = {
[0fbdcf2]	37	.user = usuario,
	38	.passwd = pasguor,
	39	.host = datasource,
[0631b0e]	40	.port = db_port,
[0fbdcf2]	41	.database = catalog,
	42	};
	43
[af30cc7]	44	#define OG_CMD_MAXLEN 64
[20dcb0a]	45
[b9eb98b]	46	// ________________________________________________________________________________________________________
	47	// Función: actualizaConfiguracion
	48	//
	49	// Descripción:
	50	// Esta función actualiza la base de datos con la configuracion de particiones de un cliente
	51	// Parámetros:
	52	// - db: Objeto base de datos (ya operativo)
	53	// - tbl: Objeto tabla
	54	// - cfg: cadena con una Configuración
	55	// - ido: Identificador del ordenador cliente
	56	// Devuelve:
[9dea2d6]	57	// true: Si el proceso es correcto
	58	// false: En caso de ocurrir algún error
[b9eb98b]	59	// Especificaciones:
	60	// Los parametros de la configuración son:
	61	// par= Número de partición
	62	// cpt= Codigo o tipo de partición
	63	// sfi= Sistema de ficheros que está implementado en la partición
	64	// soi= Nombre del sistema de ficheros instalado en la partición
	65	// tam= Tamaño de la partición
	66	// ________________________________________________________________________________________________________
[fa6b891]	67	bool actualizaConfiguracion(struct og_dbi dbi, char cfg, int ido)
[b9eb98b]	68	{
[827bac5]	69	int lon, p, c,i, dato, swu, idsoi, idsfi,k;
[3de93a9]	70	char ptrPar[MAXPAR], ptrCfg[7], *ptrDual[2], tbPar[LONSTD];
[24df599]	71	char ser, disk, par, cpt, sfi, soi, tam, uso; // Parametros de configuración.
[fa6b891]	72	dbi_result result, result_update;
	73	const char *msglog;
[b9eb98b]	74
[9a2dc88]	75	lon = 0;
[b9eb98b]	76	p = splitCadena(ptrPar, cfg, '\n');
	77	for (i = 0; i < p; i++) {
	78	c = splitCadena(ptrCfg, ptrPar[i], '\t');
[24df599]	79
	80	// Si la 1ª línea solo incluye el número de serie del equipo; actualizar BD.
	81	if (i == 0 && c == 1) {
	82	splitCadena(ptrDual, ptrCfg[0], '=');
	83	ser = ptrDual[1];
	84	if (strlen(ser) > 0) {
	85	// Solo actualizar si número de serie no existía.
[fa6b891]	86	result = dbi_conn_queryf(dbi->conn,
	87	"UPDATE ordenadores SET numserie='%s'"
[b502279]	88	" WHERE idordenador=%d AND numserie IS NULL",
[24df599]	89	ser, ido);
[fa6b891]	90	if (!result) {
	91	dbi_conn_error(dbi->conn, &msglog);
[bf8ba6c]	92	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	93	__func__, __LINE__, msglog);
[9dea2d6]	94	return false;
[24df599]	95	}
[bf8ba6c]	96	dbi_result_free(result);
[24df599]	97	}
	98	continue;
	99	}
	100
	101	// Distribución de particionado.
[c4b75b1]	102	disk = par = cpt = sfi = soi = tam = uso = NULL;
[24df599]	103
[b9eb98b]	104	splitCadena(ptrDual, ptrCfg[0], '=');
[99f74d8]	105	disk = ptrDual[1]; // Número de disco
[b9eb98b]	106
	107	splitCadena(ptrDual, ptrCfg[1], '=');
[99f74d8]	108	par = ptrDual[1]; // Número de partición
	109
[d1e9613]	110	k=splitCadena(ptrDual, ptrCfg[2], '=');
	111	if(k==2){
	112	cpt = ptrDual[1]; // Código de partición
	113	}else{
[24df599]	114	cpt = (char*)"0";
[d1e9613]	115	}
[b9eb98b]	116
[99f74d8]	117	k=splitCadena(ptrDual, ptrCfg[3], '=');
[b9eb98b]	118	if(k==2){
	119	sfi = ptrDual[1]; // Sistema de ficheros
[eb99080]	120	/* Comprueba existencia del s0xistema de ficheros instalado */
[fa6b891]	121	idsfi = checkDato(dbi, sfi, "sistemasficheros", "descripcion","idsistemafichero");
[b9eb98b]	122	}
	123	else
	124	idsfi=0;
	125
[99f74d8]	126	k=splitCadena(ptrDual, ptrCfg[4], '=');
[b9eb98b]	127	if(k==2){ // Sistema operativo detecdtado
	128	soi = ptrDual[1]; // Nombre del S.O. instalado
	129	/* Comprueba existencia del sistema operativo instalado */
[fa6b891]	130	idsoi = checkDato(dbi, soi, "nombresos", "nombreso", "idnombreso");
[b9eb98b]	131	}
	132	else
	133	idsoi=0;
	134
[99f74d8]	135	splitCadena(ptrDual, ptrCfg[5], '=');
[b9eb98b]	136	tam = ptrDual[1]; // Tamaño de la partición
	137
[c4b75b1]	138	splitCadena(ptrDual, ptrCfg[6], '=');
	139	uso = ptrDual[1]; // Porcentaje de uso del S.F.
	140
[9a2dc88]	141	lon += sprintf(tbPar + lon, "(%s, %s),", disk, par);
[b9eb98b]	142
[fa6b891]	143	result = dbi_conn_queryf(dbi->conn,
	144	"SELECT numdisk, numpar, tamano, uso, idsistemafichero, idnombreso"
[c4b75b1]	145	" FROM ordenadores_particiones"
	146	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
[99f74d8]	147	ido, disk, par);
[fa6b891]	148	if (!result) {
	149	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	150	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	151	__func__, __LINE__, msglog);
[9dea2d6]	152	return false;
[b9eb98b]	153	}
[fa6b891]	154	if (!dbi_result_next_row(result)) {
	155	result_update = dbi_conn_queryf(dbi->conn,
	156	"INSERT INTO ordenadores_particiones(idordenador,numdisk,numpar,codpar,tamano,uso,idsistemafichero,idnombreso,idimagen)"
[c4b75b1]	157	" VALUES(%d,%s,%s,0x%s,%s,%s,%d,%d,0)",
	158	ido, disk, par, cpt, tam, uso, idsfi, idsoi);
[fa6b891]	159	if (!result_update) {
	160	dbi_conn_error(dbi->conn, &msglog);
[bf8ba6c]	161	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	162	__func__, __LINE__, msglog);
[9dea2d6]	163	return false;
[b9eb98b]	164	}
[fa6b891]	165	dbi_result_free(result_update);
	166
[b9eb98b]	167	} else { // Existe el registro
[9dea2d6]	168	swu = true; // Se supone que algún dato ha cambiado
[fa6b891]	169
	170	dato = dbi_result_get_uint(result, "tamano");
	171	if (atoi(tam) == dato) {// Parámetro tamaño igual al almacenado
	172	dato = dbi_result_get_uint(result, "idsistemafichero");
	173	if (idsfi == dato) {// Parámetro sistema de fichero igual al almacenado
	174	dato = dbi_result_get_uint(result, "idnombreso");
	175	if (idsoi == dato) {// Parámetro sistema de fichero distinto al almacenado
[1845104]	176	swu = false; // Todos los parámetros de la partición son iguales, no se actualiza
[b9eb98b]	177	}
	178	}
	179	}
	180	if (swu) { // Hay que actualizar los parámetros de la partición
[fa6b891]	181	result_update = dbi_conn_queryf(dbi->conn,
	182	"UPDATE ordenadores_particiones SET "
[b9eb98b]	183	" codpar=0x%s,"
	184	" tamano=%s,"
[c4b75b1]	185	" uso=%s,"
[b9eb98b]	186	" idsistemafichero=%d,"
	187	" idnombreso=%d,"
[599c505]	188	" idimagen=0,"
	189	" idperfilsoft=0,"
	190	" fechadespliegue=NULL"
[99f74d8]	191	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
[c4b75b1]	192	cpt, tam, uso, idsfi, idsoi, ido, disk, par);
[d56675d]	193	} else { // Actualizar porcentaje de uso.
[fa6b891]	194	result_update = dbi_conn_queryf(dbi->conn,
	195	"UPDATE ordenadores_particiones SET "
[696c5bb]	196	" codpar=0x%s,"
[d56675d]	197	" uso=%s"
	198	" WHERE idordenador=%d AND numdisk=%s AND numpar=%s",
[696c5bb]	199	cpt, uso, ido, disk, par);
[d56675d]	200	}
[fa6b891]	201	if (!result_update) {
	202	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	203	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	204	__func__, __LINE__, msglog);
[9dea2d6]	205	return false;
[b9eb98b]	206	}
[fa6b891]	207
	208	dbi_result_free(result_update);
[b9eb98b]	209	}
[bf8ba6c]	210	dbi_result_free(result);
[b9eb98b]	211	}
[9a2dc88]	212	lon += sprintf(tbPar + lon, "(0,0)");
[b9eb98b]	213	// Eliminar particiones almacenadas que ya no existen
[fa6b891]	214	result_update = dbi_conn_queryf(dbi->conn,
	215	"DELETE FROM ordenadores_particiones WHERE idordenador=%d AND (numdisk, numpar) NOT IN (%s)",
[9a2dc88]	216	ido, tbPar);
[fa6b891]	217	if (!result_update) {
	218	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	219	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	220	__func__, __LINE__, msglog);
[9dea2d6]	221	return false;
[b9eb98b]	222	}
[fa6b891]	223	dbi_result_free(result_update);
	224
[9dea2d6]	225	return true;
[b9eb98b]	226	}
	227	// ________________________________________________________________________________________________________
	228	// Función: checkDato
	229	//
	230	// Descripción:
	231	// Esta función comprueba si existe un dato en una tabla y si no es así lo incluye. devuelve en
	232	// cualquier caso el identificador del registro existenet o del insertado
	233	// Parámetros:
	234	// - db: Objeto base de datos (ya operativo)
	235	// - tbl: Objeto tabla
	236	// - dato: Dato
	237	// - tabla: Nombre de la tabla
	238	// - nomdato: Nombre del dato en la tabla
	239	// - nomidentificador: Nombre del identificador en la tabla
	240	// Devuelve:
	241	// El identificador del registro existente o el del insertado
	242	//
	243	// Especificaciones:
	244	// En caso de producirse algún error se devuelve el valor 0
	245	// ________________________________________________________________________________________________________
	246
[fa6b891]	247	int checkDato(struct og_dbi dbi, char dato, const char *tabla,
[59fb4d5]	248	const char nomdato, const char nomidentificador)
	249	{
[fa6b891]	250	const char *msglog;
[b9eb98b]	251	int identificador;
[fa6b891]	252	dbi_result result;
[b9eb98b]	253
	254	if (strlen(dato) == 0)
	255	return (0); // EL dato no tiene valor
[fa6b891]	256	result = dbi_conn_queryf(dbi->conn,
	257	"SELECT %s FROM %s WHERE %s ='%s'", nomidentificador,
[b9eb98b]	258	tabla, nomdato, dato);
	259
	260	// Ejecuta consulta
[fa6b891]	261	if (!result) {
	262	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	263	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	264	__func__, __LINE__, msglog);
[b9eb98b]	265	return (0);
	266	}
[fa6b891]	267	if (!dbi_result_next_row(result)) { // Software NO existente
	268	dbi_result_free(result);
	269
	270	result = dbi_conn_queryf(dbi->conn,
	271	"INSERT INTO %s (%s) VALUES('%s')", tabla, nomdato, dato);
	272	if (!result) {
	273	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	274	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	275	__func__, __LINE__, msglog);
[b9eb98b]	276	return (0);
	277	}
	278	// Recupera el identificador del software
[fa6b891]	279	identificador = dbi_conn_sequence_last(dbi->conn, NULL);
[b9eb98b]	280	} else {
[fa6b891]	281	identificador = dbi_result_get_uint(result, nomidentificador);
[b9eb98b]	282	}
[fa6b891]	283	dbi_result_free(result);
	284
[b9eb98b]	285	return (identificador);
	286	}
[96b9bb8]	287
[b9eb98b]	288	// ________________________________________________________________________________________________________
	289	// Función: Levanta
	290	//
	291	// Descripción:
	292	// Enciende ordenadores a través de la red cuyas macs se pasan como parámetro
	293	// Parámetros:
[0cee7a6]	294	// - iph: Cadena de direcciones ip separadas por ";"
[b9eb98b]	295	// - mac: Cadena de direcciones mac separadas por ";"
[0cee7a6]	296	// - mar: Método de arranque (1=Broadcast, 2=Unicast)
[b9eb98b]	297	// Devuelve:
[9dea2d6]	298	// true: Si el proceso es correcto
	299	// false: En caso de ocurrir algún error
[b9eb98b]	300	// ________________________________________________________________________________________________________
[507c75c]	301
[06af0c2]	302	bool Levanta(char ptrIP[], char ptrMacs[], char *ptrNetmasks[], int lon,
	303	char *mar)
[0cee7a6]	304	{
[060e31c]	305	int i, s;
	306
	307	s = wol_socket_open();
	308	if (s < 0)
[9dea2d6]	309	return false;
[63a3d4d]	310
[b9eb98b]	311	for (i = 0; i < lon; i++) {
[06af0c2]	312	if (!WakeUp(s, ptrIP[i], ptrMacs[i], ptrNetmasks[i], mar)) {
[b56cbeb]	313	syslog(LOG_ERR, "problem sending magic packet\n");
[b9eb98b]	314	close(s);
[9dea2d6]	315	return false;
[b9eb98b]	316	}
	317	}
	318	close(s);
[9dea2d6]	319	return true;
[b9eb98b]	320	}
[2baf362]	321
	322	enum wol_delivery_type {
	323	OG_WOL_BROADCAST = 1,
	324	OG_WOL_UNICAST = 2
	325	};
	326
[b9eb98b]	327	//_____________________________________________________________________________________________________________
	328	// Función: WakeUp
	329	//
	330	// Descripción:
	331	// Enciende el ordenador cuya MAC se pasa como parámetro
	332	// Parámetros:
	333	// - s : Socket para enviar trama magic packet
[0cee7a6]	334	// - iph : Cadena con la dirección ip
[b9eb98b]	335	// - mac : Cadena con la dirección mac en formato XXXXXXXXXXXX
[0cee7a6]	336	// - mar: Método de arranque (1=Broadcast, 2=Unicast)
[b9eb98b]	337	// Devuelve:
[9dea2d6]	338	// true: Si el proceso es correcto
	339	// false: En caso de ocurrir algún error
[b9eb98b]	340	//_____________________________________________________________________________________________________________
[0cee7a6]	341	//
[06af0c2]	342	bool WakeUp(int s, char* iph, char mac, char netmask, char *mar)
[0cee7a6]	343	{
[06af0c2]	344	struct in_addr addr, netmask_addr, broadcast_addr ={};
[429bd36]	345	unsigned int macaddr[OG_WOL_MACADDR_LEN];
[2baf362]	346	char HDaddress_bin[OG_WOL_MACADDR_LEN];
	347	struct sockaddr_in WakeUpCliente;
	348	struct wol_msg Trama_WakeUp;
	349	bool ret;
	350	int i;
[b9eb98b]	351
[06af0c2]	352	if (inet_aton(iph, &addr) < 0) {
	353	syslog(LOG_ERR, "bad IP address\n");
	354	return false;
	355	}
	356
	357	if (inet_aton(netmask, &netmask_addr) < 0) {
	358	syslog(LOG_ERR, "bad netmask address: %s\n", netmask);
	359	return false;
	360	}
	361
	362	broadcast_addr.s_addr = addr.s_addr \| ~netmask_addr.s_addr;
	363
[b9eb98b]	364	for (i = 0; i < 6; i++) // Primera secuencia de la trama Wake Up (0xFFFFFFFFFFFF)
	365	Trama_WakeUp.secuencia_FF[i] = 0xFF;
	366
[63a3d4d]	367	sscanf(mac, "%02x%02x%02x%02x%02x%02x",
[429bd36]	368	&macaddr[0], &macaddr[1], &macaddr[2],
	369	&macaddr[3], &macaddr[4], &macaddr[5]);
	370
	371	for (i = 0; i < 6; i++)
	372	HDaddress_bin[i] = (uint8_t)macaddr[i];
[b9eb98b]	373
	374	for (i = 0; i < 16; i++) // Segunda secuencia de la trama Wake Up , repetir 16 veces su la MAC
	375	memcpy(&Trama_WakeUp.macbin[i][0], &HDaddress_bin, 6);
	376
	377	/* Creación de socket del cliente que recibe la trama magic packet */
	378	WakeUpCliente.sin_family = AF_INET;
	379	WakeUpCliente.sin_port = htons((short) PUERTO_WAKEUP);
	380
[2baf362]	381	switch (atoi(mar)) {
	382	case OG_WOL_BROADCAST:
[b38ed0d]	383	ret = wake_up_broadcast(s, &WakeUpCliente, &Trama_WakeUp);
[96b02b5]	384	ret &= wake_up_send(s, &WakeUpCliente, &Trama_WakeUp,
	385	&broadcast_addr);
[2baf362]	386	break;
	387	case OG_WOL_UNICAST:
[96b02b5]	388	ret = wake_up_send(s, &WakeUpCliente, &Trama_WakeUp, &addr);
[2baf362]	389	break;
	390	default:
	391	syslog(LOG_ERR, "unknown wol type\n");
	392	ret = false;
	393	break;
	394	}
	395	return ret;
[b9eb98b]	396	}
	397
	398	// ________________________________________________________________________________________________________
	399	// Función: actualizaCreacionImagen
	400	//
	401	// Descripción:
	402	// Esta función actualiza la base de datos con el resultado de la creación de una imagen
	403	// Parámetros:
	404	// - db: Objeto base de datos (ya operativo)
	405	// - tbl: Objeto tabla
	406	// - idi: Identificador de la imagen
[599c505]	407	// - dsk: Disco de donde se creó
[b9eb98b]	408	// - par: Partición de donde se creó
	409	// - cpt: Código de partición
	410	// - ipr: Ip del repositorio
	411	// - ido: Identificador del ordenador modelo
	412	// Devuelve:
[9dea2d6]	413	// true: Si el proceso es correcto
	414	// false: En caso de ocurrir algún error
[b9eb98b]	415	// ________________________________________________________________________________________________________
[9cc156c]	416	bool actualizaCreacionImagen(struct og_dbi dbi, char idi, char *dsk,
[59fb4d5]	417	char par, char cpt, char ipr, char ido)
	418	{
[9cc156c]	419	const char *msglog;
	420	dbi_result result;
[ed05cd5]	421	int idr,ifs;
[b9eb98b]	422
[80d1dfd]	423	/* Toma identificador del repositorio correspondiente al ordenador modelo */
[9cc156c]	424	result = dbi_conn_queryf(dbi->conn,
[599c505]	425	"SELECT repositorios.idrepositorio"
[80d1dfd]	426	" FROM repositorios"
	427	" LEFT JOIN ordenadores USING (idrepositorio)"
	428	" WHERE repositorios.ip='%s' AND ordenadores.idordenador=%s", ipr, ido);
[b9eb98b]	429
[9cc156c]	430	if (!result) {
	431	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	432	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	433	__func__, __LINE__, msglog);
[9dea2d6]	434	return false;
[b9eb98b]	435	}
[9cc156c]	436	if (!dbi_result_next_row(result)) {
	437	syslog(LOG_ERR,
	438	"repository does not exist in database (%s:%d)\n",
	439	__func__, __LINE__);
	440	dbi_result_free(result);
[9dea2d6]	441	return false;
[b9eb98b]	442	}
[9cc156c]	443	idr = dbi_result_get_uint(result, "idrepositorio");
	444	dbi_result_free(result);
[b9eb98b]	445
	446	/* Toma identificador del perfilsoftware */
[9cc156c]	447	result = dbi_conn_queryf(dbi->conn,
[599c505]	448	"SELECT idperfilsoft"
	449	" FROM ordenadores_particiones"
	450	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s", ido, dsk, par);
[b9eb98b]	451
[9cc156c]	452	if (!result) {
	453	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	454	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	455	__func__, __LINE__, msglog);
[9dea2d6]	456	return false;
[b9eb98b]	457	}
[9cc156c]	458	if (!dbi_result_next_row(result)) {
	459	syslog(LOG_ERR,
	460	"software profile does not exist in database (%s:%d)\n",
	461	__func__, __LINE__);
	462	dbi_result_free(result);
[9dea2d6]	463	return false;
[b9eb98b]	464	}
[9cc156c]	465	ifs = dbi_result_get_uint(result, "idperfilsoft");
	466	dbi_result_free(result);
[b9eb98b]	467
	468	/* Actualizar los datos de la imagen */
[9cc156c]	469	result = dbi_conn_queryf(dbi->conn,
[faee12e]	470	"UPDATE imagenes"
	471	" SET idordenador=%s, numdisk=%s, numpar=%s, codpar=%s,"
	472	" idperfilsoft=%d, idrepositorio=%d,"
	473	" fechacreacion=NOW(), revision=revision+1"
	474	" WHERE idimagen=%s", ido, dsk, par, cpt, ifs, idr, idi);
[b9eb98b]	475
[9cc156c]	476	if (!result) {
	477	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	478	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	479	__func__, __LINE__, msglog);
[9dea2d6]	480	return false;
[b9eb98b]	481	}
[9cc156c]	482	dbi_result_free(result);
	483
[faee12e]	484	/* Actualizar los datos en el cliente */
[9cc156c]	485	result = dbi_conn_queryf(dbi->conn,
[faee12e]	486	"UPDATE ordenadores_particiones"
[ed05cd5]	487	" SET idimagen=%s, revision=(SELECT revision FROM imagenes WHERE idimagen=%s),"
	488	" fechadespliegue=NOW()"
[faee12e]	489	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s",
[ed05cd5]	490	idi, idi, ido, dsk, par);
[9cc156c]	491	if (!result) {
	492	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	493	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	494	__func__, __LINE__, msglog);
[9dea2d6]	495	return false;
[faee12e]	496	}
[e81d230]	497	dbi_result_free(result);
[b9eb98b]	498
[e81d230]	499	return true;
[eb99080]	500	}
[e81d230]	501
[eb99080]	502	// ________________________________________________________________________________________________________
[b9eb98b]	503	// Función: actualizaRestauracionImagen
	504	//
	505	// Descripción:
[eb99080]	506	// Esta función actualiza la base de datos con el resultado de la restauración de una imagen
[b9eb98b]	507	// Parámetros:
	508	// - db: Objeto base de datos (ya operativo)
	509	// - tbl: Objeto tabla
	510	// - idi: Identificador de la imagen
[599c505]	511	// - dsk: Disco de donde se restauró
[b9eb98b]	512	// - par: Partición de donde se restauró
	513	// - ido: Identificador del cliente donde se restauró
	514	// - ifs: Identificador del perfil software contenido en la imagen
	515	// Devuelve:
[9dea2d6]	516	// true: Si el proceso es correcto
	517	// false: En caso de ocurrir algún error
[b9eb98b]	518	// ________________________________________________________________________________________________________
[fa6b891]	519	bool actualizaRestauracionImagen(struct og_dbi dbi, char idi,
[59fb4d5]	520	char dsk, char par, char ido, char ifs)
	521	{
[fa6b891]	522	const char *msglog;
	523	dbi_result result;
[b9eb98b]	524
	525	/* Actualizar los datos de la imagen */
[fa6b891]	526	result = dbi_conn_queryf(dbi->conn,
[599c505]	527	"UPDATE ordenadores_particiones"
[60bbc25]	528	" SET idimagen=%s, idperfilsoft=%s, fechadespliegue=NOW(),"
[9e3c02a]	529	" revision=(SELECT revision FROM imagenes WHERE idimagen=%s),"
	530	" idnombreso=IFNULL((SELECT idnombreso FROM perfilessoft WHERE idperfilsoft=%s),0)"
[c20cf9c]	531	" WHERE idordenador=%s AND numdisk=%s AND numpar=%s", idi, ifs, idi, ifs, ido, dsk, par);
[b9eb98b]	532
[fa6b891]	533	if (!result) {
	534	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	535	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	536	__func__, __LINE__, msglog);
[9dea2d6]	537	return false;
[b9eb98b]	538	}
[fa6b891]	539	dbi_result_free(result);
	540
[9dea2d6]	541	return true;
[b9eb98b]	542	}
	543	// ________________________________________________________________________________________________________
	544	// Función: actualizaHardware
	545	//
	546	// Descripción:
	547	// Actualiza la base de datos con la configuracion hardware del cliente
	548	// Parámetros:
	549	// - db: Objeto base de datos (ya operativo)
	550	// - tbl: Objeto tabla
	551	// - hrd: cadena con el inventario hardware
	552	// - ido: Identificador del ordenador
	553	// - npc: Nombre del ordenador
	554	// - idc: Identificador del centro o Unidad organizativa
	555	// ________________________________________________________________________________________________________
[eb99080]	556	//
[03f1941]	557	bool actualizaHardware(struct og_dbi dbi, char hrd, char ido, char npc,
[59fb4d5]	558	char *idc)
[eb99080]	559	{
[03f1941]	560	const char *msglog;
[b9eb98b]	561	int idtipohardware, idperfilhard;
	562	int lon, i, j, aux;
[7f46c45]	563	bool retval;
[eb99080]	564	char *whard;
[b9eb98b]	565	int tbidhardware[MAXHARDWARE];
[03f1941]	566	char tbHardware[MAXHARDWARE],dualHardware[2], strInt[LONINT], *idhardwares;
	567	dbi_result result;
[b9eb98b]	568
	569	/* Toma Centro (Unidad Organizativa) */
[03f1941]	570	result = dbi_conn_queryf(dbi->conn,
	571	"SELECT idperfilhard FROM ordenadores WHERE idordenador=%s",
	572	ido);
	573	if (!result) {
	574	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	575	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	576	__func__, __LINE__, msglog);
[9dea2d6]	577	return false;
[b9eb98b]	578	}
[03f1941]	579	if (!dbi_result_next_row(result)) {
	580	syslog(LOG_ERR, "client does not exist in database (%s:%d)\n",
	581	__func__, __LINE__);
	582	dbi_result_free(result);
[9dea2d6]	583	return false;
[b9eb98b]	584	}
[03f1941]	585	idperfilhard = dbi_result_get_uint(result, "idperfilhard");
	586	dbi_result_free(result);
	587
[eb99080]	588	whard=escaparCadena(hrd); // Codificar comillas simples
	589	if(!whard)
[9dea2d6]	590	return false;
[b9eb98b]	591	/* Recorre componentes hardware*/
[eb99080]	592	lon = splitCadena(tbHardware, whard, '\n');
[b9eb98b]	593	if (lon > MAXHARDWARE)
	594	lon = MAXHARDWARE; // Limita el número de componentes hardware
	595	/*
	596	for (i=0;i<lon;i++){
	597	sprintf(msglog,"Linea de inventario: %s",tbHardware[i]);
[9dea2d6]	598	RegistraLog(msglog,false);
[b9eb98b]	599	}
	600	*/
	601	for (i = 0; i < lon; i++) {
	602	splitCadena(dualHardware, rTrim(tbHardware[i]), '=');
	603	//sprintf(msglog,"nemonico: %s",dualHardware[0]);
[9dea2d6]	604	//RegistraLog(msglog,false);
[b9eb98b]	605	//sprintf(msglog,"valor: %s",dualHardware[1]);
[9dea2d6]	606	//RegistraLog(msglog,false);
[03f1941]	607	result = dbi_conn_queryf(dbi->conn,
	608	"SELECT idtipohardware,descripcion FROM tipohardwares WHERE nemonico='%s'",
	609	dualHardware[0]);
	610	if (!result) {
	611	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	612	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	613	__func__, __LINE__, msglog);
[9dea2d6]	614	return false;
[b9eb98b]	615	}
[03f1941]	616	if (!dbi_result_next_row(result)) { // Tipo de Hardware NO existente
	617	dbi_result_free(result);
[9dea2d6]	618	return false;
[b9eb98b]	619	} else { // Tipo de Hardware Existe
[03f1941]	620	idtipohardware = dbi_result_get_uint(result, "idtipohardware");
	621	dbi_result_free(result);
[b9eb98b]	622
[03f1941]	623	result = dbi_conn_queryf(dbi->conn,
	624	"SELECT idhardware FROM hardwares WHERE idtipohardware=%d AND descripcion='%s'",
	625	idtipohardware, dualHardware[1]);
[b9eb98b]	626
[03f1941]	627	if (!result) {
	628	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	629	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	630	__func__, __LINE__, msglog);
[9dea2d6]	631	return false;
[b9eb98b]	632	}
	633
[03f1941]	634	if (!dbi_result_next_row(result)) { // Hardware NO existente
	635	dbi_result_free(result);
	636	result = dbi_conn_queryf(dbi->conn,
	637	"INSERT hardwares (idtipohardware,descripcion,idcentro,grupoid) "
[b9eb98b]	638	" VALUES(%d,'%s',%s,0)", idtipohardware,
	639	dualHardware[1], idc);
[03f1941]	640	if (!result) {
	641	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	642	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	643	__func__, __LINE__, msglog);
[9dea2d6]	644	return false;
[b9eb98b]	645	}
[03f1941]	646
	647	// Recupera el identificador del hardware
	648	tbidhardware[i] = dbi_conn_sequence_last(dbi->conn, NULL);
[b9eb98b]	649	} else {
[03f1941]	650	tbidhardware[i] = dbi_result_get_uint(result, "idhardware");
[b9eb98b]	651	}
[03f1941]	652	dbi_result_free(result);
[b9eb98b]	653	}
	654	}
	655	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
	656
	657	for (i = 0; i < lon - 1; i++) {
	658	for (j = i + 1; j < lon; j++) {
	659	if (tbidhardware[i] > tbidhardware[j]) {
	660	aux = tbidhardware[i];
	661	tbidhardware[i] = tbidhardware[j];
	662	tbidhardware[j] = aux;
	663	}
	664	}
	665	}
	666	/* Crea cadena de identificadores de componentes hardware separados por coma */
	667	sprintf(strInt, "%d", tbidhardware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
	668	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
[eba3c79]	669	idhardwares = calloc(1, sizeof(aux) * lon + lon);
[b9eb98b]	670	if (idhardwares == NULL) {
[b56cbeb]	671	syslog(LOG_ERR, "%s:%d OOM\n", __FILE__, __LINE__);
[9dea2d6]	672	return false;
[b9eb98b]	673	}
	674	aux = sprintf(idhardwares, "%d", tbidhardware[0]);
	675	for (i = 1; i < lon; i++)
	676	aux += sprintf(idhardwares + aux, ",%d", tbidhardware[i]);
	677
[03f1941]	678	if (!cuestionPerfilHardware(dbi, idc, ido, idperfilhard, idhardwares,
[b9eb98b]	679	npc, tbidhardware, lon)) {
[b56cbeb]	680	syslog(LOG_ERR, "Problem updating client hardware\n");
[9dea2d6]	681	retval=false;
[01586d6]	682	} else {
[9dea2d6]	683	retval=true;
[7f46c45]	684	}
[01586d6]	685	free(whard);
	686	free(idhardwares);
	687
[7f46c45]	688	return (retval);
[b9eb98b]	689	}
	690	// ________________________________________________________________________________________________________
	691	// Función: cuestionPerfilHardware
	692	//
	693	// Descripción:
	694	// Comprueba existencia de perfil hardware y actualización de éste para el ordenador
	695	// Parámetros:
	696	// - db: Objeto base de datos (ya operativo)
	697	// - tbl: Objeto tabla
	698	// - idc: Identificador de la Unidad organizativa donde se encuentra el cliente
	699	// - ido: Identificador del ordenador
	700	// - tbidhardware: Identificador del tipo de hardware
	701	// - con: Número de componentes detectados para configurar un el perfil hardware
	702	// - npc: Nombre del cliente
	703	// ________________________________________________________________________________________________________
[03f1941]	704	bool cuestionPerfilHardware(struct og_dbi dbi, char idc, char *ido,
[59fb4d5]	705	int idperfilhardware, char idhardwares, char npc, int *tbidhardware,
[b9eb98b]	706	int lon)
	707	{
[03f1941]	708	const char *msglog;
	709	dbi_result result;
[b9eb98b]	710	int i;
	711	int nwidperfilhard;
	712
	713	// Busca perfil hard del ordenador que contenga todos los componentes hardware encontrados
[03f1941]	714	result = dbi_conn_queryf(dbi->conn,
	715	"SELECT idperfilhard FROM"
[b9eb98b]	716	" (SELECT perfileshard_hardwares.idperfilhard as idperfilhard,"
	717	" group_concat(cast(perfileshard_hardwares.idhardware AS char( 11) )"
	718	" ORDER BY perfileshard_hardwares.idhardware SEPARATOR ',' ) AS idhardwares"
	719	" FROM perfileshard_hardwares"
	720	" GROUP BY perfileshard_hardwares.idperfilhard) AS temp"
	721	" WHERE idhardwares LIKE '%s'", idhardwares);
[b56cbeb]	722
[03f1941]	723	if (!result) {
	724	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	725	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	726	__func__, __LINE__, msglog);
[9dea2d6]	727	return false;
[b9eb98b]	728	}
[03f1941]	729	if (!dbi_result_next_row(result)) {
	730	// No existe un perfil hardware con esos componentes de componentes hardware, lo crea
	731	dbi_result_free(result);
	732	result = dbi_conn_queryf(dbi->conn,
	733	"INSERT perfileshard (descripcion,idcentro,grupoid)"
[bde1389]	734	" VALUES('Perfil hardware (%s) ',%s,0)", npc, idc);
[03f1941]	735	if (!result) {
	736	dbi_conn_error(dbi->conn, &msglog);
	737	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	738	__func__, __LINE__, msglog);
[9dea2d6]	739	return false;
[b9eb98b]	740	}
[03f1941]	741	dbi_result_free(result);
	742
[b9eb98b]	743	// Recupera el identificador del nuevo perfil hardware
[03f1941]	744	nwidperfilhard = dbi_conn_sequence_last(dbi->conn, NULL);
	745
[b9eb98b]	746	// Crea la relación entre perfiles y componenetes hardware
	747	for (i = 0; i < lon; i++) {
[03f1941]	748	result = dbi_conn_queryf(dbi->conn,
	749	"INSERT perfileshard_hardwares (idperfilhard,idhardware)"
[b9eb98b]	750	" VALUES(%d,%d)", nwidperfilhard, tbidhardware[i]);
[03f1941]	751	if (!result) {
	752	dbi_conn_error(dbi->conn, &msglog);
	753	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	754	__func__, __LINE__, msglog);
[9dea2d6]	755	return false;
[b9eb98b]	756	}
[03f1941]	757	dbi_result_free(result);
[b9eb98b]	758	}
	759	} else { // Existe un perfil con todos esos componentes
[03f1941]	760	nwidperfilhard = dbi_result_get_uint(result, "idperfilhard");
	761	dbi_result_free(result);
[b9eb98b]	762	}
	763	if (idperfilhardware != nwidperfilhard) { // No coinciden los perfiles
	764	// Actualiza el identificador del perfil hardware del ordenador
[03f1941]	765	result = dbi_conn_queryf(dbi->conn,
	766	"UPDATE ordenadores SET idperfilhard=%d"
[b9eb98b]	767	" WHERE idordenador=%s", nwidperfilhard, ido);
[03f1941]	768	if (!result) {
	769	dbi_conn_error(dbi->conn, &msglog);
	770	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	771	__func__, __LINE__, msglog);
[9dea2d6]	772	return false;
[b9eb98b]	773	}
[03f1941]	774	dbi_result_free(result);
[b9eb98b]	775	}
	776	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
[03f1941]	777	result = dbi_conn_queryf(dbi->conn,
	778	"DELETE FROM perfileshard_hardwares WHERE idperfilhard IN "
[b9eb98b]	779	" (SELECT idperfilhard FROM perfileshard WHERE idperfilhard NOT IN"
	780	" (SELECT DISTINCT idperfilhard from ordenadores))");
[03f1941]	781	if (!result) {
	782	dbi_conn_error(dbi->conn, &msglog);
	783	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	784	__func__, __LINE__, msglog);
[9dea2d6]	785	return false;
[b9eb98b]	786	}
[03f1941]	787	dbi_result_free(result);
[b9eb98b]	788
	789	/* Eliminar Perfiles hardware que quedan húerfanos */
[03f1941]	790	result = dbi_conn_queryf(dbi->conn,
	791	"DELETE FROM perfileshard WHERE idperfilhard NOT IN"
[7f46c45]	792	" (SELECT DISTINCT idperfilhard FROM ordenadores)");
[03f1941]	793	if (!result) {
	794	dbi_conn_error(dbi->conn, &msglog);
	795	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	796	__func__, __LINE__, msglog);
[9dea2d6]	797	return false;
[b9eb98b]	798	}
[03f1941]	799	dbi_result_free(result);
	800
[b9eb98b]	801	/* Eliminar Relación de hardwares con Perfiles hardware que quedan húerfanos */
[03f1941]	802	result = dbi_conn_queryf(dbi->conn,
	803	"DELETE FROM perfileshard_hardwares WHERE idperfilhard NOT IN"
[7f46c45]	804	" (SELECT idperfilhard FROM perfileshard)");
[03f1941]	805	if (!result) {
	806	dbi_conn_error(dbi->conn, &msglog);
	807	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	808	__func__, __LINE__, msglog);
[9dea2d6]	809	return false;
[b9eb98b]	810	}
[03f1941]	811	dbi_result_free(result);
	812
[9dea2d6]	813	return true;
[b9eb98b]	814	}
	815	// ________________________________________________________________________________________________________
	816	// Función: actualizaSoftware
	817	//
	818	// Descripción:
	819	// Actualiza la base de datos con la configuración software del cliente
	820	// Parámetros:
	821	// - db: Objeto base de datos (ya operativo)
	822	// - tbl: Objeto tabla
	823	// - sft: cadena con el inventario software
	824	// - par: Número de la partición
	825	// - ido: Identificador del ordenador del cliente en la tabla
	826	// - npc: Nombre del ordenador
	827	// - idc: Identificador del centro o Unidad organizativa
	828	// Devuelve:
[9dea2d6]	829	// true: Si el proceso es correcto
	830	// false: En caso de ocurrir algún error
[8712fd9]	831	//
	832	// Versión 1.1.0: Se incluye el sistema operativo. Autora: Irina Gómez - ETSII Universidad Sevilla
[b9eb98b]	833	// ________________________________________________________________________________________________________
[fa6b891]	834	bool actualizaSoftware(struct og_dbi dbi, char sft, char par,char ido,
[59fb4d5]	835	char npc, char idc)
[eb99080]	836	{
[8712fd9]	837	int i, j, lon, aux, idperfilsoft, idnombreso;
[7f46c45]	838	bool retval;
[eb99080]	839	char *wsft;
[b9eb98b]	840	int tbidsoftware[MAXSOFTWARE];
[fa6b891]	841	char tbSoftware[MAXSOFTWARE], strInt[LONINT], idsoftwares;
	842	const char *msglog;
	843	dbi_result result;
[b9eb98b]	844
	845	/* Toma Centro (Unidad Organizativa) y perfil software */
[fa6b891]	846	result = dbi_conn_queryf(dbi->conn,
	847	"SELECT idperfilsoft,numpar"
[b9eb98b]	848	" FROM ordenadores_particiones"
	849	" WHERE idordenador=%s", ido);
[fa6b891]	850	if (!result) {
	851	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	852	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	853	__func__, __LINE__, msglog);
[9dea2d6]	854	return false;
[b9eb98b]	855	}
	856	idperfilsoft = 0; // Por defecto se supone que el ordenador no tiene aún detectado el perfil software
[fa6b891]	857	while (dbi_result_next_row(result)) {
	858	aux = dbi_result_get_uint(result, "numpar");
[b9eb98b]	859	if (aux == atoi(par)) { // Se encuentra la partición
[fa6b891]	860	idperfilsoft = dbi_result_get_uint(result, "idperfilsoft");
[b9eb98b]	861	break;
	862	}
	863	}
[fa6b891]	864	dbi_result_free(result);
[eb99080]	865	wsft=escaparCadena(sft); // Codificar comillas simples
	866	if(!wsft)
[9dea2d6]	867	return false;
[b9eb98b]	868
	869	/* Recorre componentes software*/
[eb99080]	870	lon = splitCadena(tbSoftware, wsft, '\n');
	871
[b9eb98b]	872	if (lon == 0)
[9dea2d6]	873	return true; // No hay lineas que procesar
[b9eb98b]	874	if (lon > MAXSOFTWARE)
	875	lon = MAXSOFTWARE; // Limita el número de componentes software
	876
[1c0eaf2]	877	idnombreso = 0;
[b9eb98b]	878	for (i = 0; i < lon; i++) {
[8712fd9]	879	// Primera línea es el sistema operativo: se obtiene identificador
	880	if (i == 0) {
[fa6b891]	881	idnombreso = checkDato(dbi, rTrim(tbSoftware[i]), "nombresos", "nombreso", "idnombreso");
[8712fd9]	882	continue;
	883	}
	884
[fa6b891]	885	result = dbi_conn_queryf(dbi->conn,
[b9eb98b]	886	"SELECT idsoftware FROM softwares WHERE descripcion ='%s'",
	887	rTrim(tbSoftware[i]));
[fa6b891]	888	if (!result) {
	889	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	890	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	891	__func__, __LINE__, msglog);
[9dea2d6]	892	return false;
[b9eb98b]	893	}
	894
[fa6b891]	895	if (!dbi_result_next_row(result)) {
	896	dbi_result_free(result);
	897	result = dbi_conn_queryf(dbi->conn,
	898	"INSERT INTO softwares (idtiposoftware,descripcion,idcentro,grupoid)"
[b9eb98b]	899	" VALUES(2,'%s',%s,0)", tbSoftware[i], idc);
[fa6b891]	900	if (!result) { // Error al insertar
	901	dbi_conn_error(dbi->conn, &msglog);
[26736ed]	902	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	903	__func__, __LINE__, msglog);
[9dea2d6]	904	return false;
[b9eb98b]	905	}
[fa6b891]	906
[b9eb98b]	907	// Recupera el identificador del software
[fa6b891]	908	tbidsoftware[i] = dbi_conn_sequence_last(dbi->conn, NULL);
[b9eb98b]	909	} else {
[fa6b891]	910	tbidsoftware[i] = dbi_result_get_uint(result, "idsoftware");
[b9eb98b]	911	}
[26736ed]	912	dbi_result_free(result);
[b9eb98b]	913	}
	914
	915	// Ordena tabla de identificadores para cosultar si existe un pefil con esas especificaciones
	916
	917	for (i = 0; i < lon - 1; i++) {
	918	for (j = i + 1; j < lon; j++) {
	919	if (tbidsoftware[i] > tbidsoftware[j]) {
	920	aux = tbidsoftware[i];
	921	tbidsoftware[i] = tbidsoftware[j];
	922	tbidsoftware[j] = aux;
	923	}
	924	}
	925	}
	926	/* Crea cadena de identificadores de componentes software separados por coma */
	927	sprintf(strInt, "%d", tbidsoftware[lon - 1]); // Pasa a cadena el último identificador que es de mayor longitud
	928	aux = strlen(strInt); // Calcula longitud de cadena para reservar espacio a todos los perfiles
[eba3c79]	929	idsoftwares = calloc(1, (sizeof(aux)+1) * lon + lon);
[b9eb98b]	930	if (idsoftwares == NULL) {
[b56cbeb]	931	syslog(LOG_ERR, "%s:%d OOM\n", __FILE__, __LINE__);
[9dea2d6]	932	return false;
[b9eb98b]	933	}
	934	aux = sprintf(idsoftwares, "%d", tbidsoftware[0]);
	935	for (i = 1; i < lon; i++)
	936	aux += sprintf(idsoftwares + aux, ",%d", tbidsoftware[i]);
	937
	938	// Comprueba existencia de perfil software y actualización de éste para el ordenador
[fa6b891]	939	if (!cuestionPerfilSoftware(dbi, idc, ido, idperfilsoft, idnombreso, idsoftwares,
[b9eb98b]	940	npc, par, tbidsoftware, lon)) {
[9c8a139]	941	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	942	__func__, __LINE__, msglog);
[9dea2d6]	943	retval=false;
[01586d6]	944	} else {
[9dea2d6]	945	retval=true;
[7f46c45]	946	}
[01586d6]	947	free(wsft);
	948	free(idsoftwares);
	949
	950	return retval;
[b9eb98b]	951	}
	952	// ________________________________________________________________________________________________________
	953	// Función: CuestionPerfilSoftware
	954	//
	955	// Parámetros:
	956	// - db: Objeto base de datos (ya operativo)
	957	// - tbl: Objeto tabla
	958	// - idcentro: Identificador del centro en la tabla
	959	// - ido: Identificador del ordenador del cliente en la tabla
[8712fd9]	960	// - idnombreso: Identificador del sistema operativo
[b9eb98b]	961	// - idsoftwares: Cadena con los identificadores de componentes software separados por comas
	962	// - npc: Nombre del ordenador del cliente
	963	// - particion: Número de la partición
	964	// - tbidsoftware: Array con los identificadores de componentes software
	965	// - lon: Número de componentes
	966	// Devuelve:
[9dea2d6]	967	// true: Si el proceso es correcto
	968	// false: En caso de ocurrir algún error
[8712fd9]	969	//
	970	// Versión 1.1.0: Se incluye el sistema operativo. Autora: Irina Gómez - ETSII Universidad Sevilla
	971	//_________________________________________________________________________________________________________
[fa6b891]	972	bool cuestionPerfilSoftware(struct og_dbi dbi, char idc, char *ido,
[59fb4d5]	973	int idperfilsoftware, int idnombreso,
	974	char idsoftwares, char npc, char *par,
	975	int *tbidsoftware, int lon)
	976	{
[b9eb98b]	977	int i, nwidperfilsoft;
[fa6b891]	978	const char *msglog;
	979	dbi_result result;
[b9eb98b]	980
	981	// Busca perfil soft del ordenador que contenga todos los componentes software encontrados
[fa6b891]	982	result = dbi_conn_queryf(dbi->conn,
	983	"SELECT idperfilsoft FROM"
[b9eb98b]	984	" (SELECT perfilessoft_softwares.idperfilsoft as idperfilsoft,"
	985	" group_concat(cast(perfilessoft_softwares.idsoftware AS char( 11) )"
	986	" ORDER BY perfilessoft_softwares.idsoftware SEPARATOR ',' ) AS idsoftwares"
	987	" FROM perfilessoft_softwares"
	988	" GROUP BY perfilessoft_softwares.idperfilsoft) AS temp"
	989	" WHERE idsoftwares LIKE '%s'", idsoftwares);
[b56cbeb]	990
[fa6b891]	991	if (!result) {
	992	dbi_conn_error(dbi->conn, &msglog);
[b56cbeb]	993	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	994	__func__, __LINE__, msglog);
[9dea2d6]	995	return false;
[b9eb98b]	996	}
[fa6b891]	997	if (!dbi_result_next_row(result)) { // No existe un perfil software con esos componentes de componentes software, lo crea
	998	dbi_result_free(result);
	999	result = dbi_conn_queryf(dbi->conn,
	1000	"INSERT perfilessoft (descripcion, idcentro, grupoid, idnombreso)"
[8712fd9]	1001	" VALUES('Perfil Software (%s, Part:%s) ',%s,0,%i)", npc, par, idc,idnombreso);
[fa6b891]	1002	if (!result) {
	1003	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	1004	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	1005	__func__, __LINE__, msglog);
[9dea2d6]	1006	return false;
[b9eb98b]	1007	}
[fa6b891]	1008
	1009	dbi_result_free(result);
[b9eb98b]	1010	// Recupera el identificador del nuevo perfil software
[fa6b891]	1011	nwidperfilsoft = dbi_conn_sequence_last(dbi->conn, NULL);
	1012
[b9eb98b]	1013	// Crea la relación entre perfiles y componenetes software
	1014	for (i = 0; i < lon; i++) {
[fa6b891]	1015	result = dbi_conn_queryf(dbi->conn,
	1016	"INSERT perfilessoft_softwares (idperfilsoft,idsoftware)"
[b9eb98b]	1017	" VALUES(%d,%d)", nwidperfilsoft, tbidsoftware[i]);
[fa6b891]	1018	if (!result) {
	1019	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	1020	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	1021	__func__, __LINE__, msglog);
[9dea2d6]	1022	return false;
[b9eb98b]	1023	}
[fa6b891]	1024	dbi_result_free(result);
[b9eb98b]	1025	}
	1026	} else { // Existe un perfil con todos esos componentes
[fa6b891]	1027	nwidperfilsoft = dbi_result_get_uint(result, "idperfilsoft");
	1028	dbi_result_free(result);
[b9eb98b]	1029	}
	1030
	1031	if (idperfilsoftware != nwidperfilsoft) { // No coinciden los perfiles
	1032	// Actualiza el identificador del perfil software del ordenador
[fa6b891]	1033	result = dbi_conn_queryf(dbi->conn,
	1034	"UPDATE ordenadores_particiones SET idperfilsoft=%d,idimagen=0"
[7f46c45]	1035	" WHERE idordenador=%s AND numpar=%s", nwidperfilsoft, ido, par);
[fa6b891]	1036	if (!result) { // Error al insertar
	1037	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	1038	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	1039	__func__, __LINE__, msglog);
[9dea2d6]	1040	return false;
[b9eb98b]	1041	}
[fa6b891]	1042	dbi_result_free(result);
[b9eb98b]	1043	}
	1044
	1045	/* DEPURACIÓN DE PERFILES SOFTWARE */
	1046
	1047	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
[fa6b891]	1048	result = dbi_conn_queryf(dbi->conn,
	1049	"DELETE FROM perfilessoft_softwares WHERE idperfilsoft IN "\
[b9eb98b]	1050	" (SELECT idperfilsoft FROM perfilessoft WHERE idperfilsoft NOT IN"\
	1051	" (SELECT DISTINCT idperfilsoft from ordenadores_particiones) AND idperfilsoft NOT IN"\
	1052	" (SELECT DISTINCT idperfilsoft from imagenes))");
[fa6b891]	1053	if (!result) {
	1054	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	1055	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	1056	__func__, __LINE__, msglog);
[9dea2d6]	1057	return false;
[b9eb98b]	1058	}
[fa6b891]	1059	dbi_result_free(result),
[b9eb98b]	1060	/* Eliminar Perfiles software que quedan húerfanos */
[fa6b891]	1061	result = dbi_conn_queryf(dbi->conn,
	1062	"DELETE FROM perfilessoft WHERE idperfilsoft NOT IN"
[b9eb98b]	1063	" (SELECT DISTINCT idperfilsoft from ordenadores_particiones)"\
	1064	" AND idperfilsoft NOT IN"\
	1065	" (SELECT DISTINCT idperfilsoft from imagenes)");
[fa6b891]	1066	if (!result) {
	1067	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	1068	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	1069	__func__, __LINE__, msglog);
[9dea2d6]	1070	return false;
[b9eb98b]	1071	}
[fa6b891]	1072	dbi_result_free(result),
	1073
[b9eb98b]	1074	/* Eliminar Relación de softwares con Perfiles software que quedan húerfanos */
[fa6b891]	1075	result = dbi_conn_queryf(dbi->conn,
	1076	"DELETE FROM perfilessoft_softwares WHERE idperfilsoft NOT IN"
[7f46c45]	1077	" (SELECT idperfilsoft from perfilessoft)");
[fa6b891]	1078	if (!result) {
	1079	dbi_conn_error(dbi->conn, &msglog);
[9c8a139]	1080	syslog(LOG_ERR, "failed to query database (%s:%d) %s\n",
	1081	__func__, __LINE__, msglog);
[9dea2d6]	1082	return false;
[b9eb98b]	1083	}
[fa6b891]	1084	dbi_result_free(result);
	1085
[9dea2d6]	1086	return true;
[b9eb98b]	1087	}

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

Download in other formats: