Context Navigation

ogAdmServer.cpp @ bbf0cce

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 bbf0cce was bbf0cce, checked in by ramon <ramongomez@…>, 11 years ago

#677: corregir erratas de revisión r4431.

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

Property mode set to 100644

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

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

Context Navigation

source: admin/Sources/Services/ogAdmServer/sources/ogAdmServer.cpp @ bbf0cce

Download in other formats: