source: admin/Sources/Includes/ogAdmLib.c @ b8065e8

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 b8065e8 was f679cf0, checked in by ramon <ramongomez@…>, 13 years ago

#501: Integrar ticket en rama de desarrollo.

git-svn-id: https://opengnsys.es/svn/branches/version1.0@2931 a21b9725-9963-47de-94b9-378ad31fedc9

  • Property mode set to 100644
File size: 34.7 KB
Line 
1// **************************************************************************************************************************************************
2// Libreria: ogAdmLib
3// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
4// Fecha Creación: Marzo-2010
5// Fecha Última modificación: Marzo-2010
6// Nombre del fichero: ogAdmLib.c
7// Descripción: Este fichero implementa una libreria de funciones para uso común de los servicios
8// **************************************************************************************************************************************************
9// ________________________________________________________________________________________________________
10// Función: encriptar
11//
12//      Descripción:
13//              Encripta una cadena
14//      Parametros:
15//              - cadena : Cadena a encriptar
16//              - ret : Longitud de la caden cadena encriptada
17// ________________________________________________________________________________________________________
18char * encriptar(char *cadena,int*ret)
19{
20        /*
21        int i,lon;
22        char clave;
23       
24        clave = 12 & 0xFFU; // La clave elegida entre 0-255, en este caso 12
25        lon=strlen(cadena);
26        for(i=0;i<lon;i++)
27      cadena[i]=((char)cadena[i] ^ clave) & 0xFF;
28        *ret=lon;
29        */
30        return(cadena);
31}
32// ________________________________________________________________________________________________________
33// Función: desencriptar
34//
35//      Descripción:
36//              Desencripta una cadena
37//      Parametros:
38//              - cadena : Cadena a desencriptar
39//              - ret : Longitud de la caden cadena encriptada
40// ________________________________________________________________________________________________________
41char * desencriptar(char *cadena,int* ret)
42{
43        /*
44        int i,lon;
45        char clave;
46       
47        clave = 12 & 0xFFU; // La clave elegida entre 0-255, en este caso 12
48        lon=strlen(cadena);
49        for(i=0;i<lon;i++)
50                cadena[i]=((char)cadena[i] ^ clave) & 0xFF;
51        *ret=lon;
52        */
53        return(cadena);
54
55}
56// ________________________________________________________________________________________________________
57// Función: tomaHora
58//
59//      Descripción:
60//              Devuelve la hora del sistema
61//      Parametros:
62//              Ninguno
63// ________________________________________________________________________________________________________
64struct tm * tomaHora()
65{
66        time_t rawtime;
67        time ( &rawtime );
68        return(localtime(&rawtime));
69}
70// ________________________________________________________________________________________________________
71// Función: registraLog
72//
73//      Descripción:
74//              Registra los eventos en un fichero log ya sean errores o información
75//      Parametros:
76//              - fileLog : Ruta completa del archivo de log
77//              - msg : Descripción del error
78//              - swe: Switch que indica si se debe recuperar además el literal de error del propio sistema operativo
79// ________________________________________________________________________________________________________
80void registraLog(const char* filelog,const char *msg,int swe)
81{
82        FILE *flog;
83        struct tm * t;
84
85        t = tomaHora();
86        flog=fopen(filelog,"at");
87        if(swe)
88                fprintf (flog,"%02d/%02d/%d %02d:%02d %s: %s\n",t->tm_mday,t->tm_mon+1,t->tm_year+1900,t->tm_hour,t->tm_min,msg,strerror(errno));
89        else
90                fprintf (flog,"%02d/%02d/%d %02d:%02d %s\n",t->tm_mday,t->tm_mon+1,t->tm_year+1900,t->tm_hour,t->tm_min,msg);
91        fclose(flog);
92}
93// ________________________________________________________________________________________________________
94// Función: errorLog
95//
96//      Descripción:
97//              Registra los sucesos de errores preestablecidos en el fichero de log
98//      Parametros:
99//              - coderr : Código del mensaje de error
100//              - swe: Switch que indica si se debe recuperar además el literal de error del propio sistema operativo
101// ________________________________________________________________________________________________________
102void errorLog(const char *modulo, int coderr, int swe) {
103        char msglog[LONSUC];
104
105        sprintf(msglog, "*** Error: %s. Módulo %s", tbErrores[coderr], modulo);
106        registraLog(szPathFileLog, msglog, swe);
107}
108// ________________________________________________________________________________________________________
109// Función: errorInfo
110//
111//      Descripción:
112//              Registra los sucesos de errores dinámicos en el fichero de log
113//      Parametros:
114//              - msgerr : Descripción del error
115//              - swe: Switch que indica si se debe recuperar además el literal de error del propio sistema operativo
116// ________________________________________________________________________________________________________
117void errorInfo(const char *modulo, char *msgerr) {
118        char msglog[LONSUC];
119
120        sprintf(msglog, "*** Error: %s. Módulo %s", msgerr, modulo);
121        registraLog(szPathFileLog, msglog, FALSE);
122}
123// ________________________________________________________________________________________________________
124// Función: infoLog
125//
126//      Descripción:
127//              Registra los sucesos de información en el fichero de log
128//      Parametros:
129//              - coderr : Código del mensaje de información
130// ________________________________________________________________________________________________________
131void infoLog(int codinf) {
132        char msglog[LONSUC];
133
134        sprintf(msglog, "*** Info: %s", tbMensajes[codinf]);
135        registraLog(szPathFileLog, msglog, FALSE);
136}
137// ________________________________________________________________________________________________________
138// Función: infoDebug
139//
140//      Descripción:
141//              Registra los mensajes de debugs en el fichero de log
142//      Parametros:
143//              - msgdeb : Descripción del mensaje de información
144// ________________________________________________________________________________________________________
145void infoDebug(char* msgdeb) {
146        char msglog[LONSUC];
147
148        sprintf(msglog, "*** Debug: %d-%s", ndebug, msgdeb);
149        registraLog(szPathFileLog, msglog, FALSE);
150}
151//______________________________________________________________________________________________________
152// Función: ValidacionParametros
153//
154//       Descripción:
155//              Valida que los parametros de ejecución del programa sean correctos
156//      Parámetros:
157//              - argc: Número de argumentos
158//              - argv: Puntero a cada argumento
159//              - eje:  Tipo de ejecutable (1=Servicio,2=Repositorio o 3=Cliente)
160//      Devuelve:
161//              - TRUE si los argumentos pasados son correctos
162//              - FALSE en caso contrario
163//      Especificaciones:
164//              La sintaxis de los argumentos es la siguiente
165//                      -f      Archivo de configuración del servicio
166//                      -l      Archivo de logs
167//                      -d      Nivel de debuger (mensages que se escribirán en el archivo de logs)
168//      Devuelve:
169//              TRUE: Si el proceso es correcto
170//              FALSE: En caso de ocurrir algún error
171//______________________________________________________________________________________________________
172BOOLEAN validacionParametros(int argc, char*argv[],int eje) {
173        int i;
174        char modulo[] = "validacionParametros()";
175
176        switch(eje){
177                case 1: // Administrador
178                        strcpy(szPathFileCfg, "ogAdmServer.cfg"); // Valores por defecto de archivos
179                        strcpy(szPathFileLog, "ogAdmServer.log"); // de configuración y de logs
180                        break;
181                case 2: // Repositorio
182                        strcpy(szPathFileCfg, "ogAdmRepo.cfg"); // Valores por defecto de archivos
183                        strcpy(szPathFileLog, "ogAdmRepo.log"); // de configuración y de logs
184                        break;
185                case 3: // Cliente OpenGnsys
186                        strcpy(szPathFileCfg, "ogAdmClient.cfg"); // Valores por defecto de archivos
187                        strcpy(szPathFileLog, "ogAdmClient.log"); // de configuración y de logs
188                        break;
189                case 4: // Servicios DHCP,BOOTP Y TFTP
190                        strcpy(szPathFileCfg, "ogAdmBoot.cfg"); // Valores por defecto de archivos
191                        strcpy(szPathFileLog, "ogAdmBoot.log"); // de configuración y de logs
192                        break;
193                case 5: // Agente
194                        strcpy(szPathFileCfg, "ogAdmAgent.cfg"); // Valores por defecto de archivos
195                        strcpy(szPathFileLog, "ogAdmAgent.log"); // de configuración y de logs
196                        break;
197                case 6: // Agente
198                        strcpy(szPathFileCfg, "ogAdmWinClient.cfg"); // Valores por defecto de archivos
199                        strcpy(szPathFileLog, "ogAdmWinClient.log"); // de configuración y de logs
200                        break;                 
201        }
202
203        ndebug = 1; // Nivel de debuger por defecto
204
205        for (i = 1; (i + 1) < argc; i += 2) {
206                if (argv[i][0] == '-') {
207                        switch (tolower(argv[i][1])) {
208                        case 'f':
209                                if (argv[i + 1] != NULL)
210                                        strcpy(szPathFileCfg, argv[i + 1]);
211                                else {
212                                        errorLog(modulo, 10, FALSE);
213                                        return (FALSE);
214                                }
215                                break;
216                        case 'l':
217                                if (argv[i + 1] != NULL)
218                                        strcpy(szPathFileLog, argv[i + 1]);
219                                else {
220                                        errorLog(modulo, 11, FALSE);
221                                        return (FALSE);
222                                }
223                                break;
224                        case 'd':
225                                if (argv[i + 1] != NULL) {
226                                        ndebug = atoi(argv[i + 1]);
227                                        if (ndebug < 1)
228                                                ndebug = 1; // Por defecto el nivel de debug es 1
229                                } else
230                                        ndebug = 1; // Por defecto el nivel de debug es 1
231                                break;
232                        default:
233                                errorLog(modulo, 12, FALSE);
234                                exit(EXIT_FAILURE);
235                                break;
236                        }
237                }
238        }
239        return (TRUE);
240}
241//______________________________________________________________________________________________________
242// Función: reservaMemoria
243//
244//      Descripción:
245//              Reserva memoria para una variable
246//      Parámetros:
247//              - lon:  Longitud en bytes de la reserva
248//      Devuelve:
249//              Un puntero a la zona de memoria reservada que ha sido previamente rellena con zeros o nulos
250//______________________________________________________________________________________________________
251char* reservaMemoria(int lon)
252{
253        char *mem;
254
255        mem=(char*)malloc(lon);
256        if(mem!=NULL)
257                memset(mem,0,lon);
258        return(mem);
259}
260//______________________________________________________________________________________________________
261// Función: ampliaMemoria
262//
263//      Descripción:
264//              Amplia memoria para una variable
265//      Parámetros:
266//              - ptr:  Puntero al buffer de memoria que se quiere ampliar
267//              - lon:  Longitud en bytes de la amplicación
268//      Devuelve:
269//              Un puntero a la zona de memoria reservada que ha sido previamente rellena con zeros o nulos
270//______________________________________________________________________________________________________
271char* ampliaMemoria(char* ptr,int lon)
272{
273        char *mem;
274
275        mem=(char*)realloc(ptr,lon*sizeof(char*));
276        if(mem!=NULL)
277                return(mem);
278        return(NULL);
279}
280//______________________________________________________________________________________________________
281// Función: liberaMemoria
282//
283//      Descripción:
284//              Libera memoria para una variable
285//      Parámetros:
286//              - ptr:  Puntero al buffer de memoria que se quiere liberar
287//      Devuelve:
288//              Nada
289//______________________________________________________________________________________________________
290void liberaMemoria(char* ptr)
291{
292        if(ptr)
293                free (ptr);
294}
295// ________________________________________________________________________________________________________
296// Función: splitCadena
297//
298//      Descripción:
299//                      Trocea una cadena según un carácter delimitador
300//      Parámetros:
301//                      - trozos: Array de punteros a cadenas
302//                      - cadena: Cadena a trocear
303//                      - chd: Carácter delimitador
304//      Devuelve:
305//              Número de trozos en que se divide la cadena
306// ________________________________________________________________________________________________________
307int splitCadena(char **trozos,char *cadena, char chd)
308{
309        int w=0;
310        if(cadena==NULL) return(w);
311
312        trozos[w++]=cadena;
313        while(*cadena!='\0'){
314                if(*cadena==chd){
315                        *cadena='\0';
316                        if(*(cadena+1)!='\0')
317                                trozos[w++]=cadena+1;
318                }
319                cadena++;
320        }
321        return(w); // Devuelve el número de trozos
322}
323// ________________________________________________________________________________________________________
324// Función: sustituir
325//
326//      Descripción:
327//                      Sustituye las apariciones de un caracter por otro en una cadena
328//      Parámetros:
329//                      - cadena: Cadena a convertir
330//                      - cho: Caracter a sustituir
331//                      - chs: Caracter sustituto
332// ________________________________________________________________________________________________________
333void sustituir(char *cadena,char cho,char chs)
334{
335        int x=0;
336
337        while(cadena[x]!=0) {
338                if (cadena[x]==cho)
339                        cadena[x]=chs;
340                x++;
341        }
342}
343// ________________________________________________________________________________________________________
344// Función: escaparCadena
345//
346//      Descripción:
347//                      Sustituye las apariciones de un caracter comila simple ' por \'
348//      Parámetros:
349//                      - cadena: Cadena a escapar
350// Devuelve:
351//              La cadena con las comillas simples sustituidas por \'
352// ________________________________________________________________________________________________________
353char* escaparCadena(char *cadena)
354{
355        int b,c;
356        char *buffer;
357
358        buffer = (char*) reservaMemoria(strlen(cadena)*2); // Toma memoria para el buffer de conversión
359        if (buffer == NULL) { // No hay memoria suficiente para el buffer
360                return (FALSE);
361        }
362
363        c=b=0;
364        while(cadena[c]!=0) {
365                if (cadena[c]=='\''){
366                        buffer[b++]='\\';
367                        buffer[b++]='\'';
368                }
369                else{
370                        buffer[b++]=cadena[c];
371                }
372                c++;
373        }
374        return(buffer);
375}
376// ________________________________________________________________________________________________________
377// Función: StrToUpper
378//
379//      Descripción:
380//                      Convierta una cadena en mayúsculas
381//      Parámetros:
382//                      - cadena: Cadena a convertir
383// ________________________________________________________________________________________________________
384char* StrToUpper(char *cadena)
385{
386        int x=0;
387
388        while(cadena[x]!=0) {
389                if (cadena[x] >= 'a' && cadena[x] <= 'z') {
390                        cadena[x] -= 32;
391                }
392                x++;
393        }
394        return(cadena);
395}
396// ________________________________________________________________________________________________________
397// Función: StrToUpper
398//
399//      Descripción:
400//                      Convierta una cadena en mayúsculas
401//      Parámetros:
402//                      - cadena: Cadena a convertir
403// ________________________________________________________________________________________________________
404char* StrToLower(char *cadena)
405{
406        int x=0;
407
408        while(cadena[x]!=0) {
409                if (cadena[x] >= 'A' && cadena[x] <= 'Z') {
410                        cadena[x] += 32;
411                }
412                x++;
413        }
414        return(cadena);
415}
416// ________________________________________________________________________________________________________
417// Función: INTROaFINCAD
418//
419//              Descripción:
420//                      Cambia caracteres INTROS por fin de cadena ('\0')  en una trama
421//              Parametros:
422//                      - parametros: Puntero a los parametros de la trama
423//                      - lon: Longitud de la cadena de parametros
424// ________________________________________________________________________________________________________
425void INTROaFINCAD(TRAMA* ptrTrama)
426{
427        char *i,*a,*b;
428
429        a=ptrTrama->parametros;
430        b=a+ptrTrama->lonprm;
431        for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
432                if(*i=='\r') *i='\0';
433        }
434}
435// ________________________________________________________________________________________________________
436// Función: FINCADaINTRO
437//
438//              Descripción:
439//                      Cambia caracteres fin de cadena ('\0') por INTROS en una trama
440//              Parametros:
441//                      - parametros: Puntero a los parametros de la trama
442//                      - lon: Longitud de la cadena de parametros
443// ________________________________________________________________________________________________________
444void FINCADaINTRO(TRAMA* ptrTrama)
445{
446        char *i,*a,*b;
447
448        a=ptrTrama->parametros;
449        b=a+ptrTrama->lonprm;
450        for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
451                if(*i=='\0') *i='\r';
452        }
453}
454// ________________________________________________________________________________________________________
455// Función: cuentaIPES
456//
457//              Descripción:
458//                      Cuenta los caracteres "." de las IPES dentro del parámetros iph de una trama
459//                      con lo cual dividiendo por 3 se puede saber la cantdad de direcciones IPES en la cadena
460//              Parametros:
461//                      - ipes: Cadena con las IPES separadas por ";"
462// ________________________________________________________________________________________________________
463int cuentaIPES(char* ipes)
464{
465        int i,a,b,c=0;
466
467        a=0;
468        b=strlen(ipes);
469        for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
470                if(ipes[i]=='.') c++;
471        }
472        return(c/3);
473}
474// ________________________________________________________________________________________________________
475// Función: tomaParametro
476//
477//              Descripción:
478//                      Devuelve el valor de un parametro incluido en una cadena con formatos: "nombre=valor"
479//              Parámetros:
480//                      - nombre: Nombre del parámetro a recuperar
481//                      - paramestros: Cadena que contiene todos los parámetros
482// ________________________________________________________________________________________________________
483char* tomaParametro(const char* nombre,TRAMA* ptrTrama)
484{
485        char *a,*b,*pos;
486
487        a=ptrTrama->parametros;
488        b=a+ptrTrama->lonprm;
489        for(pos=a;pos<b;pos++){ // Busca valor del parámetro
490                if(pos[0]==nombre[0]){
491                        if(pos[1]==nombre[1]){
492                                if(pos[2]==nombre[2]){
493                                        if(pos[3]=='='){
494                                                pos+=4;
495                                                return(pos);
496                                        }
497                                }
498                        }
499                }
500        }
501        return(NULL);
502}
503//______________________________________________________________________________________________________
504// Función: copiaParametro
505//
506//      Descripción:
507//              Devuelve una copia del valor de un parámetro
508//      Parámetros:
509//              - ptrTrama: contenido del mensaje
510//              - parametro: Nombre del parámetro
511//              - lon: Nombre del parámetro
512//      Devuelve:
513//              Un puntero a la cadena que contiene el valor del parámetro
514// ________________________________________________________________________________________________________
515char* copiaParametro(const char*nombre,TRAMA* ptrTrama)
516{
517        char *prm,*buffer;
518        char modulo[] = "copiaParametro()";
519
520
521        prm=tomaParametro(nombre,ptrTrama); // Toma identificador de acción
522        if(!prm)
523                return(NULL);
524        buffer = (char*) reservaMemoria(strlen(prm)+1); // Toma memoria para el buffer de lectura.
525        if (buffer == NULL) { // No hay memoria suficiente para el buffer
526                errorLog(modulo, 3, FALSE);
527                return (FALSE);
528        }
529        strcpy(buffer,prm);
530        return(buffer);
531}
532// ________________________________________________________________________________________________________
533// Función: igualIP
534//
535//      Descripción:
536//              Comprueba si una cadena con una dirección IP está incluida en otra que  contienen varias direcciones ipes
537//              separadas por punto y coma
538//      Parámetros:
539//              - cadenaiph: Cadena de direcciones IPES
540//              - ipcliente: Cadena de la IP a buscar
541//      Devuelve:
542//              TRUE: Si el proceso es correcto
543//              FALSE: En caso de ocurrir algún error
544// ________________________________________________________________________________________________________
545BOOLEAN contieneIP(char *cadenaiph,char *ipcliente)
546{
547char *posa,*posb;
548        int lon,lst;
549
550        posa=strstr(cadenaiph,ipcliente);
551        lst=strlen(cadenaiph);
552
553        if(posa==NULL) return(FALSE); // No existe la IP en la cadena
554        posb=posa; // Iguala direcciones
555        while(TRUE){
556                posb++;
557                if(*posb==';') break;
558                if(*posb=='\0') break;
559                if(*posb=='\r') break;
560        }
561        lon=strlen(ipcliente);
562        if((posb-posa)==lon) return(TRUE); // IP encontrada
563
564        if(posb<posa+lst)
565                return(contieneIP(posb,ipcliente));
566        return(FALSE);
567}
568// ________________________________________________________________________________________________________
569// Función: rTrim
570//
571//               Descripción:
572//                      Elimina caracteres de espacios y de asci menor al espacio al final de la cadena
573//              Parámetros:
574//                      - cadena: Cadena a procesar
575// ________________________________________________________________________________________________________
576char* rTrim(char *cadena)
577{
578        int i,lon;
579       
580        lon=strlen(cadena);
581        for (i=lon-1;i>=0;i--){
582                if(cadena[i]<32)
583                        cadena[i]='\0';
584                else
585                        return(cadena);
586        }
587        return(cadena);
588}
589// ________________________________________________________________________________________________________
590// Función: mandaTrama
591//
592//      Descripción:
593//              Envía una trama por la red
594//      Parametros:
595//                      - sock : El socket del host al que se dirige la trama
596//                      - trama: El contenido de la trama
597//                      - lon: Longitud de la parte de parametros de la trama que se va a mandar
598//      Devuelve:
599//              TRUE: Si el proceso es correcto
600//              FALSE: En caso de ocurrir algún error
601// ________________________________________________________________________________________________________
602BOOLEAN mandaTrama(SOCKET *sock, TRAMA* ptrTrama)
603{
604        int lonprm;
605        char *buffer,hlonprm[LONHEXPRM+1];
606
607        lonprm=strlen(ptrTrama->parametros);
608        ptrTrama->parametros=encriptar(ptrTrama->parametros,&lonprm); // Encripta los parámetros
609        sprintf(hlonprm,"%05X",LONGITUD_CABECERATRAMA+LONHEXPRM+lonprm); // Convierte en hexadecimal la longitud
610
611        buffer=reservaMemoria(LONGITUD_CABECERATRAMA+LONHEXPRM+lonprm); // Longitud total de la trama
612        if(buffer==NULL)
613                return(FALSE);
614        memcpy(buffer,ptrTrama,LONGITUD_CABECERATRAMA); // Copia cabecera de trama
615        memcpy(&buffer[LONGITUD_CABECERATRAMA],hlonprm,LONHEXPRM); // Copia longitud de la trama
616        memcpy(&buffer[LONGITUD_CABECERATRAMA+LONHEXPRM],ptrTrama->parametros,lonprm); // Copia parametros encriptados
617        if(!sendData(sock,buffer,LONGITUD_CABECERATRAMA+LONHEXPRM+lonprm))
618                return (FALSE);
619        return(TRUE);
620}
621// ________________________________________________________________________________________________________
622// Función: sendData
623//
624//      Descripción:
625//              Envía datos por la red a través de un socket
626//      Parametros:
627//                      - sock : El socket por donde se envía
628//                      - datos: El contenido a enviar
629//                      - lon: Cantidad de bites a enviar
630//      Devuelve:
631//              TRUE: Si el proceso es correcto
632//              FALSE: En caso de ocurrir algún error
633// ________________________________________________________________________________________________________
634BOOLEAN sendData(SOCKET *sock, char* datos,int lon)
635{
636        int idx,ret;
637        idx = 0;
638        while (lon > 0) {
639                ret = send(*sock,&datos[idx],lon, 0);
640                if (ret == 0) { // Conexión cerrada por parte del cliente (Graceful close)
641                        break;
642                }
643                else{
644                        if (ret == SOCKET_ERROR)
645                                return (FALSE);
646                }
647                lon -= ret;
648                idx += ret;
649        }
650        return (TRUE);
651}
652// ________________________________________________________________________________________________________
653// Función: recibeTrama
654//
655//      Descripción:
656//              Recibe una trama por la red
657//      Parametros:
658//              - sock : El socket del cliente
659//              - trama: El buffer para recibir la trama
660//      Devuelve:
661//              Un puntero a una estrucutra TRAMA o NULL si ha habido algún error
662//              FALSE: En caso de ocurrir algún error
663// ________________________________________________________________________________________________________
664TRAMA* recibeTrama(SOCKET *sock)
665{
666        int ret,lon,lSize;
667        char *buffer,bloque[LONBLK],*hlonprm;
668        TRAMA * ptrTrama;
669
670        lon=lSize=0;
671        do{
672                if(!recData(sock,bloque,LONBLK,&ret)) // Lee bloque
673                        return(NULL);
674
675                if(lSize==0){ // Comprueba tipo de trama y longitud total de los parámetros
676                        if (strncmp(bloque, "@JMMLCAMDJ_MCDJ",15)!=0)
677                                return(NULL); // No se reconoce la trama
678                        hlonprm=reservaMemoria(LONHEXPRM+1);
679                        if(!hlonprm)
680                                return(NULL);
681                        memcpy(hlonprm,&bloque[LONGITUD_CABECERATRAMA],LONHEXPRM);
682                        lSize=strtol(hlonprm,NULL,16); // Longitud total de la trama con los parametros encriptados
683                        buffer=(char*)reservaMemoria(lSize); // Toma memoria para la trama completa
684                        if(!buffer)
685                                return(NULL);
686                }
687
688                if(ret>0){ // Datos recibidos
689                        memcpy(&buffer[lon],bloque,ret); // Añade bloque
690                        lon+=ret;
691                }
692        }while(lon<lSize);
693
694        ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
695        if (!ptrTrama)
696                return(NULL);
697        memcpy(ptrTrama,buffer,LONGITUD_CABECERATRAMA); // Copia cabecera de trama
698        lon=lSize-(LONGITUD_CABECERATRAMA+LONHEXPRM); // Longitud de los parametros aún encriptados
699        buffer=desencriptar(&buffer[LONGITUD_CABECERATRAMA+LONHEXPRM],&lon);
700        initParametros(ptrTrama,lon); // Desencripta la trama
701        memcpy(ptrTrama->parametros,buffer,lon);
702        ptrTrama->lonprm=lon; // Almacena longitud de los parámetros ya desencriptados
703        return(ptrTrama);
704}
705// ________________________________________________________________________________________________________
706// Función: recData
707//
708//      Descripción:
709//              Recibe datos por la red a través de un socket
710//      Parametros:
711//              - sock : El socket por el que se reciben los datos
712//              - datos: El buffer donde se almacenan
713//              - lon: Cantidad máxima de bites a recibir
714//              - ret: Cantidad de bites recibidos (Parámetro de salida)
715//      Devuelve:
716//              TRUE: Si el proceso es correcto
717//              FALSE: En caso de ocurrir algún error
718// ________________________________________________________________________________________________________
719BOOLEAN recData(SOCKET *sock, char* buffer,int lon,int* ret)
720{
721        *ret = 0;
722
723        while (TRUE) { // Bucle para recibir datos del cliente
724                *ret = recv(*sock,buffer, lon, 0);
725                if (*ret == 0) // Conexión cerrada por parte del cliente (Graceful close)
726                        break;
727                else {
728                        if (*ret == SOCKET_ERROR) {
729                                return (FALSE);
730                        } else
731                                // Datos recibidos
732                                break;
733                }
734        }
735        return(TRUE);
736}
737//______________________________________________________________________________________________________
738// Función: enviaFlag
739//
740//      Descripción:
741//              Envia una señal de sincronización
742//      Parámetros:
743//              - socket_c: (Salida) Socket utilizado para el envío (operativo)
744//              - ptrTrama: contenido del mensaje
745//      Devuelve:
746//              TRUE: Si el proceso es correcto
747//              FALSE: En caso de ocurrir algún error
748// ________________________________________________________________________________________________________
749BOOLEAN enviaFlag(SOCKET *socket_c,TRAMA *ptrTrama)
750{
751        char modulo[] = "enviaFlag()";
752        if (!mandaTrama(socket_c,ptrTrama)) {
753                errorLog(modulo,26,FALSE);
754                return (FALSE);
755        }
756        return(TRUE);
757}
758//______________________________________________________________________________________________________
759// Función: recibeFlag
760//
761//      Descripción:
762//              Recibe una señal de sincronización
763//      Parámetros:
764//              - socket_c: Socket utilizadopara la recepción (operativo)
765//              - ptrTrama: (Salida) Contenido del mensaje
766//      Devuelve:
767//              TRUE: Si el proceso es correcto
768//              FALSE: En caso de ocurrir algún error
769// ________________________________________________________________________________________________________
770BOOLEAN recibeFlag(SOCKET *socket_c,TRAMA *ptrTrama)
771{
772        ptrTrama=recibeTrama(socket_c);
773        if(!ptrTrama){
774                return(FALSE);
775        }
776        return(TRUE);
777}
778//______________________________________________________________________________________________________
779// Función: URLEncode
780//
781//      Descripción:
782//              Codifica una cadena en UrlEncode
783//      Parámetros:
784//              - src: La cadena a decodificar
785//      Devuelve:
786//              La cadena decodificada
787// ________________________________________________________________________________________________________
788char* URLEncode(char *src)
789{
790        char *dest;
791        int i,j=0,lon;
792
793        lon=strlen(src);
794        dest=(char*)reservaMemoria(lon*2);      // Reserva buffer  para la cadena
795        for(i=0;i<lon;i++){
796                if(src[i]==0x20){ // Espacio
797                        dest[j++] = '%';
798                        dest[j++] = '2';
799                        dest[j++] = '0';
800                }
801                else
802                        dest[j++] = src[i];
803        }
804        return(dest);
805}
806//______________________________________________________________________________________________________
807// Función: URLDecode
808//
809//      Descripción:
810//              Decodifica una cadena codificada con UrlEncode
811//      Parámetros:
812//              - src: La cadena a decodificar
813//      Devuelve:
814//              La cadena decodificada
815// ________________________________________________________________________________________________________
816char* URLDecode(char *src)
817{
818        const char *p = src;
819        char code[3] = {0};
820        unsigned long ascii = 0;
821        char *end = NULL;
822        char *dest,*cad;
823
824        dest=(char*)reservaMemoria(strlen(src));        // Reserva buffer  para la cadena
825        cad=dest;
826        while(*p){
827                if(*p == '%'){
828                        memcpy(code, ++p, 2);
829                        ascii = strtoul(code, &end, 16);
830                        *dest++ = (char)ascii;
831                        p += 2;
832                }
833                else
834                        *dest++ = *p++;
835        }
836        return(cad);
837}
838// ________________________________________________________________________________________________________
839// Función: leeArchivo
840//
841//      Descripción:
842//              Lee un archivo
843//      Parámetros:
844//              fil: Nombre completo del archivo
845//      Devuelve:
846//              Un puntero al buffer con el contenido leido
847
848//______________________________________________________________________________________________________
849char * leeArchivo(char *fil)
850{
851        FILE *f;
852        long lSize;
853        char* buffer;
854
855        f=fopen(fil,"rb");
856        if (!f)
857                return(NULL);
858        fseek (f,0,SEEK_END); // Obtiene tamaño del fichero.
859        lSize = ftell (f);
860        rewind (f);
861        buffer = (char*) reservaMemoria(lSize+1); // Toma memoria para el buffer de lectura.
862        if (!buffer) // No hay memoria suficiente para el buffer
863                return (NULL);
864        lSize=fread (buffer,1,lSize,f); // Lee contenido del fichero
865        fclose(f);
866        return (buffer);
867}
868// ________________________________________________________________________________________________________
869// Función: leeArchivo
870//
871//      Descripción:
872//              Calcula la longitud de un archivo
873//      Parámetros:
874//              fil: Nombre completo del archivo
875//      Devuelve:
876//              Un puntero al buffer con el contenido leido
877
878//______________________________________________________________________________________________________
879int lonArchivo(char *fil)
880{
881        FILE *f;
882        long lSize;
883
884        f=fopen(fil,"rb");
885        if (!f)
886                return(0);
887        fseek (f,0,SEEK_END); // Obtiene tamaño del fichero.
888        lSize = ftell (f);
889        fclose(f);
890        return (lSize);
891}
892// ________________________________________________________________________________________________________
893// Función: escribeArchivo
894//
895//      Descripción:
896//              Escribe un archivo
897//      Parámetros:
898//              fil: Nombre completo del archivo
899//              buffer: Un puntero al buffer con el contenido a escribir
900//      Devuelve:
901//______________________________________________________________________________________________________
902BOOLEAN escribeArchivo(char *fil,char*buffer)
903{
904        FILE *f;
905        long lSize;
906
907        f=fopen(fil,"wb");
908        if (!f){
909                return(FALSE);
910        }
911        lSize=strlen(buffer);
912        fwrite(buffer,1,lSize,f); // Escribe el contenido en el fichero
913        fclose(f);
914        return (TRUE);
915}
916// ________________________________________________________________________________________________________
917// Función: sendArchivo
918//
919//      Descripción:
920//              Envía un archivo por la red
921//      Parámetros:
922//              sock: Socket para el envío
923//              fil: Nombre local completo del archivo
924//      Devuelve:
925//              TRUE: Si el proceso es correcto
926//              FALSE: En caso de ocurrir algún error
927//______________________________________________________________________________________________________
928BOOLEAN sendArchivo(SOCKET *sock,char *fil)
929{
930        long lSize;
931        FILE *f;
932        char buffer[LONBLK];
933
934        f = fopen(fil,"rb");
935        if(!f) // El fichero no existe
936                return(FALSE);
937
938        while(!feof(f)){
939                lSize=fread (buffer,1,LONBLK,f); // Lee el contenido del fichero
940                if(!sendData(sock,buffer,lSize))
941                        return (FALSE);
942        }
943        fclose(f);
944        return(TRUE);
945}
946// ________________________________________________________________________________________________________
947// Función: recArchivo
948//
949//      Descripción:
950//              Recibe un archivo por la red
951//      Parámetros:
952//              sock: Socket para la recepción
953//              fil: Nombre local completo del archivo que se creará
954//      Devuelve:
955//              TRUE: Si el proceso es correcto
956//              FALSE: En caso de ocurrir algún error
957//______________________________________________________________________________________________________
958BOOLEAN recArchivo(SOCKET *sock,char *fil)
959{
960        int lon;
961        FILE *f;
962        char buffer[LONBLK];
963
964        f = fopen(fil,"wb");
965        if(!f) // No se ha podido crear el archivo
966                return(FALSE);
967        do{
968                if(!recData(sock,buffer,LONBLK,&lon))
969                        return(FALSE);
970                // Datos recibidos
971                if(lon>0)
972                        fwrite(buffer,1,lon,f); // Lee el contenido del fichero
973        }while(lon>0); // Bucle para recibir datos del cliente
974        fclose(f);
975        return(TRUE);
976}
977//______________________________________________________________________________________________________
978// Función: initParammetros
979//
980//       Descripción:
981//              Libera memoria del buffer de los parametros de la trama y vuelve a reservar espacio
982//      Parámetros:
983//              - parametros : Puntero a la zona donde están los parametros de una trama
984//              - lon : Tamaño de la nueva reserva de espacio para los parametros
985//      Devuelve:
986//              Un puntero a la nueva zona de memoria o NULL si ha habido algún error
987// Especificaciones:
988//              En caso de que el parámetro lon valga cero el tamaño a reservar será el estandar
989//______________________________________________________________________________________________________
990BOOLEAN initParametros(TRAMA* ptrTrama,int lon)
991{
992        if(lon==0) lon=LONGITUD_PARAMETROS;
993        ptrTrama->parametros=(char*)ampliaMemoria(ptrTrama->parametros,lon);
994        if(!ptrTrama->parametros)
995                return(FALSE);
996        else
997                return(TRUE);
998}
999//______________________________________________________________________________________________________
1000// Función: TCPConnect
1001//
1002//       Descripción:
1003//              Crea un socket y lo conecta a un servidor
1004//      Parámetros:
1005//              - ips : La Dirección IP del servidor
1006//              - port : Puerto para la comunicación
1007//      Devuelve:
1008//              Un socket para comunicaciones por protocolo TCP
1009//______________________________________________________________________________________________________
1010SOCKET TCPConnect(char *ips,char* port)
1011{
1012        SOCKET s;
1013    struct sockaddr_in server;
1014        char modulo[] = "TCPConnect()";
1015
1016        s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1017        if (s == INVALID_SOCKET){
1018                return (INVALID_SOCKET);
1019        }
1020        server.sin_family = AF_INET;
1021        server.sin_port = htons((short)atoi(port));
1022        server.sin_addr.s_addr = inet_addr(ips);
1023
1024        if (connect(s, (struct sockaddr *)&server, sizeof(server)) == INVALID_SOCKET){
1025                errorLog(modulo,38,TRUE);
1026                return (INVALID_SOCKET);
1027        }
1028
1029        return(s);
1030}
1031//______________________________________________________________________________________________________
1032// Función: AbreConexion
1033//
1034//       Descripción:
1035//              Abre la conexión entre el cliente y el servidor de administración
1036//      Parámetros:
1037//              - Ninguno
1038//      Devuelve:
1039//              Un socket de cliente para comunicaciones
1040//______________________________________________________________________________________________________
1041SOCKET abreConexion(void)
1042{
1043        int swloop=0;
1044        SOCKET s;
1045
1046        while(swloop<MAXCNX){
1047                s=TCPConnect(servidoradm,puerto);
1048                if(s!= INVALID_SOCKET){
1049                        return(s);
1050                }
1051                swloop++;
1052                #ifdef  __WINDOWS__
1053                        Sleep(5*1000);
1054                #else
1055                        sleep(5); // Espera cinco segundos antes de intentar una nueva conexión
1056                #endif
1057        }
1058        return(INVALID_SOCKET);
1059}
1060//______________________________________________________________________________________________________
1061// Función: enviaMensaje
1062//
1063//      Descripción:
1064//              Envia un mensaje al servidor de Administración
1065//      Parámetros:
1066//              - socket_c: (Salida) Socket utilizado para el envío
1067//              - ptrTrama: contenido del mensaje
1068//              - tipo: Tipo de mensaje
1069//                              C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
1070//      Devuelve:
1071//              TRUE: Si el proceso es correcto
1072//              FALSE: En caso de ocurrir algún error
1073// ________________________________________________________________________________________________________
1074BOOLEAN enviaMensaje(SOCKET *socket_c,TRAMA *ptrTrama,char tipo)
1075{
1076        char modulo[] = "enviaMensaje()";
1077
1078        *socket_c=abreConexion();
1079        if(*socket_c==INVALID_SOCKET){
1080                errorLog(modulo,38,FALSE); // Error de conexión con el servidor
1081                return(FALSE);
1082        }
1083        ptrTrama->arroba='@'; // Cabecera de la trama
1084        strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14);   // identificador de la trama
1085        ptrTrama->tipo=tipo; // Tipo de mensaje
1086
1087        if (!mandaTrama(socket_c,ptrTrama)) {
1088                errorLog(modulo,26,FALSE);
1089                return (FALSE);
1090        }
1091        return(TRUE);
1092}
1093//______________________________________________________________________________________________________
1094// Función: recibeMensaje
1095//
1096//      Descripción:
1097//              Recibe un mensaje del servidor de Administración
1098//      Parámetros:
1099//              - socket_c: Socket utilizadopara la recepción
1100//              - ptrTrama: (Salida) Contenido del mensaje
1101//      Devuelve:
1102//              TRUE: Si el proceso es correcto
1103//              FALSE: En caso de ocurrir algún error
1104// ________________________________________________________________________________________________________
1105TRAMA* recibeMensaje(SOCKET *socket_c)
1106{
1107        TRAMA* ptrTrama;
1108        char modulo[] = "recibeMensaje()";
1109
1110        ptrTrama=recibeTrama(socket_c);
1111        if(!ptrTrama){
1112                errorLog(modulo,17,FALSE);
1113                return(NULL);
1114        }
1115        return(ptrTrama);
1116}
Note: See TracBrowser for help on using the repository browser.