Context Navigation

ogAdmServer.cpp @ 212d995

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 212d995 was 38e2328, checked in by irina <irinagomez@…>, 9 years ago

#738 #713 Inventario de software: se muestra sistema operativo y se guarda en el perfil de software

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

Property mode set to 100644

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

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

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ 212d995

Download in other formats: