Context Navigation

ogAdmClient.c @ 09bf701

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 09bf701 was 380fe92, checked in by alonso <alonso@…>, 12 years ago
git-svn-id: https://opengnsys.es/svn/branches/version1.0@3665 a21b9725-9963-47de-94b9-378ad31fedc9
Property mode set to `100644`
File size: 73.5 KB

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

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

Context Navigation

source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 09bf701

Download in other formats: