source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ 81b4351

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 81b4351 was 81b4351, checked in by alonso <alonso@…>, 15 years ago

git-svn-id: https://opengnsys.es/svn/trunk@1073 a21b9725-9963-47de-94b9-378ad31fedc9

  • Property mode set to 100644
File size: 86.6 KB
Line 
1//****************************************************************************************************************************************************
2//      Aplicación OpenGNSys
3//      Autor: José Manuel Alonso.
4//      Licencia: Open Source
5//      Fichero: ogAdmClient.c
6//      Descripción:
7//              Este módulo de la aplicación OpenGNSys implementa las comunicaciones con el Cliente.
8// ****************************************************************************************************************************************************
9#include "ogAdmClient.h"
10#include "ogAdmLib.c"
11//______________________________________________________________________________________________________
12// Función: ValidacionParametros
13//
14//       Descripción:
15//              Valida que los parametros de ejecución del programa sean correctos
16//      Parámetros:
17//              - argc: Número de argumentos
18//              - argv: Puntero a cada argumento
19//      Devuelve:
20//              true si los argumentos pasados son correctos y false en caso contrario
21//      Especificaciones:
22//              La sintaxis de los argumentos es la siguiente
23//                      -f      Archivo de configuración del cliente
24//                      -l      Archivo de logs
25//                      -d      Nivel de debuger (Mensages que se escribirán en el archivo de logs)
26//______________________________________________________________________________________________________
27int ValidacionParametros(int argc,char*argv[])
28{
29        int i;
30
31        for(i = 1; i < argc; i++){
32                if (argv[i][0] == '-'){
33                        switch (tolower(argv[i][1])){
34                                case 'f':
35                                        if (argv[i+1]!=NULL)
36                                                strcpy(szPathFileCfg, argv[i+1]);
37                                        else
38                                                return(false);  // Error en el argumento archivo de configuración
39                                        break;
40                                case 'l':
41                                        if (argv[i+1]!=NULL)
42                                                strcpy(szPathFileLog, argv[i+1]);       // Error en el argumento archivo de log
43                                        else
44                                                return(false);
45                                        break;
46                                case 'd':
47                                        if (argv[i+1]!=NULL){
48                                                ndebug=atoi(argv[i+1]);
49                                                if(ndebug<1 )
50                                                ndebug=1;       // Por defecto el nivel de debug es 1
51                                        }
52                                        else
53                                                return(false); // Error en el argumento nivel de debug
54                                        break;
55                                default:
56                                        return(false);
57                                        break;
58                        }
59                }
60        }
61        return(true);
62}
63//______________________________________________________________________________________________________
64// Función: CrearArchivoLog
65//
66//       Descripción:
67//              Abre el archivo de log para añadir registros desde el principio y si no existe lo crea de nuevo
68//      Parámetros:
69//              - szPathFileLog:        Nombre del archivo
70//      Devuelve:
71//              true si la acción ha sido correcta y false en caso contrario
72//______________________________________________________________________________________________________
73int CrearArchivoLog(char* szPathFileLog)
74{       
75        return(true);
76        FILE* FLog;
77        FLog=fopen(szPathFileLog,"wt"); // Abre de log para escritura al comienzo
78        if(FLog!=NULL){
79                fclose(FLog);
80                return(true);
81        }
82        return(false);
83}
84//______________________________________________________________________________________________________
85// Función: LeeFileConfiguracion
86//
87//       Descripción:
88//              Lee el fichero de configuración y toma el valor de los parámetros de configuración
89//      Parámetros:
90//              Ninguno
91//      Devuelve:
92//              true si todos los parámetros de configuración son correctos y false en caso contrario
93//______________________________________________________________________________________________________
94int LeeFileConfiguracion()
95{
96        long lSize;
97        char * buffer,*lineas[100],*dualparametro[2];
98        char ch[2];
99        int i,numlin,resul;
100        FILE* Fsalida;
101       
102        if(szPathFileCfg==NULL) return(false); // Nombre del fichero de configuración erróneo
103
104        if(ndebug>5)
105                RegistraLog("Abre fichero de configuración", false);
106
107        Fsalida = fopen ( szPathFileCfg , "rb" );       // Abre  fichero de configuración
108        if (Fsalida==NULL)
109                return(false); // Error de apertura del fichero de configuración
110        fseek (Fsalida , 0 , SEEK_END);
111        lSize = ftell (Fsalida);        // Obtiene tamaño del fichero.
112        rewind (Fsalida);       // Coloca puntero de lectura al principio
113       
114        if(ndebug>5)
115                RegistraLog("Lee fichero de configuración", false);
116        buffer =(char*)ReservaMemoria(lSize);   // Toma memoria para el buffer de lectura.
117        if (buffer == NULL)
118                return(false); // Error de reserva de memoria para buffer de lectura
119        fread (buffer,1,lSize,Fsalida); // Lee contenido del fichero
120        fclose(Fsalida);
121
122        //inicializar variables globales
123        IPlocal[0]='\0';        // IP local
124        Servidorhidra[0]='\0';  // IP servidor de Administración
125        Puerto[0]='\0'; // Puerto de comunicaciones con el servidor de administración
126        HIDRACHEIMAGENES[0]='\0';       // Path al directorio donde están las imágenes (en la caché)
127        HIDRASRVIMAGENES[0]='\0';       // Path al directorio donde están las imágenes (en el repositorio)
128        HIDRASRVCMD[0]='\0';    // Path del directorio del repositorio donde se depositan los comandos para el cliente
129        HIDRASCRIPTS[0]='\0';   // Path al directorio donde estan los scripts de interface con la API de funciones
130       
131        strcpy(ch,"\n");        // Carácter delimitador (salto de linea)
132        numlin=split_parametros(lineas,buffer,ch); // Toma lineas del  fichero
133        if(ndebug>5)
134                RegistraLog("Lee parámetros del fichero de configuración", false);
135        for (i=0;i<numlin;i++){
136                strcpy(ch,"="); // Caracter delimitador
137                split_parametros(dualparametro,lineas[i],ch); // Toma nombre del parámetros
138                if(ndebug>5){
139                        sprintf(msglog," Parámetro %s del fichero de configuración",dualparametro[0]);
140                        RegistraLog(msglog,false);
141                        sprintf(msglog," Valor del parámetro %s del fichero de configuración:%s",dualparametro[0],dualparametro[0]);
142                        RegistraLog(msglog,false);
143                }
144                resul = strcmp(dualparametro[0], "ServerIP");
145                if (resul == 0)
146                        strcpy(Servidorhidra, dualparametro[1]);
147
148                resul = strcmp(dualparametro[0], "Puerto");
149                if (resul == 0)
150                        strcpy(Puerto, dualparametro[1]);
151
152                resul = strcmp(dualparametro[0], "ClientScripts");
153                if (resul == 0)
154                        strcpy(HIDRASCRIPTS, dualparametro[1]);
155
156                resul = strcmp(dualparametro[0], "UrlMenu");
157                if (resul == 0)
158                        strcpy(URLMENU, dualparametro[1]);
159
160                resul = strcmp(dualparametro[0], "UrlMsg");
161                if (resul == 0)
162                        strcpy(URLMSG, dualparametro[1]);
163        }
164        if (Servidorhidra[0] == '\0') {
165                        RegistraLog("ServerIP, NO se ha definido este parámetro", false);
166                        return (FALSE);
167        }
168        if (Puerto[0] == '\0') {
169                        RegistraLog("Puerto, NO se ha definido este parámetro", false);
170                        return (FALSE);
171        }
172        if (HIDRASCRIPTS[0] == '\0') {
173                        RegistraLog("HIDRASCRIPTS, NO se ha definido este parámetro", false);
174                        return (FALSE);
175        }
176        if (URLMENU[0] == '\0') {
177                        RegistraLog("URLMENU, NO se ha definido este parámetro", false);
178                        return (FALSE);
179        }
180        if (URLMSG[0] == '\0') {
181                        RegistraLog("URLMSG, NO se ha definido este parámetro", false);
182                        return (FALSE);
183        }
184        return(true);
185}
186
187//______________________________________________________________________________________________________
188// Función: UltimoError
189//
190//       Descripción:
191//              Almacena el último error producido y lo registra en el log
192//      Parámetros:
193//              - herror: Código del error
194//              - modulo: Función donde se produjo el error
195//______________________________________________________________________________________________________
196void UltimoError(int herror,char*modulo)
197{
198        e.herror=herror;
199        if(herror>MAXERROR){
200                strcpy(e.msg,tbErrores[MAXERROR]);
201        }
202        else
203                strcpy(e.msg,tbErrores[herror]);       
204        strcpy(e.modulo,modulo);       
205        sprintf(msglog,"Error en el Servicio: %d.-(%s) en modulo %s",e.herror,e.msg,e.modulo);
206        RegistraLog(msglog,false);
207}
208
209//______________________________________________________________________________________________________
210// Función: UltimoErrorScript
211//
212//       Descripción:
213//              Almacena el último error producido al ejecutar un script de la API y lo registra en el log
214//      Parámetros:
215//              - herror: Código del error
216//              - modulo: Función donde se produjo el error
217//______________________________________________________________________________________________________
218void UltimoErrorScript(int herror,char*modulo)
219{
220        e.herror=herror;
221        if(herror>MAXERRORSCRIPT){
222                strcpy(e.msg,tbErroresScripts[MAXERRORSCRIPT]);
223        }
224        else
225                strcpy(e.msg,tbErroresScripts[herror]);
226        strcpy(e.modulo,modulo);       
227        sprintf(msglog,"Error al ejecutar Script %d.-(%s) en modulo %s",e.herror,e.msg,e.modulo);
228        RegistraLog(msglog,false);
229}
230
231
232//______________________________________________________________________________________________________
233// Función: EjecutarCodigo
234//
235//       Descripción:
236//              Ejecuta un script de la shell creando un proceso hijo para ello
237//      Parámetros:
238//              - script: Nombre del script de la  shell
239//              - parametros: Parámetros que se le pasarán al script
240//              - salida: Recoge la salida por pantalla que genera el script
241//              - swasci: Filtra la respuesta del script:
242//                                       true=Elimina de la respuesta caracteres menores de asci 32
243//                                       false= No los elimina                                 
244//      Devuelve:
245//              Código de error de la ejecución. ( Ver tabla de código de errores en la documentación)
246//      Especificaciones:
247//              El parámetro salida recoge la salida por pantalla que se genera en la ejecución del script siempre que
248//              sea disinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
249//______________________________________________________________________________________________________
250int EjecutarCodigo ( char *script,char * parametros,char *salida,int swasci)
251{
252        int  descr[2];  /* Descriptores de E y S de la turbería */
253        int  bytesleidos;       /* Bytes leidos en el mensaje */
254        int resul;
255        int estado;     
256        pid_t  pid;
257        char buffer[512];
258        pipe (descr);
259        int i,nargs;
260   
261        if(ndebug>2){
262                sprintf(msglog,"Ejecución del script: %s",script);
263                RegistraLog(msglog,false);
264        }
265       
266        nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
267        for(i=nargs;i<MAXARGS;i++){
268                argumentos[i]=NULL;
269        }
270   
271        if(ndebug>2){
272                for(i=0;i<nargs;i++){
273                        sprintf(msglog,"Parámetro %d del script: %s",i,argumentos[i]);
274                        RegistraLog(msglog,false);
275                }
276        }
277       
278        if((pid=fork())==0){
279                /* Proceso hijo que ejecuta el script */
280                close (descr[LEER]);
281                dup2 (descr[ESCRIBIR], 1);
282                close (descr[ESCRIBIR]);
283                resul=execv(script,argumentos);
284                //resul=execlp (script, script, argumentos[0],argumentos[1],NULL);   
285                exit(resul);   
286        }
287        else {
288                if (pid ==-1){
289                        sprintf(msglog,"***Error en la creación del proceso hijo pid=%d",pid);
290                        RegistraLog(msglog,false);
291                        return(-1);
292                }
293                /* Proceso padre que lee la salida del script */
294                close (descr[ESCRIBIR]);
295                bytesleidos = read (descr[LEER], buffer, 512);
296                while(bytesleidos>0){
297                        if(salida!=(char*)NULL){ // Si se solicita retorno de información...                   
298                                buffer[bytesleidos]='\0';
299                                for(i=bytesleidos-1;i>=0;i--){
300                                        if(buffer[i]<32 && swasci) // Caracter Asci menor de 32
301                                                buffer[i]='\0';
302                                }
303                                strcat(salida,buffer);
304                        }
305                        bytesleidos = read (descr[LEER], buffer, 512);
306                }
307                close (descr[LEER]);
308                if(ndebug>2){
309                        sprintf(msglog,"Información devuelta %s",salida);
310                        RegistraLog(msglog,false);
311                }
312                //kill(pid,SIGQUIT);
313                waitpid(pid,&estado,0); 
314                resul=WEXITSTATUS(estado);
315                if(ndebug>2){
316                        sprintf(msglog,"Estatus de finalización del script:%d",resul);
317                        RegistraLog(msglog,false);
318                }   
319                return(resul);
320        }
321        return(-1);
322}
323//______________________________________________________________________________________________________
324// Función: EjecutarScript
325//
326//       Descripción:
327//              Ejecuta un script de la shell creando un proceso hijo para ello
328//      Parámetros:
329//              - script: Nombre del script de la  shell
330//              - parametros: Parámetros que se le pasarán al script
331//              - salida: Recoge la salida por pantalla que genera el script
332//              - swasci: Filtra la respuesta del script:
333//                                       true=Elimina de la respuesta caracteres menores de asci 32
334//                                       false= No los elimina                                 
335//      Devuelve:
336//              Código de error de la ejecución. ( Ver tabla de código de errores en la documentación)
337//      Especificaciones:
338//              El parámetro salida recoge la salida desde un fichero que se genera en la ejecución del script siempre que
339//              sea distinto de NULL, esto es, si al llamar a la función este parámetro es NULL no se recogerá dicha salida.
340//______________________________________________________________________________________________________
341int EjecutarScript ( char *script,char * parametros,char *salida,int swasci)
342{
343        int  descr[2];  /* Descriptores de E y S de la turbería */
344        int resul,bytesleidos,estado;   
345        pid_t  pid;
346        pipe (descr);
347        int i,nargs;
348    FILE *Fretorno;
349    char buffer[512];
350   
351        if(ndebug>2){
352                sprintf(msglog,"Ejecución del script: %s",script);
353                RegistraLog(msglog,false);
354        }
355       
356        nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
357        for(i=nargs;i<MAXARGS;i++){
358                argumentos[i]=NULL;
359        }
360        if(ndebug>2){
361                for(i=0;i<nargs;i++){
362                        sprintf(msglog,"Parámetro %d del script: %s",i,argumentos[i]);
363                        RegistraLog(msglog,false);
364                }
365        }
366        if(salida!=(char*)NULL){ // Si se solicita retorno de información...
367                Fretorno = fopen("/tmp/retorno","w" );
368                if (Fretorno==NULL){
369                        return(8); // Error en la eliminación del archivo temporal de intercambio"
370                }
371                fclose(Fretorno);
372        }       
373        if((pid=fork())==0){
374                /* Proceso hijo que ejecuta el script */
375                close (descr[LEER]);
376                dup2 (descr[ESCRIBIR], 1);
377                close (descr[ESCRIBIR]);
378                resul=execv(script,argumentos);
379                //resul=execlp (script, script, argumentos[0],argumentos[1],NULL);   
380                exit(resul);   
381        }
382        else {
383                if (pid ==-1){
384                        sprintf(msglog,"***Error en la creación del proceso hijo pid=%d",pid);
385                        RegistraLog(msglog,false);
386                        return(-1);
387                }
388                /* Proceso padre que lee la salida del script */
389                close (descr[ESCRIBIR]);
390                bytesleidos = read (descr[LEER], buffer, 512);
391                while(bytesleidos>0){
392                        bytesleidos = read (descr[LEER], buffer, 512);
393                }
394                close (descr[LEER]);
395                if(salida!=(char*)NULL){ // Si se solicita retorno de información...                   
396                        FILE *Fretorno = fopen("/tmp/retorno","rb" );
397                        long lSize;
398                        if (Fretorno!=NULL){
399                                fseek (Fretorno , 0 , SEEK_END);  // Obtiene tamaño del fichero.
400                                lSize = ftell (Fretorno);
401                                rewind (Fretorno);
402                                if(lSize>LONGITUD_SCRIPTSALIDA){
403                                        lSize=LONGITUD_SCRIPTSALIDA;
404                                        RegistraLog("***Aviso, la información de salida excede de la longitud permitida. Puede haberse truncado",false);
405                                }
406                                fread (salida,1,lSize,Fretorno);        // Lee contenido del fichero
407                                for(i=lSize-1;i>=0;i--){
408                                        if(salida[i]<32 && swasci) // Caracter Asci menor de 32
409                                        salida[i]='\0';
410                                }
411                                fclose(Fretorno);
412                        }
413                        else
414                                return(9); // Error en la eliminación del archivo temporal de intercambio"
415                       
416                }
417
418                if(ndebug>2){
419                        sprintf(msglog,"Información devuelta %s",salida);
420                        RegistraLog(msglog,false);
421                }
422                //kill(pid,SIGQUIT);
423                waitpid(pid,&estado,0); 
424                resul=WEXITSTATUS(estado);
425                if(ndebug>2){
426                        sprintf(msglog,"Estatus de finalización del script:%d",resul);
427                        RegistraLog(msglog,false);
428                }   
429                return(resul);
430                }
431        return(-1);
432}
433//______________________________________________________________________________________________________
434// Función: ReservaMemoria
435//
436//       Descripción:
437//              Reserva memoria para una variable
438//      Parámetros:
439//              - lon:  Longitud en bytes de la reserva
440//      Devuelve:
441//              Un puntero a la zona de memoria reservada que ha sido previamente rellena con ceros o nulos
442//______________________________________________________________________________________________________
443char* ReservaMemoria(int lon)
444{
445        char *mem;
446        mem=(char*)malloc(lon);
447        if(mem!=NULL)
448                memset(mem,0,lon);
449        return(mem);
450}
451//______________________________________________________________________________________________________
452// Función: TCPConnect
453//
454//       Descripción:
455//              Crea un socket y lo conecta a un servidor
456//      Parámetros:
457//              - ips : La Dirección IP del servidor
458//              - port : Puerto para la comunicación
459//      Devuelve:
460//              Un socket para comunicaciones por protocolo TCP
461//______________________________________________________________________________________________________
462SOCKET TCPConnect(char *ips,char* port)
463{
464        SOCKET s;
465    struct sockaddr_in server;
466
467        s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
468        if (s == INVALID_SOCKET){
469                return (INVALID_SOCKET);
470        }
471        server.sin_family = AF_INET;
472        server.sin_port = htons((short)atoi(port));
473        server.sin_addr.s_addr = inet_addr(ips);
474
475        if (connect(s, (struct sockaddr *)&server, sizeof(server)) == INVALID_SOCKET)
476                return (INVALID_SOCKET);
477               
478        return(s);
479}
480//______________________________________________________________________________________________________
481// Función: TCPClose
482//
483//       Descripción:
484//              Cierra una conexión establecida a través de un socket
485//      Parámetros:
486//              - s : El socket que implementa la conexión
487//______________________________________________________________________________________________________
488void TCPClose(SOCKET s){
489        close(s);
490}
491//______________________________________________________________________________________________________
492// Función: AbreConexionTCP
493//
494//       Descripción:
495//              Abre la conexión entre el cliente y el  servidor de administración
496//      Parámetros:
497//       Ninguno
498//      Devuelve:
499//              True si abre la conexión o false en caso contrario.
500//______________________________________________________________________________________________________
501int AbreConexionTCP()
502{
503        BOOLEAN swloop=true;
504        int vez=0;             
505
506        while(swloop){                 
507                sock=TCPConnect(Propiedades.servidorhidra,Propiedades.puerto);
508                if(sock!= INVALID_SOCKET){
509                        return(true);
510                }
511                if(swloop){
512                        vez++;
513                        if (vez>MAXCNX){
514                                swloop=false;
515                                UltimoError(2,"AbreConexionTCP()");
516                                return(false); 
517                        }
518                }
519                sleep(5); // Espera dos cinco antes de intentar una nueva conexión con el Servidor de Administración
520        }
521        return(true);
522}
523//______________________________________________________________________________________________________
524// Función: CierraConexionTCP
525//
526//       Descripción:
527//              Cierra la conexión entre el cliente y el  servidor de administración
528//      Parámetros:
529//       Ninguno
530//______________________________________________________________________________________________________
531void CierraConexionTCP()
532{
533        TCPClose(sock);
534}
535//______________________________________________________________________________________________________
536// Función: EnviaTramasHidra
537//
538//       Descripción:
539//              Envía una trama TCP al Servidor de Administración
540//      Parámetros:
541//              s: socket TCP
542//              trama: contenido a  enviar
543//      Devuelve:
544//              true si el envío ha sido correcto o false en caso contrario
545//______________________________________________________________________________________________________
546int EnviaTramasHidra(SOCKET s,TRAMA *trama)
547{
548        int lon;
549       
550        trama->arroba='@';      // cabecera de la trama
551        strcpy(trama->identificador,"JMMLCAMDJ");       // identificador de la trama
552        trama->ejecutor='1';    // Origen del envío  1=el servidor de administración  2=el cliente  3=el repositorio de imágenes
553                               
554        lon=strlen(trama->parametros);  // Compone la trama
555        lon+=sprintf(trama->parametros+lon,"iph=%s\r",Propiedades.IPlocal);     // Ip del ordenador
556        lon+=sprintf(trama->parametros+lon,"ido=%s\r",Propiedades.idordenador); // Identificador del ordenador
557        return(TCPWrite(s,trama));
558}
559
560//______________________________________________________________________________________________________
561// Función: TCPWrite
562//
563//       Descripción:
564//              Envia una trama por la red (TCP)
565//      Parámetros:
566//              s: socket TCP
567//              trama: contenido a  enviar
568//      Devuelve:
569//              true si el envío ha sido correcto o false en caso contrario
570//______________________________________________________________________________________________________
571int TCPWrite(SOCKET s,TRAMA* trama)
572{
573        int nLeft,idx,ret;
574       
575        Encriptar((char*)trama);
576        nLeft = strlen((char*)trama);
577        idx = 0;
578        while(nLeft > 0){
579                ret = send(s,(char*)&trama[idx], nLeft, 0);
580                if (ret == 0)
581                        break;
582                else
583                        if (ret == SOCKET_ERROR){
584                                return(false);
585                        }
586                nLeft -= ret;
587                idx += ret;
588        }
589        return(true);
590}
591
592//______________________________________________________________________________________________________
593// Función: UDPConnect
594//
595//       Descripción:
596//              Crea un socket UDP para la comunicación con su repositorio
597//      Parámetros:
598//              Ninguno
599//      Devuelve:
600//              Un socket para comunicaciones por protocolo UDP
601//______________________________________________________________________________________________________
602SOCKET UDPConnect()
603{
604        SOCKET socket_c;
605
606        socket_c = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
607        if (socket_c == SOCKET_ERROR)
608                return (INVALID_SOCKET);
609        return(socket_c);
610}
611//______________________________________________________________________________________________________
612// Función: EnviaTramaRepo
613//
614//       Descripción:
615//              Envía una trama UDP a su repositorio de imágenes
616//      Parámetros:
617//              s: socket UDP
618//              trama: contenido a  enviar
619//              iprepo: Dirección IP del repositorio
620//              puertorepo: Puerto de destino donde el repositorio espera la trama
621//      Devuelve:
622//              true si el envío ha sido correcto o false en caso contrario
623//______________________________________________________________________________________________________
624int EnviaTramaRepo(SOCKET s,TRAMA* trama, char* iprepo,char *puertorepo)
625{
626        int ret,lon;
627        struct sockaddr_in  addrRepo;
628         
629        trama->arroba='@';      // cabecera de la trama
630        strcpy(trama->identificador,"JMMLCAMDJ");       // identificador de la trama
631        trama->ejecutor='2';    // Origen del envío  1=el servidor  2=el cliente  3=el repositorio de imágenes
632                               
633        lon=strlen(trama->parametros);  // Compone la trama
634        lon+=sprintf(trama->parametros+lon,"iph=%s\r",Propiedades.IPlocal);     // Ip local del ordenador
635        lon+=sprintf(trama->parametros+lon,"ido=%s\r",Propiedades.idordenador); // identificador del ordenador
636       
637        addrRepo.sin_family = AF_INET;
638    addrRepo.sin_port = htons((short)atoi(puertorepo)); //  Puerto del repositorio
639    addrRepo.sin_addr.s_addr = inet_addr(iprepo); //  Dirección IP del repositorio
640       
641        Encriptar((char*)trama); // Encripta la trama
642        ret = sendto(s,(char *)trama,lon+11,0,(struct sockaddr *)&addrRepo, sizeof(addrRepo));
643    if (ret == SOCKET_ERROR)
644                return(false);
645        return true;
646}
647//______________________________________________________________________________________________________
648// Función: RecibeTramaRepo
649//
650//       Descripción:
651//              Recibe una trama UDP por la red
652//      Parámetros:
653//              s: socket UDP con el que se envío anteriormente una trama al repositorio
654//              sw: Si es true se desencripta la trama, en caso contrario no
655//      Devuelve:
656//              true si la receción ha sido correcta o false en caso contrario
657//______________________________________________________________________________________________________
658int RecibeTramaRepo(SOCKET s,int sw)
659{
660        int ret;
661        struct sockaddr_in addrRepo;
662       
663        socklen_t iAddrSize = sizeof(addrRepo);
664        ret = recvfrom(s,(char *)trama, LONGITUD_TRAMA,0,(struct sockaddr *)&addrRepo,&iAddrSize);
665        if (ret != SOCKET_ERROR){
666                if(sw)
667                        Desencriptar((char*)trama);     // Desencripta la trama
668                return(true);
669        }
670        return(false);
671}
672//______________________________________________________________________________________________________
673// Función: CreateTextFile
674//
675//      Descripción:
676//              Crea un fichero de texto local y escribe en él cierto contenido
677//      Parámetros:
678//              - nomfile: Nombre del fichero
679//              - texto: Texto a escribir en el fichero
680//      Devuelve:
681//              - La longitud en bytes del contenido escrito
682//______________________________________________________________________________________________________
683long CreateTextFile(char *nomfile,char *texto)
684{
685        long lSize;
686        FILE *f;
687        f = fopen(nomfile,"wt");
688        if(!f){ // El fichero por algún motivo no ha podido crearse
689                UltimoError(3,"CreateTextFile()");
690                return(0);
691        }
692        lSize=strlen(texto);
693        fwrite(texto,1,lSize,f);        // Escribe el contenido del fichero
694        fclose(f);
695        return(lSize);
696}
697//______________________________________________________________________________________________________
698// Función: ExisteFichero
699//
700//      Descripción:
701//              Comprueba si un archivo existe en su repositorio
702//      Parámetros:
703//              - nomfile : Nombre del fichero
704//      Devuelve:
705//              true si el archivo existe o false en caso contrario
706// ________________________________________________________________________________________________________
707int ExisteFichero(char *nomfile)
708{
709        SOCKET udpsock;
710        int res;
711       
712        udpsock=UDPConnect();
713        if (udpsock == INVALID_SOCKET){
714                UltimoError(15,"ExisteFichero()");
715                return(false);
716        }
717        sprintf(trama->parametros,"nfn=ExisteFichero\rnfl=%s\r",nomfile);       // Nombre de la función a ejecutar en el  servidor de administración
718        if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
719                res=RecibeTramaRepo(udpsock,TRUE);
720                close(udpsock);
721                if(res)
722                        return(GestionTramas(trama));
723        }
724        else{
725                UltimoError(16,"ExisteFichero()");
726                return(false);
727        }
728        return(true);
729}
730//______________________________________________________________________________________________________
731// Función: RemoveFile
732//
733//      Descripción:
734//              Elimina un fichero del repositorio
735//      Parámetros:
736//              - nomfile : Nombre del fichero
737//      Devuelve:
738//              true si el archivo se ha eliminado correctamente o false en caso contrario
739// ________________________________________________________________________________________________________
740int RemoveFile(char *nomfile)
741{
742        SOCKET udpsock;
743        int res;
744       
745        udpsock=UDPConnect();
746        if (udpsock == INVALID_SOCKET){
747                UltimoError(15,"RemoveFile()");
748                return(false);
749        }
750        sprintf(trama->parametros,"nfn=EliminaFichero\rnfl=%s\r",nomfile);      // Nombre de la función a ejecutar en el  servidor de administración
751        if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
752                res=RecibeTramaRepo(udpsock,TRUE);
753                close(udpsock);
754                if(res)
755                        return(GestionTramas(trama));
756        }
757        else{
758                UltimoError(16,"RemoveFile()");
759                return(false);
760        }
761        return(true);
762}
763//______________________________________________________________________________________________________
764// Función: LoadTextFile
765//
766//      Descripción:
767//              Lee un fichero del repositorio
768//      Parámetros:
769//              - nomfile : Nombre del fichero
770//      Devuelve:
771//              true si el proceso es correcto y false en caso contrario
772//      Especificaciones:
773//              En los parametros de la trama se copian el contenido del del archivo de comandos               
774// ________________________________________________________________________________________________________
775int LoadTextFile(char *nomfile)
776{
777        SOCKET udpsock;
778        int res;
779        char *txt;
780               
781        udpsock=UDPConnect();
782        if (udpsock == INVALID_SOCKET){
783                UltimoError(15,"LoadTextFile()");
784                return(false);
785        }
786        sprintf(trama->parametros,"nfn=LeeFicheroTexto\rnfl=%s\r",nomfile);     // Nombre de la función a ejecutar en el  servidor de administración
787        if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
788                res=RecibeTramaRepo(udpsock,TRUE);
789                close(udpsock);
790                if(res){
791                        if(GestionTramas(trama)){
792                                txt=toma_parametro("txt",trama->parametros); // Toma contenido del fichero de  comandos
793                                strcpy(trama->parametros,txt);
794                                if(ndebug>4){
795                                        sprintf(msglog,"Archivo de comando:\r%s",trama->parametros);
796                                        RegistraLog(msglog,false);
797                                }
798                                return(true); // Devuelve contrenido del fichero
799                        }
800                        else{
801                                UltimoError(3,"LoadTextFile()");
802                                return(false);                         
803                        }
804                }
805                else{
806                        UltimoError(16,"LoadTextFile()");
807                        return(false);
808                }                               
809        }
810        else{
811                UltimoError(16,"LoadTextFile()");
812                return(false);
813        }
814}
815//______________________________________________________________________________________________________
816// Función: recibeFichero
817//
818//      Descripción:
819//              Se trae un fichero del repositorio y lo coloca en el diretorio /tmp
820//      Parámetros:
821//              - nomfilesrc : Nombre completo del fichero fuente
822//      - nomfiledst : Nombre completo del fichero destino
823//      Devuelve:
824//              true si el proceso es correcto y false en caso contrario
825//      Especificaciones:
826//              En los parametros de la trama se copian el contenido del del archivo de comandos
827// ________________________________________________________________________________________________________
828int recibeFichero(char *nomfilesrc, char *nomfiledst)
829{
830        SOCKET udpsock;
831        int blk,lsize,res;
832        char *b,*l;
833        FILE *f;
834
835        udpsock=UDPConnect();
836        if (udpsock == INVALID_SOCKET){
837                UltimoError(15,"recibeFichero()");
838                return(false);
839        }
840
841        f=fopen(nomfiledst,"wb");
842        if(!f){
843                RegistraLog("*** No se ha podido crear archivo",false);
844                return(false);
845        }
846
847        sprintf(trama->parametros,"nfn=mandaFichero\rnfl=%s\r",nomfilesrc);     // Nombre de la función a ejecutar en el  servidor de administración
848        if(EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo)){
849                b=&trama->arroba; // Puntero al comienzo de la trama para colocar el bloque leido
850                l=b+sizeof(blk); // Puntero después del dato bloque para colocar los bytes leidos
851                do{
852                        res=RecibeTramaRepo(udpsock,FALSE);
853                        if(res){
854                                memcpy(&blk,b,sizeof(blk));
855                                memcpy(&lsize,l,sizeof(lsize));
856                                if(lsize>0)
857                                        lsize=fwrite (trama->parametros,1,lsize,f); // Escribe contenido en el fichero
858                                else{
859                                        fclose(f);
860                                        close(udpsock);
861                                        return(true);
862                                }
863                        }
864                        else{
865                                RegistraLog("*** Error de recepción de archivo",false);
866                                break;
867                        }
868                        EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo); // Confirmación;
869                }while(lsize>0);
870                fclose(f);
871        }
872        else{
873                UltimoError(16,"recibeFichero()");
874                fclose(f);
875                return(false);
876        }
877        close(udpsock);
878        return(true);
879}
880//______________________________________________________________________________________________________
881// Función: sesionMulticast
882//
883//      Descripción:
884//              Notifica a su repositorio que esta preparado para recibir datos por multicast
885//      Parámetros:
886//              - nipes : Número de ordenadores necesarios para comenzar la sesión
887//      Devuelve:
888//              true si el archivo existe o false en caso contrario
889// ________________________________________________________________________________________________________
890int sesionMulticast(char *fileimg,char *nipes,char *ide)
891{
892        SOCKET udpsock;
893        int res,lon;
894
895        udpsock=UDPConnect();
896        if (udpsock == INVALID_SOCKET){
897                UltimoError(15,"sesionMulticast()");
898                return(false);
899        }
900        int modo=atoi(Propiedades.modmulticast);
901
902        lon = sprintf(trama->parametros, "nfn=sesionMulticast\r");
903        lon += sprintf(trama->parametros + lon, "img=%s\r", fileimg);
904        lon += sprintf(trama->parametros + lon, "ipm=%s\r", Propiedades.ipmulticast);
905        lon += sprintf(trama->parametros + lon, "pom=%s\r", Propiedades.pormulticast);
906        lon += sprintf(trama->parametros + lon, "mom=%s\r", tbmodmul[modo]);
907        lon += sprintf(trama->parametros + lon, "vlm=%s\r", Propiedades.velmulticast);
908        lon += sprintf(trama->parametros + lon, "iph=%s\r", Propiedades.IPlocal);
909        lon += sprintf(trama->parametros + lon, "nip=%s\r", nipes);
910        lon += sprintf(trama->parametros + lon, "ide=%s\r", ide);
911
912        res=EnviaTramaRepo(udpsock,trama,Propiedades.iprepo,Propiedades.puertorepo);
913        close(udpsock);
914        if(!res)
915                UltimoError(16,"sesionMulticast()");
916        return(res);
917}
918//______________________________________________________________________________________________________
919// Función: ProcesaComandos
920//
921//      Descripción:
922//              Espera comando desde el Servidor de Administración para ejecutarlos
923//      Parámetros:
924//              Ninguno
925//      Devuelve:
926//              true si el archivo se ha eliminado correctamente o false en caso contrario
927// ________________________________________________________________________________________________________
928int ProcesaComandos()
929{
930        int lon;
931
932        while(TRUE){
933                lon=sprintf(trama->parametros,"nfn=DisponibilidadComandos\r");
934                lon+=sprintf(trama->parametros+lon,"swd=1\r");  // Disponible
935
936                if(AbreConexionTCP()){
937                        if(!EnviaTramasHidra(sock,trama)){
938                                UltimoError(21,"ProcesaComandos()"); // No se pudo enviar trama
939                                return(false);
940                        }
941                        if(!recibe_tramas(sock,trama)){
942                                UltimoError(22,"ProcesaComandos()"); // No se pudo recuperar trama
943                                return(false);
944                        }
945                        CierraConexionTCP();
946                        GestionTramas(trama);   // Analiza procesa la trama
947                }
948                else{
949                        UltimoError(2,"ProcesaComandos()");
950                        return(false);
951                }
952        }
953        return(true);
954}
955//______________________________________________________________________________________________________
956// Función: ProcesaComandos
957//
958//      Descripción:
959//              Espera comando desde el Servidor de Administración para ejecutarlos
960//      Parámetros:
961//              Ninguno
962//      Devuelve:
963//              true si el archivo se ha eliminado correctamente o false en caso contrario
964// ________________________________________________________________________________________________________
965/*
966int ProcesaComandos()
967
968{
969                sprintf(filecmd,"/comandos/CMD_%s",Propiedades.IPlocal);        // Nombre del fichero de comandos               
970                if(ExisteFichero(filecmd))      // Borra fichero de comandos si previamente exista de anteriores procesos
971                        RemoveFile(filecmd);
972                if(!DisponibilidadComandos(true)){      // Notifica  al servidor de Adminsitración su disponibilidad para recibir comandos
973                        UltimoError(0,"ProcesaComandos()");     
974                        return(false); 
975                }
976                PRCCMD=true;
977                while(PRCCMD){  // Bucle de espera de comandos interactivos
978                        if(ExisteFichero(filecmd)){     // Busca fichero de comandos
979                                RegistraLog("Comando recibido desde el Servidor de Administración",false);
980                                if(!LoadTextFile(filecmd)){     // Toma comando
981                                        UltimoError(1,"ProcesaComandos()");
982                                        return(false);
983                                }
984                                GestionTramas(trama);   // Analiza la trama y ejecuta el comando
985                                RegistraLog("Procesa comandos pendientes",false);
986                                ComandosPendientes(); // Bucle para procesar comandos pendientes
987                                RegistraLog("Disponibilidad para comandos interactivos activada ...",false);
988                                if(!DisponibilidadComandos(true)){      // Notifica  al servidor de Administración su disponibilidad para recibir comandos
989                                        UltimoError(0,"ProcesaComandos()");     
990                                        return(false);
991                                }
992                                if(!RemoveFile(filecmd)){       // Lo elimina
993                                        UltimoError(0,"ProcesaComandos()");
994                                        return(false);
995                                }
996                        }
997                        sleep(1);       // Espera 1 segundo antes de volver a esperar comandos
998                }
999                return(true);
1000}
1001*/
1002
1003//______________________________________________________________________________________________________
1004// Función: DisponibilidadComandos
1005//
1006//      Descripción:
1007//              Notifica al servidor su disponibilidad a recibir comandos ( Lgica negativa )
1008//      Parámetros:
1009//              - swdis : Indica disponibilidad si es true y NO disponibilidad en caso de ser false
1010//      Devuelve:
1011//              true si el proceso es correcto y false en caso contrario
1012// ________________________________________________________________________________________________________
1013/*
1014int DisponibilidadComandos(int swdis)
1015{
1016                int lon;
1017
1018                lon=sprintf(trama->parametros,"nfn=DisponibilidadComandos\r");
1019                if(!swdis)
1020                        lon+=sprintf(trama->parametros+lon,"swd=0\r");  // No disponible                               
1021                else
1022                        lon+=sprintf(trama->parametros+lon,"swd=1\r");  // Disponible
1023                       
1024                if(AbreConexionTCP()){
1025                        if(!EnviaTramasHidra(sock,trama)){
1026                                UltimoError(21,"DisponibilidadComandos()"); // No se pudo recuperar la configuración hardware
1027                                return(false);
1028                        }
1029                        if(!recibe_tramas(sock,trama)){
1030                                UltimoError(22,"DisponibilidadComandos()"); // No se pudo recuperar la configuración hardware
1031                                return(false);
1032                        }
1033                        CierraConexionTCP();
1034                        GestionTramas(trama);   // Analiza la trama
1035                }
1036                else{
1037                        UltimoError(2,"DisponibilidadComandos()");     
1038                        return(false);
1039                }
1040                return(true);
1041}
1042*/
1043//______________________________________________________________________________________________________
1044// Función: GestionTramas
1045//
1046//      Descripción:
1047//              Gestiona las tramas recibidas por la red
1048//      Parámetros:
1049//              - trama : Una trama recibida
1050//      Devuelve:
1051//              true o false dependiendo del éxito en la ejecución del comandoo si se trata de una trama
1052//              del Servidor de Administración o bien del resultado de la petición de información al repositorio
1053// ________________________________________________________________________________________________________
1054int GestionTramas(TRAMA *trama)
1055{
1056        TRAMA *nwtrama=NULL;
1057        int res;
1058        char *nombrefuncion;
1059
1060        INTROaFINCAD(trama->parametros);
1061        nombrefuncion=toma_parametro("nfn",trama->parametros);
1062        nwtrama=(TRAMA*)ReservaMemoria(LONGITUD_TRAMA); // Reserva buffer  para la trama        devuelta               
1063        if(!nwtrama){
1064                UltimoError(1,"GestionTramas()");
1065                return(false);
1066        }
1067        if(ndebug>6){
1068                sprintf(msglog,"Gestión de tramas.-Función a ejecutar:%s",nombrefuncion);
1069                RegistraLog(msglog,false);
1070        }
1071        // Mensajes entre el cliente y el Servidor de Administración
1072        res=strcmp(nombrefuncion,"Apagar");
1073        if(res==0)
1074                return(Apagar(trama,nwtrama));
1075
1076        res=strcmp(nombrefuncion,"Arrancar");
1077        if(res==0)
1078                return(Arrancar(trama,nwtrama));
1079                       
1080        res=strcmp(nombrefuncion,"Reiniciar");
1081        if(res==0)
1082                return(Reiniciar(trama,nwtrama));
1083                       
1084        res=strcmp(nombrefuncion,"IniciarSesion");
1085        if(res==0)
1086                return(IniciarSesion(trama,nwtrama));
1087
1088        res=strcmp(nombrefuncion,"RESPUESTA_InclusionCliente");
1089        if(res==0)
1090                return(RESPUESTA_InclusionCliente(trama));
1091                       
1092        res=strcmp(nombrefuncion,"Actualizar");
1093        if(res==0)
1094                return(Actualizar());           
1095               
1096        res=strcmp(nombrefuncion,"ConsolaRemota");
1097        if(res==0)
1098                return(ConsolaRemota(trama,nwtrama));   
1099
1100        res=strcmp(nombrefuncion,"NoComandosPtes");
1101        if(res==0)
1102                return(NoComandosPtes());
1103                       
1104        res=strcmp(nombrefuncion,"Cortesia");
1105        if(res==0)
1106                return(Cortesia());                     
1107                                       
1108       
1109        res=strcmp(nombrefuncion,"ExecShell");
1110        if(res==0)
1111                return(ExecShell(trama,nwtrama));                       
1112                       
1113        res=strcmp(nombrefuncion,"CrearPerfilSoftware");
1114        if(res==0)
1115                return(CrearPerfilSoftware(trama,nwtrama));                     
1116
1117        res=strcmp(nombrefuncion,"RestaurarImagen");
1118        if(res==0)
1119                return(RestaurarImagen(trama,nwtrama));                 
1120       
1121        res=strcmp(nombrefuncion,"TomaConfiguracion");
1122        if(res==0)
1123                return(TomaConfiguracion(trama,nwtrama));               
1124               
1125        res=strcmp(nombrefuncion,"InventarioHardware");
1126        if(res==0)
1127                return(InventarioHardware(trama,nwtrama));             
1128               
1129        res=strcmp(nombrefuncion,"InventarioSoftware");
1130        if(res==0)
1131                return(InventarioSoftware(trama,nwtrama));             
1132
1133        res=strcmp(nombrefuncion,"ParticionaryFormatear");
1134        if(res==0)
1135                return(ParticionaryFormatear(trama,nwtrama));                           
1136                       
1137        // Mensajes entre el cliente y el repositorio           
1138        res=strcmp(nombrefuncion,"Respuesta_ExisteFichero");
1139        if(res==0){
1140                res=atoi(toma_parametro("res",trama->parametros));
1141                return(res);
1142        }
1143                       
1144        res=strcmp(nombrefuncion,"Respuesta_EliminaFichero");
1145        if(res==0){
1146                res=atoi(toma_parametro("res",trama->parametros));
1147                return(res);
1148        }
1149               
1150        res=strcmp(nombrefuncion,"Respuesta_LeeFicheroTexto");
1151        if(res==0){
1152                res=atoi(toma_parametro("res",trama->parametros));
1153                return(res);
1154        }                       
1155        return(true);
1156}
1157//______________________________________________________________________________________________________
1158// Función: Cortesia
1159//
1160//       Descripción:
1161//               Respuesta estandar del Servidor de Administración
1162//      Parámetros:
1163//              Ninguno
1164//      Devuelve:
1165//              true siempre
1166//      Especificaciones:
1167//              Esta función se ejecuta de forma estandar para cerrar la conversación con el Servidor de Administración
1168//______________________________________________________________________________________________________
1169int Cortesia(){
1170         return(true);
1171}
1172//______________________________________________________________________________________________________
1173// Función: NoComandosPtes
1174//
1175//       Descripción:
1176//               Conmuta el switch de los comandos pendientes y lo pone a false
1177//      Parámetros:
1178//              Ninguno
1179//      Devuelve:
1180//              true siempre
1181//      Especificaciones:
1182//              Cuando se ejecuta esta función se sale del bucle que recupera los comandos pendientes en el servidor y
1183//              el cliente pasa a a estar disponible para recibir comandos desde el éste.
1184//______________________________________________________________________________________________________
1185int NoComandosPtes(){
1186        CMDPTES=false; // Corta el bucle de comandos pendientes
1187        return(true);
1188}
1189//______________________________________________________________________________________________________
1190// Función: TomaIPlocal
1191//
1192//       Descripción:
1193//              Recupera la IP local
1194//      Parámetros:
1195//              Ninguno
1196//      Devuelve:
1197//              Una cadena con el valor de la IP en formato xxx.xxx.xxx.xxx
1198//      Especificaciones:
1199//              En caso de no encontrar la IP o generarse algún error se devuelve la dirección 0.0.0.0
1200//______________________________________________________________________________________________________
1201int TomaIPlocal()
1202{
1203        int herror;
1204
1205        sprintf(cmdshell,"%s/admGetIpAddress",HIDRASCRIPTS);
1206        herror=EjecutarScript (cmdshell,NULL,IPlocal,true);
1207        RegistraLog(msglog,false);
1208        if(herror){
1209                UltimoErrorScript(herror,"TomaIPlocal()"); // Se ha producido algún error
1210                return(false);
1211        }
1212        return(true);
1213}
1214//______________________________________________________________________________________________________
1215// Función: cuestionCache
1216//
1217//       Descripción:
1218//              Procesa la cache en caso de existir.
1219//      Parámetros:
1220//              tamcache : Tamaño de la cache
1221//      Devuelve:
1222//              true o false dependiendo de si se ha ejecutado correctamente el script de configuración
1223//
1224//             
1225//______________________________________________________________________________________________________
1226int cuestionCache(char* tamcache)
1227{
1228        int herror;
1229       
1230        if(ndebug>3){
1231                sprintf(msglog,"Tamaño de la cache: %s",tamcache);
1232                RegistraLog(msglog,false);
1233        }
1234
1235        sprintf(cmdshell,"%s/initCache",HIDRASCRIPTS);
1236        sprintf(parametros,"%s %s","initCache",tamcache);
1237
1238
1239        herror=EjecutarScript (cmdshell,parametros,NULL,true); 
1240        if(herror){
1241                UltimoErrorScript(herror,"cuestionCache()"); // Se ha producido algún error
1242                return(false);
1243        }
1244        if(tamcache>0)
1245         CACHEEXISTS=true;
1246        else
1247         CACHEEXISTS=false;
1248
1249        return(true);
1250}
1251//______________________________________________________________________________________________________
1252// Función: InclusionCliente
1253//       Descripción:
1254//              Abre una sesión en el servidor de administración y registra al cliente en el sistema
1255//      Parámetros:
1256//              Ninguno
1257//      Devuelve:
1258//              true si el registro ha tenido éxito o false en caso contrario
1259//______________________________________________________________________________________________________
1260int InclusionCliente()
1261{
1262        int lon;       
1263        char *parametroscfg;
1264       
1265        parametroscfg=(char*)ReservaMemoria(256);
1266        if(!parametroscfg){
1267                UltimoError(1,"InclusionCliente()"); // No se pudo reservar memoria
1268                return(false);
1269        }
1270       
1271        char *disco=(char*)ReservaMemoria(2);
1272        sprintf(disco,"1"); // Siempre el disco 1
1273        parametroscfg=LeeConfiguracion(disco);  // Toma configuración
1274       
1275        if(ndebug>3){
1276                sprintf(msglog,"CONFIGURACION=%s",parametroscfg);
1277                RegistraLog(msglog,false);
1278        }
1279       
1280        if(!parametroscfg){
1281                UltimoError(18,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
1282                return(false);
1283        }
1284        lon=sprintf(trama->parametros,"nfn=InclusionCliente\r");        // Nombre de la función a ejecutar en el servidor de Adminsitración
1285        lon+=sprintf(trama->parametros+lon,"cfg=%s\r",parametroscfg);   // Configuración de los Sistemas Operativos del cliente
1286        if(AbreConexionTCP()){
1287                RegistraLog("Enviando peticion de inclusion al Servidor de Administración",false);
1288                if(!EnviaTramasHidra(sock,trama)){
1289                        UltimoError(21,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
1290                        return(false);
1291                }
1292                RegistraLog("Recibiendo respuesta del Servidor de Administración",false);
1293                if(!recibe_tramas(sock,trama)){
1294                        UltimoError(22,"InclusionCliente()"); // No se pudo recuperar la configuración hardware
1295                        return(false);
1296                }
1297                CierraConexionTCP();
1298                if(!GestionTramas(trama)){      // Analiza la trama
1299                        UltimoError(0,"InclusionCliente()");
1300                        return(false);         
1301                }
1302                return(true);
1303        }
1304        else{
1305                UltimoError(2,"InclusionCliente()"); // No se pudo conectar con el servidor de administración
1306                return(false);
1307        }               
1308        return(true);                           
1309}
1310//______________________________________________________________________________________________________
1311// Función: RESPUESTA_InclusionCliente
1312//
1313//       Descripción:
1314//              Respuesta del servidor de administración a la petición de inicio enviando los datos identificativos del cliente y otras configuraciones
1315//      Parámetros:
1316//              trama:  Trama recibida por el cliente desde el Servidor de Administración
1317//      Devuelve:
1318//              true si el registro ha tenido éxito o false en caso contrario
1319//______________________________________________________________________________________________________
1320int RESPUESTA_InclusionCliente(TRAMA *trama)
1321{
1322        strcpy(Propiedades.idordenador,toma_parametro("ido",trama->parametros));        // Identificador del ordenador
1323        strcpy(Propiedades.nombreordenador,toma_parametro("npc",trama->parametros));    //  Nombre del ordenador
1324        strcpy(Propiedades.idaula,toma_parametro("ida",trama->parametros));     //  Identificador del aula a la que pertenece
1325        strcpy(Propiedades.idperfilhard,toma_parametro("ifh",trama->parametros));       // Identificador del perfil hardware del ordenador
1326        strcpy(Propiedades.servidorhidra,toma_parametro("hrd",trama->parametros));      // Dirección IP del servidor de Administración
1327        strcpy(Propiedades.puerto,toma_parametro("prt",trama->parametros));             // Puerto de comunicación con el servidor de Administración
1328        strcpy(Propiedades.iprepo,toma_parametro("ipr",trama->parametros));     // Dirección IP del repositorio
1329        strcpy(Propiedades.puertorepo,toma_parametro("rep",trama->parametros)); // Puerto de comunicación con el repositorio
1330        strcpy(Propiedades.cache,toma_parametro("che",trama->parametros));      // Tamaño de la cache
1331
1332        strcpy(Propiedades.ipmulticast,toma_parametro("ipm",trama->parametros)); // Dirección IP multicast
1333        strcpy(Propiedades.pormulticast,toma_parametro("pom",trama->parametros)); // Puerto multicast
1334        strcpy(Propiedades.modmulticast,toma_parametro("mom",trama->parametros));       // Modo de transmisión multicast
1335        strcpy(Propiedades.velmulticast,toma_parametro("vlm",trama->parametros));       // Velocidad de transmisión multicast
1336
1337        // Guarda items del menú
1338        char* cabmenu=toma_parametro("cmn",trama->parametros);
1339        if (cabmenu){
1340                swmnu=true;
1341                char *auxCab[15];
1342                split_parametros(auxCab,cabmenu,"&");   // Caracter separador de los elementos de un item
1343                strcpy(CabMnu.titulo,auxCab[0]);        // Tìtulo del menú
1344                strcpy(CabMnu.coorx,auxCab[1]); // Coordenada x del menú público
1345                strcpy(CabMnu.coory,auxCab[2]); // Coordenada y del menú público
1346                strcpy(CabMnu.modalidad,auxCab[3]);     // Modalidad de columnas del menú público
1347                strcpy(CabMnu.scoorx,auxCab[4]);        // Coordenada x del menú privado
1348                strcpy(CabMnu.scoory,auxCab[5]);        // Coordenada y del menú privado
1349                strcpy(CabMnu.smodalidad,auxCab[6]);    // Modalidad de columnas del menú privado
1350                strcpy(CabMnu.resolucion,auxCab[7]);    // Resolución de pantalla
1351        }
1352        /*char* menu=toma_parametro("mnu",trama->parametros);    // Menú estandar
1353       
1354        char* auxMenu[MAXITEMS],auxItem[10];
1355        int iMnu=split_parametros(auxMenu,menu,"?"); // Caracter separador de  los item
1356        int i,nitem;
1357       
1358        for( i = 0; i<iMnu; i++){
1359                struct s_Item Item;
1360                nitem=split_parametros(auxItem,auxMenu[i],"&"); // Caracter separador de los elementos de un item
1361                strcpy(Item.idaccionmenu,auxItem[0]);   // Identificador de la acción
1362                strcpy(Item.urlimg,auxItem[1]); // Url de la imagen del item
1363                strcpy(Item.literal,auxItem[2]);        // Literal del item
1364                strcpy(Item.tipoitem,auxItem[3]);       // Tipo de item ( Público o privado )
1365                strcpy(Item.tipoaccion,auxItem[4]);     // Tipo de acción ( Procedimiento,Tarea oTrabajo )
1366                tbMenu[i]=Item;
1367        }
1368        contitems=i;    // Número de items totales de los dos menús
1369        */
1370        return(true);
1371}
1372//______________________________________________________________________________________________________
1373// Función: ComandosPendientes
1374//
1375//      Parámetros:
1376//       Ninguno
1377//       Descripción:
1378//               Búsqueda de acciones pendientes en el  servidor de administración
1379//______________________________________________________________________________________________________
1380int ComandosPendientes()
1381{
1382        CMDPTES=true;
1383        while(CMDPTES){
1384                sprintf(trama->parametros,"nfn=ComandosPendientes\r");  // Nombre de la función a ejecutar en el  servidor de administración
1385                if(AbreConexionTCP()){
1386                        if(!EnviaTramasHidra(sock,trama)){
1387                                UltimoError(21,"ComandosPendientes()"); // No se pudo recuperar la configuración hardware
1388                                return(false);
1389                        }
1390                        if(!recibe_tramas(sock,trama)){
1391                                UltimoError(22,"ComandosPendientes()"); // No se pudo recuperar la configuración hardware
1392                                return(false);
1393                        }
1394                        CierraConexionTCP();
1395                        GestionTramas(trama);   // Analiza la trama
1396                }
1397                else{
1398                        UltimoError(2,"ComandosPendientes()"); // No se pudo conectar con el servidor de Administración
1399                        return(false);
1400                }
1401        }
1402        CMDPTES=false;
1403        return(true);
1404}
1405//_____________________________________________________________________________________________________
1406// Función: Arrancar
1407//
1408//       Descripción:
1409//              Contesta ante un comando de arrancar
1410//      Parámetros:
1411//              - trama: Trama recibida con las especificaciones del comando
1412//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1413//      Devuelve:
1414//              true siempre
1415//_____________________________________________________________________________________________________
1416int Arrancar(TRAMA *trama,TRAMA *nwtrama)
1417{
1418        sprintf(nwtrama->parametros,"nfn=RESPUESTA_Arrancar\r");                                       
1419        return(RespuestaEjecucionComando(trama,nwtrama,true)); 
1420}
1421//_____________________________________________________________________________________________________
1422// Función: Apagar
1423//
1424//       Descripción:
1425//              Apaga el cliente
1426//      Parámetros:
1427//              - trama: Trama recibida con las especificaciones del comando
1428//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1429//      Devuelve:
1430//              true si el proceso fue correcto o false en caso contrario
1431//_____________________________________________________________________________________________________
1432int Apagar(TRAMA *trama,TRAMA *nwtrama)
1433{
1434        int res;
1435       
1436        sprintf(nwtrama->parametros,"nfn=RESPUESTA_Apagar\r");                                 
1437        res=RespuestaEjecucionComando(trama,nwtrama,true);     
1438        sprintf(cmdshell,"poweroff");
1439        res=ExecBash(cmdshell);
1440        if(!res){
1441                UltimoErrorScript(10,"Reiniciar()");    // Se ha producido algún error
1442        }       
1443        return(res);           
1444}
1445//______________________________________________________________________________________________________
1446// Función: Reiniciar
1447//
1448//       Descripción:
1449//              Reinicia el cliente
1450//      Parámetros:
1451//              - trama: Trama recibida con las especificaciones del comando
1452//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1453//      Devuelve:
1454//              true si el proceso fue correcto o false en caso contrario
1455//______________________________________________________________________________________________________
1456int Reiniciar(TRAMA *trama,TRAMA *nwtrama)
1457{
1458        int res;
1459       
1460        sprintf(nwtrama->parametros,"nfn=RESPUESTA_Reiniciar\r");                                       
1461        res=RespuestaEjecucionComando(trama,nwtrama,true);     
1462        sprintf(cmdshell,"reboot");
1463        res=ExecBash(cmdshell);
1464        if(!res){
1465                UltimoErrorScript(10,"Reiniciar()");    // Se ha producido algún error
1466        }       
1467        return(res);   
1468}
1469//______________________________________________________________________________________________________
1470// Función: IniciarSesion
1471//
1472//       Descripción:
1473//              Inicia Sesión en algún sistema operativo instalado en la máquina
1474//      Parámetros:
1475//              - trama: Trama recibida con las especificaciones del comando
1476//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1477//      Devuelve:
1478//              true si el proceso fue correcto o false en caso contrario
1479//              *** En ese proceso se devuelve correcto aún sabiendo que no se se sabe si va a funcionar
1480//                      pero esto evita que si se ha lanzado con seguimiento, la tarea no quede sin norificar.
1481//______________________________________________________________________________________________________
1482int  IniciarSesion(TRAMA *trama,TRAMA *nwtrama)
1483{
1484        int res;
1485        char *particion=toma_parametro("par",trama->parametros);
1486        char *disco=(char*)ReservaMemoria(2);
1487        sprintf(disco,"1"); // Siempre el disco 1
1488
1489        sprintf(nwtrama->parametros,"nfn=RESPUESTA_IniciarSesion\r");                                   
1490        res=RespuestaEjecucionComando(trama,nwtrama,true);
1491        sprintf(cmdshell,"%s/admBootOs %s %s",HIDRASCRIPTS,disco,particion);
1492        res=ExecBash(cmdshell);
1493        if(!res){
1494                UltimoErrorScript(10,"IniciarSesion()");        // Se ha producido algún error
1495        }       
1496        return(res);
1497}
1498//______________________________________________________________________________________________________
1499// Función: Actualizar
1500//
1501//       Descripción:
1502//              Actualiza los datos de un ordenador  como si volviera a solicitar la entrada  en el sistema al  servidor de administración
1503//      Parámetros:
1504//       Ninguno
1505//      Devuelve:
1506//              true si el proceso fue correcto o false en caso contrario
1507//______________________________________________________________________________________________________
1508int Actualizar()
1509{
1510        int res;
1511
1512        MuestraMensaje(1,NULL);
1513        res=InclusionCliente();
1514        //cuestionCache(Propiedades.cache);
1515        MuestraMenu(URLMENU);
1516        //kill(pidmenu,SIGQUIT);
1517        return(res);
1518}
1519//______________________________________________________________________________________________________
1520// Función: CrearPerfilSoftware
1521//
1522//       Descripción:
1523//              Genera una imagen de una partición
1524//      Parámetros:
1525//              - trama: Trama recibida con las especificaciones del comando
1526//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1527//      Devuelve:
1528//              true si el proceso fue correcto o false en caso contrario
1529//_____________________________________________________________________________________________________
1530int CrearPerfilSoftware(TRAMA*trama,TRAMA*nwtrama)
1531{
1532                int res=0;
1533                char *wparticion=toma_parametro("par",trama->parametros);       // Partición de donde se crear el perfil
1534                char *widperfilsoft=toma_parametro("ifs",trama->parametros);    // Perfil software a crear
1535                char *widperfilhard=toma_parametro("ifh",trama->parametros);    // Perfil hardware del ordenador
1536                char *wnemonico=toma_parametro("nem",trama->parametros);        // Nemónico del S.O. de la partición
1537                               
1538                char *disco=(char*)ReservaMemoria(2);
1539                sprintf(disco,"1"); // Siempre el disco 1
1540                                       
1541                char pathperfil[250];
1542                sprintf(pathperfil,"%s/%s",HIDRACHEIMAGENES,wnemonico); // Path del perfil creado       
1543                       
1544                char fileperfil[64];
1545                sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard);    // Nombre de la imagen ( del perfil creado)
1546               
1547                char filemasterboot[64];
1548                sprintf(filemasterboot,"PS%s_PH%s.msb",widperfilsoft,widperfilhard);    // Idem para el sector de arranque MBR
1549                res=CrearPerfil(disco,fileperfil,pathperfil,wparticion,Propiedades.iprepo);
1550                RegistraLog("Finalizada la creacion del perfil software",false);
1551                int lon;
1552                lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_CrearPerfilSoftware\r");
1553                lon+=sprintf(nwtrama->parametros+lon,"ifs=%s\r",widperfilsoft);         
1554                lon+=sprintf(nwtrama->parametros+lon,"ifh=%s\r",widperfilhard);         
1555                RespuestaEjecucionComando(trama,nwtrama,res);   
1556                return(res);   
1557}
1558//______________________________________________________________________________________________________
1559// Función: CrearPerfil
1560//
1561//       Descripción:
1562//              Crea una imagen de una partición
1563//      Parámetros:
1564//              -disco          Disco a clonar  1,2,3..
1565//              -fileimg        Nombre de la imagen
1566//              -pathimg        Ruta de la imagen
1567//              -particion      Partición a clonar
1568//              -iprepo Dirección IP del repositorio ( Si es la IP local el repositorio será la caché)
1569//      Devuelve:
1570//              true si el proceso fue correcto o false en caso contrario
1571//______________________________________________________________________________________________________
1572int CrearPerfil(char* disco,char* fileimg,char* pathimg,char* particion,char*iprepo)   
1573{
1574        int herror;
1575
1576        MuestraMensaje(2,NULL);
1577       
1578        sprintf(cmdshell,"%s/admCreateImage",HIDRASCRIPTS);
1579        sprintf(parametros,"%s %s %s %s %s","createImage",disco,particion,"REPO",fileimg);
1580       
1581        if(ndebug>3){
1582                sprintf(msglog,"Creando Imagen disco:%s, partición:%s, Repositorio:%s, Imagen:%s, Ruta:%s",disco,particion,Propiedades.iprepo,fileimg,"");
1583                RegistraLog(msglog, false);
1584        }
1585
1586        herror=EjecutarScript(cmdshell,parametros,NULL,true);
1587        if(herror)
1588                MuestraMensaje(10,NULL);
1589        else
1590                MuestraMensaje(9,NULL);
1591        MuestraMenu(URLMENU);
1592
1593        if(herror){
1594                UltimoErrorScript(herror,"CrearPerfil()");       // Se ha producido algún error
1595                return(false);
1596        }
1597        else
1598                return(true);
1599}
1600//______________________________________________________________________________________________________
1601// Función: Nemonico
1602//
1603//       Descripción:
1604//              Devuelve el código de un nemonico de S.O.
1605//      Parámetros:
1606//              -nem            Nemonico del S.O.
1607//      Devuelve:
1608//              El código del nemónico
1609//______________________________________________________________________________________________________
1610int Nemonico(char* nem)
1611{
1612        if(strcmp(nem,"MsDos")==0)
1613                return(MsDos);
1614        if(strcmp(nem,"Win98")==0)
1615                return(Win98);
1616        if(strcmp(nem,"Win2K")==0)
1617                return(Win2K);
1618        if(strcmp(nem,"WinXP")==0)
1619                return( WinXP);
1620        if(strcmp(nem,"Linux")==0)
1621                return(Linux);
1622        return(0);
1623}
1624//______________________________________________________________________________________________________
1625// Función: RestaurarImagen
1626//
1627//       Descripción:
1628//              Restaura una imagen en una partición
1629//      Parámetros:
1630//              - trama: Trama recibida con las especificaciones del comando
1631//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1632//      Devuelve:
1633//              true si el proceso fue correcto o false en caso contrario
1634//______________________________________________________________________________________________________
1635int RestaurarImagen(TRAMA*trama,TRAMA*nwtrama)
1636{
1637                int res=0;
1638                int idxpath;
1639
1640                char *disco=(char*)ReservaMemoria(2);
1641                sprintf(disco,"1"); // Siempre el disco 1       
1642
1643                char *wparticion=toma_parametro("par",trama->parametros); // partición de donde se crear el perfil
1644                char *widimagen=toma_parametro("idi",trama->parametros);        // Identificador de la imagen
1645                char *widperfilsoft=toma_parametro("ifs",trama->parametros); // Perfil software
1646                char *widperfilhard=toma_parametro("ifh",trama->parametros); // Perfil hardware
1647                char *wpathimagen=toma_parametro("pth",trama->parametros); // Indica si la imagen se descargar de la caché o del repositorio
1648                char *wprotclona=toma_parametro("mcl",trama->parametros); // Protocolo de clonacion
1649                char *wnipes=toma_parametro("nip",trama->parametros); // Numero de clientes de la sesión multicast
1650                char *wide=toma_parametro("ide",trama->parametros); // Identificador sesión multicast
1651
1652                if(wpathimagen=='\0') wpathimagen="1";  // Por defecto de caché
1653                idxpath=atoi(wpathimagen);
1654                if(!CACHEEXISTS) idxpath=2;     // Sin no existe cache siempre desde el servidor
1655
1656                char fileperfil[64];
1657                sprintf(fileperfil,"PS%s_PH%s",widperfilsoft,widperfilhard);    // Nombre del fichero del perfil creado
1658                res=RestaurandoImagen(disco,fileperfil,wparticion,tbPathImg[idxpath],wprotclona,wnipes,wide);
1659                       
1660                // Toma la nueva configuración
1661                char *parametroscfg=LeeConfiguracion(disco);
1662                RegistraLog("Finalizada la restauracion de imagen", false);
1663
1664                int lon;                       
1665                lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_RestaurarImagen\r");     
1666                lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);         
1667                lon+=sprintf(nwtrama->parametros+lon,"idi=%s\r",widimagen);     
1668                lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",wparticion);   
1669                lon+=sprintf(nwtrama->parametros+lon,"ifs=%s\r",widperfilsoft);
1670                RespuestaEjecucionComando(trama,nwtrama,res);   
1671                return(res);           
1672}
1673//______________________________________________________________________________________________________
1674// Función: RestaurandoImagen
1675//
1676//       Descripción:
1677//              Restaura na imagen en una partición
1678//      Parámetros:
1679//              -disco          Disco a clonar  1,2,3..
1680//              -fileimg        Nombre de la imagen
1681//              -particion      Partición a clonar
1682//              -pathImg        Ruta de la imagen
1683//              -protclona  Protocolo de clonación para la imagen
1684//      -nipes      Número de ordenadores
1685//      -ide      Identificador de la sesión multicast (Es la hora en segundos del momento del envío del comando)
1686//      Devuelve:
1687//              true si el proceso fue correcto o false en caso contrario
1688//____________________________________________________________________________________________________
1689int RestaurandoImagen(char* disco,char *fileimg,char* particion,char *pathImg,char *protclona,char *nipes,char *ide)
1690{
1691        int herror;
1692       
1693        MuestraMensaje(3,NULL);
1694
1695        sprintf(cmdshell,"%s/admRestoreImage",HIDRASCRIPTS);
1696        sprintf(parametros,"%s %s %s %s %s %s %s","admRestoreImage",pathImg,fileimg,disco,particion,protclona,Propiedades.pormulticast);
1697       
1698        herror=EjecutarScript(cmdshell,parametros,NULL,true);
1699        if(herror) // Restauración correcta
1700                MuestraMensaje(12,NULL);
1701        else
1702                MuestraMensaje(11,NULL);
1703        MuestraMenu(URLMENU);
1704
1705        if(herror){
1706                UltimoErrorScript(herror,"RestaurandoImagen()");        // Se ha producido algún error
1707                return(false);
1708        }
1709        else{
1710                if(strcmp(protclona,"MULTICAST")==0){
1711                        if(!sesionMulticast(fileimg,nipes,ide))
1712                                RegistraLog("***Error en el proceso de preparación de transferencia multicast", false);
1713                }
1714                return(true);
1715        }
1716}
1717//______________________________________________________________________________________________________
1718// Función: ParticionaryFormatear
1719//
1720//       Descripción:
1721//              Modifica la tabla de particiones del sector de arranque master y formatea particiones
1722//      Parámetros:
1723//              - trama: Trama recibida con las especificaciones del comando
1724//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
1725//      Devuelve:
1726//              true si el proceso fue correcto o false en caso contrario
1727//____________________________________________________________________________________________________
1728int ParticionaryFormatear(TRAMA*trama,TRAMA*nwtrama)
1729{
1730        int res,i,parfor;
1731        char* parametroscfg;
1732        char ch[2],*parhdc[8];
1733        char *PrimaryPartitions=toma_parametro("ppa",trama->parametros);
1734        char *LogicalPartitions=toma_parametro("lpa",trama->parametros);
1735        char *HDCleanPartition=toma_parametro("hdc",trama->parametros);
1736
1737        char *disco=(char*)ReservaMemoria(2);
1738        sprintf(disco,"1"); // Siempre el disco 1
1739       
1740
1741        RegistraLog("Creando o modificando tabla de particiones", false);
1742        //Pantallas
1743        MuestraMensaje(4,NULL);
1744        res=Particionar(disco,PrimaryPartitions,LogicalPartitions); // Creando las particiones
1745        if(res)
1746                MuestraMensaje(13,NULL);
1747        else
1748                MuestraMensaje(14,NULL);
1749
1750        if(res){
1751                strcpy(ch,";"); // Caracter delimitador
1752                parfor=split_parametros(parhdc,HDCleanPartition,ch);
1753                for(i = 0; i<parfor; i++){ // Formateando particiones
1754                        //Pantallas
1755                        MuestraMensaje(5,NULL);
1756                        res=Formatear(disco,parhdc[i]);
1757                        if(res)
1758                                MuestraMensaje(15,NULL);
1759                        else
1760                                MuestraMensaje(16,NULL);
1761                        if(!res) break;
1762                }
1763        }
1764        MuestraMenu(URLMENU);
1765        RegistraLog("Finalizado el particionado y formateado de particiones", false);
1766        parametroscfg=LeeConfiguracion(disco);  // Toma la nueva configuración
1767       
1768        int lon;
1769        lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ParticionaryFormatear\r");               
1770        lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
1771        RespuestaEjecucionComando(trama,nwtrama,res);   
1772       
1773        return(res);
1774}
1775//______________________________________________________________________________________________________
1776// Función: Particionar
1777//
1778//       Descripción:
1779//              Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
1780//      Parámetros:
1781//              - disco: Número del disco
1782//              - PrParticion: Cadena con la sintaxis de particionado de las particiones primarias
1783//              - LoParticion: Cadena con la sintaxis de particionado de las particiones secundarias
1784//      Devuelve:
1785//              true si el proceso fue correcto o false en caso contrario
1786//______________________________________________________________________________________________________
1787int Particionar(char* disco,char* PrParticion,char* LoParticion)
1788{
1789        if (strlen(PrParticion)>0){
1790                if(Particionando(disco,PrParticion,"admCreatePrimaryPartitions")){      // Particiones Primarias
1791                        if (strlen(LoParticion)>0)
1792                                return(Particionando(disco,PrParticion,"admCreateLogicalPartitions"));  // Particiones Logicas
1793                        else
1794                                return(true);
1795                }
1796                else
1797                        return(false);
1798        }
1799        if (strlen(LoParticion)>0)
1800                return(Particionando(disco,PrParticion,"admCreateLogicalPartitions"));
1801        else
1802                return(false);
1803}
1804//______________________________________________________________________________________________________
1805// Función: Particionando
1806//
1807//       Descripción:
1808//              Modifica la tabla de particiones del sector de arranque master pero SIN formatear ninguna partición
1809//      Parámetros:
1810//              - disco: Disco en el que se modificará la tabla de particiones 1,2,3..
1811//              - StxParticion: Cadena con la sintaxis de particionado de las particiones primarias
1812//              - script: Nombre del script que se ejecutará
1813//      Devuelve:
1814//              true si el proceso fue correcto o false en caso contrario
1815//      Especificaciones:
1816//              Esta función es auxiliar de la anterior y es llamda por esta en dos ocasiones, para las particiones Primarias y Lógicas
1817//______________________________________________________________________________________________________
1818int Particionando(char* disco,char* stxParticion,char* script)
1819{       
1820        int herror;
1821       
1822        sprintf(cmdshell,"%s/%s",HIDRASCRIPTS,script);
1823        sprintf(parametros,"%s %s %s",script,disco,stxParticion);
1824
1825        sprintf(msglog,"Modificando tabla de particiones:%s disco:%s, cadena:%s",script,disco,stxParticion);
1826        if(ndebug>1){
1827                RegistraLog(msglog, false);
1828        }
1829        herror=EjecutarScript(cmdshell,parametros,NULL,true);
1830        if(herror){
1831                UltimoErrorScript(herror,"Particionar()");       // Se ha producido algún error
1832                return(false);
1833    }
1834    else
1835                return(true);
1836}
1837//______________________________________________________________________________________________________
1838// Función: Formatear
1839//
1840//       Descripción:
1841//              Formatea una partición
1842//      Parámetros:
1843//              - disco: Número del disco
1844//              - particion: Número de partición a formatear
1845//      Devuelve:
1846//              true si el proceso fue correcto o false en caso contrario
1847//______________________________________________________________________________________________________
1848int Formatear(char* disco,char* particion)
1849{
1850        int herror;
1851
1852        sprintf(cmdshell,"%s/admFormatFs",HIDRASCRIPTS);       
1853        sprintf(parametros,"%s %s %s","FormatFs",disco,particion);
1854        herror=EjecutarScript(cmdshell,parametros,NULL,true);
1855        if(herror){
1856            UltimoErrorScript(herror,"Formatear()");     // Se ha producido algún error
1857                return(false);
1858    }
1859        return(true);
1860}
1861//______________________________________________________________________________________________________
1862// Función: SetCachePartitionSize
1863//
1864//      Descripción:
1865//              Dimensiona el tamaño de la caché
1866//      Parámetros:
1867//              - t : Tamaño a asignar de la caché
1868//      Devuelve:
1869//              true si el proceso fue correcto o false en caso contrario
1870// ________________________________________________________________________________________________________
1871int SetCachePartitionSize(int t)
1872{
1873        return(true);
1874}
1875//___________________________________________________________________________________________________
1876//
1877// 
1878//______________________________________________________________________________________________________
1879// Función: AutoexecClienteHidra
1880//
1881//  Parámetros:
1882//              Ninguno
1883//      Descripción:
1884//              Ejecuta un fichero autoexec preparado para  el cliente
1885// ________________________________________________________________________________________________________
1886int AutoexecClienteHidra()
1887{
1888        sprintf(fileini,"/autoexec/INI_%s",Propiedades.IPlocal);        // Nombre del fichero autoexec         
1889        if(ExisteFichero(fileini)){
1890                if(LoadTextFile(fileini)){ // Lee fichero autoexec             
1891                        GestionTramas(trama);   // Analiza la trama
1892                }
1893                else{
1894                        UltimoError(6,"AutoexecClienteHidra()");
1895                        return(false);
1896                }
1897        }
1898        return(true);
1899}
1900//______________________________________________________________________________________________________
1901// Función: LeeConfiguracion
1902//
1903//      Descripción:
1904//              Recupera la configuración de particiones del ordenador
1905//      Parámetros:
1906//              disco:  Disco a analizar 1,2,3..
1907//      Devuelve:
1908//              Una cadena con la configuración del cliente (ver manual)
1909// ________________________________________________________________________________________________________
1910char* LeeConfiguracion(char* disco)
1911{
1912        int herror;
1913        char *cadenaparticiones;
1914        char *nomso;
1915       
1916        cadenaparticiones=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
1917        sprintf(cmdshell,"%s/admListPrimaryPartitions",HIDRASCRIPTS);   
1918        sprintf(parametros,"%s %s","admListPrimaryPartitions",disco);
1919        herror=EjecutarScript(cmdshell,parametros,cadenaparticiones,true);
1920        if(herror){
1921            UltimoErrorScript(herror,"LeeConfiguracion()");      // Se ha producido algún error
1922                return(NULL);
1923    }
1924        struct s_Particiones *tbcfg[MAXPARTICIONES];
1925        char *duplasparticiones[MAXPARTICIONES],*duplaparticion[2];
1926       
1927        int iPar=split_parametros(duplasparticiones,cadenaparticiones," ");     // Caracter separatorio de los elementos de un item
1928
1929        if(ndebug>4){
1930                sprintf(msglog,"Número de particiones detectadas %d",iPar);
1931                RegistraLog(msglog,false);
1932        }
1933        int i,j;
1934        for( i = 0; i<iPar; i++){
1935                split_parametros(duplaparticion,duplasparticiones[i],":");
1936                tbcfg[i]=(struct s_Particiones*)ReservaMemoria(sizeof(struct s_Particiones)); // Toma espacio para tabla de configuraciones
1937                strcpy(tbcfg[i]->tipopart,duplaparticion[0]); // Tipo de partición
1938                strcpy(tbcfg[i]->tamapart,duplaparticion[1]); // Tamaño de partición
1939                sprintf(tbcfg[i]->numpart,"%d",i+1); // Número de partición
1940               
1941                for(j=0;j<ntiposo;j++){
1942                        if(strcmp(tiposos[j].tipopart,duplaparticion[0])==0 && strcmp(tiposos[j].tipopart,"LINUX-SWAP")!=0 && strcmp(tiposos[j].tipopart,"EMPTY")!=0){
1943                                nomso=TomaNomSO(disco,i+1);
1944                                if(nomso!=NULL){ // Averigua qué sistema operativo está instalado en la partición
1945                                        strcpy(tbcfg[i]->tiposo,tiposos[j].tiposo); // Nombre S.O.
1946                                        strcpy(tbcfg[i]->nombreso,nomso); // Nombre completo S.O.
1947                                }
1948                                else{
1949                                        strcpy(tbcfg[i]->tiposo,""); // Nombre S.O.
1950                                        strcpy(tbcfg[i]->nombreso,""); // Nombre completo S.O.
1951                                }
1952                                break;
1953                        }
1954                }
1955        }
1956        char *cfg=ReservaMemoria(LONGITUD_CONFIGURACION);
1957        if(!cfg){
1958                UltimoError(1,"LeeConfiguracion()");
1959                return(NULL);
1960        }
1961        int lon=0;
1962        for( i = 0; i<iPar; i++){
1963                lon+=sprintf(cfg+lon,"@cfg\n");
1964                lon+=sprintf(cfg+lon,"tiposo=%s\n",tbcfg[i]->tiposo);   
1965                lon+=sprintf(cfg+lon,"tipopart=%s\n",tbcfg[i]->tipopart);
1966                lon+=sprintf(cfg+lon,"tamapart=%s\n",tbcfg[i]->tamapart);
1967                lon+=sprintf(cfg+lon,"numpart=%s\n",tbcfg[i]->numpart);         
1968                lon+=sprintf(cfg+lon,"nombreso=%s\t",tbcfg[i]->nombreso);
1969        }
1970        return(cfg);
1971}
1972//______________________________________________________________________________________________________
1973// Función: TomaNomSO
1974//
1975//      Descripción:
1976//              Recupera el nombre del sistema operativo instalado en una partición
1977//      Parámetros:
1978//              disco:  Disco  1,2,3..
1979//              particion:      Número de la partición 
1980//      Devuelve:
1981//              Una cadena con el nombre del S.O.
1982// ________________________________________________________________________________________________________
1983char* TomaNomSO(char*disco,int particion)
1984{
1985        int herror,lon;
1986        char *infosopar;
1987        char* sover[2];
1988        char ch[2];
1989       
1990        infosopar=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA); // Información del S.O. de la partición
1991       
1992        sprintf(cmdshell,"%s/admGetOsVersion",HIDRASCRIPTS);   
1993        sprintf(parametros,"%s %s %d","admGetOsVersion",disco,particion);
1994        herror=EjecutarScript(cmdshell,parametros,infosopar,true);
1995                if(herror){
1996            UltimoErrorScript(herror,"TomaNomSO()");     // Se ha producido algún error
1997                return(NULL);
1998    }
1999    if(strlen(infosopar)==0) return(NULL); // NO Existe S.O. en la partición
2000    strcpy(ch,":");// caracter delimitador (dos puntos)
2001        lon=split_parametros(sover,infosopar,ch);
2002        return(sover[1]);
2003}
2004//______________________________________________________________________________________________________
2005// Función: MuestraMenu
2006//
2007//      Descripción:
2008//              Muestra menú del cliente
2009//      Parámetros:
2010//
2011//        urp: Path o url de la página web que muestra el menu del cliente
2012//
2013//      Devuelve:
2014//              True si muestra el menú
2015// ________________________________________________________________________________________________________
2016int MuestraMenu(char *urp)
2017{
2018        int nargs,resul;
2019
2020        if(ndebug>4){
2021                sprintf(msglog,"Url:%s",urp);
2022                RegistraLog(msglog, false);
2023        }
2024
2025        if(pidmenu>0)
2026                kill(pidmenu,SIGQUIT); // Se carga el proceso hijo anterior y se queda sólo el actual
2027
2028        //sprintf(cmdshell,"%s/admMenuBrowser",HIDRASCRIPTS);
2029        //sprintf(parametros,"%s %s","admMenuBrowser",urp);     
2030
2031        sprintf(cmdshell,"/opt/opengnsys/bin/browser");
2032        sprintf(parametros,"%s %s %s","browser","-qws",urp);   
2033
2034        nargs=split_parametros(argumentos,parametros," "); // Crea matriz de los argumentos del scripts
2035        if((pidmenu=fork())==0){
2036                /* Proceso hijo que ejecuta el script */
2037                resul=execv(cmdshell,argumentos);
2038                exit(resul);   
2039        }
2040        else {
2041                if (pidmenu ==-1){
2042                        UltimoErrorScript(23,"MuestraMenu()");  // Se ha producido algún error
2043                        return(false); 
2044                }               
2045        }
2046        return(true);
2047}
2048//______________________________________________________________________________________________________
2049// Función: MuestraMensaje
2050//
2051//      Descripción:
2052//              Envia una página al browser con un mensaje determinado
2053//      Parámetros:
2054//              - idx: Indice de la cadena del mensaje
2055//              - msg: Mensaje
2056// ________________________________________________________________________________________________________
2057void MuestraMensaje(int idx,char*msg){
2058        if(msg)
2059                sprintf(urlpag,"%s?msg=%s",URLMSG,URLEncode(msg)); // Url de la página de mensajes
2060        else
2061                sprintf(urlpag,"%s?idx=%d",URLMSG,idx); // Url de la página de mensajes
2062        MuestraMenu(urlpag);
2063}
2064//______________________________________________________________________________________________________
2065// Función: InventarioHardware
2066//
2067//      Descripción:
2068//              Recupera la configuración de hardware del ordenador
2069//      Parámetros:
2070//              - trama: Trama recibida con las especificaciones del comando
2071//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2072//      Devuelve:
2073//              true si el proceso fue correcto o false en caso contrario
2074//      Especificaciones:
2075//              Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
2076//              está función. (Vease scripts hidraHardwareInfo)
2077// ________________________________________________________________________________________________________
2078int InventarioHardware(TRAMA *trama,TRAMA *nwtrama)
2079{
2080        int herror,res;
2081        char *parametroshrd;
2082
2083        MuestraMensaje(6,NULL);
2084       
2085        parametroshrd=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
2086        sprintf(cmdshell,"%s/admListHardwareInfo",HIDRASCRIPTS);
2087
2088        herror=EjecutarScript(cmdshell,NULL,parametroshrd,true);
2089
2090        if(herror)
2091                MuestraMensaje(0,msglog);
2092        else
2093                MuestraMensaje(17,NULL);
2094        MuestraMenu(URLMENU);
2095
2096        if(herror){
2097            UltimoErrorScript(herror,"InventarioHardware()");   // Se ha producido algún error
2098    }
2099    res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
2100
2101        int lon;
2102        lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaHardware\r");               
2103        lon+=sprintf(nwtrama->parametros+lon,"hrd=%s\r",parametroshrd);
2104        lon+=sprintf(nwtrama->parametros+lon,"ipr=%s\r",Propiedades.iprepo);
2105        lon+=sprintf(nwtrama->parametros+lon,"rep=%s\r",Propiedades.puertorepo);
2106
2107        RespuestaEjecucionComando(trama,nwtrama,res);   
2108        return(res);
2109}
2110//______________________________________________________________________________________________________
2111// Función: InventarioSoftware
2112//
2113//      Descripción:
2114//              Recupera la configuración de software del ordenador
2115//      Parámetros:
2116//              - trama: Trama recibida con las especificaciones del comando
2117//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2118//      Devuelve:
2119//              true si el proceso fue correcto o false en caso contrario
2120//      Especificaciones:
2121//              Lo que se envía al servidor es una cadena con el formato de salida del script que ejecuta
2122//              está función. (Vease scripts hidraSoftwareInfo)
2123// ________________________________________________________________________________________________________
2124int InventarioSoftware(TRAMA *trama,TRAMA *nwtrama)
2125{
2126        int herror,res;
2127        char *parametrossft,*infopar;
2128        char *particion=toma_parametro("par",trama->parametros); // Toma partición
2129        //char *tipo=toma_parametro("tpl",trama->parametros); // Toma tipo de listado
2130
2131        char *disco=(char*)ReservaMemoria(2);
2132        sprintf(disco,"1"); // Siempre el disco 1
2133
2134        MuestraMensaje(7,NULL);
2135
2136        sprintf(cmdshell,"%s/admListSoftwareInfo",HIDRASCRIPTS);
2137        sprintf(parametros,"%s %s %s","admListSoftwareInfo",disco,particion);
2138
2139        parametrossft=(char*)ReservaMemoria(LONGITUD_SCRIPTSALIDA);
2140
2141        herror=EjecutarScript(cmdshell,parametros,parametrossft,true);
2142        if(herror)
2143                MuestraMensaje(20,NULL);
2144        else
2145                MuestraMensaje(19,NULL);
2146        MuestraMenu(URLMENU);
2147
2148        if(herror){
2149            UltimoErrorScript(herror,"InventarioSoftware()");   // Se ha producido algún error
2150    }
2151    res=(herror==0); // Si se ha producido algún error el resultado de la ejecución de error
2152        // Toma tipo de partición
2153                infopar=(char*)ReservaMemoria(16); //Tipo de partición
2154                if(res && infopar){
2155                                sprintf(cmdshell,"%s/admGetFsType",HIDRASCRIPTS);       
2156                                sprintf(parametros,"%s %s %s","getFsType",disco,particion);
2157                                herror=EjecutarScript(cmdshell,parametros,infopar,true);
2158                                if(herror){
2159                                UltimoErrorScript(herror,"InventarioSoftware()");        // Se ha producido algún error
2160                                }
2161        }
2162  int lon;
2163        lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaSoftware\r");               
2164        lon+=sprintf(nwtrama->parametros+lon,"sft=%s\r",parametrossft);
2165        lon+=sprintf(nwtrama->parametros+lon,"par=%s\r",particion);     
2166        lon+=sprintf(nwtrama->parametros+lon,"tfs=%s\r",infopar);       
2167        lon+=sprintf(nwtrama->parametros+lon,"ipr=%s\r",Propiedades.iprepo);
2168        lon+=sprintf(nwtrama->parametros+lon,"rep=%s\r",Propiedades.puertorepo);
2169
2170        RespuestaEjecucionComando(trama,nwtrama,res);   
2171        return(res);
2172}
2173//______________________________________________________________________________________________________
2174// Función: TomaConfiguracion
2175//
2176//      Descripción:
2177//              Toma la configuración de particiones de un ordenador
2178//      Parámetros:
2179//              - trama: Trama recibida con las especificaciones del comando
2180//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2181//      Devuelve:
2182//              true si el proceso fue correcto o false en caso contrario
2183// ________________________________________________________________________________________________________
2184int TomaConfiguracion(TRAMA *trama,TRAMA *nwtrama)
2185{       
2186                char* parametroscfg;
2187               
2188                char *disco=(char*)ReservaMemoria(2);
2189                sprintf(disco,"1"); // Siempre el disco 1
2190
2191                parametroscfg=LeeConfiguracion(disco);
2192               
2193                int lon;                       
2194                lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_TomaConfiguracion\r");   
2195                lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);         
2196                RespuestaEjecucionComando(trama,nwtrama,true); 
2197               
2198                return(true);
2199}
2200//______________________________________________________________________________________________________
2201// Función: ExecShell
2202//
2203//      Descripción:
2204//              Ejecuta un script de la Shell
2205//      Parámetros:
2206//              - trama: Trama recibida con las especificaciones del comando
2207//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2208//      Devuelve:
2209//              true si el proceso fue correcto o false en caso contrario
2210// ________________________________________________________________________________________________________
2211int ExecShell(TRAMA *trama,TRAMA *nwtrama)
2212{
2213        int res;
2214
2215        char* wscript=toma_parametro("scp",trama->parametros);  // Código del script
2216        char* codigo=URLDecode(wscript);        // Decodifica el código recibido con formato URLCode
2217       
2218        //Pantallas
2219        MuestraMensaje(8,NULL);
2220        res=ExecBash(codigo);
2221        if(res)
2222                MuestraMensaje(21,NULL);
2223        else
2224                MuestraMensaje(22,NULL);
2225        MuestraMenu(URLMENU);
2226
2227        if(!res){
2228                UltimoErrorScript(10,"ExecShell()");    // Se ha producido algún error
2229        }
2230                       
2231        char *disco=(char*)ReservaMemoria(2);
2232        sprintf(disco,"1"); // Siempre el disco 1
2233        char* parametroscfg=LeeConfiguracion(disco);
2234        int lon;                       
2235        lon=sprintf(nwtrama->parametros,"nfn=RESPUESTA_ExecShell\r");   
2236        lon+=sprintf(nwtrama->parametros+lon,"cfg=%s\r",parametroscfg);
2237        RespuestaEjecucionComando(trama,nwtrama,res);   
2238        return(true);   
2239}
2240//______________________________________________________________________________________________________
2241// Función: ConsolaRemota
2242//
2243//      Descripción:
2244//              Ejecuta un comando de la Shell y envia el eco al servidor (Consola remota)
2245//      Parámetros:
2246//              - trama: Trama recibida con las especificaciones del comando
2247//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2248//      Devuelve:
2249//              true siempre
2250// ________________________________________________________________________________________________________
2251int ConsolaRemota(TRAMA *trama,TRAMA *nwtrama)
2252{
2253        FILE* f;
2254        long lSize;
2255        int herror;
2256
2257        char* comando=toma_parametro("cmd",trama->parametros);  // Código del comando
2258        sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
2259        f = fopen(filecmdshell,"wt");   // Abre fichero de script
2260        if(f==NULL)
2261                RegistraLog("*** No se puede crear fichero temporal para ejecutar la consola remota", false);
2262        else{
2263                lSize=strlen(comando);
2264                fwrite(comando,1,lSize,f);      // Escribe el código a ejecutar
2265                fclose(f);
2266                sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
2267                sprintf(parametros,"%s %s %s","/bin/chmod","+x",filecmdshell);
2268                herror=EjecutarScript(cmdshell,parametros,NULL,true);
2269                if(herror){
2270                        UltimoErrorScript(herror,"ConsolaRemota()");    // Se ha producido algún error
2271                }
2272                else{
2273                                sprintf(cmdshell,"%s/remoteConsole",HIDRASCRIPTS);
2274                                herror=EjecutarScript(cmdshell,NULL,NULL,true);
2275                                if(herror){
2276                                        UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2277                                }       
2278                }
2279        }
2280        return(true);
2281}
2282//______________________________________________________________________________________________________
2283// Función: ExecBash
2284//
2285//      Descripción:
2286//              Ejecuta código bash
2287//      Parámetros:
2288//              - codigo: Código a ejecutar
2289//      Devuelve:
2290//              true si el proceso fue correcto o false en caso contrario
2291// ________________________________________________________________________________________________________
2292int ExecBash(char*codigo){
2293        FILE* f;
2294        long lSize;
2295        int herror,res;
2296       
2297        sprintf(filecmdshell,"%s/%s","/tmp","_hidrascript_");
2298        f = fopen(filecmdshell,"wt");   // Abre fichero de script
2299        if(f==NULL)
2300                res=false; // Error de apertura del fichero de configuración
2301        else{
2302                lSize=strlen(codigo);
2303                fwrite(codigo,1,lSize,f);       // Escribe el código a ejecutar
2304                fclose(f);
2305                sprintf(cmdshell,"/bin/chmod"); // Da permiso de ejecución al fichero
2306                sprintf(parametros,"%s %s %s","/bin/chmod","+x",filecmdshell);
2307                herror=EjecutarScript(cmdshell,parametros,NULL,true);
2308                if(herror){
2309                        UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2310                        res=false;     
2311                }
2312                else{
2313                        sprintf(cmdshell,"%s",filecmdshell);    // Ejecución el fichero de script creado
2314                        //int herror=EjecutarScript(cmdshell,NULL,NULL,true);
2315                        int herror=system(cmdshell);
2316                        if(herror){
2317                                UltimoErrorScript(herror,"ExecBash()"); // Se ha producido algún error
2318                                res=false;     
2319                        }               
2320                }
2321        }
2322        return(res);
2323}
2324//______________________________________________________________________________________________________
2325// Función: URLDecode
2326//
2327//      Descripción:
2328//              Decodifica una cadena codificada con UrlEncode
2329//      Parámetros:
2330//              - src: La cadena a decodificar
2331//      Devuelve:
2332//              La cadena decodificada
2333// ________________________________________________________________________________________________________
2334char* URLDecode(char *src)
2335{
2336        const char *p = src;
2337        char code[3] = {0};
2338        unsigned long ascii = 0;       
2339        char *end = NULL;
2340        char *dest,*cad;
2341
2342        dest=(char*)ReservaMemoria(strlen(src));        // Reserva buffer  para la cadena                       
2343        cad=dest;
2344        while(*p){
2345                if(*p == '%'){
2346                        memcpy(code, ++p, 2);
2347                        ascii = strtoul(code, &end, 16);
2348                        *dest++ = (char)ascii;
2349                        p += 2;
2350                }
2351                else
2352                        *dest++ = *p++;
2353        }
2354        return(cad);   
2355}
2356//______________________________________________________________________________________________________
2357// Función: URLEncode
2358//
2359//      Descripción:
2360//              Codifica una cadena en UrlEncode
2361//      Parámetros:
2362//              - src: La cadena a decodificar
2363//      Devuelve:
2364//              La cadena decodificada
2365// ________________________________________________________________________________________________________
2366char* URLEncode(char *src)
2367{
2368        char *dest;
2369        int i,j=0,lon;
2370       
2371        lon=strlen(src);
2372        dest=(char*)ReservaMemoria(lon*2);      // Reserva buffer  para la cadena                       
2373        for(i=0;i<lon;i++){
2374                if(src[i]==0x20){ // Espacio
2375                        dest[j++] = '%';       
2376                        dest[j++] = '2';
2377                        dest[j++] = '0';
2378                }
2379                else
2380                        dest[j++] = src[i];
2381        }
2382        return(dest);   
2383}
2384//______________________________________________________________________________________________________
2385// Función: RespuestaEjecucionComando
2386//
2387//      Descripción:
2388//              Envia una respuesta a una ejecución de comando al servidor de Administración
2389//      Parámetros:
2390//              - trama: Trama recibida con las especificaciones del comando
2391//              - nwtrama: Nueva trama a enviar al servidor con la respuesta de la acción, si ésta procede
2392//              - res:  Resultado de la ejecución (true si la ejecución es correcta y false en caso contrario)
2393//      Devuelve:
2394//              true si la respuesta se envía correctamente al servidor
2395// ________________________________________________________________________________________________________
2396int RespuestaEjecucionComando(TRAMA* trama, TRAMA *nwtrama, int res)
2397{
2398                int idsuceso=0;
2399                char *widsuceso=toma_parametro("ids",trama->parametros);
2400                if(widsuceso) idsuceso=atoi(widsuceso);
2401                int lon;
2402                lon=strlen(nwtrama->parametros);
2403                lon+=sprintf(nwtrama->parametros+lon,"ids=%d\r",idsuceso);      //  Identificador del suceso
2404                char descrierror[250];
2405                if (res){ // Resultado satisfactorio
2406                        lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","1");   // Resultado de la ejecucin del comando
2407                        sprintf(descrierror,"%s "," ");
2408                        lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror);   // Dscripcin del error si lo ha habido
2409                }       
2410                else{ // Algún error
2411                        lon+=sprintf(nwtrama->parametros+lon,"res=%s\r","2");   // Resultado de la ejecución del comando               
2412                        sprintf(descrierror,"Error.-(%s) en modulo %s",e.msg,e.modulo);
2413                        lon+=sprintf(nwtrama->parametros+lon,"der=%s\r",descrierror);   // Descripción del error si lo ha habido
2414                }
2415                if(AbreConexionTCP()){
2416                        if(!EnviaTramasHidra(sock,nwtrama)){
2417                                UltimoError(21,"RespuestaEjecucionComando()");
2418                                return(false);
2419                        }
2420                        if(!recibe_tramas(sock,trama)){
2421                                UltimoError(22,"RespuestaEjecucionComando()");
2422                                return(false); 
2423                        }               
2424                        CierraConexionTCP();
2425                        GestionTramas(trama);   // Analiza la trama
2426                }
2427                else{
2428                        UltimoError(2,"RespuestaEjecucionComando()");   
2429                        return(false);                 
2430                }
2431                return(true);
2432}
2433//***********************************************************************************************************************
2434// PROGRAMA PRINCIPAL
2435//***********************************************************************************************************************
2436int  main(int argc, char *argv[])
2437{
2438       
2439        //Archivos por defecto
2440        strcpy(szPathFileCfg,"ogAdmClient.cfg");
2441        strcpy(szPathFileLog,"ogAdmClient.log");
2442
2443        // Validación de argumentos y lectura del fichero de configuración
2444        if(ndebug>5)
2445                RegistraLog("ValidacionParametros", false);
2446
2447        if(!ValidacionParametros(argc,argv))
2448                exit(EXIT_FAILURE);
2449        else{   
2450                if(ndebug>5)
2451                        RegistraLog("CrearArchivoLog", false);
2452                if(!CrearArchivoLog(szPathFileLog))
2453                        exit(EXIT_FAILURE);
2454                else{
2455                        if(ndebug>5)
2456                                RegistraLog("LeeFileConfiguracion", false);
2457                        if(!LeeFileConfiguracion(szPathFileCfg)){ // Toma parámetros de configuración
2458                                UltimoError(13,"Main()");       
2459                                exit(EXIT_FAILURE);
2460                        }
2461                }
2462        }
2463        if(ndebug>5)
2464                RegistraLog("Guarda datos básicos del cliente", false);
2465
2466        strcpy(Propiedades.servidorhidra,Servidorhidra);       
2467        strcpy(Propiedades.puerto,Puerto);     
2468        strcpy(Propiedades.idordenador,"0");
2469        if(!TomaIPlocal()){ // Error al recuperar la IP local   
2470                UltimoError(0,"Main()");       
2471                exit(EXIT_FAILURE);
2472        }
2473        MuestraMensaje(0,NULL);
2474        sleep(2);
2475        strcpy(Propiedades.IPlocal,IPlocal);   
2476        RegistraLog("Abriendo sesión en el servidor de Administración", false);
2477        if(InclusionCliente()){ // El cliente ha abierto sesión correctamente
2478                if(strcmp(Propiedades.idordenador,"0")==0){     // Ha habido algún problema al inciar sesión
2479                        UltimoError(0,"Main()");       
2480                        exit(EXIT_FAILURE);
2481                }
2482                RegistraLog("Cliente iniciado", false);
2483
2484                if(!cuestionCache(Propiedades.cache)){ // Procesa la cache     
2485                        UltimoError(0,"Main()");       
2486                        exit(EXIT_FAILURE);
2487                }
2488       
2489                RegistraLog("Ejecución de archivo Autoexec", false);
2490                if(!AutoexecClienteHidra()){  // Ejecución fichero autoexec     
2491                        UltimoError(0,"Main()");       
2492                        exit(EXIT_FAILURE);
2493                }                               
2494                RegistraLog("Procesa comandos pendientes", false);
2495                ComandosPendientes(); // Bucle para procesar comandos pendientes
2496                RegistraLog("Acciones pendientes procesadas", false);
2497                MuestraMenu(URLMENU);
2498                RegistraLog("Disponibilidad para comandos interactivos activada ...", false);
2499                ProcesaComandos(); // Bucle para procesar comandos interactivos
2500                RegistraLog("Disponibilidad para comandos interactivos desactivada...", false);
2501        }
2502        else{
2503                UltimoError(0,"Main()");       
2504                exit(EXIT_FAILURE);
2505        }
2506        exit(0);
2507}
2508
2509       
2510
2511
Note: See TracBrowser for help on using the repository browser.