Context Navigation

ogAdmServer.cpp @ 1e8645b

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 1e8645b was ab4ab39, checked in by irina <irinagomez@…>, 9 years ago

#737 Comando crear imagen de la consola: actualiza en la base de datos las propiedades de la particion: imagen, revisión y fecha de despliegue.

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

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

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ 1e8645b

Download in other formats: