source: admin/Services/ogAdmClient/sources/ogAdmClient.c @ af6c52a

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 af6c52a was d08ec1cc, checked in by alonso <alonso@…>, 16 years ago

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