Context Navigation

ogAdmClient.c @ 5a8c831

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

#677: corregir erratas de revisión r4431.

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

Property mode set to 100644

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

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

Context Navigation

source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 5a8c831

Download in other formats: