Context Navigation

ogAdmServer.cpp @ 103bc82

Visit:

918-git-images-111dconfigfileconfigure-oglivegit-imageslgromero-new-oglivemainmaint-cronmount-efivarfsmultivmmultivm-ogboot-installerogClonningEngineogboot-installer-jenkinsoglive-ipv6test-python-scriptsticket-301ticket-50ticket-50-oldticket-577ticket-585ticket-611ticket-612ticket-693ticket-700ubu24tplunification2use-local-agent-oglivevarios-instalacionwebconsole3

Last change on this file since 103bc82 was 21bfeb0, checked in by irina <irinagomez@…>, 8 years ago

#559 ogAdmServer: Se libera memoria de variables y de resultados de la base de datos. Database.cpp y Database.h: Se crea función liberaResult.

git-svn-id: https://opengnsys.es/svn/branches/version1.1@5132 a21b9725-9963-47de-94b9-378ad31fedc9

Property mode set to 100644

File size: 128.9 KB

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

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

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ 103bc82

Download in other formats: