source: admin/Services/ogAdmRepo/sources/ogAdmRepo.cpp @ 5eae07e

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

primeros archivos de administración

git-svn-id: https://opengnsys.es/svn/trunk@539 a21b9725-9963-47de-94b9-378ad31fedc9
  • Property mode set to 100644
File size: 34.1 KB
Line 
1//****************************************************************************************************************************************************
2//      Aplicación OpenGNSys
3//      Autor: José Manuel Alonso.
4//      Licencia: Open Source
5//      Fichero: ogAdmServer.cpp
6//      Descripción:
7//              Este módulo de la aplicación OpenGNSys implementa las comunicaciones con el Repositorio.
8// ****************************************************************************************************************************************************
9#include "ogAdmRepo.h"
10#include "encriptacion.c"
11// ________________________________________________________________________________________________________
12// Funcin�:RegistraLog
13//
14//              Descripcin�:
15//                      Esta funcin� registra los evento de errores en un fichero log
16//              Parametros:
17//                      - msg : Mensage de error
18//                      - swerrno: Switch que indica que recupere literal de error del sistema
19// ________________________________________________________________________________________________________
20void RegistraLog(const char *msg,int swerrno)
21{
22        time_t rawtime;
23        struct tm * timeinfo;
24
25        time ( &rawtime );
26        timeinfo = gmtime(&rawtime);
27
28        FLog=fopen(szPathFileLog,"at");
29        if(swerrno)
30                fprintf (FLog,"%02d/%02d/%d %02d:%02d ***%s:%s\n",timeinfo->tm_mday,timeinfo->tm_mon+1,timeinfo->tm_year+1900,timeinfo->tm_hour,timeinfo->tm_min,msg,strerror(errno));
31        else
32                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);
33        fclose(FLog);
34}
35
36//________________________________________________________________________________________________________
37// Funcinn: TomaConfiguracion
38//
39//              Descripcinn:
40//              Esta funcinn lee el fichero de configuracinn del programa
41//              Parametros:
42//                              - pathfilecfg : Ruta al fichero de configuracinn
43//________________________________________________________________________________________________________
44int TomaConfiguracion(char* pathfilecfg)
45{
46        long lSize;
47        char * buffer,*lineas[100],*dualparametro[2];
48        char ch[2];
49        int i,numlin,resul;
50
51        if(pathfilecfg==NULL) exit(EXIT_FAILURE);; // Nombre del fichero en blanco
52
53        Fconfig = fopen ( pathfilecfg , "rb" );
54        if (Fconfig==NULL)      exit(EXIT_FAILURE);;
55        fseek (Fconfig , 0 , SEEK_END);  // Obtiene tamaño del fichero.
56        lSize = ftell (Fconfig);
57        rewind (Fconfig);
58        buffer = (char*) malloc (lSize);  // Toma memoria para el buffer de lectura.
59        if (buffer == NULL)             exit(EXIT_FAILURE);;
60        fread (buffer,1,lSize,Fconfig);         // Lee contenido del fichero
61        fclose(Fconfig);
62
63        //inicializar
64        IPlocal[0]=(char)NULL;
65        servidorhidra[0]=(char)NULL;
66        Puerto[0]=(char)NULL;
67       
68        strcpy(ch,"\n");// caracter delimitador ( salto de linea)
69        numlin=split_parametros(lineas,buffer,ch);
70        for (i=0;i<numlin;i++){
71                strcpy(ch,"=");// caracter delimitador
72                split_parametros(dualparametro,lineas[i],ch); // Toma primer nombre del parametros
73
74                resul=strcmp(dualparametro[0],"IPlocal");
75                if(resul==0) strcpy(IPlocal,dualparametro[1]);
76
77                resul=strcmp(dualparametro[0],"IPhidra");
78                if(resul==0) strcpy(servidorhidra,dualparametro[1]);
79
80                resul=strcmp(dualparametro[0],"Puerto");
81                if(resul==0) strcpy(Puerto,dualparametro[1]);
82               
83        }
84        if(IPlocal[0]==(char)NULL){
85                RegistraLog("IPlocal, NO se ha definido este parámetro",false);
86                exit(EXIT_FAILURE);;
87        }
88        if(servidorhidra[0]==(char)NULL){
89                RegistraLog("IPhidra, NO se ha definido este parámetro",false);
90                exit(EXIT_FAILURE);;
91        }
92        if(Puerto[0]==(char)NULL){
93                RegistraLog("Puerto, NO se ha definido este parámetro",false);
94                exit(EXIT_FAILURE);;
95        }
96        puerto=atoi(Puerto);
97
98        return(TRUE);
99}
100// ________________________________________________________________________________________________________
101// Funcinn: INTROaFINCAD
102//
103//              Descripcinn?:
104//                      Cambia INTROS por caracteres fin de cadena ('\0') en una cadena
105//              Parametros:
106//                              - parametros : La cadena a explorar
107// ________________________________________________________________________________________________________
108void INTROaFINCAD(char* parametros)
109{
110        int lon,i;
111        lon=strlen(parametros);
112        for(i=0;i<lon;i++){ // Cambia los INTROS por NULOS
113                if(parametros[i]=='\r') parametros[i]='\0';
114        }
115}
116// ________________________________________________________________________________________________________
117// Funcinn: INTROaFINCAD
118//
119//              Descripcinn?:
120//                      Cambia INTROS por caracteres fin de cadena ('\0') en una cadena
121//              Parametros:
122//                              - parametros : La cadena a explorar
123// ________________________________________________________________________________________________________
124void FINCADaINTRO(char* a,char *b)
125{
126        char *i;
127        for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
128                if(*i=='\0') *i='\r';
129        }
130}
131// ________________________________________________________________________________________________________
132// Funcinn: toma_parametro
133//
134//              Descripcinn?:
135//                      Esta funci? devuelve el valor de un parametro incluido en la trmInfo.
136//                      El formato del protocolo es: "nombre_parametro=valor_parametro"
137//              Par?etros:
138//                      - nombre_parametro: Es el nombre del par?etro a recuperar
139//                      - parametros: Es la matriz que contiene todos los par?etros
140// ________________________________________________________________________________________________________
141char * toma_parametro(const char* nombre_parametro,char *parametros)
142{
143        int i=0;
144        char* pos;
145
146        for(i=0;i<LONGITUD_PARAMETROS-4;i++){
147                if(parametros[i]==nombre_parametro[0]){
148                        if(parametros[i+1]==nombre_parametro[1]){
149                                if(parametros[i+2]==nombre_parametro[2]){
150                                        if(parametros[i+3]=='='){
151                                                pos=&parametros[i+4];
152                                                return(pos);
153                                        }
154                                }
155                        }
156                }
157        }
158        return(NULL);
159}
160// ________________________________________________________________________________________________________
161// Funci�: split_parametros
162//
163//              Descripción:
164//                      Esta funci� trocea una cadena segn un car�ter delimitador, Devuelve el nmero de trozos
165//              Par�etros:
166//                      - trozos: Array de punteros a cadenas
167//                      - cadena: Cadena a trocear
168//                      - ch: Car�ter delimitador
169// ________________________________________________________________________________________________________
170int split_parametros(char **trozos,char *cadena, char * ch){
171        int i=0;
172        char* token;
173
174        token= strtok(cadena,ch); // Trocea segn delimitador
175        while( token != NULL ){
176                trozos[i++]=token;
177                token=strtok(NULL,ch); // Siguiente token
178        }
179        trozos[i++]=token;
180        return(i-1); // Devuelve el numero de trozos
181}
182//_______________________________________________________________________________________________________________
183//
184// Comprueba si la IP del cliente est?a en la base de datos de Hidra
185// parámetros:
186//              trmInfo: Puntero a la estructura de control de la conversacin DHCP
187//              ipmac: IP o MAC del cliente que ha abierto la hebra
188//              sw: Si vale 1 o 2 o 3 el parmetro anterior ser una IP en caso contrario ser una MAC
189//
190//      Devuelve:
191//              true: Si el cliente est en la base de datos
192//              false: En caso contrario
193//
194//  Comentarios:
195//              Slo se procesarn mensages dhcp de clientes hidra.
196//_______________________________________________________________________________________________________________
197int ClienteExistente(TramaRepos *trmInfo)
198{
199        char sqlstr[1000],ErrStr[200]; 
200        Database db;
201        Table tbl;
202
203        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
204        // ACCESO atnico A TRAVEZ DE OBJETO MUTEX a este trozo de cnigo
205        pthread_mutex_lock(&guardia);
206       
207        if(strcmp(servidorhidra,inet_ntoa(trmInfo->cliente.sin_addr))==0){ // Se trata del servidor hidra
208                pthread_mutex_unlock(&guardia);
209                return(true);
210        }
211
212        // Abre conexion con base de datos
213        if(!db.Open(usuario,pasguor,datasource,catalog)){ // error de conexion
214                db.GetErrorErrStr(ErrStr);
215                pthread_mutex_unlock(&guardia);
216                return(false);
217        }       
218       
219        sprintf(sqlstr,"SELECT ip FROM ordenadores WHERE ip='%s' ",inet_ntoa(trmInfo->cliente.sin_addr));
220        if(!db.Execute(sqlstr,tbl)){ // Error al leer
221                db.GetErrorErrStr(ErrStr);
222                pthread_mutex_unlock(&guardia);
223                db.Close();
224                return(false);
225        }
226
227        if(tbl.ISEOF()){ // No existe el cliente
228                db.Close();
229                pthread_mutex_unlock(&guardia);
230                return(false);
231        }
232        db.Close();
233        pthread_mutex_unlock(&guardia);
234        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
235        return(true);
236}
237//___________________________________________________________________________________________________
238// Funcin: inclusion_REPO
239//
240//              Descripcin:
241//                       Abre una sesin en el servidor Hidra
242//___________________________________________________________________________________________________
243int inclusion_REPO()
244{
245        TRAMA *trama;
246        SOCKET sock;
247        // Compone la trama
248        int lon;               
249
250        trama=(TRAMA*)malloc(LONGITUD_TRAMA);
251        if(!trama)
252                return(false);
253        lon=sprintf(trama->parametros,"nfn=inclusion_REPO\r");  // Nombre de la funcin a ejecutar en el servidor HIDRA
254        lon+=sprintf(trama->parametros+lon,"iph=%s\r",IPlocal); // Ip del ordenador
255
256        sock=Abre_conexion(servidorhidra,puerto);
257        if(sock==INVALID_SOCKET) {
258                sprintf(msglog,"Error al crear socket del Repositorio");
259                RegistraLog(msglog,false);
260                return(false);
261        }
262        envia_tramas(sock,trama);
263        recibe_tramas(sock,trama);
264        close(sock);
265        if(!RESPUESTA_inclusionREPO(trama)){
266                return(false);
267        }
268        return(true);
269}
270// ________________________________________________________________________________________________________
271// Funcin: Abre_conexion
272//
273//              Descripcin:
274//                      Crea un socket y lo conecta a un servidor
275//              parámetros:
276//                      - ips : La direccin IP del servidor
277//                      - port : Puerto para la comunicacin
278//              Devuelve:
279//                      - El socket o nulo dependiendo de si se ha establecido la comunicacin
280// ________________________________________________________________________________________________________
281SOCKET Abre_conexion(char *ips,int wpuerto)
282{
283    struct sockaddr_in server;
284        SOCKET s;
285        // Crea el socket y se intenta conectar
286        s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
287        if (s == INVALID_SOCKET){
288                return (INVALID_SOCKET);
289        }
290        server.sin_family = AF_INET;
291        server.sin_port = htons((short)wpuerto);
292        server.sin_addr.s_addr = inet_addr(ips);
293        if (connect(s, (struct sockaddr *)&server, sizeof(server)) == INVALID_SOCKET)
294                return (INVALID_SOCKET);
295        return(s); // Conectado
296}
297//___________________________________________________________________________________________________
298//
299//  Enva tramas al servidor HIDRA
300//___________________________________________________________________________________________________
301int envia_tramas(SOCKET s,TRAMA *trama)
302{
303        trama->arroba='@';                                                      // cabecera de la trama
304        strcpy(trama->identificador,"JMMLCAMDJ");       // identificador de la trama
305        trama->ejecutor='1';                                            // ejecutor de la trama 1=el servidor hidra  2=el cliente hidra
306
307        int nLeft,idx,ret;
308        Encriptar((char*)trama);
309        nLeft = strlen((char*)trama);
310        idx = 0;
311        while(nLeft > 0){
312                ret = send(s,(char*)&trama[idx], nLeft, 0);
313                if (ret == 0)
314                        break;
315                else
316                        if (ret == SOCKET_ERROR){
317                                return(false);
318                        }
319                nLeft -= ret;
320                idx += ret;
321        }
322        return(true);
323}
324//___________________________________________________________________________________________________
325//
326// Recibe tramas desde el servidor HIDRA
327//___________________________________________________________________________________________________
328int recibe_tramas(SOCKET s,TRAMA *trama)
329{
330        int ret;
331
332        ret = recv(s,(char*)trama,LONGITUD_TRAMA,0);
333        if (ret == 0) // Conexin cerrada por parte del cliente (Graceful close)
334                return (false);
335        else{
336                if (ret == SOCKET_ERROR){
337                        return (false);
338                }
339                else{ // Datos recibidos
340                        Desencriptar((char*)trama);
341                        trama->parametros[ret-11]=(char)NULL; // Coloca caracter fin de cadena en trama
342                        return(true);
343                }
344        }
345}
346//_______________________________________________________________________________________________________________
347//
348// Gestiona la conexion con un cliente que sea Hidra para el servicio de repositorio
349//_______________________________________________________________________________________________________________
350LPVOID GestionaServicioRepositorio(LPVOID lpParam)
351{
352        TramaRepos *trmInfo=(TramaRepos *)lpParam;
353       
354        Desencriptar((char*)&trmInfo->trama);
355        if (strncmp(trmInfo->trama.identificador,"JMMLCAMDJ",9)==0){ // Es una trmInfo hidra
356                //if(ClienteExistente(trmInfo)) // Comprueba que se trata de un cliente Hidra
357                        gestiona_comando(trmInfo);
358        }
359        free(trmInfo);
360        return(trmInfo);
361}
362//_______________________________________________________________________________________________________________
363//
364// Gestiona la conexion con un cliente que sea Hidra para el servicio de repositorio
365//_______________________________________________________________________________________________________________
366void NwGestionaServicioRepositorio(TramaRepos * trmInfo)
367{
368        Desencriptar((char*)&trmInfo->trama);
369        if (strncmp(trmInfo->trama.identificador,"JMMLCAMDJ",9)==0){ // Es una trmInfo hidra
370                //if(ClienteExistente(trmInfo)) // Comprueba que se trata de un cliente Hidra
371                        gestiona_comando(trmInfo);
372        }
373        free(trmInfo);
374}
375//_______________________________________________________________________________________________________________
376//
377// Gestiona la conexion con un cliente que sea Hidra para el servicio de repositorio
378//_______________________________________________________________________________________________________________
379int gestiona_comando(TramaRepos *trmInfo)
380{
381        char* nombrefuncion;
382        int resul;
383
384        INTROaFINCAD(trmInfo->trama.parametros);
385        nombrefuncion=toma_parametro("nfn=",trmInfo->trama.parametros); // Toma nombre funcin
386       
387       
388        resul=strcmp(nombrefuncion,"Arrancar");
389        if(resul==0)
390                return(Arrancar(trmInfo));
391               
392        resul=strcmp(nombrefuncion,"Apagar");
393        if(resul==0)
394                return(RegistraComando(trmInfo));       
395                       
396        resul=strcmp(nombrefuncion,"Reiniciar");
397        if(resul==0)
398                return(RegistraComando(trmInfo));               
399       
400        resul=strcmp(nombrefuncion,"FicheroOperador");
401        if(resul==0)
402                return(FicheroOperador(trmInfo));
403               
404        resul=strcmp(nombrefuncion,"Actualizar");
405        if(resul==0){
406                return(RegistraComando(trmInfo));
407        }
408
409        resul=strcmp(nombrefuncion,"IconoItem");
410        if(resul==0)
411                return(IconoItem(trmInfo));             
412               
413        resul=strcmp(nombrefuncion,"ExisteFichero");
414        if(resul==0)
415                return(ExisteFichero(trmInfo));
416       
417        resul=strcmp(nombrefuncion,"EliminaFichero");
418        if(resul==0)
419                return(EliminaFichero(trmInfo));
420
421        resul=strcmp(nombrefuncion,"LeeFicheroTexto");
422        if(resul==0)
423                return(LeeFicheroTexto(trmInfo));
424
425        resul=strcmp(nombrefuncion,"ExecShell");
426        if(resul==0)
427                return(RegistraComando(trmInfo));       
428
429        resul=strcmp(nombrefuncion,"TomaConfiguracion");
430        if(resul==0)
431                return(RegistraComando(trmInfo));       
432               
433        resul=strcmp(nombrefuncion,"InventarioHardware");
434        if(resul==0)
435                return(RegistraComando(trmInfo));                                       
436                       
437        resul=strcmp(nombrefuncion,"InventarioSoftware");
438        if(resul==0)
439                return(RegistraComando(trmInfo));               
440
441        resul=strcmp(nombrefuncion,"RestaurarImagen");
442        if(resul==0)
443                return(RegistraComando(trmInfo));               
444                                       
445        resul=strcmp(nombrefuncion,"CrearPerfilSoftware");
446        if(resul==0)
447                return(RegistraComando(trmInfo));       
448               
449        resul=strcmp(nombrefuncion,"ParticionaryFormatear");
450        if(resul==0)
451                return(RegistraComando(trmInfo));
452                       
453        return(false); 
454}
455//_____________________________________________________________________________________________________________
456// Funcinn: RegistraComando
457//
458//       Descripcinn:
459//              Crea un fichero de comando para cada cliente hidra
460//_____________________________________________________________________________________________________________
461int RegistraComando(TramaRepos *trmInfo)
462{
463        char* ipes[MAXIMOS_CLIENTES];
464        char ch[2];
465        int i,numipes,lon;
466        char nomfilecmd[1024];
467        FILE *Fcomandos;
468       
469        char *iph=toma_parametro("iph",trmInfo->trama.parametros); // Toma nombre funcin
470        if(!iph) return(false);
471        strcpy(ch,";");// caracter delimitador
472        numipes=split_parametros(ipes,iph,ch);
473       
474        FINCADaINTRO(trmInfo->trama.parametros,iph);
475        *(iph-4)=(char)NULL;
476        lon=strlen((char*)&trmInfo->trama);     
477       
478        //sprintf(msglog,"Registra comandos %s",(char*)&trmInfo->trama);
479        RegistraLog(msglog,false);
480       
481        for(i=0;i<numipes;i++){
482                strcpy(nomfilecmd,PathComandos);
483                strcat(nomfilecmd,"/CMD_");
484                strcat(nomfilecmd,ipes[i]);
485                //sprintf(msglog,"Crea fichero de comandos %s",nomfilecmd);
486                RegistraLog(msglog,false);
487               
488                Fcomandos=fopen( nomfilecmd,"w");
489                if(!Fcomandos) return(false);
490                //sprintf(msglog,"Fichero creado %s",nomfilecmd);
491                RegistraLog(msglog,false);
492               
493                fwrite((char*)&trmInfo->trama,lon,1,Fcomandos);
494                fclose(Fcomandos);
495        }
496        return(true);
497}
498//_____________________________________________________________________________________________________________
499// Funcin: Arrancar
500//
501//       Descripcinn:
502//              Esta funcinn enciende un ordenadores
503//      Parámetros de entrada:
504//              - parametros: Cadena con las mac de los ordenadores que se van a arrancar separadas por punto y coma
505//_____________________________________________________________________________________________________________
506int Arrancar(TramaRepos *trmInfo)
507{
508        int i,nummacs;
509        char* macs[MAXIMOS_CLIENTES];
510        char ch[2]; // Caracter delimitador
511
512        char *mac=toma_parametro("mac",trmInfo->trama.parametros); // Toma Mac
513        strcpy(ch,";");// caracter delimitador
514        nummacs=split_parametros(macs,mac,ch);
515        for(i=0;i<nummacs;i++){
516                levanta(macs[i]);
517        }
518        return(RegistraComando(trmInfo));
519}
520//_____________________________________________________________________________________________________________
521// Funcinn: levanta
522//
523// Descripcion:
524//    Enciende el ordenador cuya MAC se pasa como parámetro
525//      Parámetros de entrada:
526//              - mac: La mac del ordenador
527//_____________________________________________________________________________________________________________
528int levanta(char * mac)
529{
530        BOOL          bOpt;
531        SOCKET            s;
532    sockaddr_in   local;
533        int     ret;
534
535        int puertowakeup=PUERTO_WAKEUP;
536        s = socket(AF_INET, SOCK_DGRAM, 0); // Crea socket
537        if (s == INVALID_SOCKET) {
538                RegistraLog("Fallo en creacin de socket, mndulo levanta",true);
539                return(FALSE);
540        }
541        bOpt = TRUE;    // Pone el socket en modo Broadcast
542        ret = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *)&bOpt,sizeof(bOpt));
543        if (ret == SOCKET_ERROR){
544                RegistraLog("Fallo en funcinn setsockopt(SO_BROADCAST), mndulo levanta",true);
545                return(FALSE);
546    }
547    local.sin_family = AF_INET;
548    local.sin_port = htons((short)puertowakeup);
549        local.sin_addr.s_addr = htonl(INADDR_ANY); // cualquier interface
550    if (bind(s, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR){
551                RegistraLog("Fallo en funcinn bind(), mndulo levanta",true);
552                return(FALSE);
553    }
554        Wake_Up(s,mac);
555        close(s);
556        return(TRUE);
557}
558//_____________________________________________________________________________________________________________
559// Funcinn: Wake_Up
560//
561//       Descripcion:
562//              Enciende el ordenador cuya MAC se pasa como parámetro
563//      Parámetros:
564//              - s : Socket para enviar trama en modo broadcast o a la ip del ordenador en cuestin
565//              - mac : Cadena con el contenido de la mac
566//_____________________________________________________________________________________________________________
567int Wake_Up(SOCKET s,char * mac)
568{
569        int i,ret;
570        char HDaddress_bin[6];
571        struct {
572                BYTE secuencia_FF[6];
573                char macbin[16][6];
574        }Trama_WakeUp;
575    sockaddr_in    WakeUpCliente;
576
577        int puertowakeup=PUERTO_WAKEUP;
578        for (i=0;i<6;i++)       // Primera secuencia de la trama Wake Up (0xFFFFFFFFFFFF)
579                Trama_WakeUp.secuencia_FF[i] = 0xFF;
580        PasaHexBin( mac,HDaddress_bin); // Pasa a binario la MAC
581        for (i=0;i<16;i++) // Segunda secuencia de la trama Wake Up , repetir 16 veces su la MAC
582                memcpy( &Trama_WakeUp.macbin[i][0], &HDaddress_bin, 6 );
583        WakeUpCliente.sin_family = AF_INET;
584    WakeUpCliente.sin_port = htons((short)puertowakeup);
585    WakeUpCliente.sin_addr.s_addr = htonl(INADDR_BROADCAST); //  Para hacerlo con broadcast
586        ret = sendto(s,(char *)&Trama_WakeUp, sizeof(Trama_WakeUp), 0,(sockaddr *)&WakeUpCliente, sizeof(WakeUpCliente));
587    if (ret == SOCKET_ERROR){
588                RegistraLog("Fallo en funcinn send(), mndulo Wake_Up",true);
589                return(FALSE);
590        }
591        return 0;
592}
593//_____________________________________________________________________________________________________________
594// Funcinn: PasaHexBin
595//
596//              Descripcion:
597//                      Convierte a binario una direccinn mac desde una cadena de longitud 12
598//
599//              Parámetros de entrada:
600//                      - cadena : Cadena con el contenido de la mac
601//              Parámetros de salida:
602//                      - numero : la direccinn mac convertida a binario (6 bytes)
603//_____________________________________________________________________________________________________________
604void PasaHexBin( char *cadena,char *numero)
605{
606        int i,j,p;     
607        char matrizHex[]="0123456789ABCDEF";
608        char Ucadena[12], aux;
609
610        for (i=0;i<12;i++)
611                Ucadena[i]=toupper(cadena[i]);
612        p=0;
613        for (i=0;i<12;i++){
614                for (j=0;j<16;j++){
615                        if (Ucadena[i]==matrizHex[j]){
616                                if (i%2){
617                                        aux=numero[p];
618                                        aux=(aux << 4);
619                                        numero[p]=j;
620                                        numero[p]=numero[p] | aux;
621                                        p++;
622                                }
623                                else
624                                        numero[p]=j;
625                                break;
626                        }
627                }
628        }
629}
630//_____________________________________________________________________________________________________________
631// Funcinn: FicheroOperador
632//
633//       Descripcinn:
634//              Crea un fichero para que un operador de aula o administrador de centro pueda entrar en el menú privado de los clientes rembo
635//      Parámetros de entrada:
636//              - parametros: Parámetros del comando
637//_____________________________________________________________________________________________________________
638int FicheroOperador(TramaRepos *trmInfo)
639{
640        FILE *FLogin;
641        char *amb,*usu,*psw,*ida;
642        char nomfilelogin[250];
643        char nomcmd[512];
644        int op,resul,ext;
645
646        amb=toma_parametro("amb",trmInfo->trama.parametros); // Toma operacion: Alta,o Baja
647        usu=toma_parametro("usu",trmInfo->trama.parametros); // Toma nombre del fichero de login de operador
648        psw=toma_parametro("psw",trmInfo->trama.parametros); // Toma login del fichero de login de operador
649        ida=toma_parametro("ida",trmInfo->trama.parametros); // Toma identificador del aula
650        strcpy(nomfilelogin,PathUsuarios);
651        strcat(nomfilelogin,usu);
652        ext=atoi(ida);
653        if(ext>0){
654                strcat(nomfilelogin,"-");
655                strcat(nomfilelogin,ida);
656        }
657        op=atoi(amb);
658        switch(op){
659                case 1:
660                        FLogin=fopen( nomfilelogin,"w");
661                        if(FLogin==NULL)
662                                RegistraLog("PathComandos, NO existe el Path para el fichero de login de operador ",false);
663                        Encriptar(psw);
664                        fprintf (FLogin,"%s",psw);
665                        fclose(FLogin);
666                        break;
667                case 3:
668                        strcpy(nomcmd,"rm -f ");
669                        strcat(nomcmd,nomfilelogin);
670                        resul=system(nomcmd);
671                        break;
672        }
673        return(true);
674}
675//_____________________________________________________________________________________________________________
676// Funcinn: FicheroOperador
677//
678//       Descripcinn:
679//              Crea un fichero para que un operador de aula o administrador de centro pueda entrar en el menú privado de los clientes rembo
680//      Parámetros de entrada:
681//              - parametros: Parámetros del comando
682//_____________________________________________________________________________________________________________
683int IconoItem(TramaRepos *trmInfo)
684{
685        FILE *FIcono;
686        char *nii,*amb,*lii,*iit;
687        int lon,op,resul;
688        char nomfileicono[250];
689        char nomcmd[260];
690       
691        nii=toma_parametro("nii",trmInfo->trama.parametros); // Toma el nombre del fichero
692        amb=toma_parametro("amb",trmInfo->trama.parametros); // Toma operacion: Alta,o Baja
693        lii=toma_parametro("lii",trmInfo->trama.parametros); // Toma longitud del fichero de icono
694        iit=toma_parametro("iit",trmInfo->trama.parametros); // Toma contenido del fichero de icono
695        lon=atoi(lii);
696        op=atoi(amb);
697        strcpy(nomfileicono,PathIconos);
698        strcat(nomfileicono,nii);
699        switch(op){
700                case 1:
701                        FIcono=fopen( nomfileicono,"w");
702                        fwrite (iit,lon,1,FIcono);
703                        fclose(FIcono);
704                        break;
705                case 3:
706                        strcpy(nomcmd,"rm -f ");
707                        strcat(nomcmd,nomfileicono);
708                        resul=system(nomcmd);
709                        break;
710        }
711        return(true);
712}
713//_______________________________________________________________________________________________________________
714//
715// Comprueba si existe un fichero
716//_______________________________________________________________________________________________________________
717bool ExisteFichero(TramaRepos *trmInfo)
718{
719        FILE *f;
720        char swf[2];
721        char pathfile[250];
722                       
723        char *nomfile=toma_parametro("nfl",trmInfo->trama.parametros); // Toma nombre funcin
724        sprintf(pathfile,"%s%s",PathHidra,nomfile);
725       
726        f = fopen(pathfile,"rt");
727        if(f==NULL)
728                strcpy(swf,"0");
729        else
730                strcpy(swf,"1");
731        if(f) fclose(f);
732        return(respuesta_peticion(trmInfo,"Respuesta_ExisteFichero",swf,nomfile));
733}
734//_______________________________________________________________________________________________________________
735//
736// Envia respuesta a peticin de comando
737//_______________________________________________________________________________________________________________
738bool respuesta_clienteHidra(TramaRepos *trmInfo)
739{
740        int ret;
741        //MandaRespuesta
742        Encriptar((char*)&trmInfo->trama);
743        ret=sendto(trmInfo->sck,(char*)&trmInfo->trama,strlen(trmInfo->trama.parametros)+11,0,(struct sockaddr*)&trmInfo->cliente,trmInfo->sockaddrsize);
744        if (ret == SOCKET_ERROR){
745                RegistraLog("***sendto() fallo al enviar respuesta modulo respuesta_clienteHidra() :",true);
746                return(false);
747        }
748        return(true);   
749}
750//_______________________________________________________________________________________________________________
751//
752// Envia respuesta a peticin de comando
753//_______________________________________________________________________________________________________________
754bool respuesta_peticion(TramaRepos *trmInfo,const char *LitRes,char* swf,char*txt)
755{
756        int lon,ret;
757        TRAMA *trama=(TRAMA*)malloc(LONGITUD_TRAMA);
758        if(!trama){
759                RegistraLog("No hay memoria suficiente para enviar la respuesta al comando",false);
760                return(false);
761        }
762        trama->arroba='@';
763        strncpy(trama->identificador,"JMMLCAMDJ",9);
764        trama->ejecutor='1';
765        lon=sprintf(trama->parametros,"nfn=%s\r",LitRes);
766        lon+=sprintf(trama->parametros+lon,"res=%s\r",swf);             
767        lon+=sprintf(trama->parametros+lon,"txt=%s\r",txt);             
768        //MandaRespuesta
769        Encriptar((char*)trama);
770        ret=sendto(trmInfo->sck,(char*)trama,lon+11,0,(struct sockaddr*)&trmInfo->cliente,trmInfo->sockaddrsize);
771        if (ret == SOCKET_ERROR){
772                RegistraLog("***sendto() fallo al enviar respuesta a peticin de comando:",true);
773                return(false);
774        }
775        return(true);   
776}
777//_______________________________________________________________________________________________________________
778//
779// Comprueba si existe un fichero
780//_______________________________________________________________________________________________________________
781bool EliminaFichero(TramaRepos *trmInfo)
782{
783        char swf[2];
784        char cmdshell[512];
785        int res;
786        char pathfile[250];
787       
788        char *nomfile=toma_parametro("nfl",trmInfo->trama.parametros); // Toma nombre funcin
789        sprintf(pathfile,"%s%s",PathHidra,nomfile);
790        sprintf(cmdshell,"rm -f %s",pathfile);
791        res=system(cmdshell);
792        if(res==0)
793                strcpy(swf,"1");
794        else
795                strcpy(swf,"0");
796        return(respuesta_peticion(trmInfo,"Respuesta_EliminaFichero",swf,nomfile));
797}
798//_______________________________________________________________________________________________________________
799//
800// Comprueba si existe un fichero
801//_______________________________________________________________________________________________________________
802bool LeeFicheroTexto(TramaRepos *trmInfo)
803{
804        char *texto;
805        long lSize;
806        FILE *f;       
807        char pathfile[250];
808        char swf[2];
809       
810        char *nomfile=toma_parametro("nfl",trmInfo->trama.parametros); // Toma nombre funcin
811        sprintf(pathfile,"%s%s",PathHidra,nomfile);
812       
813        f = fopen(pathfile,"rt");
814        if(!f){ // El fichero no existe
815                texto=(char*)malloc(2);
816                strcpy(texto," ");
817                strcpy(swf,"0");
818        }
819        else{
820                fseek(f,0,SEEK_END);
821                lSize=ftell(f);
822                texto=(char*)malloc(lSize);
823                if(!texto){
824                        texto=(char*)malloc(2);
825                        strcpy(texto," ");
826                        strcpy(swf,"0");
827                }
828                else{                           
829                        rewind (f);                                                             // Coloca al principio el puntero de lectura
830                        fread (texto,1,lSize,f);        // Lee el contenido del fichero
831                        strcpy(swf,"1");
832                        fclose(f);
833                }
834        }
835        return(respuesta_peticion(trmInfo,"Respuesta_LeeFicheroTexto",swf,texto));
836}
837
838//_________________________________________________________________________________________________
839//      Funcin: Buffer
840//
841//      Descripcin:
842//              Reserva memoria 
843//      parámetros:
844//              - l:    Longitud en bytes de la reserva
845//      Devuelve:
846//              Un puntero a la memoria reservada
847//___________________________________________________________________________________________________
848char * Buffer(int l)
849{
850        char *buf;
851        buf=(char*)malloc(l);
852        if(buf==NULL){
853                RegistraLog("*** fallo de reserva de memoria en modulo Buffer()",true);
854                return(false);
855        }
856        memset(buf,0,l);       
857        return(buf);
858}
859//_______________________________________________________________________________________________________________
860//
861// Crea un socket en un puerto determinado para la conversacin UDP con el repositorio
862//
863//_______________________________________________________________________________________________________________
864int TomaPuertoLibre(int * puerto)
865{
866        SOCKET socket_c; // Socket para hebras (UDP)
867        struct sockaddr_in cliente;
868        int puertolibre;
869
870        socket_c = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Crea socket para UDP
871
872        if (socket_c == SOCKET_ERROR)
873                return (false);
874
875        cliente.sin_addr.s_addr = inet_addr(IPlocal); // selecciona interface
876        cliente.sin_family = AF_INET;
877        puertolibre=PUERTOMINUSER;
878        while(puertolibre<PUERTOMAXUSER){ // Busca puerto libre
879                cliente.sin_port = htons(puertolibre); // Puerto asignado
880                if (bind(socket_c,(struct sockaddr *)&cliente,sizeof(cliente)) == SOCKET_ERROR)
881                        puertolibre++;
882                else
883                        break;
884        }
885        if(puertolibre>=PUERTOMAXUSER){ // No hay puertos libres
886                return(INVALID_SOCKET);
887        }
888        *puerto=puertolibre;
889        return(true);
890}
891//________________________________________________________________________________________________________
892// Funcinn: TomaRestoConfiguracion;
893//
894//              Descripcinn:
895//              Esta funcinn lee la trama respuesta de inclusin del repositorio hidra
896
897//________________________________________________________________________________________________________
898int RESPUESTA_inclusionREPO(TRAMA *trama)
899{
900
901        INTROaFINCAD(trama->parametros);
902        char* prm;
903        prm=toma_parametro("prp",trama->parametros); // Puero de comunicaciones
904       
905        if (prm == NULL){
906                RegistraLog("ATENCIÓN.- Este repositorio no está dado de alta en el sistema. Utilice la consola de administración para hacer esto.",false);
907                return(false);
908     }
909       
910        puertorepo=atoi(prm);
911        prm=toma_parametro("pth",trama->parametros); // Path al directorio base de Hidra
912        strcpy(PathHidra,prm);
913        prm=toma_parametro("ptx",trama->parametros); // Path al directorio PXE
914        strcpy(PathPXE,prm);
915       
916        strcpy(PathUsuarios,PathHidra);
917        strcpy(PathIconos,PathHidra);
918        strcpy(PathComandos,PathHidra);
919        strcat(PathComandos,"/comandos");
920        strcat(PathUsuarios,"/usuarios/");
921        strcat(PathIconos,"/iconos/");
922       
923        prm=toma_parametro("usu",trama->parametros); // usuario acceso B.D.
924        strcpy(usuario,prm);
925        prm=toma_parametro("pwd",trama->parametros); // Pasword
926        strcpy(pasguor,prm);
927        prm=toma_parametro("dat",trama->parametros); // Ip gestor de datos
928        strcpy(datasource,prm);
929        prm=toma_parametro("cat",trama->parametros); // Nombre B.D.
930        strcpy(catalog,prm);
931
932        return(true);
933}
934//***************************************************************************************************************
935// PROGRAMA PRINCIPAL
936//***************************************************************************************************************
937
938
939
940
941int main(int argc, char **argv)
942{
943    SOCKET socket_s; // Socket donde escucha el repositorio
944        TramaRepos *trmInfo;
945        struct sockaddr_in local;
946        int i,ret;
947
948        strcpy(szPathFileCfg,"ogAdmRepo.cfg");
949        strcpy(szPathFileLog,"ogAdmRepo.log"); 
950        for(i = 1; i < argc; i++){
951       if (argv[i][0] == '-'){
952           switch (tolower(argv[i][1])){
953               case 'f':
954                   if (argv[i+1]!=NULL)
955                       strcpy(szPathFileCfg, argv[i+1]);
956                                else{
957                                        RegistraLog("Fallo en los parámetros: Debe especificar el fichero de configuracin del servicio",false);
958                                        exit(EXIT_FAILURE);
959                                }
960                   break;
961               case 'l':
962                   if (argv[i+1]!=NULL)
963                       strcpy(szPathFileLog, argv[i+1]);
964                                else{
965                                        RegistraLog("Fallo en los parámetros: Debe especificar el fichero de log para el servicio",false);
966                                        exit(EXIT_FAILURE);
967                                }
968                   break;
969               default:
970                        RegistraLog("Fallo de sintaxis en los parámetros: Debe especificar -f nombre_del_fichero_de_configuracin_del_servicio -l nombre_del_fichero_de_log_del_servicio",false);
971                                        exit(EXIT_FAILURE);
972                   break;
973           }
974       }
975    }
976        if(!TomaConfiguracion(szPathFileCfg)){ // Toma parametros de configuracion
977                RegistraLog("NO existe fichero de configuración o contiene un error de sintaxis",false);
978                exit(EXIT_FAILURE);
979        }
980        if(!inclusion_REPO()){
981                RegistraLog("Ha habido algún problema al abrir sesión con el servidor de administración",false);
982                exit(EXIT_FAILURE);
983        }
984       
985        RegistraLog("***Inicio de sesion***",false);
986
987        socket_s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Crea socket para UDP
988        if (socket_s == SOCKET_ERROR){
989                RegistraLog("***Error al crear socket para servicio del Repositorio:",true);
990                exit(EXIT_FAILURE);
991        }
992        RegistraLog("***Creando Socket para comunicaciones***",false);
993       
994        local.sin_addr.s_addr = inet_addr(IPlocal);// selecciona interface
995        local.sin_family = AF_INET;     
996        local.sin_port = htons(puertorepo); // Puerto
997
998        // Enlaza socket
999        if (bind(socket_s,(struct sockaddr *)&local,sizeof(local)) == SOCKET_ERROR){
1000                RegistraLog("***Error al enlazar socket con interface para servicio de Repositorio Hidra",true);
1001                exit(EXIT_FAILURE);;
1002        }
1003        RegistraLog("***Enlazado Socket para comunicaciones***",false);
1004        while(true){
1005                trmInfo = (TramaRepos*)malloc(sizeof(TramaRepos)); // Crea estructura de control para hebra
1006        if (trmInfo == NULL){
1007                        RegistraLog("***Fallo al crear estructura de control para protocolo REPO",false);
1008                        exit(EXIT_FAILURE);;
1009        }
1010                // Inicializa trmInfo
1011                memset(trmInfo,0,sizeof(struct  TramaRepos));
1012                trmInfo->sockaddrsize = sizeof(trmInfo->cliente);
1013                trmInfo->sck=socket_s;
1014                // Espera trmInfos Repositorio
1015                ret = recvfrom(trmInfo->sck,(char *)&trmInfo->trama, sizeof(trmInfo->trama),0,(struct sockaddr *)&trmInfo->cliente, &trmInfo->sockaddrsize);
1016                if (ret == SOCKET_ERROR){
1017                        RegistraLog("***Error al recibir mensaje de cliente hidra. Se para el servicio de repositorio",true);
1018                        exit(EXIT_FAILURE);
1019                }
1020                else{
1021                        if (ret>0){
1022                                /*
1023                                resul=pthread_create(&hThread,NULL,GestionaServicioRepositorio,(LPVOID)trmInfo);
1024                                if(resul!=0){
1025                                        RegistraLog("***Fallo al crear la hebra cliente de repositorio Hidra",false);
1026                                exit(EXIT_FAILURE);
1027                        }
1028                        pthread_detach(hThread);       
1029                        */
1030                                NwGestionaServicioRepositorio(trmInfo);
1031                        }
1032                }
1033        }
1034        close(socket_s);
1035        exit(EXIT_SUCCESS);
1036}
Note: See TracBrowser for help on using the repository browser.