source: admin/Sources/Clients/ogAdmClient/sources/ogAdmClient.c @ 684b3e6

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 684b3e6 was 3a254b9, checked in by ramon <ramongomez@…>, 12 years ago

#579: Corregir fallos al comparar tamaños de cadenas.

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