/[mcrypt]/libmcrypt/lib/mcrypt_extra.c
ViewVC logotype

Diff of /libmcrypt/lib/mcrypt_extra.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by nmav, Mon May 22 13:07:52 2000 UTC revision 1.26 by nmav, Tue Dec 17 10:53:34 2002 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 1998,1999 Nikos Mavroyanopoulos   * Copyright (C) 1998,1999,2001 Nikos Mavroyanopoulos
3   *   *
4   * This library is free software; you can redistribute it and/or modify it under the terms of the   * This library is free software; you can redistribute it and/or modify it under the terms of the
5   * GNU Library General Public License as published by the Free Software   * GNU Library General Public License as published by the Free Software
# Line 19  Line 19 
19    
20  /* $Id$ */  /* $Id$ */
21    
 #ifndef LIBDEFS_H  
 #define LIBDEFS_H  
22  #include <libdefs.h>  #include <libdefs.h>
 #endif  
23  #include <bzero.h>  #include <bzero.h>
24  #include <xmemory.h>  #include <xmemory.h>
25  #include <mcrypt_internal.h>  #include <mcrypt_internal.h>
26    
27  #if 0  int mcrypt_algorithm_module_ok(const char *file, const char *directory);
28  extern int preloaded_symbols;  int mcrypt_mode_module_ok(const char *file, const char *directory);
29  #endif  
30    void *mcrypt_dlopen(mcrypt_dlhandle * handle, const char *a_directory,
31                        const char *m_directory, const char *filename);
32    
33    #ifdef HAVE_READDIR_R
34    # define MAXPATHLEN 256
35    #endif
36    
37    WIN32DLL_DEFINE char *mcrypt_readdir(DIR * dirstream)
38    {
39    
40            char *result;
41            struct dirent *ret = NULL;
42    #ifdef HAVE_READDIR_R
43            struct dirent ret2[sizeof(struct dirent) + MAXPATHLEN];
44    #endif
45    
46    #ifdef HAVE_READDIR_R
47            readdir_r(dirstream, ret2, &ret);
48    #else
49            ret = readdir(dirstream);
50    #endif
51            if (ret == NULL)
52                    return NULL;
53    
54            result = strdup(ret->d_name);
55            if (result == NULL) {
56                    return NULL;
57            }
58    
59            return result;
60    
61    }
62    
63  int mcrypt_algorithm_module_ok(const char *file, const char* directory);  extern const mcrypt_preloaded mps[];
 int mcrypt_mode_module_ok(const char *file, const char* directory);  
