Context Navigation

ogAdmClient.c @ 426ca26

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 426ca26 was d9fb091, checked in by irina <irinagomez@…>, 8 years ago

#770 ogAdmClient al crear las imágenes sincronizadas hace antes el inverntario de software (para tipo archivo y directorio, básicas y diferenciales).

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

Property mode set to 100644

File size: 77.5 KB

Line
1	// ********************************************************************************************************
2	// Cliernte: ogAdmClient
3	// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
4	// Fecha Creación: Marzo-2010
5	// Fecha Última modificación: Abril-2010
6	// Nombre del fichero: ogAdmClient.c
7	// Descripción :Este fichero implementa el cliente general del sistema
8	// ********************************************************************************************************
9
10	#include "ogAdmClient.h"
11	#include "ogAdmLib.c"
12	//________________________________________________________________________________________________________
13	// Función: tomaConfiguracion
14	//
15	// Descripción:
16	// Lee el fichero de configuración del servicio
17	// Parámetros:
18	// filecfg : Ruta completa al fichero de configuración
19	// Devuelve:
20	// TRUE: Si el proceso es correcto
21	// FALSE: En caso de ocurrir algún error
22	//________________________________________________________________________________________________________
23	BOOLEAN tomaConfiguracion(char* filecfg)
24	{
25	char modulo[] = "tomaConfiguracion()";
26
27	if (filecfg == NULL \|\| strlen(filecfg) == 0) {
28	errorLog(modulo, 1, FALSE); // Fichero de configuración del cliente vacío
29	return (FALSE);
30	}
31	FILE *fcfg;
32	int lSize;
33	char * buffer, lineas[MAXPRM], dualparametro[2];
34	int i, numlin, resul;
35
36	fcfg = fopen(filecfg, "rt");
37	if (fcfg == NULL) {
38	errorLog(modulo, 2, FALSE); // No existe fichero de configuración del cliente
39	return (FALSE);
40	}
41
42	fseek(fcfg, 0, SEEK_END);
43	lSize = ftell(fcfg); // Obtiene tamaño del fichero.
44	rewind(fcfg);
45	buffer = (char*) reservaMemoria(lSize+1); // Toma memoria para el buffer de lectura.
46	if (buffer == NULL) { // No hay memoria suficiente para el buffer
47	errorLog(modulo, 3, FALSE);
48	return (FALSE);
49	}
50	lSize=fread(buffer, 1, lSize, fcfg); // Lee contenido del fichero
51	buffer[lSize]=CHARNULL;
52	fclose(fcfg);
53
54	/* Inicializar variables globales */
55	servidoradm[0]=CHARNULL;
56	puerto[0] = CHARNULL;
57	pathinterface[0]=CHARNULL;
58	urlmenu[0]=CHARNULL;
59	urlmsg[0]=CHARNULL;
60
61	numlin = splitCadena(lineas, buffer, '\n');
62	for (i = 0; i < numlin; i++) {
63	splitCadena(dualparametro, lineas[i], '=');
64
65	resul = strcmp(StrToUpper(dualparametro[0]), "SERVIDORADM");
66	if (resul == 0)
67	strcpy(servidoradm, dualparametro[1]);
68
69	resul = strcmp(StrToUpper(dualparametro[0]), "PUERTO");
70	if (resul == 0)
71	strcpy(puerto, dualparametro[1]);
72
73	resul = strcmp(StrToUpper(dualparametro[0]), "PATHINTERFACE");
74	if (resul == 0)
75	strcpy(pathinterface, dualparametro[1]);
76
77	resul = strcmp(StrToUpper(dualparametro[0]), "URLMENU");
78	if (resul == 0)
79	strcpy(urlmenu, dualparametro[1]);
80
81	resul = strcmp(StrToUpper(dualparametro[0]), "URLMSG");
82	if (resul == 0)
83	strcpy(urlmsg, dualparametro[1]);
84	}
85
86	if (servidoradm[0] == CHARNULL) {
87	liberaMemoria(buffer);
88	errorLog(modulo,4, FALSE); // Falta parámetro SERVIDORADM
89	return (FALSE);
90	}
91
92	if (puerto[0] == CHARNULL) {
93	liberaMemoria(buffer);
94	errorLog(modulo,5, FALSE); // Falta parámetro PUERTO
95	return (FALSE);
96	}
97	if (pathinterface[0] == CHARNULL) {
98	liberaMemoria(buffer);
99	errorLog(modulo,56, FALSE); // Falta parámetro PATHINTERFACE
100	return (FALSE);
101	}
102
103	if (urlmenu[0] == CHARNULL) {
104	liberaMemoria(buffer);
105	errorLog(modulo,89, FALSE); // Falta parámetro URLMENU
106	return (FALSE);
107	}
108	if (urlmsg[0] == CHARNULL) {
109	liberaMemoria(buffer);
110	errorLog(modulo,90, FALSE); // Falta parámetro URLMSG
111	return (FALSE);
112	}
113	liberaMemoria(buffer);
114	return (TRUE);
115	}
116	//______________________________________________________________________________________________________
117	// Función: FinterfaceAdmin
118	//
119	// Descripción:
120	// Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.
121	// La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;
122	// esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface
123	// podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.
124	//
125	// Parámetros:
126	// - script: Nombre del módulo,función o script de la interface
127	// - parametros: Parámetros que se le pasarán a la interface
128	// - salida: Recoge la salida que genera la llamada a la interface
129
130	// Devuelve:
131	// Código de error de la ejecución al módulo , función o script de la interface
132	//
133	// Especificaciones:
134	// El parámetro salida recoge la salida desde un fichero que se genera en la ejecución del script siempre que
135	// sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
136	// Este fichero tiene una ubicación fija: /tmp/_retinterface
137	//______________________________________________________________________________________________________
138
139	int FinterfaceAdmin( char script,char parametros,char* salida)
140	{
141	FILE *f;
142	int lSize,nargs,i,resul;
143	char msglog[LONSTD],*argumentos[MAXARGS];
144	char modulo[] = "FinterfaceAdmin()";
145
146
147	if (ndebug>= DEBUG_MEDIO) {
148	sprintf(msglog, "%s:%s", tbMensajes[8], script);
149	infoDebug(msglog);
150	}
151
152	/* Crea matriz de los argumentos */
153	nargs=splitCadena(argumentos,parametros,32);
154	for(i=nargs;i<MAXARGS;i++){
155	argumentos[i]=NULL;
156	}
157
158	/* Muestra matriz de los argumentos */
159	for(i=0;i<nargs;i++){
160	if (ndebug>= DEBUG_ALTO) {
161	sprintf(msglog, "%s: #%d-%s", tbMensajes[9],i+1,argumentos[i]);
162	infoDebug(msglog);
163	}
164	}
165	/* Elimina fichero de retorno */
166	if(salida!=(char*)NULL){
167	f = fopen("/tmp/_retinterface_","w" );
168	if (f==NULL){ // Error de eliminación
169	scriptLog(modulo,10);
170	resul=8;
171	scriptLog(modulo,resul);
172	return(resul);
173	}
174	fclose(f);
175	}
176	/* Compone linea de comando */
177	if(parametros){
178	strcat(script," ");
179	strcat(script,parametros);
180	}
181	/* LLamada función interface */
182	resul=system(script);
183	if(resul){
184	scriptLog(modulo,10);
185	scriptLog(modulo,resul);
186	return(resul);
187	}
188	/* Lee fichero de retorno */
189	if(salida!=(char*)NULL){
190	f = fopen("/tmp/_retinterface_","rb" );
191	if (f==NULL){ // Error de apertura
192	scriptLog(modulo,10);
193	resul=9;
194	scriptLog(modulo,resul);
195	return(resul);
196	}
197	else{
198	fseek (f ,0,SEEK_END); // Obtiene tamaño del fichero.
199	lSize = ftell (f);
200	rewind (f);
201	if(lSize>LONGITUD_SCRIPTSALIDA){
202	scriptLog(modulo,10);
203	resul=11;
204	scriptLog(modulo,resul);
205	return(resul);
206	}
207	fread (salida,1,lSize,f); // Lee contenido del fichero
208	rTrim(salida);
209	fclose(f);
210	}
211	}
212	/* Muestra información de retorno */
213	if(salida!=(char*)NULL){
214	if(ndebug>2){
215	sprintf(msglog,"Información devuelta %s",salida);
216	infoDebug(msglog);
217	}
218	}
219	return(resul);
220	}
221	//______________________________________________________________________________________________________
222	// Función: interfaceAdmin
223	//
224	// Descripción:
225	// Esta función es la puerta de comunicación entre el módulo de administración y el motor de clonación.
226	// La Aplicación de administración utiliza una interface para ejecutar funciones del motor de clonación;
227	// esta interface llamará a la API del motor con lo que cambiando el comportamiento de esta interface
228	// podremos hacer llamadas a otras API de clonación y de esta manera probar distintos motores.
229	//
230	// Parámetros:
231	// - script: Nombre del módulo,función o script de la interface
232	// - parametros: Parámetros que se le pasarán a la interface
233	// - salida: Recoge la salida que genera la llamada a la interface
234
235	// Devuelve:
236	// Código de error de la ejecución al módulo , función o script de la interface
237	//
238	// Especificaciones:
239	// El parámetro salida recoge la salida desde el procedimiento hijo que se genera en la ejecución de éste
240	// siempre que sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se
241	// recogerá dicha salida.
242	//______________________________________________________________________________________________________
243
244	int interfaceAdmin( char script,char parametros,char* salida)
245	{
246	int descr[2]; /* Descriptores de E y S de la turbería */
247	int bytesleidos; /* Bytes leidos en el mensaje */
248	int estado;
249	pid_t pid;
250	char buffer[LONBLK]; // Buffer de lectura de fichero
251	pipe (descr);
252	int i,nargs,resul;
253	int lon; // Longitud de cadena
254	char msglog[LONSUC]; // Mensaje de registro de sucesos
255	char *argumentos[MAXARGS];
256	char modulo[] = "interfaceAdmin()";
257	if (ndebug>= DEBUG_MEDIO) {
258	sprintf(msglog, "%s:%s", tbMensajes[8], script);
259	infoDebug(msglog);
260	}
261
262	/* Crea matriz de los argumentos */
263	nargs=splitCadena(argumentos,parametros,32);
264	for(i=nargs;i<MAXARGS;i++){
265	argumentos[i]=NULL;
266	}
267	/* Muestra matriz de los argumentos */
268	for(i=1;i<nargs;i++){
269	if (ndebug>= DEBUG_ALTO) {
270	// Truncar la cadena si es mayor que el tamaño de la línea de log.
271	sprintf(msglog, "%s: #%d-", tbMensajes[9], i+1);
272	lon = strlen (msglog);
273	if (lon + strlen (argumentos[i]) < LONSUC) {
274	strcat (msglog, argumentos[i]);
275	}
276	else
277	{
278	strncat (msglog, argumentos[i], LONSUC - lon - 4);
279	strcat (msglog, "...");
280	}
281	infoDebug(msglog);
282	}
283	}
284
285	if((pid=fork())==0)
286	{
287	//_______________________________________________________________
288
289	/* Proceso hijo que ejecuta la función de interface */
290
291	close (descr[LEER]);
292	dup2 (descr[ESCRIBIR], 1);
293	close (descr[ESCRIBIR]);
294	resul=execv(script,argumentos);
295	//resul=execlp (script, script, argumentos[0],argumentos[1],NULL);
296	exit(resul);
297
298	/* Fin de proceso hijo */
299	//_______________________________________________________________
300	}
301	else
302	{
303	//_______________________________________________________________
304
305	/* Proceso padre que espera la ejecución del hijo */
306
307	if (pid ==-1){ // Error en la creación del proceso hijo
308	scriptLog(modulo,10);
309	resul=13;
310	scriptLog(modulo,resul);
311	return(resul);
312	}
313	close (descr[ESCRIBIR]);
314	bytesleidos = read (descr[LEER], buffer, LONBLK-1);
315	while(bytesleidos>0){
316	if(salida!=(char*)NULL){ // Si se solicita retorno de información...
317	buffer[bytesleidos]='\0';
318	// Error si se supera el tamaño máximo de cadena de salida.
319	if(strlen(buffer)+strlen(salida)>LONGITUD_SCRIPTSALIDA){
320	scriptLog(modulo,10);
321	resul=11;
322	scriptLog(modulo,resul);
323	return(resul);
324	}
325	rTrim(buffer);
326	strcat(salida,buffer);
327	}
328	bytesleidos = read (descr[LEER], buffer, LONBLK-1);
329	}
330	close (descr[LEER]);
331	//kill(pid,SIGQUIT);
332	waitpid(pid,&estado,0);
333	resul=WEXITSTATUS(estado);
334	if(resul){
335	scriptLog(modulo,10);
336	scriptLog(modulo,resul);
337	return(resul);
338	}
339	/* Fin de proceso padre */
340	//_______________________________________________________________
341	}
342
343	/* Muestra información de retorno */
344	if(salida!=(char*)NULL){
345	if(ndebug>2){
346	// Truncar la cadena si es mayor que el tamaño de la línea de log.
347	strcpy(msglog,"Informacion devuelta ");
348	lon = strlen (msglog);
349	if (lon + strlen (salida) < LONSUC) {
350	strcat (msglog, salida);
351	}
352	else
353	{
354	strncat (msglog, salida, LONSUC-lon-4);
355	strcat (msglog, "...");
356	}
357	infoDebug(msglog);
358	}
359	}
360	return(resul);
361	}
362	//______________________________________________________________________________________________________
363	// Función: scriptLog
364	//
365	// Descripción:
366	// Registra los sucesos de errores de scripts en el fichero de log
367	// Parametros:
368	// - modulo: Módulo donde se produjo el error
369	// - coderr : Código del mensaje de error del script
370	//______________________________________________________________________________________________________
371	void scriptLog(const char *modulo,int coderr)
372	{
373	char msglog[LONSUC];
374
375	if(coderr<MAXERRORSCRIPT)
376	errorInfo(modulo,tbErroresScripts[coderr]); // Se ha producido algún error registrado
377	else{
378	sprintf(msglog,"%s: %d",tbErroresScripts[MAXERRORSCRIPT],coderr);
379	errorInfo(modulo,msglog);
380	}
381	}
382	//______________________________________________________________________________________________________
383	// Función: TomaIPlocal
384	//
385	// Descripción:
386	// Recupera la IP local
387	// Parámetros:
388	// Ninguno
389	// Devuelve:
390	// TRUE: Si el proceso es correcto
391	// FALSE: En caso de ocurrir algún error
392	// Especificaciones:
393	// En caso de no encontrar la IP o generarse algún error la IP local sería 0.0.0.0
394	//______________________________________________________________________________________________________
395	BOOLEAN tomaIPlocal()
396	{
397	char modulo[] = "tomaIPlocal()";
398
399	// Para debug
400	//strcpy(IPlocal,"10.1.15.203");
401	//return(TRUE);
402
403	sprintf(interface,"%s/getIpAddress",pathinterface);
404	herror=interfaceAdmin(interface,NULL,IPlocal);
405	if(herror){
406	errorLog(modulo,85,FALSE);
407	return(FALSE);
408	}
409	return(TRUE);
410	}
411	//______________________________________________________________________________________________________
412	//
413	// Función: cuestionCache
414	//
415	// Descripción:
416	// Procesa la cache en caso de existir.
417	// Parámetros:
418	// tam : Tamaño de la cache
419	// Devuelve:
420	// TRUE: Si el proceso es correcto
421	// FALSE: En caso de ocurrir algún error
422	//______________________________________________________________________________________________________
423	BOOLEAN cuestionCache(char* tam)
424	{
425	return(TRUE);
426	//>>>>>>>>>>>>>>>>>>>>>>>>>>
427	char msglog[LONSTD];
428	char modulo[] = "cuestionCache()";
429
430	sprintf(interface,"%s/%s",pathinterface,"procesaCache");
431	sprintf(parametros,"%s %s","procesaCache",tam);
432
433	herror=interfaceAdmin(interface,parametros,NULL);
434	if(herror){
435	sprintf(msglog,"%s",tbErrores[88]);
436	errorInfo(modulo,msglog);
437	return(FALSE);
438	}
439
440	return(TRUE);
441	}
442	//______________________________________________________________________________________________________
443	// Función: cargaPaginaWeb
444	//
445	// Descripción:
446	// Muestra una pégina web usando el browser
447	// Parámetros:
448	// urp: Dirección url de la página
449	// Devuelve:
450	// TRUE: Si el proceso es correcto
451	// FALSE: En caso de ocurrir algún error
452	// ________________________________________________________________________________________________________
453	int cargaPaginaWeb(char *url)
454	{
455	pid_t pidbrowser; // Identificador del proceso que se crea para mostrar una página web con el browser
456	int resul=0;
457	char* argumentos[4];
458	char modulo[] = "cargaPaginaWeb()";
459
460	// Destruye los procesos del Browser y lanza uno nuevo.
461	system("pkill -9 browser");
462
463	sprintf(interface,"/opt/opengnsys/bin/browser");
464	sprintf(parametros,"browser -qws %s",url);
465
466	splitCadena(argumentos,parametros,' '); // Crea matriz de los argumentos del scripts
467	argumentos[3]=NULL;
468	if((pidbrowser=fork())==0){
469	/* Proceso hijo que ejecuta el script */
470	resul=execv(interface,argumentos);
471	exit(resul);
472	}
473	else {
474	if (pidbrowser ==-1){
475	scriptLog(modulo,10);
476	resul=13;
477	scriptLog(modulo,resul);
478	return(resul);
479	}
480	}
481	return(resul);
482	}
483	//________________________________________________________________________________________________________
484	// Función: muestraMenu
485	//
486	// Descripción:
487	// Muestra el menu inicial del cliente
488	// Parámetros:
489	// Ninguno
490	// Devuelve:
491	// TRUE: Si el proceso es correcto
492	// FALSE: En caso de ocurrir algún error
493	//________________________________________________________________________________________________________
494	void muestraMenu()
495	{
496	cargaPaginaWeb(urlmenu);
497	}
498	//______________________________________________________________________________________________________
499	// Función: muestraMensaje
500	//
501	// Descripción:
502	// Muestra un mensaje en pantalla
503	// Parámetros:
504	// - idx: Indice del mensaje
505	// - msg: Descripción Mensaje
506	// ________________________________________________________________________________________________________
507	void muestraMensaje(int idx,char*msg)
508	{
509	char *msgpan,url[250];
510
511	if(msg){
512	msgpan=URLEncode(msg);
513	sprintf(url,"%s?msg=%s",urlmsg,msgpan); // Url de la página de mensajes
514	liberaMemoria(msgpan);
515	}
516	else
517	sprintf(url,"%s?idx=%d",urlmsg,idx); // Url de la página de mensajes
518	cargaPaginaWeb(url);
519	}
520	//______________________________________________________________________________________________________
521	// Función: InclusionCliente
522	// Descripción:
523	// Abre una sesión en el servidor de administración y registra al cliente en el sistema
524	// Parámetros:
525	// Ninguno
526	// Devuelve:
527	// TRUE: Si el proceso es correcto
528	// FALSE: En caso de ocurrir algún error
529	//______________________________________________________________________________________________________
530	BOOLEAN inclusionCliente(TRAMA* ptrTrama)
531	{
532	int lon; // Longitud de cadena
533	char msglog[LONSUC]; // Mensaje de registro de sucesos
534	char *cfg; // Datos de configuración
535	SOCKET socket_c;
536	char modulo[] = "inclusionCliente()";
537
538	cfg=LeeConfiguracion();
539
540	if(!cfg){ // No se puede recuperar la configuración del cliente
541	errorLog(modulo,36,FALSE);
542	errorLog(modulo,37,FALSE);
543	return(FALSE);
544	}
545	if (ndebug>= DEBUG_ALTO) {
546	// Truncar la cadena si es mayor que el tamaño de la línea de log.
547	sprintf(msglog, "%s", tbMensajes[14]);
548	lon = strlen (msglog);
549	if (lon + strlen (cfg) < LONSUC) {
550	strcat (msglog, cfg);
551	}
552	else
553	{
554	strncat (msglog, cfg, LONSUC - lon - 4);
555	strcat (msglog, "...");
556	}
557	infoDebug(msglog);
558	}
559	initParametros(ptrTrama,0);
560	lon=sprintf(ptrTrama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor
561	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
562	liberaMemoria(cfg);
563
564	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
565	errorLog(modulo,37,FALSE);
566	return(FALSE);
567	}
568	ptrTrama=recibeMensaje(&socket_c);
569	if(!ptrTrama){
570	errorLog(modulo,45,FALSE);
571	return(FALSE);
572	}
573
574	close(socket_c);
575
576	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
577	errorLog(modulo,39,FALSE);
578	return(FALSE);
579	}
580
581	return(TRUE);
582	}
583	//______________________________________________________________________________________________________
584	// Función: RESPUESTA_InclusionCliente
585	//
586	// Descripción:
587	// Respuesta del servidor de administración a la petición de inicio
588	// enviando los datos identificativos del cliente y otras configuraciones
589	// Parámetros:
590	// - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
591	// Devuelve:
592	// TRUE: Si el proceso es correcto
593	// FALSE: En caso de ocurrir algún error
594	//______________________________________________________________________________________________________
595	BOOLEAN RESPUESTA_InclusionCliente(TRAMA* ptrTrama)
596	{
597	char* res;
598	char modulo[] = "RESPUESTA_InclusionCliente()";
599
600	res=copiaParametro("res",ptrTrama); // Resultado del proceso de inclusión
601	if(atoi(res)==0){ // Error en el proceso de inclusión
602	liberaMemoria(res);
603	errorLog(modulo,41,FALSE);
604	return (FALSE);
605	}
606	liberaMemoria(res);
607
608	idordenador=copiaParametro("ido",ptrTrama); // Identificador del ordenador
609	nombreordenador=copiaParametro("npc",ptrTrama); // Nombre del ordenador
610	cache=copiaParametro("che",ptrTrama); // Tamaño de la caché reservada al cliente
611	idproautoexec=copiaParametro("exe",ptrTrama); // Procedimento de inicio (Autoexec)
612	idcentro=copiaParametro("idc",ptrTrama); // Identificador de la Unidad Organizativa
613	idaula=copiaParametro("ida",ptrTrama); // Identificador del aula
614
615	if(idordenador==NULL \|\| nombreordenador==NULL){
616	errorLog(modulo,40,FALSE);
617	return (FALSE);
618	}
619	return(TRUE);
620	}
621	//______________________________________________________________________________________________________
622	//
623	// Función: LeeConfiguracion
624	// Descripción:
625	// Abre una sesión en el servidor de administración y registra al cliente en el sistema
626	// Parámetros:
627	// Ninguno
628	// Devuelve:
629	// TRUE: Si el proceso es correcto
630	// FALSE: En caso de ocurrir algún error
631	//______________________________________________________________________________________________________
632
633	char* LeeConfiguracion()
634	{
635	char* parametroscfg;
636	char modulo[] = "LeeConfiguracion()";
637
638	// Reservar memoria para los datos de cofiguración.
639	parametroscfg=(char*)reservaMemoria(LONGITUD_SCRIPTSALIDA);
640	if(!parametroscfg){
641	errorLog(modulo,3,FALSE);
642	return(NULL);
643	}
644	// Ejecutar script y obtener datos.
645	sprintf(interface,"%s/%s",pathinterface,"getConfiguration");
646	herror=interfaceAdmin(interface,NULL,parametroscfg);
647
648	if(herror){ // No se puede recuperar la configuración del cliente
649	liberaMemoria(parametroscfg);
650	errorLog(modulo,36,FALSE);
651	return(NULL);
652	}
653	return(parametroscfg);
654	}
655	//________________________________________________________________________________________________________
656	// Función: autoexecCliente
657	//
658	// Descripción:
659	// Solicita procedimiento de autoexec para el cliebnte
660	// Parámetros:
661	// Ninguno
662	// Devuelve:
663	// TRUE: Si el proceso es correcto
664	// FALSE: En caso de ocurrir algún error
665	//________________________________________________________________________________________________________
666	BOOLEAN autoexecCliente(TRAMA* ptrTrama)
667	{
668	SOCKET socket_c;
669	char modulo[] = "autoexecCliente()";
670
671	initParametros(ptrTrama,0);
672	sprintf(ptrTrama->parametros,"nfn=AutoexecCliente\rexe=%s\r",idproautoexec);
673
674	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
675	errorLog(modulo,42,FALSE);
676	return(FALSE);
677	}
678	ptrTrama=recibeMensaje(&socket_c);
679	if(!ptrTrama){
680	errorLog(modulo,45,FALSE);
681	return(FALSE);
682	}
683
684	close(socket_c);
685
686	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
687	errorLog(modulo,39,FALSE);
688	return(FALSE);
689	}
690
691	return(TRUE);
692	}
693	//________________________________________________________________________________________________________
694	// Función: autoexecCliente
695	//
696	// Descripción:
697	// Ejecuta un script de autoexec personalizado en todos los inicios para el cliente
698	// Parámetros:
699	// Ninguno
700	// Devuelve:
701	// TRUE: Si el proceso es correcto
702	// FALSE: En caso de ocurrir algún error
703	//________________________________________________________________________________________________________
704	BOOLEAN RESPUESTA_AutoexecCliente(TRAMA* ptrTrama)
705	{
706	SOCKET socket_c;
707	char res,nfl;
708	char modulo[] = "RESPUESTA_AutoexecCliente()";
709
710	res=copiaParametro("res",ptrTrama);
711	if(atoi(res)==0){ // Error en el proceso de autoexec
712	liberaMemoria(res);
713	return (FALSE);
714	}
715	liberaMemoria(res);
716
717	nfl=copiaParametro("nfl",ptrTrama);
718	initParametros(ptrTrama,0);
719	sprintf(ptrTrama->parametros,"nfn=enviaArchivo\rnfl=%s\r",nfl);
720	liberaMemoria(nfl);
721
722	/* Envía petición */
723	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
724	errorLog(modulo,42,FALSE);
725	return(FALSE);
726	}
727	/* Nombre del archivo destino (local)*/
728	char fileautoexec[LONPRM];
729	sprintf(fileautoexec,"/tmp/_autoexec_%s",IPlocal);
730
731	/* Recibe archivo */
732	if(!recArchivo(&socket_c,fileautoexec)){
733	errorLog(modulo,58, FALSE);
734	close(socket_c);
735	return(FALSE);
736	}
737
738	close(socket_c);
739
740	/* Ejecuta archivo */
741	ejecutaArchivo(fileautoexec,ptrTrama);
742	return(TRUE);
743	}
744	//______________________________________________________________________________________________________
745	// Función: comandosPendientes
746	//
747	// Descripción:
748	// Búsqueda de acciones pendientes en el servidor de administración
749	// Parámetros:
750	// Ninguno
751	// Devuelve:
752	// TRUE: Si el proceso es correcto
753	// FALSE: En caso de ocurrir algún error
754	//______________________________________________________________________________________________________
755	BOOLEAN comandosPendientes(TRAMA* ptrTrama)
756	{
757	SOCKET socket_c;
758	char modulo[] = "comandosPendientes()";
759
760	CMDPTES=TRUE;
761	initParametros(ptrTrama,0);
762
763	while(CMDPTES){
764	sprintf(ptrTrama->parametros,"nfn=ComandosPendientes\r");
765	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
766	errorLog(modulo,42,FALSE);
767	return(FALSE);
768	}
769	ptrTrama=recibeMensaje(&socket_c);
770	if(!ptrTrama){
771	errorLog(modulo,45,FALSE);
772	return(FALSE);
773	}
774
775	close(socket_c);
776
777	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
778	errorLog(modulo,39,FALSE);
779	return(FALSE);
780	}
781	}
782	return(TRUE);
783	}
784	//______________________________________________________________________________________________________
785	// Función: NoComandosPtes
786	//
787	// Descripción:
788	// Conmuta el switch de los comandos pendientes y lo pone a false
789	// Parámetros:
790	// - ptrTrama: contenido del mensaje
791	// Devuelve:
792	// TRUE siempre
793	// Especificaciones:
794	// Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el
795	// servidor y el cliente pasa a a estar disponible para recibir comandos desde el éste.
796	//______________________________________________________________________________________________________
797	BOOLEAN NoComandosPtes(TRAMA* ptrTrama)
798	{
799	CMDPTES=FALSE; // Corta el bucle de comandos pendientes
800	return(TRUE);
801	}
802	//______________________________________________________________________________________________________
803	// Función: ProcesaComandos
804	//
805	// Descripción:
806	// Espera comando desde el Servidor de Administración para ejecutarlos
807	// Parámetros:
808	// Ninguno
809	// Devuelve:
810	// TRUE: Si el proceso es correcto
811	// FALSE: En caso de ocurrir algún error
812	// ________________________________________________________________________________________________________
813	void procesaComandos(TRAMA* ptrTrama)
814	{
815	int lon;
816	SOCKET socket_c;
817	char modulo[] = "procesaComandos()";
818
819	initParametros(ptrTrama,0);
820	while(TRUE){
821	lon=sprintf(ptrTrama->parametros,"nfn=DisponibilidadComandos\r");
822	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS); // Activar disponibilidad
823	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_INFORMACION)){
824	errorLog(modulo,43,FALSE);
825	return;
826	}
827	infoLog(19); // Disponibilidad de cliente activada
828	ptrTrama=recibeMensaje(&socket_c);
829	if(!ptrTrama){
830	errorLog(modulo,46,FALSE);
831	return;
832	}
833
834	close(socket_c);
835
836	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
837	errorLog(modulo,39,FALSE);
838	return;
839	}
840	if(!comandosPendientes(ptrTrama)){
841	errorLog(modulo,42,FALSE);
842	}
843	}
844	}
845	//______________________________________________________________________________________________________
846	// Función: Actualizar
847	//
848	// Descripción:
849	// Actualiza los datos de un ordenador como si volviera a solicitar la entrada
850	// en el sistema al servidor de administración
851	// Parámetros:
852	// ptrTrama: contenido del mensajede
853	// Devuelve:
854	// TRUE: Si el proceso es correcto
855	// FALSE: En caso de ocurrir algún error
856	//______________________________________________________________________________________________________
857	BOOLEAN Actualizar(TRAMA* ptrTrama)
858	{
859	char msglog[LONSTD]; // Mensaje de log
860	char *cfg; // Cadena de datos de configuración
861	int lon; // Longitud de cadena
862	char modulo[] = "Actualizar()";
863
864	if (ndebug>=DEBUG_MAXIMO) {
865	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
866	infoDebug(msglog);
867	}
868	muestraMensaje(1,NULL);
869	if(!comandosPendientes(ptrTrama)){
870	errorLog(modulo,84,FALSE);
871	return(FALSE);
872	}
873
874	cfg=LeeConfiguracion();
875	herror=0;
876	if(!cfg){ // No se puede recuperar la configuración del cliente
877	errorLog(modulo,36,FALSE);
878	herror=3;
879	}
880	// Envia Configuracion al servidor
881	initParametros(ptrTrama,0);
882	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
883	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
884	respuestaEjecucionComando(ptrTrama,herror,0);
885
886	muestraMenu();
887
888	return(TRUE);
889	}
890	//______________________________________________________________________________________________________
891	// Función: Purgar
892	//
893	// Descripción:
894	// Detiene la ejecución del browser
895	// Parámetros:
896	// ptrTrama: contenido del mensajede
897	// Devuelve:
898	// TRUE: Si el proceso es correcto
899	// FALSE: En caso de ocurrir algún error
900	//______________________________________________________________________________________________________
901	int Purgar(TRAMA* ptrTrama)
902	{
903
904	exit(EXIT_SUCCESS);
905	}
906	//______________________________________________________________________________________________________
907	// Función: Sondeo
908	//
909	// Descripción:
910	// Envía al servidor una confirmación de que está dentro del sistema
911	// Parámetros:
912	// ptrTrama: contenido del mensajede
913	// Devuelve:
914	// TRUE: Si el proceso es correcto
915	// FALSE: En caso de ocurrir algún error
916	//______________________________________________________________________________________________________
917	BOOLEAN Sondeo(TRAMA* ptrTrama)
918	{
919	return(TRUE);
920	}
921	//______________________________________________________________________________________________________
922	// Función: ConsolaRemota
923	//
924	// Descripción:
925	// Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
926	// Parámetros:
927	// ptrTrama: contenido del mensaje
928	// Devuelve:
929	// TRUE: Si el proceso es correcto
930	// FALSE: En caso de ocurrir algún error
931	//______________________________________________________________________________________________________
932	BOOLEAN ConsolaRemota(TRAMA* ptrTrama)
933	{
934	SOCKET socket_c;
935	char nfn,scp,*aux,ecosrc[LONPRM],ecodst[LONPRM],msglog[LONSTD];;
936	char modulo[] = "ConsolaRemota()";
937
938	/* Nombre del archivo de script */
939	char filescript[LONPRM];
940	sprintf(filescript,"/tmp/_script_%s",IPlocal);
941
942	aux=copiaParametro("scp",ptrTrama);
943	scp=URLDecode(aux);
944	escribeArchivo(filescript,scp);
945	liberaMemoria(aux);
946	liberaMemoria(scp);
947
948	nfn=copiaParametro("nfn",ptrTrama);
949	sprintf(interface,"%s/%s",pathinterface,nfn);
950	sprintf(ecosrc,"/tmp/_econsola_%s",IPlocal);
951	sprintf(parametros,"%s %s %s",nfn,filescript,ecosrc);
952	herror=interfaceAdmin(interface,parametros,NULL);
953	if(herror){
954	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
955	errorInfo(modulo,msglog);
956	}
957	else{
958	/* Envía fichero de inventario al servidor */
959	sprintf(ecodst,"/tmp/_Seconsola_%s",IPlocal); // Nombre que tendra el archivo en el Servidor
960	initParametros(ptrTrama,0);
961	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",ecodst);
962	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
963	errorLog(modulo,42,FALSE);
964	return(FALSE);
965	}
966	/* Espera señal para comenzar el envío */
967	liberaMemoria(ptrTrama);
968	recibeFlag(&socket_c,ptrTrama);
969	/* Envía archivo */
970	if(!sendArchivo(&socket_c,ecosrc)){
971	errorLog(modulo,57, FALSE);
972	herror=12; // Error de envío de fichero por la red
973	}
974	close(socket_c);
975	}
976	liberaMemoria(nfn);
977	return(TRUE);
978	}
979	//_____________________________________________________________________________________________________
980	// Función: Comando
981	//
982	// Descripción:
983	// COmando personalizado enviado desde el servidor
984	// Parámetros:
985	// ptrTrama: contenido del mensaje
986	// Devuelve:
987	// TRUE: Si el proceso es correcto
988	// FALSE: En caso de ocurrir algún error
989	//_____________________________________________________________________________________________________
990	BOOLEAN Comando(TRAMA* ptrTrama)
991	{
992	char ids,nfn,msglog[LONSTD];
993	char modulo[] = "Comando()";
994
995	if (ndebug>=DEBUG_MAXIMO) {
996	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
997	infoDebug(msglog);
998	}
999	nfn=copiaParametro("nfn",ptrTrama);
1000	ids=copiaParametro("ids",ptrTrama);
1001
1002	sprintf(interface,"%s/%s",pathinterface,nfn);
1003	herror=interfaceAdmin(interface,NULL,NULL);
1004	if(herror){
1005	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1006	errorInfo(modulo,msglog);
1007	}
1008	/* Envia respuesta de ejecucución del comando */
1009	initParametros(ptrTrama,0);
1010	sprintf(ptrTrama->parametros,"nfn=RESPUESTA_%s\r",nfn);
1011	respuestaEjecucionComando(ptrTrama,herror,ids);
1012	liberaMemoria(nfn);
1013	liberaMemoria(ids);
1014	return(TRUE);
1015	}
1016	//_____________________________________________________________________________________________________
1017	// Función: Arrancar
1018	//
1019	// Descripción:
1020	// Responde a un comando de encendido por la red
1021	// Parámetros:
1022	// ptrTrama: contenido del mensaje
1023	// Devuelve:
1024	// TRUE: Si el proceso es correcto
1025	// FALSE: En caso de ocurrir algún error
1026	//_____________________________________________________________________________________________________
1027	BOOLEAN Arrancar(TRAMA* ptrTrama)
1028	{
1029	int lon;
1030	char *ids,msglog[LONSTD];
1031	char modulo[] = "Arrancar()";
1032
1033	if (ndebug>=DEBUG_MAXIMO) {
1034	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1035	infoDebug(msglog);
1036	}
1037
1038	ids=copiaParametro("ids",ptrTrama);
1039
1040	/* Envia respuesta de ejecucución del script */
1041	initParametros(ptrTrama,0);
1042	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Arrancar");
1043	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS);
1044	respuestaEjecucionComando(ptrTrama,0,ids);
1045	liberaMemoria(ids);
1046	return(TRUE);
1047	}
1048	//_____________________________________________________________________________________________________
1049	// Función: Apagar
1050	//
1051	// Descripción:
1052	// Apaga el cliente
1053	// Parámetros:
1054	// ptrTrama: contenido del mensaje
1055	// Devuelve:
1056	// TRUE: Si el proceso es correcto
1057	// FALSE: En caso de ocurrir algún error
1058	//_____________________________________________________________________________________________________
1059	BOOLEAN Apagar(TRAMA* ptrTrama)
1060	{
1061	char ids,nfn,msglog[LONSTD];
1062	char modulo[] = "Apagar()";
1063
1064	if (ndebug>=DEBUG_MAXIMO) {
1065	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1066	infoDebug(msglog);
1067	}
1068	nfn=copiaParametro("nfn",ptrTrama);
1069	ids=copiaParametro("ids",ptrTrama);
1070
1071	initParametros(ptrTrama,0);
1072	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Apagar");
1073	respuestaEjecucionComando(ptrTrama,0,ids);
1074
1075	sprintf(interface,"%s/%s",pathinterface,nfn);
1076	herror=interfaceAdmin(interface,NULL,NULL);
1077	if(herror){
1078	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1079	liberaMemoria(nfn);
1080	liberaMemoria(ids);
1081	errorInfo(modulo,msglog);
1082	return(FALSE);
1083	}
1084	liberaMemoria(nfn);
1085	liberaMemoria(ids);
1086	return(TRUE);
1087	}
1088	//_____________________________________________________________________________________________________
1089	// Función: Reiniciar
1090	//
1091	// Descripción:
1092	// Apaga el cliente
1093	// Parámetros:
1094	// ptrTrama: contenido del mensaje
1095	// Devuelve:
1096	// TRUE: Si el proceso es correcto
1097	// FALSE: En caso de ocurrir algún error
1098	//_____________________________________________________________________________________________________
1099	BOOLEAN Reiniciar(TRAMA* ptrTrama)
1100	{
1101	char nfn,ids,msglog[LONSTD];
1102	char modulo[] = "Reiniciar()";
1103
1104	if (ndebug>=DEBUG_MAXIMO) {
1105	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1106	infoDebug(msglog);
1107	}
1108	nfn=copiaParametro("nfn",ptrTrama);
1109	ids=copiaParametro("ids",ptrTrama);
1110
1111	initParametros(ptrTrama,0);
1112	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Reiniciar");
1113	respuestaEjecucionComando(ptrTrama,0,ids);
1114
1115	sprintf(interface,"%s/%s",pathinterface,nfn);
1116	herror=interfaceAdmin(interface,NULL,NULL);
1117	if(herror){
1118	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1119	liberaMemoria(nfn);
1120	liberaMemoria(ids);
1121	errorInfo(modulo,msglog);
1122	return(FALSE);
1123	}
1124	liberaMemoria(nfn);
1125	liberaMemoria(ids);
1126	return(TRUE);
1127	}
1128	//_____________________________________________________________________________________________________
1129	// Función: IniciarSesion
1130	//
1131	// Descripción:
1132	// Inicia sesión en el Sistema Operativo de una de las particiones
1133	// Parámetros:
1134	// ptrTrama: contenido del mensaje
1135	// Devuelve:
1136	// TRUE: Si el proceso es correcto
1137	// FALSE: En caso de ocurrir algún error
1138	//_____________________________________________________________________________________________________
1139	BOOLEAN IniciarSesion(TRAMA* ptrTrama)
1140	{
1141	char nfn,ids,disk,par,msglog[LONSTD];
1142	char modulo[] = "IniciarSesion()";
1143
1144	if (ndebug>=DEBUG_MAXIMO) {
1145	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1146	infoDebug(msglog);
1147	}
1148	nfn=copiaParametro("nfn",ptrTrama);
1149	ids=copiaParametro("ids",ptrTrama);
1150	disk=copiaParametro("dsk",ptrTrama);
1151	par=copiaParametro("par",ptrTrama);
1152
1153	initParametros(ptrTrama,0);
1154	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_IniciarSesion");
1155	respuestaEjecucionComando(ptrTrama,0,ids);
1156	liberaMemoria(ids);
1157
1158	sprintf(interface,"%s/%s",pathinterface,nfn);
1159	sprintf(parametros,"%s %s %s",nfn,disk,par);
1160	liberaMemoria(par);
1161
1162	herror=interfaceAdmin(interface,parametros,NULL);
1163
1164	if(herror){
1165	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1166	liberaMemoria(nfn);
1167	errorInfo(modulo,msglog);
1168	return(FALSE);
1169	}
1170	liberaMemoria(nfn);
1171	return(TRUE);
1172	}
1173	//______________________________________________________________________________________________________
1174	// Función: CrearImagen
1175	//
1176	// Descripción:
1177	// Crea una imagen de una partición
1178	// Parámetros:
1179	// ptrTrama: contenido del mensaje
1180	// Devuelve:
1181	// TRUE: Si el proceso es correcto
1182	// FALSE: En caso de ocurrir algún error
1183	//______________________________________________________________________________________________________
1184	BOOLEAN CrearImagen(TRAMA* ptrTrama)
1185	{
1186	int lon;
1187	char nfn,dsk,par,cpt,idi,ipr,nci,ids,msglog[LONSTD];
1188	char modulo[] = "CrearImagen()";
1189
1190	if (ndebug>=DEBUG_MAXIMO) {
1191	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1192	infoDebug(msglog);
1193	}
1194
1195	dsk=copiaParametro("dsk",ptrTrama); // Disco
1196	par=copiaParametro("par",ptrTrama); // Número de partición
1197	cpt=copiaParametro("cpt",ptrTrama); // Código de la partición
1198	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1199	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1200	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1201
1202	nfn=copiaParametro("nfn",ptrTrama);
1203	ids=copiaParametro("ids",ptrTrama);
1204	muestraMensaje(7,NULL);
1205
1206	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1207	muestraMensaje(2,NULL);
1208	sprintf(interface,"%s/%s",pathinterface,nfn);
1209	sprintf(parametros,"%s %s %s %s %s",nfn,dsk,par,nci,ipr);
1210	herror=interfaceAdmin(interface,parametros,NULL);
1211	if(herror){
1212	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1213	errorInfo(modulo,msglog);
1214	muestraMensaje(10,NULL);
1215	}
1216	else
1217	muestraMensaje(9,NULL);
1218	}
1219	else{
1220	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1221	errorInfo(modulo,msglog);
1222	}
1223
1224	/* Envia respuesta de ejecución de la función de interface */
1225	initParametros(ptrTrama,0);
1226	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagen");
1227	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1228	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1229	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
1230	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
1231	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
1232	respuestaEjecucionComando(ptrTrama,herror,ids);
1233
1234	liberaMemoria(dsk);
1235	liberaMemoria(par);
1236	liberaMemoria(cpt);
1237	liberaMemoria(idi);
1238	liberaMemoria(nci);
1239	liberaMemoria(ipr);
1240	liberaMemoria(nfn);
1241	liberaMemoria(ids);
1242
1243	muestraMenu();
1244
1245	return(TRUE);
1246	}
1247	//______________________________________________________________________________________________________
1248	// Función: CrearImagenBasica
1249	//
1250	// Descripción:
1251	// Crea una imagen básica a travers dela sincronización
1252	// Parámetros:
1253	// ptrTrama: contenido del mensaje
1254	//
1255	// FDevuelve:
1256	// TRUE: Si el proceso es correcto
1257	// FALSE: En caso de ocurrir algún error
1258	//______________________________________________________________________________________________________
1259	BOOLEAN CrearImagenBasica(TRAMA* ptrTrama)
1260	{
1261	int lon;
1262	char nfn,dsk,par,cpt,idi,nci,rti,ipr,msy,whl,eli,cmp,bpi,cpc,bpc,nba,*ids,msglog[LONSTD];
1263	char modulo[] = "CrearImagenBasica()";
1264
1265	if (ndebug>=DEBUG_MAXIMO) {
1266	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1267	infoDebug(msglog);
1268	}
1269	nfn=copiaParametro("nfn",ptrTrama);
1270	dsk=copiaParametro("dsk",ptrTrama); // Disco
1271	par=copiaParametro("par",ptrTrama); // Número de partición
1272	cpt=copiaParametro("cpt",ptrTrama); // Tipo de partición
1273	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1274	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1275	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1276	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1277
1278	msy=copiaParametro("msy",ptrTrama); // Método de sincronización
1279
1280	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1281	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1282	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1283
1284	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1285	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1286	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1287	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1288
1289	muestraMensaje(7,NULL); // Creando Inventario Software
1290	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1291	muestraMensaje(30,NULL);// Creando Imagen Básica, por favor espere...
1292	sprintf(interface,"%s/%s",pathinterface,nfn);
1293	sprintf(parametros,"%s %s %s %s %s %s%s%s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,whl,eli,cmp,bpi,cpc,bpc,nba,msy,rti);
1294	herror=interfaceAdmin(interface,parametros,NULL);
1295	if(herror){
1296	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1297	errorInfo(modulo,msglog);
1298	muestraMensaje(29,NULL);// Ha habido algún error en el proceso de creación de imagen básica
1299	}
1300	else
1301	muestraMensaje(28,NULL);// El proceso de creación de imagen básica ha terminado correctamente
1302	}
1303	else{
1304	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1305	errorInfo(modulo,msglog);
1306	}
1307
1308	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
1309
1310	/* Envia respuesta de ejecución de la función de interface */
1311	initParametros(ptrTrama,0);
1312	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagenBasica");
1313	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1314	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1315	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
1316	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
1317	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
1318	respuestaEjecucionComando(ptrTrama,herror,ids);
1319
1320	liberaMemoria(nfn);
1321	liberaMemoria(dsk);
1322	liberaMemoria(par);
1323	liberaMemoria(cpt);
1324	liberaMemoria(idi);
1325	liberaMemoria(nci);
1326	liberaMemoria(rti);
1327	liberaMemoria(ipr);
1328
1329	liberaMemoria(msy);
1330
1331	liberaMemoria(whl);
1332	liberaMemoria(eli);
1333	liberaMemoria(cmp);
1334
1335	liberaMemoria(bpi);
1336	liberaMemoria(cpc);
1337	liberaMemoria(bpc);
1338	liberaMemoria(nba);
1339	liberaMemoria(ids);
1340
1341	muestraMenu();
1342
1343	return(TRUE);
1344	}
1345	//______________________________________________________________________________________________________
1346	// Función: CrearSoftIncremental
1347	//
1348	// Descripción:
1349	// Crea una software incremental comparando una partición con una imagen básica
1350	// Parámetros:
1351	// ptrTrama: contenido del mensaje
1352	//
1353	// Devuelve:
1354	// TRUE: Si el proceso es correcto
1355	// FALSE: En caso de ocurrir algún error
1356	//______________________________________________________________________________________________________
1357	BOOLEAN CrearSoftIncremental(TRAMA* ptrTrama)
1358	{
1359	int lon;
1360	char nfn,dsk,par,idi,idf,ipr,nci,rti,ncf,msy,whl,eli,cmp,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
1361	char modulo[] = "CrearSoftIncremental()";
1362
1363	if (ndebug>=DEBUG_MAXIMO) {
1364	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1365	infoDebug(msglog);
1366	}
1367	nfn=copiaParametro("nfn",ptrTrama);
1368
1369	dsk=copiaParametro("dsk",ptrTrama); // Disco
1370	par=copiaParametro("par",ptrTrama); // Número de partición
1371	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1372	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1373	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1374	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1375	idf=copiaParametro("idf",ptrTrama); // Identificador de la imagen diferencial
1376	ncf=copiaParametro("ncf",ptrTrama); // Nombre canónico de la imagen diferencial
1377
1378	msy=copiaParametro("msy",ptrTrama); // Método de sincronización
1379
1380	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1381	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1382	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1383
1384	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1385	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1386	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1387	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1388
1389	muestraMensaje(7,NULL); // Creando Inventario Software
1390	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1391	muestraMensaje(25,NULL);// Creando Imagen Incremental, por favor espere...
1392	sprintf(interface,"%s/%s",pathinterface,nfn);
1393	sprintf(parametros,"%s %s %s %s %s %s %s%s%s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,ncf,whl,eli,cmp,bpi,cpc,bpc,nba,msy,rti);
1394
1395	herror=interfaceAdmin(interface,parametros,NULL);
1396	if(herror){
1397	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1398	errorInfo(modulo,msglog);
1399	muestraMensaje(27,NULL);// Ha habido algún error en el proceso de creación de imagen básica
1400	}
1401	else
1402	muestraMensaje(26,NULL);// El proceso de creación de imagen incremental ha terminado correctamente
1403	}
1404	else{
1405	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1406	errorInfo(modulo,msglog);
1407	}
1408
1409	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
1410
1411	/* Envia respuesta de ejecución de la función de interface */
1412	initParametros(ptrTrama,0);
1413	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearSoftIncremental");
1414	lon+=sprintf(ptrTrama->parametros+lon,"idf=%s\r",idf); // Identificador de la imagen incremental
1415	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1416	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1417	respuestaEjecucionComando(ptrTrama,herror,ids);
1418
1419	liberaMemoria(nfn);
1420	liberaMemoria(dsk);
1421	liberaMemoria(par);
1422	liberaMemoria(idi);
1423	liberaMemoria(nci);
1424	liberaMemoria(rti);
1425	liberaMemoria(ipr);
1426	liberaMemoria(idf);
1427	liberaMemoria(ncf);
1428	liberaMemoria(msy);
1429	liberaMemoria(whl);
1430	liberaMemoria(eli);
1431	liberaMemoria(cmp);
1432	liberaMemoria(bpi);
1433	liberaMemoria(cpc);
1434	liberaMemoria(bpc);
1435	liberaMemoria(nba);
1436	liberaMemoria(ids);
1437
1438	muestraMenu();
1439
1440	return(TRUE);
1441	}
1442	//______________________________________________________________________________________________________
1443	// Función: RestaurarImagen
1444	//
1445	// Descripción:
1446	// Restaura una imagen en una partición
1447	// Parámetros:
1448	// ptrTrama: contenido del mensaje
1449	// Devuelve:
1450	// TRUE: Si el proceso es correcto
1451	// FALSE: En bpccaso de ocurrir algún error
1452	//______________________________________________________________________________________________________
1453	BOOLEAN RestaurarImagen(TRAMA* ptrTrama)
1454	{
1455	int lon;
1456	char nfn,dsk,par,idi,ipr,ifs,cfg,nci,ids,ptc,msglog[LONSTD];
1457	char modulo[] = "RestaurarImagen()";
1458
1459	if (ndebug>=DEBUG_MAXIMO) {
1460	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1461	infoDebug(msglog);
1462	}
1463
1464	dsk=copiaParametro("dsk",ptrTrama);
1465	par=copiaParametro("par",ptrTrama);
1466	idi=copiaParametro("idi",ptrTrama);
1467	ipr=copiaParametro("ipr",ptrTrama);
1468	nci=copiaParametro("nci",ptrTrama);
1469	ifs=copiaParametro("ifs",ptrTrama);
1470	ptc=copiaParametro("ptc",ptrTrama);
1471
1472	nfn=copiaParametro("nfn",ptrTrama);
1473	ids=copiaParametro("ids",ptrTrama);
1474	muestraMensaje(3,NULL);
1475	sprintf(interface,"%s/%s",pathinterface,nfn);
1476	sprintf(parametros,"%s %s %s %s %s %s",nfn,dsk,par,nci,ipr,ptc);
1477	herror=interfaceAdmin(interface,parametros,NULL);
1478	if(herror){
1479	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1480	errorInfo(modulo,msglog);
1481	muestraMensaje(12,NULL);
1482	}
1483	else
1484	muestraMensaje(11,NULL);
1485
1486	/* Obtener nueva configuración */
1487	cfg=LeeConfiguracion();
1488	if(!cfg){ // No se puede recuperar la configuración del cliente
1489	errorLog(modulo,36,FALSE);
1490	}
1491
1492	/* Envia respuesta de ejecución de la función de interface */
1493	initParametros(ptrTrama,0);
1494	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagen");
1495	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1496	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1497	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1498	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1499	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de discos
1500	respuestaEjecucionComando(ptrTrama,herror,ids);
1501
1502	liberaMemoria(nfn);
1503	liberaMemoria(dsk);
1504	liberaMemoria(par);
1505	liberaMemoria(idi);
1506	liberaMemoria(nci);
1507	liberaMemoria(ipr);
1508	liberaMemoria(ifs);
1509	liberaMemoria(cfg);
1510	liberaMemoria(ptc);
1511	liberaMemoria(ids);
1512
1513	muestraMenu();
1514
1515	return(TRUE);
1516	}
1517	//______________________________________________________________________________________________________
1518	// Función: RestaurarImagenBasica
1519	//
1520	// Descripción:
1521	// Restaura una imagen básica en una partición
1522	// Parámetros:
1523	// ptrTrama: contenido del mensaje
1524	// Devuelve:
1525	// TRUE: Si el proceso es correcto
1526	// FALSE: En caso de ocurrir algún error
1527	//______________________________________________________________________________________________________
1528	BOOLEAN RestaurarImagenBasica(TRAMA* ptrTrama)
1529	{
1530	int lon;
1531	char nfn,dsk,par,idi,ipr,met,nci,rti,ifs,cfg,msy,whl,eli,cmp,tpt,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
1532	char modulo[] = "RestaurarImagenBasica()";
1533
1534	if (ndebug>=DEBUG_MAXIMO) {
1535	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1536	infoDebug(msglog);
1537	}
1538	dsk=copiaParametro("dsk",ptrTrama);
1539	par=copiaParametro("par",ptrTrama);
1540	idi=copiaParametro("idi",ptrTrama);
1541	ipr=copiaParametro("ipr",ptrTrama);
1542	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
1543	nci=copiaParametro("nci",ptrTrama);
1544	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1545	ifs=copiaParametro("ifs",ptrTrama);
1546
1547	tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast
1548	msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion
1549
1550	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1551	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1552	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1553
1554	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1555	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1556	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1557	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1558
1559	nfn=copiaParametro("nfn",ptrTrama);
1560	ids=copiaParametro("ids",ptrTrama);
1561	muestraMensaje(31,NULL);
1562	sprintf(interface,"%s/%s",pathinterface,nfn);
1563	sprintf(parametros,"%s %s %s %s %s %s %s%s%s %s%s%s%s %s %s %s",nfn,dsk,par,nci,ipr,tpt,whl,eli,cmp,bpi,cpc,bpc,nba,met,msy,rti);
1564	herror=interfaceAdmin(interface,parametros,NULL);
1565	if(herror){
1566	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1567	errorInfo(modulo,msglog);
1568	muestraMensaje(33,NULL);
1569	}
1570	else
1571	muestraMensaje(32,NULL);
1572
1573	/* Obtener nueva configuración */
1574	cfg=LeeConfiguracion();
1575	if(!cfg){ // No se puede recuperar la configuración del cliente
1576	errorLog(modulo,36,FALSE);
1577	}
1578
1579	/* Envia respuesta de ejecución de la función de interface */
1580	initParametros(ptrTrama,0);
1581	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagenBasica");
1582	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1583	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1584	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1585	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1586	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de discos
1587	respuestaEjecucionComando(ptrTrama,herror,ids);
1588
1589	liberaMemoria(nfn);
1590	liberaMemoria(dsk);
1591	liberaMemoria(par);
1592	liberaMemoria(idi);
1593	liberaMemoria(nci);
1594	liberaMemoria(rti);
1595	liberaMemoria(ifs);
1596	liberaMemoria(cfg);
1597	liberaMemoria(ipr);
1598	liberaMemoria(met);
1599
1600	liberaMemoria(tpt);
1601	liberaMemoria(msy);
1602
1603	liberaMemoria(whl);
1604	liberaMemoria(eli);
1605	liberaMemoria(cmp);
1606
1607	liberaMemoria(bpi);
1608	liberaMemoria(cpc);
1609	liberaMemoria(bpc);
1610	liberaMemoria(nba);
1611	liberaMemoria(ids);
1612
1613	muestraMenu();
1614
1615	return(TRUE);
1616	}
1617	//______________________________________________________________________________________________________
1618	// Función: RestaurarSoftIncremental
1619	//
1620	// Descripción:
1621	// Restaura software incremental en una partición
1622	// Parámetros:
1623	// ptrTrama: contenido del mensaje
1624	// Devuelve:
1625	// TRUE: Si el proceso es correcto
1626	// FALSE: En caso de ocurrir algún error
1627	//______________________________________________________________________________________________________
1628	BOOLEAN RestaurarSoftIncremental(TRAMA* ptrTrama)
1629	{
1630	int lon;
1631	char nfn,dsk,par,idi,ipr,met,ifs,nci,rti,idf,ncf,msy,whl,eli,cmp,tpt,bpi,cpc,bpc,nba,*ids,msglog[LONSTD];
1632	char modulo[] = "RestaurarSoftIncremental()";
1633
1634	if (ndebug>=DEBUG_MAXIMO) {
1635	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1636	infoDebug(msglog);
1637	}
1638	dsk=copiaParametro("dsk",ptrTrama);
1639	par=copiaParametro("par",ptrTrama);
1640	idi=copiaParametro("idi",ptrTrama);
1641	idf=copiaParametro("idf",ptrTrama);
1642	ipr=copiaParametro("ipr",ptrTrama);
1643	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
1644	ifs=copiaParametro("ifs",ptrTrama);
1645	nci=copiaParametro("nci",ptrTrama);
1646	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1647	ncf=copiaParametro("ncf",ptrTrama);
1648
1649	tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast
1650	msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion
1651
1652	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1653	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1654	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1655
1656	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1657	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1658	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1659	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1660
1661	nfn=copiaParametro("nfn",ptrTrama);
1662	ids=copiaParametro("ids",ptrTrama);
1663	muestraMensaje(31,NULL);
1664	sprintf(interface,"%s/%s",pathinterface,nfn);
1665	sprintf(parametros,"%s %s %s %s %s %s %s %s%s%s %s%s%s%s %s %s %s",nfn,dsk,par,nci,ipr,ncf,tpt,whl,eli,cmp,bpi,cpc,bpc,nba,met,msy,rti);
1666	herror=interfaceAdmin(interface,parametros,NULL);
1667	if(herror){
1668	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1669	errorInfo(modulo,msglog);
1670	muestraMensaje(35,NULL);
1671	}
1672	else
1673	muestraMensaje(34,NULL);
1674
1675	/* Envia respuesta de ejecución de la función de interface */
1676	initParametros(ptrTrama,0);
1677	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarSoftIncremental");
1678	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idf); // Identificador de la imagen incremental (Forzada a idi)
1679	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1680	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1681	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1682
1683	respuestaEjecucionComando(ptrTrama,herror,ids);
1684
1685	liberaMemoria(nfn);
1686	liberaMemoria(dsk);
1687	liberaMemoria(par);
1688	liberaMemoria(idi);
1689	liberaMemoria(idf);
1690	liberaMemoria(nci);
1691	liberaMemoria(rti);
1692	liberaMemoria(ncf);
1693	liberaMemoria(ifs);
1694	liberaMemoria(ipr);
1695	liberaMemoria(met);
1696
1697	liberaMemoria(tpt);
1698	liberaMemoria(msy);
1699
1700	liberaMemoria(whl);
1701	liberaMemoria(eli);
1702	liberaMemoria(cmp);
1703
1704	liberaMemoria(bpi);
1705	liberaMemoria(cpc);
1706	liberaMemoria(bpc);
1707	liberaMemoria(nba);
1708	liberaMemoria(ids);
1709
1710	muestraMenu();
1711
1712	return(TRUE);
1713	}
1714	//______________________________________________________________________________________________________
1715	// Función: Configurar
1716	//
1717	// Descripción:
1718	// Configura la tabla de particiones y formatea
1719	// Parámetros:
1720	// ptrTrama: contenido del mensaje
1721	// Devuelve:
1722	// TRUE: Si el proceso es correcto
1723	// FALSE: En caso de ocurrir algún error
1724	//______________________________________________________________________________________________________
1725	BOOLEAN Configurar(TRAMA* ptrTrama)
1726	{
1727	int lon;
1728	char nfn,dsk,cfg,ids,msglog[LONSTD];
1729	char modulo[] = "Configurar()";
1730
1731	if (ndebug>=DEBUG_MAXIMO) {
1732	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1733	infoDebug(msglog);
1734	}
1735
1736	dsk=copiaParametro("dsk",ptrTrama);
1737	cfg=copiaParametro("cfg",ptrTrama);
1738	/* Sustituir caracteres */
1739	sustituir(cfg,'\n','$');
1740	sustituir(cfg,'\t','#');
1741
1742	nfn=copiaParametro("nfn",ptrTrama);
1743	ids=copiaParametro("ids",ptrTrama);
1744	muestraMensaje(4,NULL);
1745	sprintf(interface,"%s/%s",pathinterface,nfn);
1746	sprintf(parametros,"%s %s %s",nfn,dsk,cfg);
1747
1748	herror=interfaceAdmin(interface,parametros,NULL);
1749	if(herror){
1750	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1751	errorInfo(modulo,msglog);
1752	muestraMensaje(13,NULL);
1753	}
1754	else
1755	muestraMensaje(14,NULL);
1756
1757	cfg=LeeConfiguracion();
1758	if(!cfg){ // No se puede recuperar la configuración del cliente
1759	errorLog(modulo,36,FALSE);
1760	return(FALSE);
1761	}
1762
1763	/* Envia respuesta de ejecución del comando*/
1764	initParametros(ptrTrama,0);
1765	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
1766	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
1767	respuestaEjecucionComando(ptrTrama,herror,ids);
1768
1769	liberaMemoria(dsk);
1770	liberaMemoria(cfg);
1771	liberaMemoria(nfn);
1772	liberaMemoria(ids);
1773
1774	muestraMenu();
1775
1776	return(TRUE);
1777	}
1778	// ________________________________________________________________________________________________________
1779	// Función: InventarioHardware
1780	//
1781	// Descripción:
1782	// Envia al servidor el nombre del archivo de inventario de su hardware para posteriormente
1783	// esperar que éste lo solicite y enviarlo por la red.
1784	// Parámetros:
1785	// ptrTrama: contenido del mensaje
1786	// Devuelve:
1787	// TRUE: Si el proceso es correcto
1788	// FALSE: En caso de ocurrir algún error
1789	//______________________________________________________________________________________________________
1790	BOOLEAN InventarioHardware(TRAMA* ptrTrama)
1791	{
1792	int lon;
1793	SOCKET socket_c;
1794	char nfn,ids,msglog[LONSTD],hrdsrc[LONPRM],hrddst[LONPRM];
1795	char modulo[] = "InventarioHardware()";
1796
1797	if (ndebug>=DEBUG_MAXIMO) {
1798	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1799	infoDebug(msglog);
1800	}
1801
1802	nfn=copiaParametro("nfn",ptrTrama);
1803	ids=copiaParametro("ids",ptrTrama);
1804	muestraMensaje(6,NULL);
1805
1806	sprintf(interface,"%s/%s",pathinterface,nfn);
1807	sprintf(hrdsrc,"/tmp/Chrd-%s",IPlocal); // Nombre que tendra el archivo de inventario
1808	sprintf(parametros,"%s %s",nfn,hrdsrc);
1809	herror=interfaceAdmin(interface,parametros,NULL);
1810	if(herror){
1811	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1812	errorInfo(modulo,msglog);
1813	muestraMensaje(18,NULL);
1814	}
1815	else{
1816	/* Envía fichero de inventario al servidor */
1817	sprintf(hrddst,"/tmp/Shrd-%s",IPlocal); // Nombre que tendra el archivo en el Servidor
1818	initParametros(ptrTrama,0);
1819	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",hrddst);
1820	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
1821	liberaMemoria(nfn);
1822	liberaMemoria(ids);
1823	errorLog(modulo,42,FALSE);
1824	return(FALSE);
1825	}
1826	/* Espera señal para comenzar el envío */
1827	liberaMemoria(ptrTrama);
1828	recibeFlag(&socket_c,ptrTrama);
1829	/* Envía archivo */
1830	if(!sendArchivo(&socket_c,hrdsrc)){
1831	errorLog(modulo,57, FALSE);
1832	herror=12; // Error de envío de fichero por la red
1833	}
1834	close(socket_c);
1835	muestraMensaje(17,NULL);
1836	}
1837
1838	/* Envia respuesta de ejecución de la función de interface */
1839	initParametros(ptrTrama,0);
1840	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioHardware");
1841	lon+=sprintf(ptrTrama->parametros+lon,"hrd=%s\r",hrddst);
1842	respuestaEjecucionComando(ptrTrama,herror,ids);
1843	liberaMemoria(nfn);
1844	liberaMemoria(ids);
1845
1846	muestraMenu();
1847
1848	return(TRUE);
1849	}
1850	// ________________________________________________________________________________________________________
1851	// Función: InventarioSoftware
1852	//
1853	// Descripción:
1854	// Crea el inventario software de un sistema operativo instalado en una partición.
1855	// Parámetros:
1856	// ptrTrama: contenido del mensaje
1857	// Devuelve:
1858	// TRUE: Si el proceso es correcto
1859	// FALSE: En caso de ocurrir algún error
1860	//______________________________________________________________________________________________________
1861	BOOLEAN InventarioSoftware(TRAMA* ptrTrama)
1862	{
1863	char nfn,ids,msglog[LONSTD];
1864	char modulo[] = "InventarioSoftware()";
1865
1866	if (ndebug>=DEBUG_MAXIMO) {
1867	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1868	infoDebug(msglog);
1869	}
1870	nfn=copiaParametro("nfn",ptrTrama);
1871	ids=copiaParametro("ids",ptrTrama);
1872	muestraMensaje(7,NULL);
1873	InventariandoSoftware(ptrTrama,TRUE,nfn);
1874	respuestaEjecucionComando(ptrTrama,herror,ids);
1875	liberaMemoria(nfn);
1876	liberaMemoria(ids);
1877	muestraMenu();
1878	return(TRUE);
1879	}
1880	// ________________________________________________________________________________________________________
1881	//
1882	// Función: InventariandoSoftware
1883	//
1884	// Descripción:
1885	// Envia al servidor el nombre del archivo de inventario de su software para posteriormente
1886	// esperar que éste lo solicite y enviarlo por la red.
1887	// Parámetros:
1888	// ptrTrama: contenido del mensaje
1889	// sw: switch que indica si la función es llamada por el comando InventarioSoftware(true) o CrearImagen(false)
1890	// nfn: Nombre de la función del Interface que implementa el comando
1891	// Devuelve:
1892	// TRUE: Si el proceso es correcto
1893	// FALSE: En caso de ocurrir algún error
1894	//______________________________________________________________________________________________________
1895	BOOLEAN InventariandoSoftware(TRAMA* ptrTrama,BOOLEAN sw,char *nfn)
1896	{
1897	int lon;
1898	SOCKET socket_c;
1899	char dsk,par,msglog[LONSTD],sftsrc[LONPRM],sftdst[LONPRM];
1900	char modulo[] = "InventariandoSoftware()";
1901
1902	dsk=copiaParametro("dsk",ptrTrama); // Disco
1903	par=copiaParametro("par",ptrTrama);
1904
1905	sprintf(interface,"%s/%s",pathinterface,nfn);
1906	sprintf(sftsrc,"/tmp/CSft-%s-%s",IPlocal,par); // Nombre que tendra el archivo de inventario
1907	sprintf(parametros,"%s %s %s %s",nfn,dsk,par,sftsrc);
1908
1909	herror=interfaceAdmin(interface,parametros,NULL);
1910	herror=0;
1911	if(herror){
1912	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1913	errorInfo(modulo,msglog);
1914	muestraMensaje(20,NULL);
1915	}
1916	else{
1917	/* Envía fichero de inventario al servidor */
1918	sprintf(sftdst,"/tmp/Ssft-%s-%s",IPlocal,par); // Nombre que tendra el archivo en el Servidor
1919	initParametros(ptrTrama,0);
1920
1921	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",sftdst);
1922	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
1923	errorLog(modulo,42,FALSE);
1924	liberaMemoria(dsk);
1925	liberaMemoria(par);
1926	return(FALSE);
1927	}
1928	/* Espera señal para comenzar el envío */
1929	liberaMemoria(ptrTrama);
1930	if(!recibeFlag(&socket_c,ptrTrama)){
1931	errorLog(modulo,17,FALSE);
1932	}
1933	/* Envía archivo */
1934	if(!sendArchivo(&socket_c,sftsrc)){
1935	errorLog(modulo,57, FALSE);
1936	herror=12; // Error de envío de fichero por la red
1937	}
1938	close(socket_c);
1939	muestraMensaje(19,NULL);
1940	}
1941	initParametros(ptrTrama,0);
1942	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioSoftware");
1943	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par);
1944	lon+=sprintf(ptrTrama->parametros+lon,"sft=%s\r",sftdst);
1945	if(!sw)
1946	respuestaEjecucionComando(ptrTrama,herror,"0");
1947
1948	liberaMemoria(dsk);
1949	liberaMemoria(par);
1950	return(TRUE);
1951	}
1952	// ________________________________________________________________________________________________________
1953	// Función: EjecutarScript
1954	//
1955	// Descripción:
1956	// Ejecuta código de script
1957	// Parámetros:
1958	// ptrTrama: contenido del mensaje
1959	// Devuelve:
1960	// TRUE: Si el proceso es correcto
1961	// FALSE: En caso de ocurrir algún error
1962	//______________________________________________________________________________________________________
1963	BOOLEAN EjecutarScript(TRAMA* ptrTrama)
1964	{
1965	int lon;
1966	char nfn,aux,ids,scp,*cfg,msglog[LONSTD];
1967	char modulo[] = "EjecutarScript()";
1968
1969	if (ndebug>=DEBUG_MAXIMO) {
1970	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1971	infoDebug(msglog);
1972	}
1973	aux=copiaParametro("scp",ptrTrama);
1974	scp=URLDecode(aux);
1975
1976
1977	muestraMensaje(8,NULL);
1978	/* Nombre del archivo de script */
1979	char filescript[LONPRM];
1980	sprintf(filescript,"/tmp/_script_%s",IPlocal);
1981	escribeArchivo(filescript,scp);
1982	nfn=copiaParametro("nfn",ptrTrama);
1983	sprintf(interface,"%s/%s",pathinterface,nfn);
1984	sprintf(parametros,"%s %s",nfn,filescript);
1985	herror=interfaceAdmin(interface,parametros,NULL);
1986	if(herror){
1987	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1988	errorInfo(modulo,msglog);
1989	muestraMensaje(21,NULL);
1990	}
1991	else
1992	muestraMensaje(22,NULL);
1993
1994	// Toma configuración de particiones
1995	cfg=LeeConfiguracion();
1996	if(!cfg){ // No se puede recuperar la configuración del cliente
1997	errorLog(modulo,36,FALSE);
1998	herror=36;
1999	}
2000
2001	ids=copiaParametro("ids",ptrTrama);
2002
2003	//herror=ejecutarCodigoBash(scp);
2004	initParametros(ptrTrama,0);
2005	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_EjecutarScript");
2006	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
2007	respuestaEjecucionComando(ptrTrama,herror,ids);
2008
2009	liberaMemoria(nfn);
2010	liberaMemoria(ids);
2011	liberaMemoria(aux);
2012	liberaMemoria(scp);
2013	liberaMemoria(cfg);
2014
2015	muestraMenu();
2016
2017	return(TRUE);
2018	}
2019	//______________________________________________________________________________________________________
2020	// Función: respuestaEjecucionComando
2021	//
2022	// Descripción:
2023	// Envia una respuesta a una ejecucion de comando al servidor de Administración
2024	// Parámetros:
2025	// - ptrTrama: contenido del mensaje
2026	// - res: Resultado de la ejecución (Código de error devuelto por el script ejecutado)
2027	// - ids: Identificador de la sesion (En caso de no haber seguimiento es NULO)
2028	// Devuelve:
2029	// TRUE: Si el proceso es correcto
2030	// FALSE: En caso de ocurrir algún error
2031	// ________________________________________________________________________________________________________
2032	BOOLEAN respuestaEjecucionComando(TRAMA* ptrTrama,int res,char *ids)
2033	{
2034	int lon;
2035	SOCKET socket_c;
2036	char modulo[] = "respuestaEjecucionComando()";
2037
2038	lon=strlen(ptrTrama->parametros);
2039	if(ids){ // Existe seguimiento
2040	lon+=sprintf(ptrTrama->parametros+lon,"ids=%s\r",ids); // Añade identificador de la sesión
2041	}
2042	if (res==0){ // Resultado satisfactorio
2043	lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","1");
2044	lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r","");
2045	}
2046	else{ // Algún error
2047	lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","2");
2048	if(res>MAXERRORSCRIPT)
2049	lon+=sprintf(ptrTrama->parametros+lon,"der=%s (Error de script:%d)\r",tbErroresScripts[0],res);// Descripción del error
2050	else
2051	lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r",tbErroresScripts[res]);// Descripción del error
2052	}
2053	if(!(enviaMensajeServidor(&socket_c,ptrTrama,MSG_NOTIFICACION))){
2054	errorLog(modulo,44,FALSE);
2055	return(FALSE);
2056	}
2057
2058	close(socket_c);
2059	return(TRUE);
2060	}
2061	// ________________________________________________________________________________________________________
2062	// Función: gestionaTrama
2063	//
2064	// Descripción:
2065	// Procesa las tramas recibidas.
2066	// Parametros:
2067	// ptrTrama: contenido del mensaje
2068	// Devuelve:
2069	// TRUE: Si el proceso es correcto
2070	// FALSE: En caso de ocurrir algún error
2071	// ________________________________________________________________________________________________________
2072	BOOLEAN gestionaTrama(TRAMA *ptrTrama)
2073	{
2074	int i, res;
2075	char *nfn;
2076	char modulo[] = "gestionaTrama()";
2077
2078	INTROaFINCAD(ptrTrama);
2079	nfn = copiaParametro("nfn", ptrTrama); // Toma nombre de función
2080	for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
2081	res = strcmp(tbfuncionesClient[i].nf, nfn);
2082	if (res == 0) { // Encontrada la función que procesa el mensaje
2083	liberaMemoria(nfn);
2084	return(tbfuncionesClient[i].fptr(ptrTrama)); // Invoca la función
2085	}
2086	}
2087
2088	liberaMemoria(nfn);
2089
2090	/* Sólo puede ser un comando personalizado
2091	if (ptrTrama->tipo==MSG_COMANDO)
2092	return(Comando(ptrTrama));
2093	*/
2094	errorLog(modulo, 18, FALSE);
2095	return (FALSE);
2096	}
2097	//________________________________________________________________________________________________________
2098	// Función: ejecutaArchivo
2099	//
2100	// Descripción:
2101	// Ejecuta los comando contenido en un archivo (cada comando y sus parametros separados por un
2102	// salto de linea.
2103	// Parámetros:
2104	// filecmd: Nombre del archivo de comandos
2105	// ptrTrama: Puntero a una estructura TRAMA usada en las comunicaciones por red (No debe ser NULL)
2106	// Devuelve:
2107	// TRUE: Si el proceso es correcto
2108	// FALSE: En caso de ocurrir algún error
2109	//________________________________________________________________________________________________________
2110	BOOLEAN ejecutaArchivo(char* filecmd,TRAMA *ptrTrama)
2111	{
2112	char* buffer,*lineas[MAXIMAS_LINEAS];
2113	int i,numlin;
2114	char modulo[] = "ejecutaArchivo()";
2115
2116	buffer=leeArchivo(filecmd);
2117	if(buffer){
2118	numlin = splitCadena(lineas, buffer, '@');
2119	initParametros(ptrTrama,0);
2120	for (i = 0; i < numlin; i++) {
2121	if(strlen(lineas[i])>0){
2122	strcpy(ptrTrama->parametros,lineas[i]);
2123	//strcat(ptrTrama->parametros,"\rMCDJ@"); // Fin de trama
2124	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
2125	errorLog(modulo,39,FALSE);
2126	//return(FALSE);
2127	}
2128	}
2129	}
2130	}
2131	liberaMemoria(buffer);
2132	return(TRUE);
2133	}
2134	//______________________________________________________________________________________________________
2135	// Función: enviaMensajeServidor
2136	//
2137	// Descripción:
2138	// Envia un mensaje al servidor de Administración
2139	// Parámetros:
2140	// - socket_c: (Salida) Socket utilizado para el envío
2141	// - ptrTrama: contenido del mensaje
2142	// - tipo: Tipo de mensaje
2143	// C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
2144	// Devuelve:
2145	// TRUE: Si el proceso es correcto
2146	// FALSE: En caso de ocurrir algún error
2147	// ________________________________________________________________________________________________________
2148	BOOLEAN enviaMensajeServidor(SOCKET socket_c,TRAMA ptrTrama,char tipo)
2149	{
2150	int lon;
2151	char modulo[] = "enviaMensajeServidor()";
2152
2153	*socket_c=abreConexion();
2154	if(*socket_c==INVALID_SOCKET){
2155	errorLog(modulo,38,FALSE); // Error de conexión con el servidor
2156	return(FALSE);
2157	}
2158	ptrTrama->arroba='@'; // Cabecera de la trama
2159	strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14); // identificador de la trama
2160	ptrTrama->tipo=tipo; // Tipo de mensaje
2161	lon=strlen(ptrTrama->parametros); // Compone la trama
2162	lon+=sprintf(ptrTrama->parametros+lon,"iph=%s\r",IPlocal); // Ip del ordenador
2163	lon+=sprintf(ptrTrama->parametros+lon,"ido=%s\r",idordenador); // Identificador del ordenador
2164	lon+=sprintf(ptrTrama->parametros+lon,"npc=%s\r",nombreordenador); // Nombre del ordenador
2165	lon+=sprintf(ptrTrama->parametros+lon,"idc=%s\r",idcentro); // Identificador del centro
2166	lon+=sprintf(ptrTrama->parametros+lon,"ida=%s\r",idaula); // Identificador del aula
2167
2168	if (!mandaTrama(socket_c,ptrTrama)) {
2169	errorLog(modulo,26,FALSE);
2170	return (FALSE);
2171	}
2172	return(TRUE);
2173	}
2174	// ********************************************************************************************************
2175	// PROGRAMA PRINCIPAL (CLIENTE)
2176	// ********************************************************************************************************
2177	int main(int argc, char *argv[])
2178	{
2179	TRAMA *ptrTrama;
2180	char modulo[] = "main()";
2181
2182	ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
2183	if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas
2184	errorLog(modulo, 3, FALSE);
2185	exit(EXIT_FAILURE);
2186	}
2187	/*--------------------------------------------------------------------------------------------------------
2188	Validación de parámetros de ejecución y fichero de configuración
2189	---------------------------------------------------------------------------------------------------------*/
2190	if (!validacionParametros(argc, argv,3)) // Valida parámetros de ejecución
2191	exit(EXIT_FAILURE);
2192
2193	if (!tomaConfiguracion(szPathFileCfg)) // Toma parametros de configuración
2194	exit(EXIT_FAILURE);
2195	/*--------------------------------------------------------------------------------------------------------
2196	Carga catálogo de funciones que procesan las tramas
2197	---------------------------------------------------------------------------------------------------------*/
2198	int cf = 0;
2199
2200	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_AutoexecCliente");
2201	tbfuncionesClient[cf++].fptr = &RESPUESTA_AutoexecCliente;
2202
2203	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_InclusionCliente");
2204	tbfuncionesClient[cf++].fptr = &RESPUESTA_InclusionCliente;
2205
2206	strcpy(tbfuncionesClient[cf].nf, "NoComandosPtes");
2207	tbfuncionesClient[cf++].fptr = &NoComandosPtes;
2208
2209	strcpy(tbfuncionesClient[cf].nf, "Actualizar");
2210	tbfuncionesClient[cf++].fptr = &Actualizar;
2211
2212	strcpy(tbfuncionesClient[cf].nf, "Purgar");
2213	tbfuncionesClient[cf++].fptr = &Purgar;
2214
2215	strcpy(tbfuncionesClient[cf].nf, "ConsolaRemota");
2216	tbfuncionesClient[cf++].fptr = &ConsolaRemota;
2217
2218	strcpy(tbfuncionesClient[cf].nf, "Sondeo");
2219	tbfuncionesClient[cf++].fptr = &Sondeo;
2220
2221	strcpy(tbfuncionesClient[cf].nf, "Arrancar");
2222	tbfuncionesClient[cf++].fptr = &Arrancar;
2223
2224	strcpy(tbfuncionesClient[cf].nf, "Apagar");
2225	tbfuncionesClient[cf++].fptr = &Apagar;
2226
2227	strcpy(tbfuncionesClient[cf].nf, "Reiniciar");
2228	tbfuncionesClient[cf++].fptr = &Reiniciar;
2229
2230	strcpy(tbfuncionesClient[cf].nf, "IniciarSesion");
2231	tbfuncionesClient[cf++].fptr = &IniciarSesion;
2232
2233	strcpy(tbfuncionesClient[cf].nf, "CrearImagen");
2234	tbfuncionesClient[cf++].fptr = &CrearImagen;
2235
2236	strcpy(tbfuncionesClient[cf].nf, "CrearImagenBasica");
2237	tbfuncionesClient[cf++].fptr = &CrearImagenBasica;
2238
2239	strcpy(tbfuncionesClient[cf].nf, "CrearSoftIncremental");
2240	tbfuncionesClient[cf++].fptr = &CrearSoftIncremental;
2241
2242	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagen");
2243	tbfuncionesClient[cf++].fptr = &RestaurarImagen;
2244
2245	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagenBasica");
2246	tbfuncionesClient[cf++].fptr = &RestaurarImagenBasica;
2247
2248	strcpy(tbfuncionesClient[cf].nf, "RestaurarSoftIncremental");
2249	tbfuncionesClient[cf++].fptr = &RestaurarSoftIncremental;
2250
2251
2252	strcpy(tbfuncionesClient[cf].nf, "Configurar");
2253	tbfuncionesClient[cf++].fptr = &Configurar;
2254
2255	strcpy(tbfuncionesClient[cf].nf, "EjecutarScript");
2256	tbfuncionesClient[cf++].fptr = &EjecutarScript;
2257
2258	strcpy(tbfuncionesClient[cf].nf, "InventarioHardware");
2259	tbfuncionesClient[cf++].fptr = &InventarioHardware;
2260
2261	strcpy(tbfuncionesClient[cf].nf, "InventarioSoftware");
2262	tbfuncionesClient[cf++].fptr = &InventarioSoftware;
2263
2264	/*--------------------------------------------------------------------------------------------------------
2265	Toma dirección IP del cliente
2266	---------------------------------------------------------------------------------------------------------*/
2267	if(!tomaIPlocal()){ // Error al recuperar la IP local
2268	errorLog(modulo,0,FALSE);
2269	exit(EXIT_FAILURE);
2270	}
2271	/*--------------------------------------------------------------------------------------------------------
2272	Inicio de sesión
2273	---------------------------------------------------------------------------------------------------------*/
2274	infoLog(1); // Inicio de sesión
2275	infoLog(3); // Abriendo sesión en el servidor de Administración;
2276	/*--------------------------------------------------------------------------------------------------------
2277	Inclusión del cliente en el sistema
2278	---------------------------------------------------------------------------------------------------------*/
2279	if(!inclusionCliente(ptrTrama)){ // Ha habido algún problema al abrir sesión
2280	errorLog(modulo,0,FALSE);
2281	exit(EXIT_FAILURE);
2282	}
2283	infoLog(4); // Cliente iniciado
2284
2285	/*--------------------------------------------------------------------------------------------------------
2286	Procesamiento de la cache
2287	---------------------------------------------------------------------------------------------------------*/
2288	infoLog(23); // Abriendo sesión en el servidor de Administración;
2289	if(!cuestionCache(cache)){
2290	errorLog(modulo,0,FALSE);
2291	exit(EXIT_FAILURE);
2292	}
2293	/*--------------------------------------------------------------------------------------------------------
2294	Ejecución del autoexec
2295	---------------------------------------------------------------------------------------------------------*/
2296	if(atoi(idproautoexec)>0){ // Ejecución de procedimiento Autoexec
2297	infoLog(5);
2298	if(!autoexecCliente(ptrTrama)){ // Ejecución fichero autoexec
2299	errorLog(modulo,0,FALSE);
2300	exit(EXIT_FAILURE);
2301	}
2302	}
2303	/*--------------------------------------------------------------------------------------------------------
2304	Comandos pendientes
2305	---------------------------------------------------------------------------------------------------------*/
2306	infoLog(6); // Procesa comandos pendientes
2307	if(!comandosPendientes(ptrTrama)){ // Ejecución de acciones pendientes
2308	errorLog(modulo,0,FALSE);
2309	exit(EXIT_FAILURE);
2310	}
2311	infoLog(7); // Acciones pendientes procesadas
2312	/*--------------------------------------------------------------------------------------------------------
2313	Bucle de recepción de comandos
2314	---------------------------------------------------------------------------------------------------------*/
2315	muestraMenu();
2316	procesaComandos(ptrTrama); // Bucle para procesar comandos interactivos
2317	/*--------------------------------------------------------------------------------------------------------
2318	Fin de la sesión
2319	---------------------------------------------------------------------------------------------------------*/
2320	exit(EXIT_SUCCESS);
2321	}

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

Context Navigation

source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 426ca26

Download in other formats: