source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 40bba64

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 40bba64 was 9ef26af, checked in by cientificos.sic <cientificos@…>, 12 years ago

Se ha solucionado un problema con los mensajes de depuración al leer la configuración de los equipos.

git-svn-id: https://opengnsys.es/svn/branches/version1.0@3791 a21b9725-9963-47de-94b9-378ad31fedc9
  • Property mode set to 100644
File size: 73.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//________________________________________________________________________________________________________
22BOOLEAN 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
138int 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
243int 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//______________________________________________________________________________________________________
370void 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//______________________________________________________________________________________________________
394BOOLEAN 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//______________________________________________________________________________________________________
421BOOLEAN 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// ________________________________________________________________________________________________________
451int 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//________________________________________________________________________________________________________
494void 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// ________________________________________________________________________________________________________
507void 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//______________________________________________________________________________________________________
530BOOLEAN inclusionCliente(TRAMA* ptrTrama)
531{
532        int lon;                // Longitud de cadena
533        char msglog[LONSUC];    // Mensaje de registro de sucesos
534        char *cfg;              // Datos de configuración
535        SOCKET socket_c;
536        char modulo[] = "inclusionCliente()";
537
538        cfg=LeeConfiguracion();
539       
540        if(!cfg){ // No se puede recuperar la configuración del cliente
541                errorLog(modulo,36,FALSE);
542                errorLog(modulo,37,FALSE);
543                return(FALSE);
544        }
545        if (ndebug>= DEBUG_ALTO) {
546                // Truncar la cadena si es mayor que el tamaño de la línea de log.
547                sprintf(msglog, "%s", tbMensajes[14]);
548                lon = strlen (msglog);
549                if (lon + strlen (cfg) < LONSUC) {
550                        strcat (msglog, cfg);
551                }
552                else
553                {
554                        strncat (msglog, cfg, LONSUC - lon - 4);
555                        strcat (msglog, "...");
556                }
557                infoDebug(msglog);
558        }
559        initParametros(ptrTrama,0);
560        lon=sprintf(ptrTrama->parametros,"nfn=InclusionCliente\r"); // Nombre de la función a ejecutar en el servidor
561        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
562        liberaMemoria(cfg);
563       
564        if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
565                errorLog(modulo,37,FALSE);
566                return(FALSE);
567        }
568        ptrTrama=recibeMensaje(&socket_c);
569        if(!ptrTrama){
570                errorLog(modulo,45,FALSE);
571                return(FALSE);
572        }
573
574        close(socket_c);
575
576        if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
577                errorLog(modulo,39,FALSE);
578                return(FALSE);
579        }
580
581        return(TRUE);
582}
583//______________________________________________________________________________________________________
584// Función: RESPUESTA_InclusionCliente
585//
586//      Descripción:
587//      Respuesta del servidor de administración a la petición de inicio
588//              enviando los datos identificativos del cliente y otras configuraciones
589//      Parámetros:
590//              - ptrTrama: Trama recibida por el servidor con el contenido y los parámetros
591//      Devuelve:
592//              TRUE: Si el proceso es correcto
593//              FALSE: En caso de ocurrir algún error
594//______________________________________________________________________________________________________
595BOOLEAN RESPUESTA_InclusionCliente(TRAMA* ptrTrama)
596{
597        char* res;
598        char modulo[] = "RESPUESTA_InclusionCliente()";
599
600        res=copiaParametro("res",ptrTrama); // Resultado del proceso de inclusión
601        if(atoi(res)==0){ // Error en el proceso de inclusión
602                liberaMemoria(res);
603                errorLog(modulo,41,FALSE);
604                return (FALSE);
605        }
606        liberaMemoria(res);
607
608        idordenador=copiaParametro("ido",ptrTrama); // Identificador del ordenador
609        nombreordenador=copiaParametro("npc",ptrTrama); //  Nombre del ordenador
610        cache=copiaParametro("che",ptrTrama); // Tamaño de la caché reservada al cliente
611        idproautoexec=copiaParametro("exe",ptrTrama); // Procedimento de inicio (Autoexec)
612        idcentro=copiaParametro("idc",ptrTrama); // Identificador de la Unidad Organizativa
613        idaula=copiaParametro("ida",ptrTrama); // Identificador del aula
614
615        if(idordenador==NULL || nombreordenador==NULL){
616                errorLog(modulo,40,FALSE);
617                return (FALSE);
618        }
619        return(TRUE);
620}
621//______________________________________________________________________________________________________
622//
623// Función: LeeConfiguracion
624//       Descripción:
625//              Abre una sesión en el servidor de administración y registra al cliente en el sistema
626//      Parámetros:
627//              Ninguno
628//      Devuelve:
629//              TRUE: Si el proceso es correcto
630//              FALSE: En caso de ocurrir algún error
631//______________________________________________________________________________________________________
632
633char* LeeConfiguracion()
634{
635        char* parametroscfg;
636        char modulo[] = "LeeConfiguracion()";
637
638        // Reservar memoria para los datos de cofiguración.
639        parametroscfg=(char*)reservaMemoria(LONGITUD_SCRIPTSALIDA);
640        if(!parametroscfg){
641                errorLog(modulo,3,FALSE);
642                return(NULL);
643        }
644        // Ejecutar script y obtener datos.
645        sprintf(interface,"%s/%s",pathinterface,"getConfiguration");
646        herror=interfaceAdmin(interface,NULL,parametroscfg);
647
648        if(herror){ // No se puede recuperar la configuración del cliente
649                liberaMemoria(parametroscfg);
650                errorLog(modulo,36,FALSE);
651                return(NULL);
652        }
653        return(parametroscfg);
654}
655//________________________________________________________________________________________________________
656//      Función: autoexecCliente
657//
658//      Descripción:
659//              Solicita procedimiento de autoexec para el cliebnte
660//      Parámetros:
661//              Ninguno
662//      Devuelve:
663//              TRUE: Si el proceso es correcto
664//              FALSE: En caso de ocurrir algún error
665//________________________________________________________________________________________________________
666BOOLEAN autoexecCliente(TRAMA* ptrTrama)
667{
668        int lon;
669        SOCKET socket_c;
670        char modulo[] = "autoexecCliente()";
671
672        initParametros(ptrTrama,0);
673        lon=sprintf(ptrTrama->parametros,"nfn=AutoexecCliente\rexe=%s\r",idproautoexec);
674
675        if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
676                errorLog(modulo,42,FALSE);
677                return(FALSE);
678        }
679        ptrTrama=recibeMensaje(&socket_c);
680        if(!ptrTrama){
681                errorLog(modulo,45,FALSE);
682                return(FALSE);
683        }
684
685        close(socket_c);
686
687        if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
688                errorLog(modulo,39,FALSE);
689                return(FALSE);
690        }
691
692        return(TRUE);
693}
694//________________________________________________________________________________________________________
695//      Función: autoexecCliente
696//
697//      Descripción:
698//              Ejecuta un script de autoexec personalizado en todos los inicios para el cliente
699//      Parámetros:
700//              Ninguno
701//      Devuelve:
702//              TRUE: Si el proceso es correcto
703//              FALSE: En caso de ocurrir algún error
704//________________________________________________________________________________________________________
705BOOLEAN RESPUESTA_AutoexecCliente(TRAMA* ptrTrama)
706{
707        SOCKET socket_c;
708        char *res,*nfl;
709        char modulo[] = "RESPUESTA_AutoexecCliente()";
710
711        res=copiaParametro("res",ptrTrama);
712        if(atoi(res)==0){ // Error en el proceso de autoexec
713                liberaMemoria(res);
714                return (FALSE);
715        }
716        liberaMemoria(res);
717
718        nfl=copiaParametro("nfl",ptrTrama);
719        initParametros(ptrTrama,0);
720        sprintf(ptrTrama->parametros,"nfn=enviaArchivo\rnfl=%s\r",nfl);
721        liberaMemoria(nfl);
722
723        /* Envía petición */
724        if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
725                errorLog(modulo,42,FALSE);
726                return(FALSE);
727        }
728        /* Nombre del archivo destino (local)*/
729        char fileautoexec[LONPRM];
730        sprintf(fileautoexec,"/tmp/_autoexec_%s",IPlocal);
731
732        /* Recibe archivo */
733        if(!recArchivo(&socket_c,fileautoexec)){
734                errorLog(modulo,58, FALSE);
735                close(socket_c);
736                return(FALSE);
737        }
738
739        close(socket_c);
740
741        /* Ejecuta archivo */
742        ejecutaArchivo(fileautoexec,ptrTrama);
743        return(TRUE);
744}
745//______________________________________________________________________________________________________
746// Función: comandosPendientes
747//
748//       Descripción:
749//               Búsqueda de acciones pendientes en el servidor de administración
750//      Parámetros:
751//              Ninguno
752//      Devuelve:
753//              TRUE: Si el proceso es correcto
754//              FALSE: En caso de ocurrir algún error
755//______________________________________________________________________________________________________
756BOOLEAN comandosPendientes(TRAMA* ptrTrama)
757{
758        SOCKET socket_c;
759        char modulo[] = "comandosPendientes()";
760
761        CMDPTES=TRUE;
762        initParametros(ptrTrama,0);
763
764        while(CMDPTES){
765                sprintf(ptrTrama->parametros,"nfn=ComandosPendientes\r");
766                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_PETICION)){
767                        errorLog(modulo,42,FALSE);
768                        return(FALSE);
769                }
770                ptrTrama=recibeMensaje(&socket_c);
771                if(!ptrTrama){
772                        errorLog(modulo,45,FALSE);
773                        return(FALSE);
774                }
775
776                close(socket_c);
777
778                if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
779                        errorLog(modulo,39,FALSE);
780                        return(FALSE);
781                }
782        }
783        return(TRUE);
784}
785//______________________________________________________________________________________________________
786// Función: NoComandosPtes
787//
788//       Descripción:
789//               Conmuta el switch de los comandos pendientes y lo pone a false
790//      Parámetros:
791//              - ptrTrama: contenido del mensaje
792//      Devuelve:
793//              TRUE siempre
794//      Especificaciones:
795//              Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el
796//              servidor y el cliente pasa a a estar disponible para recibir comandos desde el éste.
797//______________________________________________________________________________________________________
798BOOLEAN 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// ________________________________________________________________________________________________________
814void 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//______________________________________________________________________________________________________
858BOOLEAN 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//______________________________________________________________________________________________________
902int 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//______________________________________________________________________________________________________
940BOOLEAN 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//______________________________________________________________________________________________________
955BOOLEAN 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//_____________________________________________________________________________________________________
1013BOOLEAN 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//_____________________________________________________________________________________________________
1051BOOLEAN 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//_____________________________________________________________________________________________________
1083BOOLEAN 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//_____________________________________________________________________________________________________
1124BOOLEAN 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//_____________________________________________________________________________________________________
1165BOOLEAN 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//______________________________________________________________________________________________________
1210BOOLEAN 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//______________________________________________________________________________________________________
1284BOOLEAN CrearImagenBasica(TRAMA* ptrTrama)
1285{
1286        int lon;
1287        char *nfn,*dsk,*par,*cpt,*idi,*nci,*rti,*ipr,*whl,*eli,*cmp,*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
1303        whl=copiaParametro("whl",ptrTrama); // Envío del fichero completo si hay diferencias   
1304        eli=copiaParametro("eli",ptrTrama); // Elimiar archivos en destino que no estén en origen       
1305        cmp=copiaParametro("cmp",ptrTrama); // Comprimir antes de enviar
1306
1307        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1308        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1309        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1310        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1311
1312        //muestraMensaje(7,NULL); // Creando Inventario Software
1313        //if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1314                muestraMensaje(30,NULL);// Creando Imagen Básica, por favor espere...
1315                sprintf(interface,"%s/%s",pathinterface,nfn);
1316                sprintf(parametros,"%s %s %s %s %s %s%s%s %s%s%s%s %s",nfn,dsk,par,nci,ipr,whl,eli,cmp,bpi,cpc,bpc,nba,rti);
1317                herror=interfaceAdmin(interface,parametros,NULL);
1318                if(herror){
1319                        sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1320                        errorInfo(modulo,msglog);
1321                        muestraMensaje(29,NULL);// Ha habido algún error en el proceso de creación de imagen básica
1322                }
1323                else
1324                        muestraMensaje(28,NULL);// El proceso de creación de imagen básica ha terminado correctamente
1325        //}
1326        //else{
1327        //      sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1328        //      errorInfo(modulo,msglog);
1329        //}
1330
1331        ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
1332
1333        /* Envia respuesta de ejecución de la función de interface */
1334        initParametros(ptrTrama,0);
1335        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearImagenBasica");
1336        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1337        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición de donde se creó
1338        lon+=sprintf(ptrTrama->parametros+lon,"cpt=%s\r",cpt); // Tipo o código de partición
1339        lon+=sprintf(ptrTrama->parametros+lon,"ipr=%s\r",ipr); // Ip del repositorio donde se alojó
1340        respuestaEjecucionComando(ptrTrama,herror,ids);
1341               
1342        liberaMemoria(nfn);     
1343        liberaMemoria(dsk);     
1344        liberaMemoria(par);     
1345        liberaMemoria(cpt);     
1346        liberaMemoria(idi);     
1347        liberaMemoria(nci);     
1348        liberaMemoria(rti);     
1349        liberaMemoria(ipr);     
1350        liberaMemoria(bpi);     
1351        liberaMemoria(cpc);     
1352        liberaMemoria(bpc);     
1353        liberaMemoria(nba);
1354        liberaMemoria(ids);             
1355       
1356        muestraMenu();
1357
1358        return(TRUE);
1359}
1360//______________________________________________________________________________________________________
1361// Función: CrearSoftIncremental
1362//
1363//       Descripción:
1364//              Crea una software incremental comparando una partición con una imagen básica
1365//      Parámetros:
1366//              ptrTrama: contenido del mensaje
1367//
1368//      Devuelve:
1369//              TRUE: Si el proceso es correcto
1370//              FALSE: En caso de ocurrir algún error
1371//______________________________________________________________________________________________________
1372BOOLEAN CrearSoftIncremental(TRAMA* ptrTrama)
1373{
1374        int lon;
1375        char *nfn,*dsk,*par,*idi,*idf,*ipr,*nci,*rti,*ncf,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
1376        char modulo[] = "CrearSoftIncremental()";
1377
1378        if (ndebug>=DEBUG_MAXIMO) {
1379                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1380                infoDebug(msglog);
1381        }
1382        nfn=copiaParametro("nfn",ptrTrama);
1383
1384        dsk=copiaParametro("dsk",ptrTrama); // Disco
1385        par=copiaParametro("par",ptrTrama); // Número de partición
1386        idi=copiaParametro("idi",ptrTrama); // Identificador de la imagen
1387        nci=copiaParametro("nci",ptrTrama); // Nombre canónico de la imagen
1388        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1389        ipr=copiaParametro("ipr",ptrTrama); // Ip del repositorio
1390        idf=copiaParametro("idf",ptrTrama); // Identificador de la imagen diferencial
1391        ncf=copiaParametro("ncf",ptrTrama); // Nombre canónico de la imagen diferencial
1392        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1393        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1394        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1395        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1396
1397//      muestraMensaje(7,NULL); // Creando Inventario Software
1398//      if(InventariandoSoftware(ptrTrama,FALSE,"InventarioSoftware")){ // Crea inventario Software previamente
1399                muestraMensaje(25,NULL);// Creando Imagen Incremental, por favor espere...
1400                sprintf(interface,"%s/%s",pathinterface,nfn);
1401                sprintf(parametros,"%s %s %s %s %s %s %s%s%s%s %s",nfn,dsk,par,nci,ipr,ncf,bpi,cpc,bpc,nba,rti);
1402                herror=interfaceAdmin(interface,parametros,NULL);
1403                if(herror){
1404                        sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1405                        errorInfo(modulo,msglog);
1406                        muestraMensaje(27,NULL);// Ha habido algún error en el proceso de creación de imagen básica
1407                }
1408                else
1409                        muestraMensaje(26,NULL);// El proceso de creación de imagen básica ha terminado correctamente
1410//      }
1411//      else{
1412//              sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1413//              errorInfo(modulo,msglog);
1414//      }
1415
1416        ids=copiaParametro("ids",ptrTrama); // Identificador de la sesión
1417
1418        /* Envia respuesta de ejecución de la función de interface */
1419        initParametros(ptrTrama,0);
1420        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_CrearSoftIncremental");
1421        lon+=sprintf(ptrTrama->parametros+lon,"idf=%s\r",idf); // Identificador de la imagen incremental
1422        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1423        respuestaEjecucionComando(ptrTrama,herror,ids);
1424       
1425        liberaMemoria(nfn);     
1426        liberaMemoria(dsk);     
1427        liberaMemoria(par);     
1428        liberaMemoria(idi);     
1429        liberaMemoria(nci);     
1430        liberaMemoria(rti);     
1431        liberaMemoria(ipr);     
1432        liberaMemoria(idf);     
1433        liberaMemoria(ncf);     
1434        liberaMemoria(bpi);     
1435        liberaMemoria(cpc);     
1436        liberaMemoria(bpc);     
1437        liberaMemoria(nba);
1438        liberaMemoria(ids);             
1439       
1440        muestraMenu();
1441
1442        return(TRUE);
1443}
1444//______________________________________________________________________________________________________
1445// Función: RestaurarImagen
1446//
1447//       Descripción:
1448//              Restaura una imagen en una partición
1449//      Parámetros:
1450//              ptrTrama: contenido del mensaje
1451//      Devuelve:
1452//              TRUE: Si el proceso es correcto
1453//              FALSE: En bpccaso de ocurrir algún error
1454//______________________________________________________________________________________________________
1455BOOLEAN RestaurarImagen(TRAMA* ptrTrama)
1456{
1457        int lon;
1458        char *nfn,*dsk,*par,*idi,*ipr,*ifs,*nci,*ids,*ptc,msglog[LONSTD];
1459        char modulo[] = "RestaurarImagen()";
1460
1461        if (ndebug>=DEBUG_MAXIMO) {
1462                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1463                infoDebug(msglog);
1464        }
1465
1466        dsk=copiaParametro("dsk",ptrTrama);
1467        par=copiaParametro("par",ptrTrama);
1468        idi=copiaParametro("idi",ptrTrama);
1469        ipr=copiaParametro("ipr",ptrTrama);
1470        nci=copiaParametro("nci",ptrTrama);
1471        ifs=copiaParametro("ifs",ptrTrama);
1472        ptc=copiaParametro("ptc",ptrTrama);
1473
1474        nfn=copiaParametro("nfn",ptrTrama);
1475        ids=copiaParametro("ids",ptrTrama);
1476        muestraMensaje(3,NULL);
1477        sprintf(interface,"%s/%s",pathinterface,nfn);
1478        sprintf(parametros,"%s %s %s %s %s %s",nfn,dsk,par,nci,ipr,ptc);
1479        herror=interfaceAdmin(interface,parametros,NULL);
1480        if(herror){
1481                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1482                errorInfo(modulo,msglog);
1483                muestraMensaje(12,NULL);
1484        }
1485        else
1486                muestraMensaje(11,NULL);
1487
1488
1489        /* Envia respuesta de ejecución de la función de interface */
1490        initParametros(ptrTrama,0);
1491        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagen");
1492        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1493        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1494        lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1495        respuestaEjecucionComando(ptrTrama,herror,ids);
1496       
1497        liberaMemoria(nfn);     
1498        liberaMemoria(dsk);     
1499        liberaMemoria(par);     
1500        liberaMemoria(idi);
1501        liberaMemoria(nci);     
1502        liberaMemoria(ipr);     
1503        liberaMemoria(ifs);     
1504        liberaMemoria(ptc);     
1505        liberaMemoria(ids);                     
1506
1507        muestraMenu();
1508
1509        return(TRUE);
1510}
1511//______________________________________________________________________________________________________
1512// Función: RestaurarImagenBasica
1513//
1514//       Descripción:
1515//              Restaura una imagen básica en una partición
1516//      Parámetros:
1517//              ptrTrama: contenido del mensaje
1518//      Devuelve:
1519//              TRUE: Si el proceso es correcto
1520//              FALSE: En caso de ocurrir algún error
1521//______________________________________________________________________________________________________
1522BOOLEAN RestaurarImagenBasica(TRAMA* ptrTrama)
1523{
1524        int lon;
1525        char *nfn,*dsk,*par,*idi,*ipr,*met,*nci,*rti,*ifs,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
1526        char modulo[] = "RestaurarImagenBasica()";
1527
1528        if (ndebug>=DEBUG_MAXIMO) {
1529                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1530                infoDebug(msglog);
1531        }
1532        dsk=copiaParametro("dsk",ptrTrama);
1533        par=copiaParametro("par",ptrTrama);
1534        idi=copiaParametro("idi",ptrTrama);
1535        ipr=copiaParametro("ipr",ptrTrama);
1536        met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
1537        nci=copiaParametro("nci",ptrTrama);
1538        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1539        ifs=copiaParametro("ifs",ptrTrama);
1540        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1541        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1542        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1543        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1544
1545        nfn=copiaParametro("nfn",ptrTrama);
1546        ids=copiaParametro("ids",ptrTrama);
1547        muestraMensaje(31,NULL);
1548        sprintf(interface,"%s/%s",pathinterface,nfn);
1549        sprintf(parametros,"%s %s %s %s %s %s%s%s%s %s %s",nfn,dsk,par,nci,ipr,bpi,cpc,bpc,nba,met,rti);
1550        herror=interfaceAdmin(interface,parametros,NULL);
1551        if(herror){
1552                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1553                errorInfo(modulo,msglog);
1554                muestraMensaje(33,NULL);
1555        }
1556        else
1557                muestraMensaje(32,NULL);
1558
1559        /* Envia respuesta de ejecución de la función de interface */
1560        initParametros(ptrTrama,0);
1561        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarImagenBasica");
1562        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idi); // Identificador de la imagen
1563        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1564        lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1565        respuestaEjecucionComando(ptrTrama,herror,ids);
1566       
1567        liberaMemoria(nfn);     
1568        liberaMemoria(dsk);     
1569        liberaMemoria(par);     
1570        liberaMemoria(idi);     
1571        liberaMemoria(nci);     
1572        liberaMemoria(rti);     
1573        liberaMemoria(ifs);     
1574        liberaMemoria(ipr);     
1575        liberaMemoria(met);
1576        liberaMemoria(bpi);     
1577        liberaMemoria(cpc);     
1578        liberaMemoria(bpc);     
1579        liberaMemoria(nba);
1580        liberaMemoria(ids);             
1581
1582        muestraMenu();
1583       
1584        return(TRUE);
1585}
1586//______________________________________________________________________________________________________
1587// Función: RestaurarSoftIncremental
1588//
1589//       Descripción:
1590//              Restaura software incremental en una partición
1591//      Parámetros:
1592//              ptrTrama: contenido del mensaje
1593//      Devuelve:
1594//              TRUE: Si el proceso es correcto
1595//              FALSE: En caso de ocurrir algún error
1596//______________________________________________________________________________________________________
1597BOOLEAN RestaurarSoftIncremental(TRAMA* ptrTrama)
1598{
1599        int lon;
1600        char *nfn,*dsk,*par,*idi,*ipr,*met,*ifs,*nci,*rti,*idf,*ncf,*bpi,*cpc,*bpc,*nba,*ids,msglog[LONSTD];
1601        char modulo[] = "RestaurarSoftIncremental()";
1602
1603        if (ndebug>=DEBUG_MAXIMO) {
1604                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1605                infoDebug(msglog);
1606        }
1607        dsk=copiaParametro("dsk",ptrTrama);
1608        par=copiaParametro("par",ptrTrama);
1609        idi=copiaParametro("idi",ptrTrama);
1610        idf=copiaParametro("idf",ptrTrama);
1611        ipr=copiaParametro("ipr",ptrTrama);
1612        met=copiaParametro("met",ptrTrama); // Método de clonación 0= desde caché 1= desde repositorio
1613        ifs=copiaParametro("ifs",ptrTrama);
1614        nci=copiaParametro("nci",ptrTrama);
1615        rti=copiaParametro("rti",ptrTrama); // Ruta de origen de la imagen
1616        ncf=copiaParametro("ncf",ptrTrama);
1617        bpi=copiaParametro("bpi",ptrTrama); // Borrar la imagen antes de crearla
1618        cpc=copiaParametro("cpc",ptrTrama); // Copiar también imagen a la cache
1619        bpc=copiaParametro("bpc",ptrTrama); // Borrarla de la cache antes de copiarla en ella
1620        nba=copiaParametro("nba",ptrTrama); // No borrar archivos en destino
1621
1622        nfn=copiaParametro("nfn",ptrTrama);
1623        ids=copiaParametro("ids",ptrTrama);
1624        muestraMensaje(31,NULL);
1625        sprintf(interface,"%s/%s",pathinterface,nfn);
1626        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);
1627        herror=interfaceAdmin(interface,parametros,NULL);
1628        if(herror){
1629                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1630                errorInfo(modulo,msglog);
1631                muestraMensaje(35,NULL);
1632        }
1633        else
1634                muestraMensaje(34,NULL);
1635
1636        /* Envia respuesta de ejecución de la función de interface */
1637        initParametros(ptrTrama,0);
1638        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_RestaurarSoftIncremental");
1639        lon+=sprintf(ptrTrama->parametros+lon,"idi=%s\r",idf); // Identificador de la imagen incremental (Forzada a idi)
1640        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par); // Número de partición
1641        lon+=sprintf(ptrTrama->parametros+lon,"ifs=%s\r",ifs); // Identificador del perfil software
1642
1643        respuestaEjecucionComando(ptrTrama,herror,ids);
1644       
1645        liberaMemoria(nfn);     
1646        liberaMemoria(dsk);     
1647        liberaMemoria(par);     
1648        liberaMemoria(idi);     
1649        liberaMemoria(idf);     
1650        liberaMemoria(nci);     
1651        liberaMemoria(rti);     
1652        liberaMemoria(ncf);     
1653        liberaMemoria(ifs);     
1654        liberaMemoria(ipr);     
1655        liberaMemoria(met);
1656        liberaMemoria(bpi);     
1657        liberaMemoria(cpc);     
1658        liberaMemoria(bpc);     
1659        liberaMemoria(nba);
1660        liberaMemoria(ids);             
1661       
1662        muestraMenu();
1663
1664        return(TRUE);
1665}
1666//______________________________________________________________________________________________________
1667// Función: Configurar
1668//
1669//       Descripción:
1670//              Configura la tabla de particiones y formatea
1671//      Parámetros:
1672//              ptrTrama: contenido del mensaje
1673//      Devuelve:
1674//              TRUE: Si el proceso es correcto
1675//              FALSE: En caso de ocurrir algún error
1676//______________________________________________________________________________________________________
1677BOOLEAN Configurar(TRAMA* ptrTrama)
1678{
1679        int lon;
1680        char *nfn,*dsk,*cfg,*ids,msglog[LONSTD];
1681        char modulo[] = "Configurar()";
1682
1683        if (ndebug>=DEBUG_MAXIMO) {
1684                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1685                infoDebug(msglog);
1686        }
1687
1688        dsk=copiaParametro("dsk",ptrTrama);
1689        cfg=copiaParametro("cfg",ptrTrama);
1690        /* Sustituir caracteres */
1691        sustituir(cfg,'\n','$');
1692        sustituir(cfg,'\t','#');
1693
1694        nfn=copiaParametro("nfn",ptrTrama);
1695        ids=copiaParametro("ids",ptrTrama);
1696        muestraMensaje(4,NULL);
1697        sprintf(interface,"%s/%s",pathinterface,nfn);
1698        sprintf(parametros,"%s %s %s",nfn,dsk,cfg);
1699
1700        herror=interfaceAdmin(interface,parametros,NULL);
1701        if(herror){
1702                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1703                errorInfo(modulo,msglog);
1704                muestraMensaje(13,NULL);
1705        }
1706        else
1707                muestraMensaje(14,NULL);
1708
1709        cfg=LeeConfiguracion();
1710        if(!cfg){ // No se puede recuperar la configuración del cliente
1711                errorLog(modulo,36,FALSE);
1712                return(FALSE);
1713        }
1714
1715        /* Envia respuesta de ejecución del comando*/
1716        initParametros(ptrTrama,0);
1717        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_Configurar");
1718        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
1719        respuestaEjecucionComando(ptrTrama,herror,ids);
1720       
1721        liberaMemoria(dsk);
1722        liberaMemoria(cfg);
1723        liberaMemoria(nfn);
1724        liberaMemoria(ids);
1725
1726        muestraMenu();
1727
1728        return(TRUE);
1729}
1730// ________________________________________________________________________________________________________
1731// Función: InventarioHardware
1732//
1733//      Descripción:
1734//              Envia al servidor el nombre del archivo de inventario de su hardware para posteriormente
1735//              esperar que éste lo solicite y enviarlo por la red.
1736//      Parámetros:
1737//              ptrTrama: contenido del mensaje
1738//      Devuelve:
1739//              TRUE: Si el proceso es correcto
1740//              FALSE: En caso de ocurrir algún error
1741//______________________________________________________________________________________________________
1742BOOLEAN InventarioHardware(TRAMA* ptrTrama)
1743{
1744        int lon;
1745        SOCKET socket_c;
1746        char *nfn,*ids,msglog[LONSTD],hrdsrc[LONPRM],hrddst[LONPRM];
1747        char modulo[] = "InventarioHardware()";
1748
1749        if (ndebug>=DEBUG_MAXIMO) {
1750                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1751                infoDebug(msglog);
1752        }
1753
1754        nfn=copiaParametro("nfn",ptrTrama);
1755        ids=copiaParametro("ids",ptrTrama);
1756        muestraMensaje(6,NULL);
1757
1758        sprintf(interface,"%s/%s",pathinterface,nfn);
1759        sprintf(hrdsrc,"/tmp/Chrd-%s",IPlocal); // Nombre que tendra el archivo de inventario
1760        sprintf(parametros,"%s %s",nfn,hrdsrc);
1761        herror=interfaceAdmin(interface,parametros,NULL);
1762        if(herror){
1763                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1764                errorInfo(modulo,msglog);
1765                muestraMensaje(18,NULL);
1766        }
1767        else{
1768                /* Envía fichero de inventario al servidor */
1769                sprintf(hrddst,"/tmp/Shrd-%s",IPlocal); // Nombre que tendra el archivo en el Servidor
1770                initParametros(ptrTrama,0);
1771                sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",hrddst);
1772                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
1773                        liberaMemoria(nfn);
1774                        liberaMemoria(ids);
1775                        errorLog(modulo,42,FALSE);
1776                        return(FALSE);
1777                }
1778                 /* Espera señal para comenzar el envío */
1779                liberaMemoria(ptrTrama);
1780                recibeFlag(&socket_c,ptrTrama);
1781                /* Envía archivo */
1782                if(!sendArchivo(&socket_c,hrdsrc)){
1783                        errorLog(modulo,57, FALSE);
1784                        herror=12; // Error de envío de fichero por la red
1785                }
1786                close(socket_c);
1787                muestraMensaje(17,NULL);
1788        }
1789
1790        /* Envia respuesta de ejecución de la función de interface */
1791        initParametros(ptrTrama,0);
1792        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioHardware");
1793        lon+=sprintf(ptrTrama->parametros+lon,"hrd=%s\r",hrddst);
1794        respuestaEjecucionComando(ptrTrama,herror,ids);
1795        liberaMemoria(nfn);
1796        liberaMemoria(ids);
1797       
1798        muestraMenu();
1799
1800        return(TRUE);
1801}
1802// ________________________________________________________________________________________________________
1803// Función: InventarioSoftware
1804//
1805//      Descripción:
1806//              Crea el inventario software de un sistema operativo instalado en una partición.
1807//      Parámetros:
1808//              ptrTrama: contenido del mensaje
1809//      Devuelve:
1810//              TRUE: Si el proceso es correcto
1811//              FALSE: En caso de ocurrir algún error
1812//______________________________________________________________________________________________________
1813BOOLEAN InventarioSoftware(TRAMA* ptrTrama)
1814{
1815        char *nfn,*ids,msglog[LONSTD];
1816        char modulo[] = "InventarioSoftware()";
1817
1818        if (ndebug>=DEBUG_MAXIMO) {
1819                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1820                infoDebug(msglog);
1821        }
1822        nfn=copiaParametro("nfn",ptrTrama);
1823        ids=copiaParametro("ids",ptrTrama);
1824        muestraMensaje(7,NULL);
1825        InventariandoSoftware(ptrTrama,TRUE,nfn);
1826        respuestaEjecucionComando(ptrTrama,herror,ids);
1827        liberaMemoria(nfn);
1828        liberaMemoria(ids);             
1829        muestraMenu();
1830        return(TRUE);
1831}
1832// ________________________________________________________________________________________________________
1833//
1834// Función: InventariandoSoftware
1835//
1836//      Descripción:
1837//              Envia al servidor el nombre del archivo de inventario de su software para posteriormente
1838//              esperar que éste lo solicite y enviarlo por la red.
1839//      Parámetros:
1840//              ptrTrama: contenido del mensaje
1841//              sw: switch que indica si la función es llamada por el comando InventarioSoftware(true) o CrearImagen(false)
1842//              nfn: Nombre de la función del Interface que implementa el comando
1843//      Devuelve:
1844//              TRUE: Si el proceso es correcto
1845//              FALSE: En caso de ocurrir algún error
1846//______________________________________________________________________________________________________
1847BOOLEAN InventariandoSoftware(TRAMA* ptrTrama,BOOLEAN sw,char *nfn)
1848{
1849        int lon;
1850        SOCKET socket_c;
1851        char *dsk,*par,msglog[LONSTD],sftsrc[LONPRM],sftdst[LONPRM];
1852        char modulo[] = "InventariandoSoftware()";
1853
1854        dsk=copiaParametro("dsk",ptrTrama); // Disco
1855        par=copiaParametro("par",ptrTrama);
1856
1857        sprintf(interface,"%s/%s",pathinterface,nfn);
1858        sprintf(sftsrc,"/tmp/CSft-%s-%s",IPlocal,par); // Nombre que tendra el archivo de inventario
1859        sprintf(parametros,"%s %s %s %s",nfn,dsk,par,sftsrc);
1860
1861        herror=interfaceAdmin(interface,parametros,NULL);
1862        herror=0;
1863        if(herror){
1864                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1865                errorInfo(modulo,msglog);
1866                muestraMensaje(20,NULL);
1867        }
1868        else{
1869                /* Envía fichero de inventario al servidor */
1870                sprintf(sftdst,"/tmp/Ssft-%s-%s",IPlocal,par); // Nombre que tendra el archivo en el Servidor
1871                initParametros(ptrTrama,0);
1872
1873                sprintf(ptrTrama->parametros,"nfn=recibeArchivo\rnfl=%s\r",sftdst);
1874                if(!enviaMensajeServidor(&socket_c,ptrTrama,MSG_COMANDO)){
1875                        errorLog(modulo,42,FALSE);
1876                        liberaMemoria(dsk);
1877                        liberaMemoria(par);                             
1878                        return(FALSE);
1879                }
1880                /* Espera señal para comenzar el envío */
1881                liberaMemoria(ptrTrama);
1882                if(!recibeFlag(&socket_c,ptrTrama)){
1883                        errorLog(modulo,17,FALSE);
1884                }
1885                /* Envía archivo */
1886                if(!sendArchivo(&socket_c,sftsrc)){
1887                        errorLog(modulo,57, FALSE);
1888                        herror=12; // Error de envío de fichero por la red
1889                }
1890                close(socket_c);
1891                muestraMensaje(19,NULL);
1892        }
1893        initParametros(ptrTrama,0);
1894        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_InventarioSoftware");
1895        lon+=sprintf(ptrTrama->parametros+lon,"par=%s\r",par);
1896        lon+=sprintf(ptrTrama->parametros+lon,"sft=%s\r",sftdst);
1897        if(!sw)
1898                respuestaEjecucionComando(ptrTrama,herror,"0");
1899
1900        liberaMemoria(dsk);
1901        liberaMemoria(par);                     
1902        return(TRUE);
1903}
1904// ________________________________________________________________________________________________________
1905// Función: EjecutarScript
1906//
1907//      Descripción:
1908//              Ejecuta código de script
1909//      Parámetros:
1910//              ptrTrama: contenido del mensaje
1911//      Devuelve:
1912//              TRUE: Si el proceso es correcto
1913//              FALSE: En caso de ocurrir algún error
1914//______________________________________________________________________________________________________
1915BOOLEAN EjecutarScript(TRAMA* ptrTrama)
1916{
1917        int lon;
1918        char *nfn,*aux,*ids,*scp,*cfg,msglog[LONSTD];
1919        char modulo[] = "EjecutarScript()";
1920
1921        if (ndebug>=DEBUG_MAXIMO) {
1922                sprintf(msglog, "%s:%s",tbMensajes[21],modulo);
1923                infoDebug(msglog);
1924        }
1925        aux=copiaParametro("scp",ptrTrama);
1926        scp=URLDecode(aux);
1927        muestraMensaje(8,NULL);
1928        /* Nombre del archivo de script */
1929        char filescript[LONPRM];
1930        sprintf(filescript,"/tmp/_script_%s",IPlocal);
1931        escribeArchivo(filescript,scp);
1932        nfn=copiaParametro("nfn",ptrTrama);
1933        sprintf(interface,"%s/%s",pathinterface,nfn);
1934        sprintf(parametros,"%s %s",nfn,filescript);
1935        herror=interfaceAdmin(interface,parametros,NULL);
1936        if(herror){
1937                sprintf(msglog,"%s:%s",tbErrores[86],nfn);
1938                errorInfo(modulo,msglog);
1939                muestraMensaje(21,NULL);
1940        }
1941        else
1942                muestraMensaje(22,NULL);
1943
1944        // Toma configuración de particiones
1945        cfg=LeeConfiguracion();
1946        if(!cfg){ // No se puede recuperar la configuración del cliente
1947                errorLog(modulo,36,FALSE);
1948                herror=36;
1949        }
1950
1951        ids=copiaParametro("ids",ptrTrama);
1952
1953        //herror=ejecutarCodigoBash(scp);
1954        initParametros(ptrTrama,0);
1955        lon=sprintf(ptrTrama->parametros,"nfn=%s\r","RESPUESTA_EjecutarScript");
1956        lon+=sprintf(ptrTrama->parametros+lon,"cfg=%s\r",cfg); // Configuración de los Sistemas Operativos del cliente
1957        respuestaEjecucionComando(ptrTrama,herror,ids);
1958       
1959        liberaMemoria(nfn);
1960        liberaMemoria(ids);             
1961        liberaMemoria(aux);             
1962        liberaMemoria(scp);     
1963        liberaMemoria(cfg);
1964
1965        muestraMenu();
1966
1967        return(TRUE);
1968}
1969//______________________________________________________________________________________________________
1970// Función: respuestaEjecucionComando
1971//
1972//      Descripción:
1973//              Envia una respuesta a una ejecucion de comando al servidor de Administración
1974//      Parámetros:
1975//              - ptrTrama: contenido del mensaje
1976//              - res: Resultado de la ejecución (Código de error devuelto por el script ejecutado)
1977//              - ids: Identificador de la sesion (En caso de no haber seguimiento es NULO)
1978//      Devuelve:
1979//              TRUE: Si el proceso es correcto
1980//              FALSE: En caso de ocurrir algún error
1981// ________________________________________________________________________________________________________
1982BOOLEAN respuestaEjecucionComando(TRAMA* ptrTrama,int res,char *ids)
1983{
1984        int lon;
1985        SOCKET socket_c;
1986        char modulo[] = "respuestaEjecucionComando()";
1987
1988        lon=strlen(ptrTrama->parametros);
1989        if(ids){ // Existe seguimiento
1990                lon+=sprintf(ptrTrama->parametros+lon,"ids=%s\r",ids); // Añade identificador de la sesión
1991        }
1992        if (res==0){ // Resultado satisfactorio
1993                lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","1");
1994                lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r","");
1995        }
1996        else{ // Algún error
1997                lon+=sprintf(ptrTrama->parametros+lon,"res=%s\r","2");
1998                if(res>MAXERRORSCRIPT)
1999                        lon+=sprintf(ptrTrama->parametros+lon,"der=%s (Error de script:%d)\r",tbErroresScripts[0],res);// Descripción del error
2000                else
2001                        lon+=sprintf(ptrTrama->parametros+lon,"der=%s\r",tbErroresScripts[res]);// Descripción del error
2002        }
2003        if(!(enviaMensajeServidor(&socket_c,ptrTrama,MSG_NOTIFICACION))){
2004                errorLog(modulo,44,FALSE);
2005                return(FALSE);
2006        }
2007
2008        close(socket_c);
2009        return(TRUE);
2010}
2011// ________________________________________________________________________________________________________
2012// Función: gestionaTrama
2013//
2014//      Descripción:
2015//              Procesa las tramas recibidas.
2016//      Parametros:
2017//              ptrTrama: contenido del mensaje
2018//      Devuelve:
2019//              TRUE: Si el proceso es correcto
2020//              FALSE: En caso de ocurrir algún error
2021// ________________________________________________________________________________________________________
2022BOOLEAN gestionaTrama(TRAMA *ptrTrama)
2023{
2024        int i, res;
2025        char *nfn;
2026        char modulo[] = "gestionaTrama()";
2027
2028        INTROaFINCAD(ptrTrama);
2029        nfn = copiaParametro("nfn", ptrTrama); // Toma nombre de función
2030        for (i = 0; i < MAXIMAS_FUNCIONES; i++) { // Recorre funciones que procesan las tramas
2031                res = strcmp(tbfuncionesClient[i].nf, nfn);
2032                if (res == 0) { // Encontrada la función que procesa el mensaje
2033                        liberaMemoria(nfn);
2034                        return(tbfuncionesClient[i].fptr(ptrTrama)); // Invoca la función
2035                }
2036        }
2037
2038        liberaMemoria(nfn);
2039
2040        /* Sólo puede ser un comando personalizado
2041        if (ptrTrama->tipo==MSG_COMANDO)
2042                return(Comando(ptrTrama));
2043         */
2044        errorLog(modulo, 18, FALSE);
2045        return (FALSE);
2046}
2047//________________________________________________________________________________________________________
2048//      Función: ejecutaArchivo
2049//
2050//      Descripción:
2051//              Ejecuta los comando contenido en un archivo (cada comando y sus parametros separados por un
2052//              salto de linea.
2053//      Parámetros:
2054//              filecmd: Nombre del archivo de comandos
2055//              ptrTrama: Puntero a una estructura TRAMA usada en las comunicaciones por red (No debe ser NULL)
2056//      Devuelve:
2057//              TRUE: Si el proceso es correcto
2058//              FALSE: En caso de ocurrir algún error
2059//________________________________________________________________________________________________________
2060BOOLEAN ejecutaArchivo(char* filecmd,TRAMA *ptrTrama)
2061{
2062        char* buffer,*lineas[MAXIMAS_LINEAS];
2063        int i,numlin;
2064        char modulo[] = "ejecutaArchivo()";
2065
2066        buffer=leeArchivo(filecmd);
2067        if(buffer){
2068                numlin = splitCadena(lineas, buffer, '@');
2069                initParametros(ptrTrama,0);
2070                for (i = 0; i < numlin; i++) {
2071                        if(strlen(lineas[i])>0){
2072                                strcpy(ptrTrama->parametros,lineas[i]);
2073                                strcat(ptrTrama->parametros,"\rMCDJ@"); // Fin de trama
2074                                if(!gestionaTrama(ptrTrama)){   // Análisis de la trama
2075                                        errorLog(modulo,39,FALSE);
2076                                        //return(FALSE);
2077                                }
2078                        }
2079                }
2080        }
2081        liberaMemoria(buffer);
2082        return(TRUE);
2083}
2084//______________________________________________________________________________________________________
2085// Función: enviaMensajeServidor
2086//
2087//      Descripción:
2088//              Envia un mensaje al servidor de Administración
2089//      Parámetros:
2090//              - socket_c: (Salida) Socket utilizado para el envío
2091//              - ptrTrama: contenido del mensaje
2092//              - tipo: Tipo de mensaje
2093//                              C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
2094//      Devuelve:
2095//              TRUE: Si el proceso es correcto
2096//              FALSE: En caso de ocurrir algún error
2097// ________________________________________________________________________________________________________
2098BOOLEAN enviaMensajeServidor(SOCKET *socket_c,TRAMA *ptrTrama,char tipo)
2099{
2100        int lon;
2101        char modulo[] = "enviaMensajeServidor()";
2102
2103        *socket_c=abreConexion();
2104        if(*socket_c==INVALID_SOCKET){
2105                errorLog(modulo,38,FALSE); // Error de conexión con el servidor
2106                return(FALSE);
2107        }
2108        ptrTrama->arroba='@'; // Cabecera de la trama
2109        strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14);   // identificador de la trama
2110        ptrTrama->tipo=tipo; // Tipo de mensaje
2111        lon=strlen(ptrTrama->parametros); // Compone la trama
2112        lon+=sprintf(ptrTrama->parametros+lon,"iph=%s\r",IPlocal);      // Ip del ordenador
2113        lon+=sprintf(ptrTrama->parametros+lon,"ido=%s\r",idordenador);  // Identificador del ordenador
2114        lon+=sprintf(ptrTrama->parametros+lon,"npc=%s\r",nombreordenador);      // Nombre del ordenador
2115        lon+=sprintf(ptrTrama->parametros+lon,"idc=%s\r",idcentro);     // Identificador del centro
2116        lon+=sprintf(ptrTrama->parametros+lon,"ida=%s\r",idaula);       // Identificador del aula
2117
2118        if (!mandaTrama(socket_c,ptrTrama)) {
2119                errorLog(modulo,26,FALSE);
2120                return (FALSE);
2121        }
2122        return(TRUE);
2123}
2124// ********************************************************************************************************
2125// PROGRAMA PRINCIPAL (CLIENTE)
2126// ********************************************************************************************************
2127int main(int argc, char *argv[])
2128{
2129        TRAMA *ptrTrama;
2130        char modulo[] = "main()";
2131
2132        ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
2133        if (ptrTrama == NULL) { // No hay memoria suficiente para el bufer de las tramas
2134                errorLog(modulo, 3, FALSE);
2135                exit(EXIT_FAILURE);
2136        }
2137        /*--------------------------------------------------------------------------------------------------------
2138                Validación de parámetros de ejecución y fichero de configuración
2139         ---------------------------------------------------------------------------------------------------------*/
2140        if (!validacionParametros(argc, argv,3)) // Valida parámetros de ejecución
2141                exit(EXIT_FAILURE);
2142
2143        if (!tomaConfiguracion(szPathFileCfg)) // Toma parametros de configuración
2144                exit(EXIT_FAILURE);
2145        /*--------------------------------------------------------------------------------------------------------
2146                Carga catálogo de funciones que procesan las tramas
2147         ---------------------------------------------------------------------------------------------------------*/
2148        int cf = 0;
2149
2150        strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_AutoexecCliente");
2151        tbfuncionesClient[cf++].fptr = &RESPUESTA_AutoexecCliente;
2152
2153        strcpy(tbfuncionesClient[cf].nf, "RESPUESTA_InclusionCliente");
2154        tbfuncionesClient[cf++].fptr = &RESPUESTA_InclusionCliente;
2155
2156        strcpy(tbfuncionesClient[cf].nf, "NoComandosPtes");
2157        tbfuncionesClient[cf++].fptr = &NoComandosPtes;
2158
2159        strcpy(tbfuncionesClient[cf].nf, "Actualizar");
2160        tbfuncionesClient[cf++].fptr = &Actualizar;
2161
2162        strcpy(tbfuncionesClient[cf].nf, "Purgar");
2163        tbfuncionesClient[cf++].fptr = &Purgar;
2164
2165        strcpy(tbfuncionesClient[cf].nf, "ConsolaRemota");
2166        tbfuncionesClient[cf++].fptr = &ConsolaRemota;
2167
2168        strcpy(tbfuncionesClient[cf].nf, "Sondeo");
2169        tbfuncionesClient[cf++].fptr = &Sondeo;
2170
2171        strcpy(tbfuncionesClient[cf].nf, "Arrancar");
2172        tbfuncionesClient[cf++].fptr = &Arrancar;
2173
2174        strcpy(tbfuncionesClient[cf].nf, "Apagar");
2175        tbfuncionesClient[cf++].fptr = &Apagar;
2176
2177        strcpy(tbfuncionesClient[cf].nf, "Reiniciar");
2178        tbfuncionesClient[cf++].fptr = &Reiniciar;
2179
2180        strcpy(tbfuncionesClient[cf].nf, "IniciarSesion");
2181        tbfuncionesClient[cf++].fptr = &IniciarSesion;
2182
2183        strcpy(tbfuncionesClient[cf].nf, "CrearImagen");
2184        tbfuncionesClient[cf++].fptr = &CrearImagen;
2185
2186        strcpy(tbfuncionesClient[cf].nf, "CrearImagenBasica");
2187        tbfuncionesClient[cf++].fptr = &CrearImagenBasica;
2188
2189        strcpy(tbfuncionesClient[cf].nf, "CrearSoftIncremental");
2190        tbfuncionesClient[cf++].fptr = &CrearSoftIncremental;
2191
2192        strcpy(tbfuncionesClient[cf].nf, "RestaurarImagen");
2193        tbfuncionesClient[cf++].fptr = &RestaurarImagen;
2194
2195        strcpy(tbfuncionesClient[cf].nf, "RestaurarImagenBasica");
2196        tbfuncionesClient[cf++].fptr = &RestaurarImagenBasica;
2197
2198        strcpy(tbfuncionesClient[cf].nf, "RestaurarSoftIncremental");
2199        tbfuncionesClient[cf++].fptr = &RestaurarSoftIncremental;
2200
2201
2202        strcpy(tbfuncionesClient[cf].nf, "Configurar");
2203        tbfuncionesClient[cf++].fptr = &Configurar;
2204
2205        strcpy(tbfuncionesClient[cf].nf, "EjecutarScript");
2206        tbfuncionesClient[cf++].fptr = &EjecutarScript;
2207
2208        strcpy(tbfuncionesClient[cf].nf, "InventarioHardware");
2209        tbfuncionesClient[cf++].fptr = &InventarioHardware;
2210
2211        strcpy(tbfuncionesClient[cf].nf, "InventarioSoftware");
2212        tbfuncionesClient[cf++].fptr = &InventarioSoftware;
2213
2214        /*--------------------------------------------------------------------------------------------------------
2215                Toma dirección IP del cliente   
2216         ---------------------------------------------------------------------------------------------------------*/
2217        if(!tomaIPlocal()){ // Error al recuperar la IP local
2218                errorLog(modulo,0,FALSE);
2219                exit(EXIT_FAILURE);
2220        }
2221        /*--------------------------------------------------------------------------------------------------------
2222                Inicio de sesión
2223         ---------------------------------------------------------------------------------------------------------*/
2224        infoLog(1); // Inicio de sesión
2225        infoLog(3); // Abriendo sesión en el servidor de Administración;               
2226        /*--------------------------------------------------------------------------------------------------------
2227                Inclusión del cliente en el sistema
2228         ---------------------------------------------------------------------------------------------------------*/
2229        if(!inclusionCliente(ptrTrama)){        // Ha habido algún problema al abrir sesión
2230                errorLog(modulo,0,FALSE);
2231                exit(EXIT_FAILURE);
2232        }
2233        infoLog(4); // Cliente iniciado
2234
2235        /*--------------------------------------------------------------------------------------------------------
2236                Procesamiento de la cache
2237         ---------------------------------------------------------------------------------------------------------*/
2238        infoLog(23); // Abriendo sesión en el servidor de Administración;
2239        if(!cuestionCache(cache)){
2240                errorLog(modulo,0,FALSE);
2241                exit(EXIT_FAILURE);
2242        }
2243        /*--------------------------------------------------------------------------------------------------------
2244                Ejecución del autoexec
2245         ---------------------------------------------------------------------------------------------------------*/
2246        if(atoi(idproautoexec)>0){  // Ejecución de procedimiento Autoexec
2247                infoLog(5);
2248                if(!autoexecCliente(ptrTrama)){  // Ejecución fichero autoexec
2249                        errorLog(modulo,0,FALSE);
2250                        exit(EXIT_FAILURE);
2251                }
2252        }
2253        /*--------------------------------------------------------------------------------------------------------
2254                Comandos pendientes
2255         ---------------------------------------------------------------------------------------------------------*/
2256        infoLog(6); // Procesa comandos pendientes
2257        if(!comandosPendientes(ptrTrama)){  // Ejecución de acciones pendientes
2258                errorLog(modulo,0,FALSE);
2259                exit(EXIT_FAILURE);
2260        }
2261        infoLog(7); // Acciones pendientes procesadas
2262        /*--------------------------------------------------------------------------------------------------------
2263                Bucle de recepción de comandos
2264         ---------------------------------------------------------------------------------------------------------*/
2265        muestraMenu();
2266        procesaComandos(ptrTrama); // Bucle para procesar comandos interactivos
2267        /*--------------------------------------------------------------------------------------------------------
2268                Fin de la sesión
2269         ---------------------------------------------------------------------------------------------------------*/
2270        exit(EXIT_SUCCESS);
2271}
Note: See TracBrowser for help on using the repository browser.