64    
65  char ** mcrypt_list_algorithms(char *libdir, int *size)  WIN32DLL_DEFINE char **mcrypt_list_algorithms(const char *libdir,
66                                                  int *size)
67  {  {
68          DIR *pdir;          DIR *pdir;
69          char directory[500];          char directory[512];
70          struct dirent *dirname;          char *dirname;
71          char **filename = NULL, *ptr;          char **filename = NULL, *ptr;
72          int tmpsize;          int tmpsize, i = 0;
73    
         *size = 0;  
74    
75          if (libdir == NULL) {          *size = 0;
                 strcpy(directory, LIBDIR);  
         } else {  
                 strcpy(directory, libdir);  
         }  
76    
77  #if 0          while (mps[i].name != 0 || mps[i].address != 0) {
78          if (preloaded_symbols!=0) { /* We have preloaded symbols */                  if (mps[i].name != NULL && mps[i].address == NULL) {
79                  i=0;                          if (mcrypt_algorithm_module_ok(mps[i].name, NULL) >
80                  for (;;) {                              0) {
81                          if (mcrypt_algorithm_module_ok(lt_preloaded_symbols[i].name, NULL) > 0 ) {                                  filename =
82                                          tmpsize=strlen(lt_preloaded_symbols[i].name);                                      realloc(filename,
83                                          filename =                                              ((*size) +
84                                              realloc(filename,                                               1) * sizeof(char *));
85                                                      (*size +                                  if (filename == NULL) {
86                                                       1) *                                          goto freeall;
87                                                      sizeof(char*));                                  }
88                                          filename[*size] =                                  filename[*size] = strdup(mps[i].name);
89                                              calloc(1, tmpsize + 1);                                  if (filename[*size] == NULL)
90                                          strcpy(filename[*size],                                          goto freeall;
91                                                 lt_preloaded_symbols[i].name);                                  (*size)++;
                                         ptr=strrchr(filename[*size], '.');  
                                         if (ptr!=NULL) *ptr='\0';  
                                         (*size)++;  
92                          }                          }
                         if (lt_preloaded_symbols[i].address==0 && lt_preloaded_symbols[i].name==NULL) break;  
                         i++;  
93                  }                  }
94                    i++;
95          }          }
96  #endif  
97    #ifdef USE_LTDL
98    
99            if (libdir == NULL) {
100                    strncpy(directory, LIBDIR, sizeof(directory)-1);
101            } else {
102                    strncpy(directory, libdir, sizeof(directory)-1);
103            }
104            directory[ sizeof(directory)-1] = 0;
105    
106          pdir = opendir(directory);          pdir = opendir(directory);
107          if (pdir == NULL) {          if (pdir == NULL) {
108    #ifdef DEBUG
109                  fprintf(stderr, "Unable to open directory %s.\n",                  fprintf(stderr, "Unable to open directory %s.\n",
110                          directory);                          directory);
111                  return NULL;  #endif
112                    return filename;
113          }          }
114    
115          for (;;) {          for (;;) {
116                  dirname = readdir(pdir);                  dirname = mcrypt_readdir(pdir);
117                  if (dirname != NULL) {                  if (dirname != NULL) {
118  #ifdef DT_REG                          tmpsize = strlen(dirname);
119                          if ((dirname->d_type == DT_REG)                          if (tmpsize > 3) {
120                              || (dirname->d_type == DT_UNKNOWN)) {  
121  #endif                                  if (mcrypt_algorithm_module_ok
122                                  if (strlen(dirname->d_name) > 3) {                                      (dirname, directory) > 0) {
123                                          tmpsize = strlen(dirname->d_name);                                          ptr = strrchr(dirname, '.');
124                                            if (ptr != NULL) {
125                                                    *ptr = '\0';
126                                                    tmpsize = strlen(dirname);
127                                            }
128    
129                                            if (_mcrypt_search_symlist_lib
130                                                (dirname) != NULL) {
131                                                    free(dirname);
132                                                    continue;       /* it's already in the list,
133                                                                     * since it's included in the lib.
134                                                                     */
135                                            }
136    
137                                            filename =
138                                                realloc(filename,
139                                                        (*size +
140                                                         1) * sizeof(char *));
141                                            if (filename == NULL) {
142                                                    free(dirname);
143                                                    goto freeall;
144                                            }
145    
146                                          if (mcrypt_algorithm_module_ok(dirname->d_name, directory) > 0 ) {                                          filename[*size] = strdup(dirname);
147                                                  filename =                                          if (filename[*size] == NULL) {
148                                                      realloc(filename,                                                  free(dirname);
149                                                              (*size +                                                  goto freeall;
                                                              1) *  
                                                             sizeof(char  
                                                                    *));  
                                                 filename[*size] =  
                                                     calloc(1, tmpsize + 1);  
                                                 strcpy(filename[*size],  
                                                        dirname->d_name);  
   
                                                 ptr=strrchr(filename[*size], '.');  
                                                 if (ptr!=NULL) *ptr='\0';  
                                                 (*size)++;  
150                                          }                                          }
151                                            (*size)++;
152                                  }                                  }
 #ifdef DT_REG  
153                          }                          }
154  #endif                          free(dirname);
155                  } else {                  } else break;
                         break;  
                 }  
   
156          }          }
157    
158    
   
159          closedir(pdir);          closedir(pdir);
160            
161    #endif
162    
163          return filename;          return filename;
164    
165          freeall:
166            for (i = 0; i < (*size); i++) {
167                    free(filename[i]);
168            }
169            free(filename);
170            return NULL;
171  }  }
172    
173  char **  mcrypt_list_modes(char *libdir, int *size)  WIN32DLL_DEFINE char **mcrypt_list_modes(const char *libdir, int *size)
174  {  {
175          DIR *pdir;          DIR *pdir;
176          char directory[500];          char directory[512];
177          struct dirent *dirname;          char *dirname;
178          char **filename = NULL, *ptr;          char **filename = NULL, *ptr;
179          int tmpsize;          int tmpsize;
180            int i = 0;
181    
182          if (libdir == NULL) {          *size = 0;
                 strcpy(directory, LIBDIR);  
         } else {  
                 strcpy(directory, libdir);  
         }  
   
         lt_dladdsearchdir(directory);  
183    
184  #if 0          while (mps[i].name != 0 || mps[i].address != 0) {
185          if (preloaded_symbols!=0) { /* We have preloaded symbols */                  if (mps[i].name != NULL && mps[i].address == NULL) {
186                  i=0;                          if (mcrypt_mode_module_ok(mps[i].name, NULL) > 0) {
187                  for (;;) {                                  filename =
188                          if (mcrypt_mode_module_ok(lt_preloaded_symbols[i].name, NULL) > 0 ) {                                      realloc(filename,
189                                          tmpsize=strlen(lt_preloaded_symbols[i].name);                                              (*size + 1) * sizeof(char *));
190                                          filename =                                  if (filename == NULL) {
191                                              realloc(filename,                                          goto freeall;
192                                                      (*size +                                  }
193                                                       1) *                                  filename[*size] = strdup(mps[i].name);
194                                                      sizeof(char*));                                  if (filename[*size] == NULL)
195                                          filename[*size] =                                          goto freeall;
196                                              calloc(1, tmpsize + 1);                                  (*size)++;
                                         strcpy(filename[*size],  
                                                lt_preloaded_symbols[i].name);  
                                         ptr=strrchr(filename[*size], '.');  
                                         if (ptr!=NULL) *ptr='\0';  
                                         (*size)++;  
197                          }                          }
                         if (lt_preloaded_symbols[i].address==0 && lt_preloaded_symbols[i].name==NULL) break;  
                         i++;  
198                  }                  }
199                    i++;
200            }
201    
202    #ifdef USE_LTDL
203    
204            if (libdir == NULL) {
205                    strncpy(directory, LIBDIR, sizeof(directory)-1);
206            } else {
207                    strncpy(directory, libdir, sizeof(directory)-1);
208          }          }
209  #endif          directory[ sizeof(directory)-1] = 0;
210    
211          pdir = opendir(directory);          pdir = opendir(directory);
212          if (pdir == NULL) {          if (pdir == NULL) {
213    #ifdef DEBUG
214                  fprintf(stderr, "Unable to open directory %s.\n",                  fprintf(stderr, "Unable to open directory %s.\n",
215                          directory);                          directory);
216                  return NULL;  #endif
217                    return filename;
218          }          }
219    
         *size = 0;  
220          for (;;) {          for (;;) {
221    
222                  dirname = readdir(pdir);                  dirname = mcrypt_readdir(pdir);
223                  if (dirname != NULL) {                  if (dirname != NULL) {
224  #ifdef DT_REG                          tmpsize = strlen(dirname);
225                          if ((dirname->d_type == DT_REG)                          if (tmpsize > 3) {
226                              || (dirname->d_type == DT_UNKNOWN)) {                                  if (mcrypt_mode_module_ok
227  #endif                                      (dirname, directory) > 0) {
228                                  if (strlen(dirname->d_name) > 3) {  
229                                          tmpsize = strlen(dirname->d_name);                                          ptr = strrchr(dirname, '.');
230                                          if ( mcrypt_mode_module_ok(dirname->d_name, directory) > 0 ) {                                          if (ptr != NULL) {
231                                                  filename =                                                  *ptr = '\0';
232                                                      realloc(filename,                                                  tmpsize = strlen(dirname);
233                                                              (*size +                                          }
234                                                               1) *                                          if (_mcrypt_search_symlist_lib
235                                                              sizeof(char                                              (dirname) != NULL) {
236                                                                     *));                                                  free(dirname);
237                                                  filename[*size] =                                                  continue;       /* it's already in the list,
238                                                      calloc(1, tmpsize + 1);                                                                   * since it's included in the lib.
239                                                  strcpy(filename[*size],                                                                   */
                                                        dirname->d_name);  
                                                 ptr=strrchr(filename[*size], '.');  
                                                 if (ptr!=NULL) *ptr='\0';  
                                                 (*size)++;  
240                                          }                                          }
241                                            filename =
242                                                realloc(filename,
243                                                        (*size +
244                                                         1) * sizeof(char *));
245                                            if (filename == NULL) {
246                                                    free(dirname);
247                                                    goto freeall;
248                                            }
249    
250                                            filename[*size] = strdup(dirname);
251                                            if (filename[*size] == NULL) {
252                                                    free(dirname);
253                                                    goto freeall;
254                                            }
255                                            (*size)++;
256                                  }                                  }
 #ifdef DT_REG  
257                          }                          }
258  #endif                          free(dirname);
259                  } else {                  } else {
260                          break;                          break;
261                  }                  }
# Line 211  char **  mcrypt_list_modes(char *libdir, Line 263  char **  mcrypt_list_modes(char *libdir,
263          }          }
264    
265          closedir(pdir);          closedir(pdir);
266    #endif
267    
268          return filename;          return filename;
 }  
269    
270          freeall:
271            for (i = 0; i < (*size); i++) {
272                    free(filename[i]);
273            }
274            free(filename);
275            return NULL;
276    }
277    
278  void  mcrypt_free_p(char** p, int size) {  WIN32DLL_DEFINE void mcrypt_free_p(char **p, int size)
279  int i;  {
280            int i;
281    
282          for (i=0;i<size;i++) {          for (i = 0; i < size; i++) {
283                  free(p[i]);                  free(p[i]);
284          }          }
285          free(p);          free(p);
286  }  }
287    
288  int  mcrypt_algorithm_module_ok(const char *file, const char* directory)  WIN32DLL_DEFINE
289        int mcrypt_algorithm_module_ok(const char *file, const char *directory)
290  {  {
291          int i;          word32 ret = 1;
292          word32 ret;          mcrypt_dlhandle _handle;
293          lt_dlhandle *_handle;          void *rr;
294          int (*_version) (void);          int (*_version) (void);
295    
296          if (file == NULL && directory==NULL) {          if (file == NULL && directory == NULL) {
297                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
298          }          }
299    
300          if (lt_dlinit()!=0) {          if (lt_dlinit() != 0) {
301                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
302          }          }
           
         i=lt_dladdsearchdir(directory);  
303    
304  /*      LTDL_SET_PRELOADED_SYMBOLS(); */          rr = mcrypt_dlopen(&_handle, directory, NULL, file);
305          _handle = lt_dlopenext(file);  
306          if (!_handle) {          if (!rr) {
                 _handle = lt_dlopen(file);  
         }  
           
           
   
         if (_handle==NULL) {  
 /*              fputs(lt_dlerror(), stderr);  
  *              fputs("\n", stderr);  
  */  
307                  lt_dlexit();                  lt_dlexit();
308                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
309          }          }
310    
311    
312          _version = lt_dlsym(_handle, "_mcrypt_algorithm_version");          _version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version");
313    
314          if (_version==NULL) {          if (_version == NULL) {
315                  lt_dlclose(_handle);                  mcrypt_dlclose(_handle);
316                  lt_dlexit();                  lt_dlexit();
317                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
318          }          }
319    
320          ret = _version();          ret = _version();
321    
322          lt_dlclose(_handle);          mcrypt_dlclose(_handle);
323    
324          lt_dlexit();          lt_dlexit();
325    
326          return ret;          return ret;
327    
328  }  }
329    
330  int  mcrypt_mode_module_ok(const char *file, const char* directory)  WIN32DLL_DEFINE
331        int mcrypt_mode_module_ok(const char *file, const char *directory)
332  {  {
         int i;  
333          word32 ret;          word32 ret;
334          lt_dlhandle *_handle;          mcrypt_dlhandle _handle;
335            void *rr;
336          int (*_version) (void);          int (*_version) (void);
337    
338          if (file == NULL && directory==NULL) {          if (file == NULL && directory == NULL) {
339                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
340          }          }
341    
342          if (lt_dlinit()!=0) {          if (lt_dlinit() != 0) {
343                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
         }        
 /*      LTDL_SET_PRELOADED_SYMBOLS(); */  
         i=lt_dladdsearchdir(directory);  
           
         _handle = lt_dlopenext(file);  
         if (!_handle) {  
                 _handle = lt_dlopen(file);  
344          }          }
345            
346          if (!_handle) {          rr = mcrypt_dlopen(&_handle, directory, NULL, file);
347            if (!rr) {
348                  lt_dlexit();                  lt_dlexit();
349                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
350          }          }
           
351    
         _version = lt_dlsym(_handle, "_mcrypt_mode_version");  
352    
353          if (_version==NULL) {          _version = mcrypt_dlsym(_handle, "_mcrypt_mode_version");
354                  lt_dlclose(_handle);  
355            if (_version == NULL) {
356                    mcrypt_dlclose(_handle);
357                  lt_dlexit();                  lt_dlexit();
358                  return MCRYPT_UNKNOWN_ERROR;                  return MCRYPT_UNKNOWN_ERROR;
359          }          }
360            
361          ret = _version();          ret = _version();
362    
363          lt_dlclose(_handle);          mcrypt_dlclose(_handle);
364          lt_dlexit();          lt_dlexit();
365    
366          return ret;          return ret;
367    
368  }  }
 #if 0  
 char **  mcrypt_list_algorithms(char *libdir, int *size)  
 {  
369    
370          char **filename;  /* Taken from libgcrypt */
         int i;  
           
         *size = 21;  
           
         filename = malloc( (*size)*sizeof(char*));  
   
         for (i=0; i<*size; i++) {  
                 filename[i]=malloc(strlen(algos[i])+1);  
                 strcpy(filename[i], algos[i]);  
         }  
   
         return filename;  
371    
372  }  static const char *parse_version_number(const char *s, int *number)
   
 char **  mcrypt_list_modes(char *libdir, int *size)  
