Context Navigation

ogAdmClient.c @ fff35b2

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 fff35b2 was 7224a0a, checked in by alonso <alonso@…>, 12 years ago

Modificación del ticket 577

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

Property mode set to 100644

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

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

Context Navigation

source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ fff35b2

Download in other formats: