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

Annotation of /libmcrypt/lib/mcrypt_modules.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.11 - (hide annotations)
Tue Jan 23 11:46:28 2001 UTC (23 years, 2 months ago) by nmav
Branch: MAIN
CVS Tags: mcrypt_2_4_9
Changes since 1.10: +0 -45 lines
File MIME type: text/plain
removed unneeded functions

1 nmav 1.1 /*
2     * Copyright (C) 1998,1999,2000 Nikos Mavroyanopoulos
3     *
4     * This library is free software; you can redistribute it and/or modify it
5     * under the terms of the GNU Library General Public License as published
6     * by the Free Software Foundation; either version 2 of the License, or
7     * (at your option) any later version.
8     *
9     * This library is distributed in the hope that it will be useful,
10     * but WITHOUT ANY WARRANTY; without even the implied warranty of
11     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12     * Library General Public License for more details.
13     *
14     * You should have received a copy of the GNU Library General Public
15     * License along with this library; if not, write to the
16     * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17     * Boston, MA 02111-1307, USA.
18     */
19    
20     #ifndef LIBDEFS_H
21     #define LIBDEFS_H
22     #include <libdefs.h>
23     #endif
24     #include <bzero.h>
25     #include <mcrypt_internal.h>
26     #include <xmemory.h>
27    
28     #if 0
29     extern int preloaded_symbols;
30     #endif
31    
32 nmav 1.5 WIN32DLL_DEFINE
33 nmav 1.1 int mcrypt_module_close(MCRYPT td)
34     {
35    
36     lt_dlclose(td->algorithm_handle);
37     lt_dlclose(td->mode_handle);
38     lt_dlexit();
39    
40     td->algorithm_handle = NULL;
41     td->mode_handle = NULL;
42    
43     td->m_encrypt = NULL;
44     td->a_encrypt = NULL;
45     td->a_decrypt = NULL;
46     td->m_decrypt = NULL;
47    
48     return 0;
49     }
50    
51 nmav 1.2 #ifndef USE_LTDL
52 nmav 1.5 WIN32DLL_DEFINE
53 nmav 1.2 void *mcrypt_dlopen_ext ( const char *filename) {
54     void *ret;
55 nmav 1.3 char full_path[1054];
56 nmav 1.2
57 nmav 1.4 if (strlen(filename)>sizeof(full_path)) return;
58    
59     strcpy(full_path, filename);
60 nmav 1.2 ret = dlopen(full_path, RTLD_LAZY);
61 nmav 1.4
62 nmav 1.2 if (ret==NULL) {
63 nmav 1.6 #ifndef WIN32
64 nmav 1.2 strcat(full_path, ".so");
65 nmav 1.6 #else
66     strcat(full_path, ".dll");
67     #endif
68 nmav 1.2 ret = dlopen(full_path, RTLD_LAZY);
69     }
70     return ret;
71    
72     }
73     #endif
74    
75 nmav 1.5 WIN32DLL_DEFINE
76 nmav 1.3 void *mcrypt_dlopen ( const char* a_directory, const char *m_directory, const char *filename) {
77 nmav 1.2 void* ret=NULL;
78 nmav 1.3
79 nmav 1.2 #ifdef USE_LTDL
80 nmav 1.3 char paths[1526];
81 nmav 1.2
82 nmav 1.3 memset( paths, 0, 1024);
83     if (a_directory != NULL) {
84     strncat( paths, a_directory, 512);
85     strcat( paths, ":");
86     }
87     if (m_directory != NULL) {
88     strncat( paths, m_directory, 512);
89     strcat( paths, ":");
90     }
91     strncat( paths, LIBDIR, 512);
92    
93     lt_dlsetsearchpath(paths);
94 nmav 1.2
95     ret = lt_dlopenext(filename);
96 nmav 1.3
97 nmav 1.2 return ret;
98 nmav 1.3
99 nmav 1.2 #else
100 nmav 1.3 char full_path[1050];
101 nmav 1.4
102 nmav 1.2 if (a_directory!=NULL) {
103     strncpy(full_path, a_directory, 512);
104     strcat(full_path, "/");
105     strncat( full_path, filename, 512);
106     ret = mcrypt_dlopen_ext(full_path);
107     }
108     if (ret==NULL) {
109     if (m_directory!=NULL) {
110     strncpy(full_path, m_directory, 512);
111     strcat(full_path, "/");
112     strncat( full_path, filename, 510);
113     ret = mcrypt_dlopen_ext(full_path);
114     }
115     }
116 nmav 1.4 if (ret==NULL) {
117     if (LIBDIR!=NULL) {
118     strncpy(full_path, LIBDIR, 512);
119     strcat(full_path, "/");
120     strncat( full_path, filename, 510);
121     ret = mcrypt_dlopen_ext(full_path);
122     }
123     }
124 nmav 1.2 return ret;
125     #endif
126    
127     }
128    
129 nmav 1.5 WIN32DLL_DEFINE
130 nmav 1.1 MCRYPT mcrypt_module_open(char *algorithm,
131     char *a_directory, char *mode, char *m_directory)
132     {
133     MCRYPT td;
134 nmav 1.8 const char* err;
135 nmav 1.2
136 nmav 1.1 td = calloc(1, sizeof(CRYPT_STREAM));
137 nmav 1.10 if (td==NULL) return MCRYPT_FAILED;
138 nmav 1.1
139     if (lt_dlinit() != 0) {
140     return MCRYPT_FAILED;
141     }
142    
143     /* LTDL_SET_PRELOADED_SYMBOLS(); */
144    
145 nmav 1.2 td->algorithm_handle = mcrypt_dlopen(a_directory, m_directory, algorithm);
146 nmav 1.1 if (td->algorithm_handle == NULL) {
147 nmav 1.4 err=lt_dlerror();
148     if (err!=NULL) fputs( err, stderr);
149 nmav 1.1 fputs("\n", stderr);
150     return MCRYPT_FAILED;
151     }
152    
153 nmav 1.2 td->mode_handle = mcrypt_dlopen(a_directory, m_directory, mode);
154 nmav 1.1
155     if (td->mode_handle == NULL) {
156 nmav 1.4 err=lt_dlerror();
157     if (err!=NULL) fputs( err, stderr);
158 nmav 1.1 lt_dlclose(td->algorithm_handle);
159     return MCRYPT_FAILED;
160     }
161    
162     td->a_encrypt = lt_dlsym(td->algorithm_handle, "_mcrypt_encrypt");
163     td->a_decrypt = lt_dlsym(td->algorithm_handle, "_mcrypt_decrypt");
164     td->m_encrypt = lt_dlsym(td->mode_handle, "_mcrypt");
165     td->m_decrypt = lt_dlsym(td->mode_handle, "_mdecrypt");
166     td->a_block_size =
167     lt_dlsym(td->algorithm_handle, "_mcrypt_get_block_size");
168    
169     if (mcrypt_enc_is_block_algorithm_mode(td) !=
170     mcrypt_enc_is_block_algorithm(td)) {
171     mcrypt_module_close(td);
172     return MCRYPT_FAILED;
173     }
174    
175     return td;
176     }
177    
178    
179    
180     /* Modules' frontends */
181    
182 nmav 1.5 WIN32DLL_DEFINE
183 nmav 1.1 int mcrypt_get_size(MCRYPT td)
184     {
185     int (*_mcrypt_get_size) (void);
186    
187     const char *error;
188     char *s;
189    
190     s = td->algorithm_handle;
191     _mcrypt_get_size = lt_dlsym(s, "_mcrypt_get_size");
192     if ((error = lt_dlerror())) {
193 nmav 1.4 if (error!=NULL) fputs(error, stderr);
194 nmav 1.1 fputs("\n", stderr);
195     return MCRYPT_UNKNOWN_ERROR;
196     }
197     return _mcrypt_get_size();
198     }
199    
200 nmav 1.5 WIN32DLL_DEFINE
201 nmav 1.1 int mcrypt_mode_get_size(MCRYPT td)
202     {
203     int (*_mcrypt_get_size) (void);
204    
205     const char *error;
206     char *s;
207    
208     s = td->mode_handle;
209     _mcrypt_get_size = lt_dlsym(s, "_mcrypt_mode_get_size");
210     if ((error = lt_dlerror())) {
211 nmav 1.4 if (error!=NULL) fputs(error, stderr);
212 nmav 1.1 fputs("\n", stderr);
213     return MCRYPT_UNKNOWN_ERROR;
214     }
215     return _mcrypt_get_size();
216     }
217    
218 nmav 1.5 WIN32DLL_DEFINE
219 nmav 1.9 int mcrypt_set_key(MCRYPT td, void *a, void *b, int c, void *d, int e)
220 nmav 1.1 {
221 nmav 1.9 int (*__mcrypt_set_key_stream) (void *, void *, int, void *, int);
222     int (*__mcrypt_set_key_block) (void *, void *, int);
223 nmav 1.1 const char *error;
224     char *s;
225    
226     s = td->algorithm_handle;
227     if (mcrypt_enc_is_block_algorithm(td) == 0) {
228     /* stream */
229     __mcrypt_set_key_stream = lt_dlsym(s, "_mcrypt_set_key");
230     if ((error = lt_dlerror())) {
231 nmav 1.4 if (error!=NULL) fputs(error, stderr);
232 nmav 1.1 fputs("\n", stderr);
233 nmav 1.9 return -2;
234 nmav 1.1 }
235 nmav 1.9 return __mcrypt_set_key_stream(a, b, c, d, e);
236 nmav 1.1 } else {
237     __mcrypt_set_key_block = lt_dlsym(s, "_mcrypt_set_key");
238     if ((error = lt_dlerror())) {
239 nmav 1.4 if (error!=NULL) fputs(error, stderr);
240 nmav 1.1 fputs("\n", stderr);
241 nmav 1.9 return -2;
242 nmav 1.1 }
243 nmav 1.9 return __mcrypt_set_key_block(a, b, c);
244 nmav 1.1 }
245     }
246    
247 nmav 1.5 WIN32DLL_DEFINE
248 nmav 1.2 int mcrypt_enc_set_state(MCRYPT td, void *iv, int size)
249     {
250     int (*__mcrypt_set_state) (void *, void *, int);
251     const char *error;
252     char *s;
253    
254     s = td->mode_handle;
255    
256     __mcrypt_set_state = lt_dlsym(s, "_mcrypt_set_state");
257     if ((error = lt_dlerror())) {
258 nmav 1.4 if (error!=NULL) fputs(error, stderr);
259 nmav 1.2 fputs("\n", stderr);
260     return MCRYPT_UNKNOWN_ERROR;
261     }
262     return __mcrypt_set_state(td->abuf, iv, size);
263     }
264    
265 nmav 1.5 WIN32DLL_DEFINE
266 nmav 1.1 int mcrypt_enc_get_block_size(MCRYPT td)
267     {
268     int (*_mcrypt_get_block_size) (void);
269    
270     _mcrypt_get_block_size = td->a_block_size;
271     return _mcrypt_get_block_size();
272     }
273    
274 nmav 1.5 WIN32DLL_DEFINE
275 nmav 1.1 int mcrypt_get_algo_iv_size(MCRYPT td)
276     {
277     int (*_mcrypt_get_algo_iv_size) (void);
278     char *s;
279    
280     s = td->algorithm_handle;
281    
282     _mcrypt_get_algo_iv_size = lt_dlsym(s, "_mcrypt_get_algo_iv_size");
283     return _mcrypt_get_algo_iv_size();
284     }
285    
286 nmav 1.5 WIN32DLL_DEFINE
287 nmav 1.1 int mcrypt_enc_get_iv_size(MCRYPT td)
288     {
289     if (mcrypt_enc_is_block_algorithm_mode(td) == 1) {
290     return mcrypt_enc_get_block_size(td);
291     } else {
292     return mcrypt_get_algo_iv_size(td);
293     }
294     }
295    
296 nmav 1.5 WIN32DLL_DEFINE
297 nmav 1.1 int mcrypt_enc_get_key_size(MCRYPT td)
298     {
299     int (*_mcrypt_get_key_size) (void);
300     char *s;
301    
302     s = td->algorithm_handle;
303    
304     _mcrypt_get_key_size = lt_dlsym(s, "_mcrypt_get_key_size");
305     return _mcrypt_get_key_size();
306     }
307    
308 nmav 1.5 WIN32DLL_DEFINE
309 nmav 1.1 int *mcrypt_enc_get_supported_key_sizes(MCRYPT td, int *len)
310     {
311     int *(*_mcrypt_get_key_sizes) (int *);
312     char *s;
313     int *size;
314    
315     s = td->algorithm_handle;
316    
317     _mcrypt_get_key_sizes =
318     lt_dlsym(s, "_mcrypt_get_supported_key_sizes");
319     size = _mcrypt_get_key_sizes(len);
320    
321     return size;
322     }
323    
324 nmav 1.5 WIN32DLL_DEFINE
325 nmav 1.1 int mcrypt_enc_is_block_algorithm(MCRYPT td)
326     {
327     int (*_is_block_algorithm) (void);
328     char *s;
329    
330     s = td->algorithm_handle;
331    
332     _is_block_algorithm = lt_dlsym(s, "_is_block_algorithm");
333     return _is_block_algorithm();
334     }
335    
336 nmav 1.5 WIN32DLL_DEFINE
337 nmav 1.1 char *mcrypt_enc_get_algorithms_name(MCRYPT td)
338     {
339     char *(*_mcrypt_get_algorithms_name) (void);
340     char *s;
341    
342     s = td->algorithm_handle;
343    
344     _mcrypt_get_algorithms_name =
345     lt_dlsym(s, "_mcrypt_get_algorithms_name");
346     return _mcrypt_get_algorithms_name();
347     }
348    
349 nmav 1.5 WIN32DLL_DEFINE
350 nmav 1.1 int init_mcrypt(MCRYPT td, void *buf, void *a, int b, void *c)
351     {
352     int (*_init_mcrypt) (void *, void *, int, void *, int);
353     char *s;
354    
355     s = td->mode_handle;
356     _init_mcrypt = lt_dlsym(s, "_init_mcrypt");
357     return _init_mcrypt(buf, a, b, c, mcrypt_enc_get_block_size(td));
358     }
359    
360 nmav 1.5 WIN32DLL_DEFINE
361 nmav 1.1 int end_mcrypt(MCRYPT td, void *buf)
362     {
363     int (*_end_mcrypt) (void *);
364     char *s;
365    
366     s = td->mode_handle;
367     _end_mcrypt = lt_dlsym(s, "_end_mcrypt");
368     return _end_mcrypt(buf);
369     }
370    
371 nmav 1.5 WIN32DLL_DEFINE
372 nmav 1.1 int mcrypt(MCRYPT td, void *buf, void *a, int b)
373     {
374     int (*_mcrypt) (void *, void *, int, int, void *, void *, void*);
375     _mcrypt = td->m_encrypt;
376    
377     return _mcrypt(buf, a, b, mcrypt_enc_get_block_size(td), td->akey,
378     td->a_encrypt, td->a_decrypt);
379     }
380    
381 nmav 1.5 WIN32DLL_DEFINE
382 nmav 1.1 int mdecrypt(MCRYPT td, void *buf, void *a, int b)
383     {
384     int (*_mdecrypt) (void *, void *, int, int, void *, void *, void*);
385    
386     _mdecrypt = td->m_decrypt;
387     return _mdecrypt(buf, a, b, mcrypt_enc_get_block_size(td),
388     td->akey, td->a_encrypt, td->a_decrypt);
389     }
390    
391 nmav 1.5 WIN32DLL_DEFINE
392 nmav 1.1 char *mcrypt_enc_get_modes_name(MCRYPT td)
393     {
394     char *(*_mcrypt_get_modes_name) (void);
395     char *s;
396    
397     s = td->mode_handle;
398    
399     _mcrypt_get_modes_name = lt_dlsym(s, "_mcrypt_get_modes_name");
400     return _mcrypt_get_modes_name();
401     }
402    
403 nmav 1.5 WIN32DLL_DEFINE
404 nmav 1.1 int mcrypt_enc_is_block_mode(MCRYPT td)
405     {
406     int (*_is_block_mode) (void);
407     char *s;
408    
409     s = td->mode_handle;
410    
411     _is_block_mode = lt_dlsym(s, "_is_block_mode");
412     return _is_block_mode();
413     }
414    
415 nmav 1.5 WIN32DLL_DEFINE
416 nmav 1.1 int mcrypt_enc_mode_has_iv(MCRYPT td)
417     {
418     int (*_has_iv) (void);
419     char *s;
420    
421     s = td->mode_handle;
422    
423     _has_iv = lt_dlsym(s, "_has_iv");
424     return _has_iv();
425     }
426    
427 nmav 1.5 WIN32DLL_DEFINE
428 nmav 1.1 int mcrypt_enc_is_block_algorithm_mode(MCRYPT td)
429     {
430     int (*_is_a_block_mode) (void);
431     char *s;
432    
433     s = td->mode_handle;
434    
435     _is_a_block_mode = lt_dlsym(s, "_is_block_algorithm_mode");
436     return _is_a_block_mode();
437     }
438    
439 nmav 1.5 WIN32DLL_DEFINE
440 nmav 1.1 int mcrypt_enc_self_test(MCRYPT td)
441     {
442     int (*_self_test) (void);
443     char *s;
444    
445     s = td->algorithm_handle;
446    
447     _self_test = lt_dlsym(s, "_mcrypt_self_test");
448    
449     return _self_test();
450     }
451    
452 nmav 1.5 WIN32DLL_DEFINE
453 nmav 1.1 int mcrypt_module_self_test(char *algorithm, char *a_directory)
454     {
455     int i;
456     lt_dlhandle *_handle;
457     int (*_self_test) (void);
458 nmav 1.8 const char* error;
459 nmav 1.1
460    
461     if (lt_dlinit() != 0) {
462     return MCRYPT_UNKNOWN_ERROR;
463     }
464     /* LTDL_SET_PRELOADED_SYMBOLS(); */
465    
466 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
467 nmav 1.1
468     if (!_handle) {
469 nmav 1.4 error=lt_dlerror();
470     if (error!=NULL) fputs( error, stderr);
471 nmav 1.1 fputs("\n", stderr);
472     return MCRYPT_UNKNOWN_ERROR;
473     }
474    
475     _self_test = lt_dlsym(_handle, "_mcrypt_self_test");
476    
477     i = _self_test();
478    
479     lt_dlclose(_handle);
480     lt_dlexit();
481     return i;
482     }
483    
484 nmav 1.5 WIN32DLL_DEFINE
485 nmav 1.1 int mcrypt_module_algorithm_version(char *algorithm, char *a_directory)
486     {
487     int i;
488     lt_dlhandle _handle;
489     int (*_version) (void);
490 nmav 1.8 const char* error;
491 nmav 1.1
492     if (lt_dlinit() != 0) {
493     return MCRYPT_UNKNOWN_ERROR;
494     }
495     /* LTDL_SET_PRELOADED_SYMBOLS(); */
496    
497 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
498 nmav 1.1 if (!_handle) {
499 nmav 1.4 error=lt_dlerror();
500     if (error!=NULL) fputs( error, stderr);
501 nmav 1.1 fputs("\n", stderr);
502     return MCRYPT_UNKNOWN_ERROR;
503     }
504    
505     _version = lt_dlsym(_handle, "_mcrypt_algorithm_version");
506    
507     i = _version();
508    
509     lt_dlclose(_handle);
510     lt_dlexit();
511    
512     return i;
513     }
514    
515 nmav 1.5 WIN32DLL_DEFINE
516 nmav 1.1 int mcrypt_module_mode_version(char *mode, char *m_directory)
517     {
518     int i;
519     lt_dlhandle *_handle;
520     int (*_version) (void);
521 nmav 1.8 const char* error;
522 nmav 1.1
523     if (lt_dlinit() != 0) {
524     return MCRYPT_UNKNOWN_ERROR;
525     }
526     /* LTDL_SET_PRELOADED_SYMBOLS(); */
527    
528 nmav 1.2 _handle = mcrypt_dlopen(m_directory, NULL, mode);
529 nmav 1.1 if (!_handle) {
530 nmav 1.4 error=lt_dlerror();
531     if(error!=NULL) fputs(error, stderr);
532 nmav 1.1 fputs("\n", stderr);
533     return MCRYPT_UNKNOWN_ERROR;
534     }
535    
536     _version = lt_dlsym(_handle, "_mcrypt_mode_version");
537    
538     i = _version();
539    
540     lt_dlclose(_handle);
541     lt_dlexit();
542    
543     return i;
544     }
545    
546 nmav 1.5 WIN32DLL_DEFINE
547 nmav 1.1 int mcrypt_module_is_block_algorithm(char *algorithm, char *a_directory)
548     {
549     int i;
550     lt_dlhandle _handle;
551     int (*_is_block_algorithm) (void);
552 nmav 1.8 const char* error;
553 nmav 1.4
554 nmav 1.1 if (lt_dlinit() != 0) {
555     return MCRYPT_UNKNOWN_ERROR;
556     }
557     /* LTDL_SET_PRELOADED_SYMBOLS(); */
558    
559 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
560    
561 nmav 1.1 if (!_handle) {
562 nmav 1.4 error=lt_dlerror();
563     if(error!=NULL) fputs( error, stderr);
564 nmav 1.1 fputs("\n", stderr);
565     return MCRYPT_UNKNOWN_ERROR;
566     }
567    
568     _is_block_algorithm = lt_dlsym(_handle, "_is_block_algorithm");
569    
570     i = _is_block_algorithm();
571    
572     lt_dlclose(_handle);
573     lt_dlexit();
574    
575     return i;
576     }
577    
578 nmav 1.5 WIN32DLL_DEFINE
579 nmav 1.1 int mcrypt_module_is_block_algorithm_mode(char *mode, char *m_directory)
580     {
581     int i;
582     lt_dlhandle *_handle;
583     int (*_is_a_block_mode) (void);
584 nmav 1.8 const char* error;
585 nmav 1.1
586     if (lt_dlinit() != 0) {
587     return MCRYPT_UNKNOWN_ERROR;
588     }
589     /* LTDL_SET_PRELOADED_SYMBOLS(); */
590    
591 nmav 1.2 _handle = mcrypt_dlopen(m_directory, NULL, mode);
592 nmav 1.1 if (!_handle) {
593 nmav 1.4 error=lt_dlerror();
594     if(error!=NULL) fputs( error, stderr);
595 nmav 1.1 fputs("\n", stderr);
596     return MCRYPT_UNKNOWN_ERROR;
597     }
598    
599     _is_a_block_mode = lt_dlsym(_handle, "_is_block_algorithm_mode");
600    
601     i = _is_a_block_mode();
602    
603     lt_dlclose(_handle);
604     lt_dlexit();
605    
606     return i;
607     }
608    
609 nmav 1.5 WIN32DLL_DEFINE
610 nmav 1.1 int mcrypt_module_is_block_mode(char *mode, char *m_directory)
611     {
612     int i;
613     lt_dlhandle *_handle;
614     int (*_is_block_mode) (void);
615 nmav 1.8 const char* error;
616 nmav 1.1
617     if (lt_dlinit() != 0) {
618     return MCRYPT_UNKNOWN_ERROR;
619     }
620     /* LTDL_SET_PRELOADED_SYMBOLS(); */
621    
622 nmav 1.2 _handle = mcrypt_dlopen(m_directory, NULL, mode);
623 nmav 1.1 if (!_handle) {
624 nmav 1.4 error=lt_dlerror();
625     if(error!=NULL) fputs( error, stderr);
626 nmav 1.1 fputs("\n", stderr);
627     return MCRYPT_UNKNOWN_ERROR;
628     }
629    
630     _is_block_mode = lt_dlsym(_handle, "_is_block_mode");
631    
632     i = _is_block_mode();
633    
634     lt_dlclose(_handle);
635     lt_dlexit();
636    
637     return i;
638     }
639    
640 nmav 1.5 WIN32DLL_DEFINE
641 nmav 1.1 int mcrypt_module_get_algo_block_size(char *algorithm, char *a_directory)
642     {
643     int i;
644     lt_dlhandle _handle;
645     int (*_get_block_size) (void);
646 nmav 1.8 const char* error;
647 nmav 1.1
648     if (lt_dlinit() != 0) {
649     return MCRYPT_UNKNOWN_ERROR;
650     }
651     /* LTDL_SET_PRELOADED_SYMBOLS(); */
652    
653 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
654 nmav 1.1 if (!_handle) {
655 nmav 1.4 error=lt_dlerror();
656     if(error!=NULL) fputs( error, stderr);
657 nmav 1.1 fputs("\n", stderr);
658     return MCRYPT_UNKNOWN_ERROR;
659     }
660    
661     _get_block_size = lt_dlsym(_handle, "_mcrypt_get_block_size");
662    
663     i = _get_block_size();
664    
665     lt_dlclose(_handle);
666     lt_dlexit();
667    
668     return i;
669     }
670    
671 nmav 1.5 WIN32DLL_DEFINE
672 nmav 1.1 int mcrypt_module_get_algo_key_size(char *algorithm, char *a_directory)
673     {
674     int i;
675     lt_dlhandle _handle;
676     int (*_get_key_size) (void);
677 nmav 1.8 const char* error;
678 nmav 1.1
679     if (lt_dlinit() != 0) {
680     return MCRYPT_UNKNOWN_ERROR;
681     }
682     /* LTDL_SET_PRELOADED_SYMBOLS(); */
683    
684 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
685 nmav 1.1 if (!_handle) {
686 nmav 1.4 error=lt_dlerror();
687     if(error!=NULL) fputs( error, stderr);
688 nmav 1.1 fputs("\n", stderr);
689     return MCRYPT_UNKNOWN_ERROR;
690     }
691    
692     _get_key_size = lt_dlsym(_handle, "_mcrypt_get_key_size");
693    
694     i = _get_key_size();
695    
696     lt_dlclose(_handle);
697     lt_dlexit();
698    
699     return i;
700     }
701    
702 nmav 1.5 WIN32DLL_DEFINE
703 nmav 1.1 int *mcrypt_module_get_algo_supported_key_sizes(char *algorithm,
704     char *a_directory,
705     int *len)
706     {
707     lt_dlhandle _handle;
708     int *(*_mcrypt_get_key_sizes) (int *);
709     int *size;
710 nmav 1.8 const char* error;
711 nmav 1.1
712     if (lt_dlinit() != 0) {
713     *len = 0;
714     return NULL;
715     }
716     /* LTDL_SET_PRELOADED_SYMBOLS(); */
717    
718 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
719 nmav 1.1 if (!_handle) {
720 nmav 1.4 error=lt_dlerror();
721     if(error!=NULL) fputs( error, stderr);
722 nmav 1.1 fputs("\n", stderr);
723     *len = 0;
724     return NULL;
725     }
726    
727     _mcrypt_get_key_sizes =
728     lt_dlsym(_handle, "_mcrypt_get_supported_key_sizes");
729    
730     size = _mcrypt_get_key_sizes(len);
731    
732     lt_dlclose(_handle);
733     lt_dlexit();
734    
735     return size;
736     }

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26