373  {  {
374          char modes[6][64] = { "stream", "ecb", "cbc", "cfb", "ofb",          int val = 0;
                 "nofb" };  
         char **filename;  
         int i;  
           
         *size = 6;  
           
         filename = malloc( (*size)*sizeof(char*));  
   
         for (i=0; i<*size; i++) {  
                 filename[i]=malloc(strlen(modes[i])+1);  
                 strcpy(filename[i], modes[i]);  
         }  
375    
376          return filename;          if (*s == '0' && isdigit(s[1]))
377  }                  return NULL;    /* leading zeros are not allowed */
378            for (; isdigit(*s); s++) {
379                    val *= 10;
380  void   mcrypt_free_p(char** p, int size) {                  val += *s - '0';
 int i;  
   
         for (i=0;i<size;i++) {  
                 free(p[i]);  
381          }          }
382          free(p);          *number = val;
383            return val < 0 ? NULL : s;
384  }  }
385    
386  int  mcrypt_algorithm_module_ok(char *file, char* directory)  
387    static const char *parse_version_string(const char *s, int *major,
388                                            int *minor, int *micro)
389  {  {
390          return algo_name2num(file);          s = parse_version_number(s, major);
391            if (!s || *s != '.')
392                    return NULL;
393            s++;
394            s = parse_version_number(s, minor);
395            if (!s || *s != '.')
396                    return NULL;
397            s++;
398            s = parse_version_number(s, micro);
399            if (!s)
400                    return NULL;
401            return s;               /* patchlevel */
402  }  }
403    
404  int  mcrypt_mode_module_ok(char *file, char* directory)  /****************
405     * Check that the the version of the library is at minimum the requested one
406     * and return the version string; return NULL if the condition is not
407     * satisfied.  If a NULL is passed to this function, no check is done,
408     * but the version string is simply returned.
409     */
410    const char *mcrypt_check_version(const char *req_version)
411  {  {
412          return mode_name2num(file);          const char *ver = VERSION;
413            int my_major, my_minor, my_micro;
414            int rq_major, rq_minor, rq_micro;
415            const char *my_plvl, *rq_plvl;
416    
417            if (!req_version)
418                    return ver;
419    
420            my_plvl =
421                parse_version_string(ver, &my_major, &my_minor, &my_micro);
422            if (!my_plvl)
423                    return NULL;    /* very strange our own version is bogus */
424            rq_plvl = parse_version_string(req_version, &rq_major, &rq_minor,
425                                           &rq_micro);
426            if (!rq_plvl)
427                    return NULL;    /* req version string is invalid */
428    
429            if (my_major > rq_major
430                || (my_major == rq_major && my_minor > rq_minor)
431                || (my_major == rq_major && my_minor == rq_minor
432                    && my_micro > rq_micro)
433                || (my_major == rq_major && my_minor == rq_minor
434                    && my_micro == rq_micro
435                    && strcmp(my_plvl, rq_plvl) >= 0)) {
436                    return ver;
437            }
438            return NULL;
439  }  }
   
 #endif  

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.26

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26