Context Navigation

ogAdmClient.c @ 03e3f88

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-instalacion

Last change on this file since 03e3f88 was 32abc01, checked in by OpenGnSys Support Team <soporte-og@…>, 6 years ago

#915 Add EjecutaComandosPendientes? for ogAdmClient

This new command kicks in pending commands execution. This simplies
the update of the web console significantly.

Property mode set to 100644

File size: 77.7 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	int herrorcfg;
638
639	// Reservar memoria para los datos de cofiguración.
640	parametroscfg=(char*)reservaMemoria(LONGITUD_SCRIPTSALIDA);
641	if(!parametroscfg){
642	errorLog(modulo,3,FALSE);
643	return(NULL);
644	}
645	// Ejecutar script y obtener datos.
646	sprintf(interface,"%s/%s",pathinterface,"getConfiguration");
647	herrorcfg=interfaceAdmin(interface,NULL,parametroscfg);
648
649	if(herrorcfg){ // No se puede recuperar la configuración del cliente
650	liberaMemoria(parametroscfg);
651	errorLog(modulo,36,FALSE);
652	return(NULL);
653	}
654	return(parametroscfg);
655	}
656	//________________________________________________________________________________________________________
657	// Función: autoexecCliente
658	//
659	// Descripción:
660	// Solicita procedimiento de autoexec para el cliebnte
661	// Parámetros:
662	// Ninguno
663	// Devuelve:
664	// TRUE: Si el proceso es correcto
665	// FALSE: En caso de ocurrir algún error
666	//________________________________________________________________________________________________________
667	BOOLEAN autoexecCliente(TRAMA* ptrTrama)
668	{
669	SOCKET socket_c;
670	char modulo[] = "autoexecCliente()";
671
672	initParametros(ptrTrama,0);
673	sprintf(ptrTrama->parametros,"nfn=AutoexecCliente\rexe=%s\r",idproautoexec);
674
675	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
676	errorLog(modulo,42,FALSE);
677	return(FALSE);
678	}
679	ptrTrama=recibeMensaje(&socket_c);
680	if(!ptrTrama){
681	errorLog(modulo,45,FALSE);
682	return(FALSE);
683	}
684
685	close(socket_c);
686
687	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
688	errorLog(modulo,39,FALSE);
689	return(FALSE);
690	}
691
692	return(TRUE);
693	}
694	//________________________________________________________________________________________________________
695	// Función: autoexecCliente
696	//
697	// Descripción:
698	// Ejecuta un script de autoexec personalizado en todos los inicios para el cliente
699	// Parámetros:
700	// Ninguno
701	// Devuelve:
702	// TRUE: Si el proceso es correcto
703	// FALSE: En caso de ocurrir algún error
704	//________________________________________________________________________________________________________
705	BOOLEAN RESPUESTA_AutoexecCliente(TRAMA* ptrTrama)
706	{
707	SOCKET socket_c;
708	char res,nfl;
709	char modulo[] = "RESPUESTA_AutoexecCliente()";
710
711	res=copiaParametro("res",ptrTrama);
712	if(atoi(res)==0){ // Error en el proceso de autoexec
713	liberaMemoria(res);
714	return (FALSE);
715	}
716	liberaMemoria(res);
717
718	nfl=copiaParametro("nfl",ptrTrama);
719	initParametros(ptrTrama,0);
720	sprintf(ptrTrama->parametros,"nfn=enviaArchivo\rnfl=%s\r",nfl);
721	liberaMemoria(nfl);
722
723	/* Envía petición */
724	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
725	errorLog(modulo,42,FALSE);
726	return(FALSE);
727	}
728	/* Nombre del archivo destino (local)*/
729	char fileautoexec[LONPRM];
730	sprintf(fileautoexec,"/tmp/_autoexec_%s",IPlocal);
731
732	/* Recibe archivo */
733	if(!recArchivo(&socket_c,fileautoexec)){
734	errorLog(modulo,58, FALSE);
735	close(socket_c);
736	return(FALSE);
737	}
738
739	close(socket_c);
740
741	/* Ejecuta archivo */
742	ejecutaArchivo(fileautoexec,ptrTrama);
743	return(TRUE);
744	}
745	//______________________________________________________________________________________________________
746	// Función: comandosPendientes
747	//
748	// Descripción:
749	// Búsqueda de acciones pendientes en el servidor de administración
750	// Parámetros:
751	// Ninguno
752	// Devuelve:
753	// TRUE: Si el proceso es correcto
754	// FALSE: En caso de ocurrir algún error
755	//______________________________________________________________________________________________________
756	BOOLEAN comandosPendientes(TRAMA* ptrTrama)
757	{
758	SOCKET socket_c;
759	char modulo[] = "comandosPendientes()";
760
761	CMDPTES=TRUE;
762	initParametros(ptrTrama,0);
763
764	while(CMDPTES){
765	sprintf(ptrTrama->parametros,"nfn=ComandosPendientes\r");
766	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
767	errorLog(modulo,42,FALSE);
768	return(FALSE);
769	}
770	ptrTrama=recibeMensaje(&socket_c);
771	if(!ptrTrama){
772	errorLog(modulo,45,FALSE);
773	return(FALSE);
774	}
775
776	close(socket_c);
777
778	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
779	errorLog(modulo,39,FALSE);
780	return(FALSE);
781	}
782	}
783	return(TRUE);
784	}
785	//______________________________________________________________________________________________________
786	// Función: NoComandosPtes
787	//
788	// Descripción:
789	// Conmuta el switch de los comandos pendientes y lo pone a false
790	// Parámetros:
791	// - ptrTrama: contenido del mensaje
792	// Devuelve:
793	// TRUE siempre
794	// Especificaciones:
795	// Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el
796	// servidor y el cliente pasa a a estar disponible para recibir comandos desde el éste.
797	//______________________________________________________________________________________________________
798	BOOLEAN NoComandosPtes(TRAMA* ptrTrama)
799	{
800	CMDPTES=FALSE; // Corta el bucle de comandos pendientes
801	return(TRUE);
802	}
803	//______________________________________________________________________________________________________
804	// Función: ProcesaComandos
805	//
806	// Descripción:
807	// Espera comando desde el Servidor de Administración para ejecutarlos
808	// Parámetros:
809	// Ninguno
810	// Devuelve:
811	// TRUE: Si el proceso es correcto
812	// FALSE: En caso de ocurrir algún error
813	// ________________________________________________________________________________________________________
814	void procesaComandos(TRAMA* ptrTrama)
815	{
816	int lon;
817	SOCKET socket_c;
818	char modulo[] = "procesaComandos()";
819
820	initParametros(ptrTrama,0);
821	while(TRUE){
822	lon=sprintf(ptrTrama->parametros,"nfn=DisponibilidadComandos\r");
823	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS); // Activar disponibilidad
824	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_INFORMACION)){
825	errorLog(modulo,43,FALSE);
826	return;
827	}
828	infoLog(19); // Disponibilidad de cliente activada
829	ptrTrama=recibeMensaje(&socket_c);
830	if(!ptrTrama){
831	errorLog(modulo,46,FALSE);
832	return;
833	}
834
835	close(socket_c);
836
837	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
838	errorLog(modulo,39,FALSE);
839	return;
840	}
841	if(!comandosPendientes(ptrTrama)){
842	errorLog(modulo,42,FALSE);
843	}
844	}
845	}
846	//______________________________________________________________________________________________________
847	// Función: Actualizar
848	//
849	// Descripción:
850	// Actualiza los datos de un ordenador como si volviera a solicitar la entrada
851	// en el sistema al servidor de administración
852	// Parámetros:
853	// ptrTrama: contenido del mensajede
854	// Devuelve:
855	// TRUE: Si el proceso es correcto
856	// FALSE: En caso de ocurrir algún error
857	//______________________________________________________________________________________________________
858	BOOLEAN Actualizar(TRAMA* ptrTrama)
859	{
860	char msglog[LONSTD]; // Mensaje de log
861	char *cfg; // Cadena de datos de configuración
862	int lon; // Longitud de cadena
863	char modulo[] = "Actualizar()";
864
865	if (ndebug>=DEBUG_MAXIMO) {
866	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
867	infoDebug(msglog);
868	}
869	muestraMensaje(1,NULL);
870	if(!comandosPendientes(ptrTrama)){
871	errorLog(modulo,84,FALSE);
872	return(FALSE);
873	}
874
875	cfg=LeeConfiguracion();
876	herror=0;
877	if(!cfg){ // No se puede recuperar la configuración del cliente
878	errorLog(modulo,36,FALSE);
879	herror=3;
880	}
881	// Envia Configuracion al servidor
882	initParametros(ptrTrama,0);
883	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
884	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
885	respuestaEjecucionComando(ptrTrama,herror,0);
886
887	muestraMenu();
888
889	return(TRUE);
890	}
891	//______________________________________________________________________________________________________
892	// Función: Purgar
893	//
894	// Descripción:
895	// Detiene la ejecución del browser
896	// Parámetros:
897	// ptrTrama: contenido del mensajede
898	// Devuelve:
899	// TRUE: Si el proceso es correcto
900	// FALSE: En caso de ocurrir algún error
901	//______________________________________________________________________________________________________
902	int Purgar(TRAMA* ptrTrama)
903	{
904
905	exit(EXIT_SUCCESS);
906	}
907	//______________________________________________________________________________________________________
908	// Función: Sondeo
909	//
910	// Descripción:
911	// Envía al servidor una confirmación de que está dentro del sistema
912	// Parámetros:
913	// ptrTrama: contenido del mensajede
914	// Devuelve:
915	// TRUE: Si el proceso es correcto
916	// FALSE: En caso de ocurrir algún error
917	//______________________________________________________________________________________________________
918	BOOLEAN Sondeo(TRAMA* ptrTrama)
919	{
920	return(TRUE);
921	}
922	//______________________________________________________________________________________________________
923	// Función: ConsolaRemota
924	//
925	// Descripción:
926	// Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
927	// Parámetros:
928	// ptrTrama: contenido del mensaje
929	// Devuelve:
930	// TRUE: Si el proceso es correcto
931	// FALSE: En caso de ocurrir algún error
932	//______________________________________________________________________________________________________
933	BOOLEAN ConsolaRemota(TRAMA* ptrTrama)
934	{
935	SOCKET socket_c;
936	char nfn,scp,*aux,ecosrc[LONPRM],ecodst[LONPRM],msglog[LONSTD];;
937	char modulo[] = "ConsolaRemota()";
938
939	/* Nombre del archivo de script */
940	char filescript[LONPRM];
941	sprintf(filescript,"/tmp/_script_%s",IPlocal);
942
943	aux=copiaParametro("scp",ptrTrama);
944	scp=URLDecode(aux);
945	escribeArchivo(filescript,scp);
946	liberaMemoria(aux);
947	liberaMemoria(scp);
948
949	nfn=copiaParametro("nfn",ptrTrama);
950	sprintf(interface,"%s/%s",pathinterface,nfn);
951	sprintf(ecosrc,"/tmp/_econsola_%s",IPlocal);
952	sprintf(parametros,"%s %s %s",nfn,filescript,ecosrc);
953	herror=interfaceAdmin(interface,parametros,NULL);
954	if(herror){
955	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
956	errorInfo(modulo,msglog);
957	}
958	else{
959	/* Envía fichero de inventario al servidor */
960	sprintf(ecodst,"/tmp/_Seconsola_%s",IPlocal); // Nombre que tendra el archivo en el Servidor
961	initParametros(ptrTrama,0);
962	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",ecodst);
963	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
964	errorLog(modulo,42,FALSE);
965	return(FALSE);
966	}
967	/* Espera señal para comenzar el envío */
968	liberaMemoria(ptrTrama);
969	recibeFlag(&socket_c,ptrTrama);
970	/* Envía archivo */
971	if(!sendArchivo(&socket_c,ecosrc)){
972	errorLog(modulo,57, FALSE);
973	herror=12; // Error de envío de fichero por la red
974	}
975	close(socket_c);
976	}
977	liberaMemoria(nfn);
978	return(TRUE);
979	}
980	//_____________________________________________________________________________________________________
981	// Función: Comando
982	//
983	// Descripción:
984	// COmando personalizado enviado desde el servidor
985	// Parámetros:
986	// ptrTrama: contenido del mensaje
987	// Devuelve:
988	// TRUE: Si el proceso es correcto
989	// FALSE: En caso de ocurrir algún error
990	//_____________________________________________________________________________________________________
991	BOOLEAN Comando(TRAMA* ptrTrama)
992	{
993	char ids,nfn,msglog[LONSTD];
994	char modulo[] = "Comando()";
995
996	if (ndebug>=DEBUG_MAXIMO) {
997	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
998	infoDebug(msglog);
999	}
1000	nfn=copiaParametro("nfn",ptrTrama);
1001	ids=copiaParametro("ids",ptrTrama);
1002
1003	sprintf(interface,"%s/%s",pathinterface,nfn);
1004	herror=interfaceAdmin(interface,NULL,NULL);
1005	if(herror){
1006	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1007	errorInfo(modulo,msglog);
1008	}
1009	/* Envia respuesta de ejecucución del comando */
1010	initParametros(ptrTrama,0);
1011	sprintf(ptrTrama->parametros,"nfn=RESPUESTA_%s\r",nfn);
1012	respuestaEjecucionComando(ptrTrama,herror,ids);
1013	liberaMemoria(nfn);
1014	liberaMemoria(ids);
1015	return(TRUE);
1016	}
1017	//_____________________________________________________________________________________________________
1018	// Función: Arrancar
1019	//
1020	// Descripción:
1021	// Responde a un comando de encendido por la red
1022	// Parámetros:
1023	// ptrTrama: contenido del mensaje
1024	// Devuelve:
1025	// TRUE: Si el proceso es correcto
1026	// FALSE: En caso de ocurrir algún error
1027	//_____________________________________________________________________________________________________
1028	BOOLEAN Arrancar(TRAMA* ptrTrama)
1029	{
1030	int lon;
1031	char *ids,msglog[LONSTD];
1032	char modulo[] = "Arrancar()";
1033
1034	if (ndebug>=DEBUG_MAXIMO) {
1035	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1036	infoDebug(msglog);
1037	}
1038
1039	ids=copiaParametro("ids",ptrTrama);
1040
1041	/* Envia respuesta de ejecucución del script */
1042	initParametros(ptrTrama,0);
1043	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Arrancar");
1044	lon+=sprintf(ptrTrama->parametros+lon,"tpc=%s\r",CLIENTE_OPENGNSYS);
1045	respuestaEjecucionComando(ptrTrama,0,ids);
1046	liberaMemoria(ids);
1047	return(TRUE);
1048	}
1049	//_____________________________________________________________________________________________________
1050	// Función: Apagar
1051	//
1052	// Descripción:
1053	// Apaga el cliente
1054	// Parámetros:
1055	// ptrTrama: contenido del mensaje
1056	// Devuelve:
1057	// TRUE: Si el proceso es correcto
1058	// FALSE: En caso de ocurrir algún error
1059	//_____________________________________________________________________________________________________
1060	BOOLEAN Apagar(TRAMA* ptrTrama)
1061	{
1062	char ids,nfn,msglog[LONSTD];
1063	char modulo[] = "Apagar()";
1064
1065	if (ndebug>=DEBUG_MAXIMO) {
1066	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1067	infoDebug(msglog);
1068	}
1069	nfn=copiaParametro("nfn",ptrTrama);
1070	ids=copiaParametro("ids",ptrTrama);
1071
1072	initParametros(ptrTrama,0);
1073	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Apagar");
1074	respuestaEjecucionComando(ptrTrama,0,ids);
1075
1076	sprintf(interface,"%s/%s",pathinterface,nfn);
1077	herror=interfaceAdmin(interface,NULL,NULL);
1078	if(herror){
1079	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1080	liberaMemoria(nfn);
1081	liberaMemoria(ids);
1082	errorInfo(modulo,msglog);
1083	return(FALSE);
1084	}
1085	liberaMemoria(nfn);
1086	liberaMemoria(ids);
1087	return(TRUE);
1088	}
1089	//_____________________________________________________________________________________________________
1090	// Función: Reiniciar
1091	//
1092	// Descripción:
1093	// Apaga el cliente
1094	// Parámetros:
1095	// ptrTrama: contenido del mensaje
1096	// Devuelve:
1097	// TRUE: Si el proceso es correcto
1098	// FALSE: En caso de ocurrir algún error
1099	//_____________________________________________________________________________________________________
1100	BOOLEAN Reiniciar(TRAMA* ptrTrama)
1101	{
1102	char nfn,ids,msglog[LONSTD];
1103	char modulo[] = "Reiniciar()";
1104
1105	if (ndebug>=DEBUG_MAXIMO) {
1106	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1107	infoDebug(msglog);
1108	}
1109	nfn=copiaParametro("nfn",ptrTrama);
1110	ids=copiaParametro("ids",ptrTrama);
1111
1112	initParametros(ptrTrama,0);
1113	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Reiniciar");
1114	respuestaEjecucionComando(ptrTrama,0,ids);
1115
1116	sprintf(interface,"%s/%s",pathinterface,nfn);
1117	herror=interfaceAdmin(interface,NULL,NULL);
1118	if(herror){
1119	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1120	liberaMemoria(nfn);
1121	liberaMemoria(ids);
1122	errorInfo(modulo,msglog);
1123	return(FALSE);
1124	}
1125	liberaMemoria(nfn);
1126	liberaMemoria(ids);
1127	return(TRUE);
1128	}
1129	//_____________________________________________________________________________________________________
1130	// Función: IniciarSesion
1131	//
1132	// Descripción:
1133	// Inicia sesión en el Sistema Operativo de una de las particiones
1134	// Parámetros:
1135	// ptrTrama: contenido del mensaje
1136	// Devuelve:
1137	// TRUE: Si el proceso es correcto
1138	// FALSE: En caso de ocurrir algún error
1139	//_____________________________________________________________________________________________________
1140	BOOLEAN IniciarSesion(TRAMA* ptrTrama)
1141	{
1142	char nfn,ids,disk,par,msglog[LONSTD];
1143	char modulo[] = "IniciarSesion()";
1144
1145	if (ndebug>=DEBUG_MAXIMO) {
1146	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1147	infoDebug(msglog);
1148	}
1149	nfn=copiaParametro("nfn",ptrTrama);
1150	ids=copiaParametro("ids",ptrTrama);
1151	disk=copiaParametro("dsk",ptrTrama);
1152	par=copiaParametro("par",ptrTrama);
1153
1154	initParametros(ptrTrama,0);
1155	sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_IniciarSesion");
1156	respuestaEjecucionComando(ptrTrama,0,ids);
1157	liberaMemoria(ids);
1158
1159	sprintf(interface,"%s/%s",pathinterface,nfn);
1160	sprintf(parametros,"%s %s %s",nfn,disk,par);
1161	liberaMemoria(par);
1162
1163	herror=interfaceAdmin(interface,parametros,NULL);
1164
1165	if(herror){
1166	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1167	liberaMemoria(nfn);
1168	errorInfo(modulo,msglog);
1169	return(FALSE);
1170	}
1171	liberaMemoria(nfn);
1172	return(TRUE);
1173	}
1174	//______________________________________________________________________________________________________
1175	// Función: CrearImagen
1176	//
1177	// Descripción:
1178	// Crea una imagen de una partición
1179	// Parámetros:
1180	// ptrTrama: contenido del mensaje
1181	// Devuelve:
1182	// TRUE: Si el proceso es correcto
1183	// FALSE: En caso de ocurrir algún error
1184	//______________________________________________________________________________________________________
1185	BOOLEAN CrearImagen(TRAMA* ptrTrama)
1186	{
1187	int lon;
1188	char nfn,dsk,par,cpt,idi,ipr,nci,ids,msglog[LONSTD];
1189	char modulo[] = "CrearImagen()";
1190
1191	if (ndebug>=DEBUG_MAXIMO) {
1192	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1193	infoDebug(msglog);
1194	}
1195
1196	dsk=copiaParametro("dsk",ptrTrama); // Disco
1197	par=copiaParametro("par",ptrTrama); // Número de partición
1198	cpt=copiaParametro("cpt",ptrTrama); // Código de la partición
1199	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1200	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1201	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1202
1203	nfn=copiaParametro("nfn",ptrTrama);
1204	ids=copiaParametro("ids",ptrTrama);
1205	muestraMensaje(7,NULL);
1206
1207	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1208	muestraMensaje(2,NULL);
1209	sprintf(interface,"%s/%s",pathinterface,nfn);
1210	sprintf(parametros,"%s %s %s %s %s",nfn,dsk,par,nci,ipr);
1211	herror=interfaceAdmin(interface,parametros,NULL);
1212	if(herror){
1213	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1214	errorInfo(modulo,msglog);
1215	muestraMensaje(10,NULL);
1216	}
1217	else
1218	muestraMensaje(9,NULL);
1219	}
1220	else{
1221	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1222	errorInfo(modulo,msglog);
1223	}
1224
1225	/* Envia respuesta de ejecución de la función de interface */
1226	initParametros(ptrTrama,0);
1227	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagen");
1228	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1229	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1230	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
1231	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
1232	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
1233	respuestaEjecucionComando(ptrTrama,herror,ids);
1234
1235	liberaMemoria(dsk);
1236	liberaMemoria(par);
1237	liberaMemoria(cpt);
1238	liberaMemoria(idi);
1239	liberaMemoria(nci);
1240	liberaMemoria(ipr);
1241	liberaMemoria(nfn);
1242	liberaMemoria(ids);
1243
1244	muestraMenu();
1245
1246	return(TRUE);
1247	}
1248	//______________________________________________________________________________________________________
1249	// Función: CrearImagenBasica
1250	//
1251	// Descripción:
1252	// Crea una imagen básica a travers dela sincronización
1253	// Parámetros:
1254	// ptrTrama: contenido del mensaje
1255	//
1256	// FDevuelve:
1257	// TRUE: Si el proceso es correcto
1258	// FALSE: En caso de ocurrir algún error
1259	//______________________________________________________________________________________________________
1260	BOOLEAN CrearImagenBasica(TRAMA* ptrTrama)
1261	{
1262	int lon;
1263	char nfn,dsk,par,cpt,idi,nci,rti,ipr,msy,whl,eli,cmp,bpi,cpc,bpc,nba,*ids,msglog[LONSTD];
1264	char modulo[] = "CrearImagenBasica()";
1265
1266	if (ndebug>=DEBUG_MAXIMO) {
1267	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1268	infoDebug(msglog);
1269	}
1270	nfn=copiaParametro("nfn",ptrTrama);
1271	dsk=copiaParametro("dsk",ptrTrama); // Disco
1272	par=copiaParametro("par",ptrTrama); // Número de partición
1273	cpt=copiaParametro("cpt",ptrTrama); // Tipo de partición
1274	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1275	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1276	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1277	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1278
1279	msy=copiaParametro("msy",ptrTrama); // Método de sincronización
1280
1281	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1282	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1283	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1284
1285	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1286	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1287	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1288	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1289
1290	muestraMensaje(7,NULL); // Creando Inventario Software
1291	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1292	muestraMensaje(30,NULL);// Creando Imagen Básica, por favor espere...
1293	sprintf(interface,"%s/%s",pathinterface,nfn);
1294	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);
1295	herror=interfaceAdmin(interface,parametros,NULL);
1296	if(herror){
1297	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1298	errorInfo(modulo,msglog);
1299	muestraMensaje(29,NULL);// Ha habido algún error en el proceso de creación de imagen básica
1300	}
1301	else
1302	muestraMensaje(28,NULL);// El proceso de creación de imagen básica ha terminado correctamente
1303	}
1304	else{
1305	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1306	errorInfo(modulo,msglog);
1307	}
1308
1309	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
1310
1311	/* Envia respuesta de ejecución de la función de interface */
1312	initParametros(ptrTrama,0);
1313	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagenBasica");
1314	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1315	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1316	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
1317	lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
1318	lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
1319	respuestaEjecucionComando(ptrTrama,herror,ids);
1320
1321	liberaMemoria(nfn);
1322	liberaMemoria(dsk);
1323	liberaMemoria(par);
1324	liberaMemoria(cpt);
1325	liberaMemoria(idi);
1326	liberaMemoria(nci);
1327	liberaMemoria(rti);
1328	liberaMemoria(ipr);
1329
1330	liberaMemoria(msy);
1331
1332	liberaMemoria(whl);
1333	liberaMemoria(eli);
1334	liberaMemoria(cmp);
1335
1336	liberaMemoria(bpi);
1337	liberaMemoria(cpc);
1338	liberaMemoria(bpc);
1339	liberaMemoria(nba);
1340	liberaMemoria(ids);
1341
1342	muestraMenu();
1343
1344	return(TRUE);
1345	}
1346	//______________________________________________________________________________________________________
1347	// Función: CrearSoftIncremental
1348	//
1349	// Descripción:
1350	// Crea una software incremental comparando una partición con una imagen básica
1351	// Parámetros:
1352	// ptrTrama: contenido del mensaje
1353	//
1354	// Devuelve:
1355	// TRUE: Si el proceso es correcto
1356	// FALSE: En caso de ocurrir algún error
1357	//______________________________________________________________________________________________________
1358	BOOLEAN CrearSoftIncremental(TRAMA* ptrTrama)
1359	{
1360	int lon;
1361	char nfn,dsk,par,idi,idf,ipr,nci,rti,ncf,msy,whl,eli,cmp,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
1362	char modulo[] = "CrearSoftIncremental()";
1363
1364	if (ndebug>=DEBUG_MAXIMO) {
1365	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1366	infoDebug(msglog);
1367	}
1368	nfn=copiaParametro("nfn",ptrTrama);
1369
1370	dsk=copiaParametro("dsk",ptrTrama); // Disco
1371	par=copiaParametro("par",ptrTrama); // Número de partición
1372	idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1373	nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1374	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1375	ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1376	idf=copiaParametro("idf",ptrTrama); // Identificador de la imagen diferencial
1377	ncf=copiaParametro("ncf",ptrTrama); // Nombre canónico de la imagen diferencial
1378
1379	msy=copiaParametro("msy",ptrTrama); // Método de sincronización
1380
1381	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1382	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1383	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1384
1385	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1386	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1387	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1388	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1389
1390	muestraMensaje(7,NULL); // Creando Inventario Software
1391	if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1392	muestraMensaje(25,NULL);// Creando Imagen Incremental, por favor espere...
1393	sprintf(interface,"%s/%s",pathinterface,nfn);
1394	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);
1395
1396	herror=interfaceAdmin(interface,parametros,NULL);
1397	if(herror){
1398	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1399	errorInfo(modulo,msglog);
1400	muestraMensaje(27,NULL);// Ha habido algún error en el proceso de creación de imagen básica
1401	}
1402	else
1403	muestraMensaje(26,NULL);// El proceso de creación de imagen incremental ha terminado correctamente
1404	}
1405	else{
1406	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1407	errorInfo(modulo,msglog);
1408	}
1409
1410	ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
1411
1412	/* Envia respuesta de ejecución de la función de interface */
1413	initParametros(ptrTrama,0);
1414	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearSoftIncremental");
1415	lon+=sprintf(ptrTrama->parametros+lon,"idf=%s\r",idf); // Identificador de la imagen incremental
1416	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1417	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1418	respuestaEjecucionComando(ptrTrama,herror,ids);
1419
1420	liberaMemoria(nfn);
1421	liberaMemoria(dsk);
1422	liberaMemoria(par);
1423	liberaMemoria(idi);
1424	liberaMemoria(nci);
1425	liberaMemoria(rti);
1426	liberaMemoria(ipr);
1427	liberaMemoria(idf);
1428	liberaMemoria(ncf);
1429	liberaMemoria(msy);
1430	liberaMemoria(whl);
1431	liberaMemoria(eli);
1432	liberaMemoria(cmp);
1433	liberaMemoria(bpi);
1434	liberaMemoria(cpc);
1435	liberaMemoria(bpc);
1436	liberaMemoria(nba);
1437	liberaMemoria(ids);
1438
1439	muestraMenu();
1440
1441	return(TRUE);
1442	}
1443	//______________________________________________________________________________________________________
1444	// Función: RestaurarImagen
1445	//
1446	// Descripción:
1447	// Restaura una imagen en una partición
1448	// Parámetros:
1449	// ptrTrama: contenido del mensaje
1450	// Devuelve:
1451	// TRUE: Si el proceso es correcto
1452	// FALSE: En bpccaso de ocurrir algún error
1453	//______________________________________________________________________________________________________
1454	BOOLEAN RestaurarImagen(TRAMA* ptrTrama)
1455	{
1456	int lon;
1457	char nfn,dsk,par,idi,ipr,ifs,cfg,nci,ids,ptc,msglog[LONSTD];
1458	char modulo[] = "RestaurarImagen()";
1459
1460	if (ndebug>=DEBUG_MAXIMO) {
1461	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1462	infoDebug(msglog);
1463	}
1464
1465	dsk=copiaParametro("dsk",ptrTrama);
1466	par=copiaParametro("par",ptrTrama);
1467	idi=copiaParametro("idi",ptrTrama);
1468	ipr=copiaParametro("ipr",ptrTrama);
1469	nci=copiaParametro("nci",ptrTrama);
1470	ifs=copiaParametro("ifs",ptrTrama);
1471	ptc=copiaParametro("ptc",ptrTrama);
1472
1473	nfn=copiaParametro("nfn",ptrTrama);
1474	ids=copiaParametro("ids",ptrTrama);
1475	muestraMensaje(3,NULL);
1476	sprintf(interface,"%s/%s",pathinterface,nfn);
1477	sprintf(parametros,"%s %s %s %s %s %s",nfn,dsk,par,nci,ipr,ptc);
1478	herror=interfaceAdmin(interface,parametros,NULL);
1479	if(herror){
1480	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1481	errorInfo(modulo,msglog);
1482	muestraMensaje(12,NULL);
1483	}
1484	else
1485	muestraMensaje(11,NULL);
1486
1487	/* Obtener nueva configuración */
1488	cfg=LeeConfiguracion();
1489	if(!cfg){ // No se puede recuperar la configuración del cliente
1490	errorLog(modulo,36,FALSE);
1491	}
1492
1493	/* Envia respuesta de ejecución de la función de interface */
1494	initParametros(ptrTrama,0);
1495	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagen");
1496	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1497	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1498	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1499	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1500	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de discos
1501	respuestaEjecucionComando(ptrTrama,herror,ids);
1502
1503	liberaMemoria(nfn);
1504	liberaMemoria(dsk);
1505	liberaMemoria(par);
1506	liberaMemoria(idi);
1507	liberaMemoria(nci);
1508	liberaMemoria(ipr);
1509	liberaMemoria(ifs);
1510	liberaMemoria(cfg);
1511	liberaMemoria(ptc);
1512	liberaMemoria(ids);
1513
1514	muestraMenu();
1515
1516	return(TRUE);
1517	}
1518	//______________________________________________________________________________________________________
1519	// Función: RestaurarImagenBasica
1520	//
1521	// Descripción:
1522	// Restaura una imagen básica en una partición
1523	// Parámetros:
1524	// ptrTrama: contenido del mensaje
1525	// Devuelve:
1526	// TRUE: Si el proceso es correcto
1527	// FALSE: En caso de ocurrir algún error
1528	//______________________________________________________________________________________________________
1529	BOOLEAN RestaurarImagenBasica(TRAMA* ptrTrama)
1530	{
1531	int lon;
1532	char nfn,dsk,par,idi,ipr,met,nci,rti,ifs,cfg,msy,whl,eli,cmp,tpt,bpi,cpc,bpc,nba,ids,msglog[LONSTD];
1533	char modulo[] = "RestaurarImagenBasica()";
1534
1535	if (ndebug>=DEBUG_MAXIMO) {
1536	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1537	infoDebug(msglog);
1538	}
1539	dsk=copiaParametro("dsk",ptrTrama);
1540	par=copiaParametro("par",ptrTrama);
1541	idi=copiaParametro("idi",ptrTrama);
1542	ipr=copiaParametro("ipr",ptrTrama);
1543	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
1544	nci=copiaParametro("nci",ptrTrama);
1545	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1546	ifs=copiaParametro("ifs",ptrTrama);
1547
1548	tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast
1549	msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion
1550
1551	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1552	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1553	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1554
1555	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1556	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1557	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1558	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1559
1560	nfn=copiaParametro("nfn",ptrTrama);
1561	ids=copiaParametro("ids",ptrTrama);
1562	muestraMensaje(31,NULL);
1563	sprintf(interface,"%s/%s",pathinterface,nfn);
1564	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);
1565	herror=interfaceAdmin(interface,parametros,NULL);
1566	if(herror){
1567	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1568	errorInfo(modulo,msglog);
1569	muestraMensaje(33,NULL);
1570	}
1571	else
1572	muestraMensaje(32,NULL);
1573
1574	/* Obtener nueva configuración */
1575	cfg=LeeConfiguracion();
1576	if(!cfg){ // No se puede recuperar la configuración del cliente
1577	errorLog(modulo,36,FALSE);
1578	}
1579
1580	/* Envia respuesta de ejecución de la función de interface */
1581	initParametros(ptrTrama,0);
1582	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagenBasica");
1583	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1584	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1585	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1586	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1587	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de discos
1588	respuestaEjecucionComando(ptrTrama,herror,ids);
1589
1590	liberaMemoria(nfn);
1591	liberaMemoria(dsk);
1592	liberaMemoria(par);
1593	liberaMemoria(idi);
1594	liberaMemoria(nci);
1595	liberaMemoria(rti);
1596	liberaMemoria(ifs);
1597	liberaMemoria(cfg);
1598	liberaMemoria(ipr);
1599	liberaMemoria(met);
1600
1601	liberaMemoria(tpt);
1602	liberaMemoria(msy);
1603
1604	liberaMemoria(whl);
1605	liberaMemoria(eli);
1606	liberaMemoria(cmp);
1607
1608	liberaMemoria(bpi);
1609	liberaMemoria(cpc);
1610	liberaMemoria(bpc);
1611	liberaMemoria(nba);
1612	liberaMemoria(ids);
1613
1614	muestraMenu();
1615
1616	return(TRUE);
1617	}
1618	//______________________________________________________________________________________________________
1619	// Función: RestaurarSoftIncremental
1620	//
1621	// Descripción:
1622	// Restaura software incremental en una partición
1623	// Parámetros:
1624	// ptrTrama: contenido del mensaje
1625	// Devuelve:
1626	// TRUE: Si el proceso es correcto
1627	// FALSE: En caso de ocurrir algún error
1628	//______________________________________________________________________________________________________
1629	BOOLEAN RestaurarSoftIncremental(TRAMA* ptrTrama)
1630	{
1631	int lon;
1632	char nfn,dsk,par,idi,ipr,met,ifs,nci,rti,idf,ncf,msy,whl,eli,cmp,tpt,bpi,cpc,bpc,nba,*ids,msglog[LONSTD];
1633	char modulo[] = "RestaurarSoftIncremental()";
1634
1635	if (ndebug>=DEBUG_MAXIMO) {
1636	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1637	infoDebug(msglog);
1638	}
1639	dsk=copiaParametro("dsk",ptrTrama);
1640	par=copiaParametro("par",ptrTrama);
1641	idi=copiaParametro("idi",ptrTrama);
1642	idf=copiaParametro("idf",ptrTrama);
1643	ipr=copiaParametro("ipr",ptrTrama);
1644	met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
1645	ifs=copiaParametro("ifs",ptrTrama);
1646	nci=copiaParametro("nci",ptrTrama);
1647	rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1648	ncf=copiaParametro("ncf",ptrTrama);
1649
1650	tpt=copiaParametro("tpt",ptrTrama); // Tipo de trasnmisión unicast o multicast
1651	msy=copiaParametro("msy",ptrTrama); // Metodo de sincronizacion
1652
1653	whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias
1654	eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen
1655	cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1656
1657	bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1658	cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1659	bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1660	nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1661
1662	nfn=copiaParametro("nfn",ptrTrama);
1663	ids=copiaParametro("ids",ptrTrama);
1664	muestraMensaje(31,NULL);
1665	sprintf(interface,"%s/%s",pathinterface,nfn);
1666	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);
1667	herror=interfaceAdmin(interface,parametros,NULL);
1668	if(herror){
1669	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1670	errorInfo(modulo,msglog);
1671	muestraMensaje(35,NULL);
1672	}
1673	else
1674	muestraMensaje(34,NULL);
1675
1676	/* Envia respuesta de ejecución de la función de interface */
1677	initParametros(ptrTrama,0);
1678	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarSoftIncremental");
1679	lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idf); // Identificador de la imagen incremental (Forzada a idi)
1680	lon+=sprintf(ptrTrama->parametros+lon,"dsk=%s\r",dsk); // Número de disco
1681	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1682	lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1683
1684	respuestaEjecucionComando(ptrTrama,herror,ids);
1685
1686	liberaMemoria(nfn);
1687	liberaMemoria(dsk);
1688	liberaMemoria(par);
1689	liberaMemoria(idi);
1690	liberaMemoria(idf);
1691	liberaMemoria(nci);
1692	liberaMemoria(rti);
1693	liberaMemoria(ncf);
1694	liberaMemoria(ifs);
1695	liberaMemoria(ipr);
1696	liberaMemoria(met);
1697
1698	liberaMemoria(tpt);
1699	liberaMemoria(msy);
1700
1701	liberaMemoria(whl);
1702	liberaMemoria(eli);
1703	liberaMemoria(cmp);
1704
1705	liberaMemoria(bpi);
1706	liberaMemoria(cpc);
1707	liberaMemoria(bpc);
1708	liberaMemoria(nba);
1709	liberaMemoria(ids);
1710
1711	muestraMenu();
1712
1713	return(TRUE);
1714	}
1715	//______________________________________________________________________________________________________
1716	// Función: Configurar
1717	//
1718	// Descripción:
1719	// Configura la tabla de particiones y formatea
1720	// Parámetros:
1721	// ptrTrama: contenido del mensaje
1722	// Devuelve:
1723	// TRUE: Si el proceso es correcto
1724	// FALSE: En caso de ocurrir algún error
1725	//______________________________________________________________________________________________________
1726	BOOLEAN Configurar(TRAMA* ptrTrama)
1727	{
1728	int lon;
1729	char nfn,dsk,cfg,ids,msglog[LONSTD];
1730	char modulo[] = "Configurar()";
1731
1732	if (ndebug>=DEBUG_MAXIMO) {
1733	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1734	infoDebug(msglog);
1735	}
1736
1737	dsk=copiaParametro("dsk",ptrTrama);
1738	cfg=copiaParametro("cfg",ptrTrama);
1739	/* Sustituir caracteres */
1740	sustituir(cfg,'\n','$');
1741	sustituir(cfg,'\t','#');
1742
1743	nfn=copiaParametro("nfn",ptrTrama);
1744	ids=copiaParametro("ids",ptrTrama);
1745	muestraMensaje(4,NULL);
1746	sprintf(interface,"%s/%s",pathinterface,nfn);
1747	sprintf(parametros,"%s %s %s",nfn,dsk,cfg);
1748
1749	herror=interfaceAdmin(interface,parametros,NULL);
1750	if(herror){
1751	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1752	errorInfo(modulo,msglog);
1753	muestraMensaje(13,NULL);
1754	}
1755	else
1756	muestraMensaje(14,NULL);
1757
1758	cfg=LeeConfiguracion();
1759	if(!cfg){ // No se puede recuperar la configuración del cliente
1760	errorLog(modulo,36,FALSE);
1761	return(FALSE);
1762	}
1763
1764	/* Envia respuesta de ejecución del comando*/
1765	initParametros(ptrTrama,0);
1766	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
1767	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
1768	respuestaEjecucionComando(ptrTrama,herror,ids);
1769
1770	liberaMemoria(dsk);
1771	liberaMemoria(cfg);
1772	liberaMemoria(nfn);
1773	liberaMemoria(ids);
1774
1775	muestraMenu();
1776
1777	return(TRUE);
1778	}
1779	// ________________________________________________________________________________________________________
1780	// Función: InventarioHardware
1781	//
1782	// Descripción:
1783	// Envia al servidor el nombre del archivo de inventario de su hardware para posteriormente
1784	// esperar que éste lo solicite y enviarlo por la red.
1785	// Parámetros:
1786	// ptrTrama: contenido del mensaje
1787	// Devuelve:
1788	// TRUE: Si el proceso es correcto
1789	// FALSE: En caso de ocurrir algún error
1790	//______________________________________________________________________________________________________
1791	BOOLEAN InventarioHardware(TRAMA* ptrTrama)
1792	{
1793	int lon;
1794	SOCKET socket_c;
1795	char nfn,ids,msglog[LONSTD],hrdsrc[LONPRM],hrddst[LONPRM];
1796	char modulo[] = "InventarioHardware()";
1797
1798	if (ndebug>=DEBUG_MAXIMO) {
1799	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1800	infoDebug(msglog);
1801	}
1802
1803	nfn=copiaParametro("nfn",ptrTrama);
1804	ids=copiaParametro("ids",ptrTrama);
1805	muestraMensaje(6,NULL);
1806
1807	sprintf(interface,"%s/%s",pathinterface,nfn);
1808	sprintf(hrdsrc,"/tmp/Chrd-%s",IPlocal); // Nombre que tendra el archivo de inventario
1809	sprintf(parametros,"%s %s",nfn,hrdsrc);
1810	herror=interfaceAdmin(interface,parametros,NULL);
1811	if(herror){
1812	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1813	errorInfo(modulo,msglog);
1814	muestraMensaje(18,NULL);
1815	}
1816	else{
1817	/* Envía fichero de inventario al servidor */
1818	sprintf(hrddst,"/tmp/Shrd-%s",IPlocal); // Nombre que tendra el archivo en el Servidor
1819	initParametros(ptrTrama,0);
1820	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",hrddst);
1821	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
1822	liberaMemoria(nfn);
1823	liberaMemoria(ids);
1824	errorLog(modulo,42,FALSE);
1825	return(FALSE);
1826	}
1827	/* Espera señal para comenzar el envío */
1828	liberaMemoria(ptrTrama);
1829	recibeFlag(&socket_c,ptrTrama);
1830	/* Envía archivo */
1831	if(!sendArchivo(&socket_c,hrdsrc)){
1832	errorLog(modulo,57, FALSE);
1833	herror=12; // Error de envío de fichero por la red
1834	}
1835	close(socket_c);
1836	muestraMensaje(17,NULL);
1837	}
1838
1839	/* Envia respuesta de ejecución de la función de interface */
1840	initParametros(ptrTrama,0);
1841	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioHardware");
1842	lon+=sprintf(ptrTrama->parametros+lon,"hrd=%s\r",hrddst);
1843	respuestaEjecucionComando(ptrTrama,herror,ids);
1844	liberaMemoria(nfn);
1845	liberaMemoria(ids);
1846
1847	muestraMenu();
1848
1849	return(TRUE);
1850	}
1851	// ________________________________________________________________________________________________________
1852	// Función: InventarioSoftware
1853	//
1854	// Descripción:
1855	// Crea el inventario software de un sistema operativo instalado en una partición.
1856	// Parámetros:
1857	// ptrTrama: contenido del mensaje
1858	// Devuelve:
1859	// TRUE: Si el proceso es correcto
1860	// FALSE: En caso de ocurrir algún error
1861	//______________________________________________________________________________________________________
1862	BOOLEAN InventarioSoftware(TRAMA* ptrTrama)
1863	{
1864	char nfn,ids,msglog[LONSTD];
1865	char modulo[] = "InventarioSoftware()";
1866
1867	if (ndebug>=DEBUG_MAXIMO) {
1868	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1869	infoDebug(msglog);
1870	}
1871	nfn=copiaParametro("nfn",ptrTrama);
1872	ids=copiaParametro("ids",ptrTrama);
1873	muestraMensaje(7,NULL);
1874	InventariandoSoftware(ptrTrama,TRUE,nfn);
1875	respuestaEjecucionComando(ptrTrama,herror,ids);
1876	liberaMemoria(nfn);
1877	liberaMemoria(ids);
1878	muestraMenu();
1879	return(TRUE);
1880	}
1881	// ________________________________________________________________________________________________________
1882	//
1883	// Función: InventariandoSoftware
1884	//
1885	// Descripción:
1886	// Envia al servidor el nombre del archivo de inventario de su software para posteriormente
1887	// esperar que éste lo solicite y enviarlo por la red.
1888	// Parámetros:
1889	// ptrTrama: contenido del mensaje
1890	// sw: switch que indica si la función es llamada por el comando InventarioSoftware(true) o CrearImagen(false)
1891	// nfn: Nombre de la función del Interface que implementa el comando
1892	// Devuelve:
1893	// TRUE: Si el proceso es correcto
1894	// FALSE: En caso de ocurrir algún error
1895	//______________________________________________________________________________________________________
1896	BOOLEAN InventariandoSoftware(TRAMA* ptrTrama,BOOLEAN sw,char *nfn)
1897	{
1898	int lon;
1899	SOCKET socket_c;
1900	char dsk,par,msglog[LONSTD],sftsrc[LONPRM],sftdst[LONPRM];
1901	char modulo[] = "InventariandoSoftware()";
1902
1903	dsk=copiaParametro("dsk",ptrTrama); // Disco
1904	par=copiaParametro("par",ptrTrama);
1905
1906	sprintf(interface,"%s/%s",pathinterface,nfn);
1907	sprintf(sftsrc,"/tmp/CSft-%s-%s",IPlocal,par); // Nombre que tendra el archivo de inventario
1908	sprintf(parametros,"%s %s %s %s",nfn,dsk,par,sftsrc);
1909
1910	herror=interfaceAdmin(interface,parametros,NULL);
1911	herror=0;
1912	if(herror){
1913	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1914	errorInfo(modulo,msglog);
1915	muestraMensaje(20,NULL);
1916	}
1917	else{
1918	/* Envía fichero de inventario al servidor */
1919	sprintf(sftdst,"/tmp/Ssft-%s-%s",IPlocal,par); // Nombre que tendra el archivo en el Servidor
1920	initParametros(ptrTrama,0);
1921
1922	sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",sftdst);
1923	if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
1924	errorLog(modulo,42,FALSE);
1925	liberaMemoria(dsk);
1926	liberaMemoria(par);
1927	return(FALSE);
1928	}
1929	/* Espera señal para comenzar el envío */
1930	liberaMemoria(ptrTrama);
1931	if(!recibeFlag(&socket_c,ptrTrama)){
1932	errorLog(modulo,17,FALSE);
1933	}
1934	/* Envía archivo */
1935	if(!sendArchivo(&socket_c,sftsrc)){
1936	errorLog(modulo,57, FALSE);
1937	herror=12; // Error de envío de fichero por la red
1938	}
1939	close(socket_c);
1940	muestraMensaje(19,NULL);
1941	}
1942	initParametros(ptrTrama,0);
1943	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioSoftware");
1944	lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par);
1945	lon+=sprintf(ptrTrama->parametros+lon,"sft=%s\r",sftdst);
1946	if(!sw)
1947	respuestaEjecucionComando(ptrTrama,herror,"0");
1948
1949	liberaMemoria(dsk);
1950	liberaMemoria(par);
1951	return(TRUE);
1952	}
1953	// ________________________________________________________________________________________________________
1954	// Función: EjecutarScript
1955	//
1956	// Descripción:
1957	// Ejecuta código de script
1958	// Parámetros:
1959	// ptrTrama: contenido del mensaje
1960	// Devuelve:
1961	// TRUE: Si el proceso es correcto
1962	// FALSE: En caso de ocurrir algún error
1963	//______________________________________________________________________________________________________
1964	BOOLEAN EjecutarScript(TRAMA* ptrTrama)
1965	{
1966	int lon;
1967	char nfn,aux,ids,scp,*cfg,msglog[LONSTD];
1968	char modulo[] = "EjecutarScript()";
1969
1970	if (ndebug>=DEBUG_MAXIMO) {
1971	sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1972	infoDebug(msglog);
1973	}
1974	aux=copiaParametro("scp",ptrTrama);
1975	scp=URLDecode(aux);
1976
1977
1978	muestraMensaje(8,NULL);
1979	/* Nombre del archivo de script */
1980	char filescript[LONPRM];
1981	sprintf(filescript,"/tmp/_script_%s",IPlocal);
1982	escribeArchivo(filescript,scp);
1983	nfn=copiaParametro("nfn",ptrTrama);
1984	sprintf(interface,"%s/%s",pathinterface,nfn);
1985	sprintf(parametros,"%s %s",nfn,filescript);
1986	herror=interfaceAdmin(interface,parametros,NULL);
1987	if(herror){
1988	sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1989	errorInfo(modulo,msglog);
1990	muestraMensaje(21,NULL);
1991	}
1992	else
1993	muestraMensaje(22,NULL);
1994
1995	// Toma configuración de particiones
1996	cfg=LeeConfiguracion();
1997	if(!cfg){ // No se puede recuperar la configuración del cliente
1998	errorLog(modulo,36,FALSE);
1999	herror=36;
2000	}
2001
2002	ids=copiaParametro("ids",ptrTrama);
2003
2004	//herror=ejecutarCodigoBash(scp);
2005	initParametros(ptrTrama,0);
2006	lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_EjecutarScript");
2007	lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
2008	respuestaEjecucionComando(ptrTrama,herror,ids);
2009
2010	liberaMemoria(nfn);
2011	liberaMemoria(ids);
2012	liberaMemoria(aux);
2013	liberaMemoria(scp);
2014	liberaMemoria(cfg);
2015
2016	muestraMenu();
2017
2018	return(TRUE);
2019	}
2020	//______________________________________________________________________________________________________
2021	// Función: respuestaEjecucionComando
2022	//
2023	// Descripción:
2024	// Envia una respuesta a una ejecucion de comando al servidor de Administración
2025	// Parámetros:
2026	// - ptrTrama: contenido del mensaje
2027	// - res: Resultado de la ejecución (Código de error devuelto por el script ejecutado)
2028	// - ids: Identificador de la sesion (En caso de no haber seguimiento es NULO)
2029	// Devuelve:
2030	// TRUE: Si el proceso es correcto
2031	// FALSE: En caso de ocurrir algún error
2032	// ________________________________________________________________________________________________________
2033	BOOLEAN respuestaEjecucionComando(TRAMA* ptrTrama,int res,char *ids)
2034	{
2035	int lon;
2036	SOCKET socket_c;
2037	char modulo[] = "respuestaEjecucionComando()";
2038
2039	lon=strlen(ptrTrama->parametros);
2040	if(ids){ // Existe seguimiento
2041	lon+=sprintf(ptrTrama->parametros+lon,"ids=%s\r",ids); // Añade identificador de la sesión
2042	}
2043	if (res==0){ // Resultado satisfactorio
2044	lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","1");
2045	lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r","");
2046	}
2047	else{ // Algún error
2048	lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","2");
2049	if(res>MAXERRORSCRIPT)
2050	lon+=sprintf(ptrTrama->parametros+lon,"der=%s (Error de script:%d)\r",tbErroresScripts[0],res);// Descripción del error
2051	else
2052	lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r",tbErroresScripts[res]);// Descripción del error
2053	}
2054	if(!(enviaMensajeServidor(&socket_c,ptrTrama,MSG_NOTIFICACION))){
2055	errorLog(modulo,44,FALSE);
2056	return(FALSE);
2057	}
2058
2059	close(socket_c);
2060	return(TRUE);
2061	}
2062	// ________________________________________________________________________________________________________
2063	// Función: gestionaTrama
2064	//
2065	// Descripción:
2066	// Procesa las tramas recibidas.
2067	// Parametros:
2068	// ptrTrama: contenido del mensaje
2069	// Devuelve:
2070	// TRUE: Si el proceso es correcto
2071	// FALSE: En caso de ocurrir algún error
2072	// ________________________________________________________________________________________________________
2073	BOOLEAN gestionaTrama(TRAMA *ptrTrama)
2074	{
2075	int i, res;
2076	char *nfn;
2077	char modulo[] = "gestionaTrama()";
2078
2079	INTROaFINCAD(ptrTrama);
2080	nfn = copiaParametro("nfn", ptrTrama); // Toma nombre de función
2081	for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
2082	res = strcmp(tbfuncionesClient[i].nf, nfn);
2083	if (res == 0) { // Encontrada la función que procesa el mensaje
2084	liberaMemoria(nfn);
2085	return(tbfuncionesClient[i].fptr(ptrTrama)); // Invoca la función
2086	}
2087	}
2088
2089	liberaMemoria(nfn);
2090
2091	/* Sólo puede ser un comando personalizado
2092	if (ptrTrama->tipo==MSG_COMANDO)
2093	return(Comando(ptrTrama));
2094	*/
2095	errorLog(modulo, 18, FALSE);
2096	return (FALSE);
2097	}
2098	//________________________________________________________________________________________________________
2099	// Función: ejecutaArchivo
2100	//
2101	// Descripción:
2102	// Ejecuta los comando contenido en un archivo (cada comando y sus parametros separados por un
2103	// salto de linea.
2104	// Parámetros:
2105	// filecmd: Nombre del archivo de comandos
2106	// ptrTrama: Puntero a una estructura TRAMA usada en las comunicaciones por red (No debe ser NULL)
2107	// Devuelve:
2108	// TRUE: Si el proceso es correcto
2109	// FALSE: En caso de ocurrir algún error
2110	//________________________________________________________________________________________________________
2111	BOOLEAN ejecutaArchivo(char* filecmd,TRAMA *ptrTrama)
2112	{
2113	char* buffer,*lineas[MAXIMAS_LINEAS];
2114	int i,numlin;
2115	char modulo[] = "ejecutaArchivo()";
2116
2117	buffer=leeArchivo(filecmd);
2118	if(buffer){
2119	numlin = splitCadena(lineas, buffer, '@');
2120	initParametros(ptrTrama,0);
2121	for (i = 0; i < numlin; i++) {
2122	if(strlen(lineas[i])>0){
2123	strcpy(ptrTrama->parametros,lineas[i]);
2124	//strcat(ptrTrama->parametros,"\rMCDJ@"); // Fin de trama
2125	if(!gestionaTrama(ptrTrama)){ // Análisis de la trama
2126	errorLog(modulo,39,FALSE);
2127	//return(FALSE);
2128	}
2129	}
2130	}
2131	}
2132	liberaMemoria(buffer);
2133	return(TRUE);
2134	}
2135
2136	BOOLEAN EjecutaComandosPendientes(TRAMA* ptrTrama)
2137	{
2138	return(TRUE);
2139	}
2140
2141	//______________________________________________________________________________________________________
2142	// Función: enviaMensajeServidor
2143	//
2144	// Descripción:
2145	// Envia un mensaje al servidor de Administración
2146	// Parámetros:
2147	// - socket_c: (Salida) Socket utilizado para el envío
2148	// - ptrTrama: contenido del mensaje
2149	// - tipo: Tipo de mensaje
2150	// C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
2151	// Devuelve:
2152	// TRUE: Si el proceso es correcto
2153	// FALSE: En caso de ocurrir algún error
2154	// ________________________________________________________________________________________________________
2155	BOOLEAN enviaMensajeServidor(SOCKET socket_c,TRAMA ptrTrama,char tipo)
2156	{
2157	int lon;
2158	char modulo[] = "enviaMensajeServidor()";
2159
2160	*socket_c=abreConexion();
2161	if(*socket_c==INVALID_SOCKET){
2162	errorLog(modulo,38,FALSE); // Error de conexión con el servidor
2163	return(FALSE);
2164	}
2165	ptrTrama->arroba='@'; // Cabecera de la trama
2166	strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14); // identificador de la trama
2167	ptrTrama->tipo=tipo; // Tipo de mensaje
2168	lon=strlen(ptrTrama->parametros); // Compone la trama
2169	lon+=sprintf(ptrTrama->parametros+lon,"iph=%s\r",IPlocal); // Ip del ordenador
2170	lon+=sprintf(ptrTrama->parametros+lon,"ido=%s\r",idordenador); // Identificador del ordenador
2171	lon+=sprintf(ptrTrama->parametros+lon,"npc=%s\r",nombreordenador); // Nombre del ordenador
2172	lon+=sprintf(ptrTrama->parametros+lon,"idc=%s\r",idcentro); // Identificador del centro
2173	lon+=sprintf(ptrTrama->parametros+lon,"ida=%s\r",idaula); // Identificador del aula
2174
2175	if (!mandaTrama(socket_c,ptrTrama)) {
2176	errorLog(modulo,26,FALSE);
2177	return (FALSE);
2178	}
2179	return(TRUE);
2180	}
2181	// ********************************************************************************************************
2182	// PROGRAMA PRINCIPAL (CLIENTE)
2183	// ********************************************************************************************************
2184	int main(int argc, char *argv[])
2185	{
2186	TRAMA *ptrTrama;
2187	char modulo[] = "main()";
2188
2189	ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
2190	if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas
2191	errorLog(modulo, 3, FALSE);
2192	exit(EXIT_FAILURE);
2193	}
2194	/*--------------------------------------------------------------------------------------------------------
2195	Validación de parámetros de ejecución y fichero de configuración
2196	---------------------------------------------------------------------------------------------------------*/
2197	if (!validacionParametros(argc, argv,3)) // Valida parámetros de ejecución
2198	exit(EXIT_FAILURE);
2199
2200	if (!tomaConfiguracion(szPathFileCfg)) // Toma parametros de configuración
2201	exit(EXIT_FAILURE);
2202	/*--------------------------------------------------------------------------------------------------------
2203	Carga catálogo de funciones que procesan las tramas
2204	---------------------------------------------------------------------------------------------------------*/
2205	int cf = 0;
2206
2207	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_AutoexecCliente");
2208	tbfuncionesClient[cf++].fptr = &RESPUESTA_AutoexecCliente;
2209
2210	strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_InclusionCliente");
2211	tbfuncionesClient[cf++].fptr = &RESPUESTA_InclusionCliente;
2212
2213	strcpy(tbfuncionesClient[cf].nf, "NoComandosPtes");
2214	tbfuncionesClient[cf++].fptr = &NoComandosPtes;
2215
2216	strcpy(tbfuncionesClient[cf].nf, "Actualizar");
2217	tbfuncionesClient[cf++].fptr = &Actualizar;
2218
2219	strcpy(tbfuncionesClient[cf].nf, "Purgar");
2220	tbfuncionesClient[cf++].fptr = &Purgar;
2221
2222	strcpy(tbfuncionesClient[cf].nf, "ConsolaRemota");
2223	tbfuncionesClient[cf++].fptr = &ConsolaRemota;
2224
2225	strcpy(tbfuncionesClient[cf].nf, "Sondeo");
2226	tbfuncionesClient[cf++].fptr = &Sondeo;
2227
2228	strcpy(tbfuncionesClient[cf].nf, "Arrancar");
2229	tbfuncionesClient[cf++].fptr = &Arrancar;
2230
2231	strcpy(tbfuncionesClient[cf].nf, "Apagar");
2232	tbfuncionesClient[cf++].fptr = &Apagar;
2233
2234	strcpy(tbfuncionesClient[cf].nf, "Reiniciar");
2235	tbfuncionesClient[cf++].fptr = &Reiniciar;
2236
2237	strcpy(tbfuncionesClient[cf].nf, "IniciarSesion");
2238	tbfuncionesClient[cf++].fptr = &IniciarSesion;
2239
2240	strcpy(tbfuncionesClient[cf].nf, "CrearImagen");
2241	tbfuncionesClient[cf++].fptr = &CrearImagen;
2242
2243	strcpy(tbfuncionesClient[cf].nf, "CrearImagenBasica");
2244	tbfuncionesClient[cf++].fptr = &CrearImagenBasica;
2245
2246	strcpy(tbfuncionesClient[cf].nf, "CrearSoftIncremental");
2247	tbfuncionesClient[cf++].fptr = &CrearSoftIncremental;
2248
2249	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagen");
2250	tbfuncionesClient[cf++].fptr = &RestaurarImagen;
2251
2252	strcpy(tbfuncionesClient[cf].nf, "RestaurarImagenBasica");
2253	tbfuncionesClient[cf++].fptr = &RestaurarImagenBasica;
2254
2255	strcpy(tbfuncionesClient[cf].nf, "RestaurarSoftIncremental");
2256	tbfuncionesClient[cf++].fptr = &RestaurarSoftIncremental;
2257
2258
2259	strcpy(tbfuncionesClient[cf].nf, "Configurar");
2260	tbfuncionesClient[cf++].fptr = &Configurar;
2261
2262	strcpy(tbfuncionesClient[cf].nf, "EjecutarScript");
2263	tbfuncionesClient[cf++].fptr = &EjecutarScript;
2264
2265	strcpy(tbfuncionesClient[cf].nf, "InventarioHardware");
2266	tbfuncionesClient[cf++].fptr = &InventarioHardware;
2267
2268	strcpy(tbfuncionesClient[cf].nf, "InventarioSoftware");
2269	tbfuncionesClient[cf++].fptr = &InventarioSoftware;
2270
2271	strcpy(tbfuncionesClient[cf].nf, "EjecutaComandosPendientes");
2272	tbfuncionesClient[cf++].fptr = &EjecutaComandosPendientes;
2273
2274	/*--------------------------------------------------------------------------------------------------------
2275	Toma dirección IP del cliente
2276	---------------------------------------------------------------------------------------------------------*/
2277	if(!tomaIPlocal()){ // Error al recuperar la IP local
2278	errorLog(modulo,0,FALSE);
2279	exit(EXIT_FAILURE);
2280	}
2281	/*--------------------------------------------------------------------------------------------------------
2282	Inicio de sesión
2283	---------------------------------------------------------------------------------------------------------*/
2284	infoLog(1); // Inicio de sesión
2285	infoLog(3); // Abriendo sesión en el servidor de Administración;
2286	/*--------------------------------------------------------------------------------------------------------
2287	Inclusión del cliente en el sistema
2288	---------------------------------------------------------------------------------------------------------*/
2289	if(!inclusionCliente(ptrTrama)){ // Ha habido algún problema al abrir sesión
2290	errorLog(modulo,0,FALSE);
2291	exit(EXIT_FAILURE);
2292	}
2293	infoLog(4); // Cliente iniciado
2294
2295	/*--------------------------------------------------------------------------------------------------------
2296	Procesamiento de la cache
2297	---------------------------------------------------------------------------------------------------------*/
2298	infoLog(23); // Abriendo sesión en el servidor de Administración;
2299	if(!cuestionCache(cache)){
2300	errorLog(modulo,0,FALSE);
2301	exit(EXIT_FAILURE);
2302	}
2303	/*--------------------------------------------------------------------------------------------------------
2304	Ejecución del autoexec
2305	---------------------------------------------------------------------------------------------------------*/
2306	if(atoi(idproautoexec)>0){ // Ejecución de procedimiento Autoexec
2307	infoLog(5);
2308	if(!autoexecCliente(ptrTrama)){ // Ejecución fichero autoexec
2309	errorLog(modulo,0,FALSE);
2310	exit(EXIT_FAILURE);
2311	}
2312	}
2313	/*--------------------------------------------------------------------------------------------------------
2314	Comandos pendientes
2315	---------------------------------------------------------------------------------------------------------*/
2316	infoLog(6); // Procesa comandos pendientes
2317	if(!comandosPendientes(ptrTrama)){ // Ejecución de acciones pendientes
2318	errorLog(modulo,0,FALSE);
2319	exit(EXIT_FAILURE);
2320	}
2321	infoLog(7); // Acciones pendientes procesadas
2322	/*--------------------------------------------------------------------------------------------------------
2323	Bucle de recepción de comandos
2324	---------------------------------------------------------------------------------------------------------*/
2325	muestraMenu();
2326	procesaComandos(ptrTrama); // Bucle para procesar comandos interactivos
2327	/*--------------------------------------------------------------------------------------------------------
2328	Fin de la sesión
2329	---------------------------------------------------------------------------------------------------------*/
2330	exit(EXIT_SUCCESS);
2331	}

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

Context Navigation

source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 03e3f88

Download in other formats: