/[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.7 - (hide annotations)
Fri Nov 3 22:59:38 2000 UTC (23 years, 4 months ago) by nmav
Branch: MAIN
Changes since 1.6: +0 -1 lines
File MIME type: text/plain
some strange (very strange) fix

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.4 char* err;
135 nmav 1.2
136 nmav 1.1 td = calloc(1, sizeof(CRYPT_STREAM));
137    
138     if (lt_dlinit() != 0) {
139     return MCRYPT_FAILED;
140     }
141    
142     /* LTDL_SET_PRELOADED_SYMBOLS(); */
143    
144 nmav 1.2 td->algorithm_handle = mcrypt_dlopen(a_directory, m_directory, algorithm);
145 nmav 1.1 if (td->algorithm_handle == NULL) {
146 nmav 1.4 err=lt_dlerror();
147     if (err!=NULL) fputs( err, stderr);
148 nmav 1.1 fputs("\n", stderr);
149     return MCRYPT_FAILED;
150     }
151    
152 nmav 1.2 td->mode_handle = mcrypt_dlopen(a_directory, m_directory, mode);
153 nmav 1.1
154     if (td->mode_handle == NULL) {
155 nmav 1.4 err=lt_dlerror();
156     if (err!=NULL) fputs( err, stderr);
157 nmav 1.1 lt_dlclose(td->algorithm_handle);
158     return MCRYPT_FAILED;
159     }
160    
161     td->a_encrypt = lt_dlsym(td->algorithm_handle, "_mcrypt_encrypt");
162     td->a_decrypt = lt_dlsym(td->algorithm_handle, "_mcrypt_decrypt");
163     td->m_encrypt = lt_dlsym(td->mode_handle, "_mcrypt");
164     td->m_decrypt = lt_dlsym(td->mode_handle, "_mdecrypt");
165     td->a_block_size =
166     lt_dlsym(td->algorithm_handle, "_mcrypt_get_block_size");
167    
168     if (mcrypt_enc_is_block_algorithm_mode(td) !=
169     mcrypt_enc_is_block_algorithm(td)) {
170     mcrypt_module_close(td);
171     return MCRYPT_FAILED;
172     }
173    
174     return td;
175     }
176    
177    
178    
179     /* Modules' frontends */
180    
181 nmav 1.5 WIN32DLL_DEFINE
182 nmav 1.1 int mcrypt_get_size(MCRYPT td)
183     {
184     int (*_mcrypt_get_size) (void);
185    
186     const char *error;
187     char *s;
188    
189     s = td->algorithm_handle;
190     _mcrypt_get_size = lt_dlsym(s, "_mcrypt_get_size");
191     if ((error = lt_dlerror())) {
192 nmav 1.4 if (error!=NULL) fputs(error, stderr);
193 nmav 1.1 fputs("\n", stderr);
194     return MCRYPT_UNKNOWN_ERROR;
195     }
196     return _mcrypt_get_size();
197     }
198    
199 nmav 1.5 WIN32DLL_DEFINE
200 nmav 1.1 int mcrypt_mode_get_size(MCRYPT td)
201     {
202     int (*_mcrypt_get_size) (void);
203    
204     const char *error;
205     char *s;
206    
207     s = td->mode_handle;
208     _mcrypt_get_size = lt_dlsym(s, "_mcrypt_mode_get_size");
209     if ((error = lt_dlerror())) {
210 nmav 1.4 if (error!=NULL) fputs(error, stderr);
211 nmav 1.1 fputs("\n", stderr);
212     return MCRYPT_UNKNOWN_ERROR;
213     }
214     return _mcrypt_get_size();
215     }
216    
217 nmav 1.5 WIN32DLL_DEFINE
218 nmav 1.1 void mcrypt_set_key(MCRYPT td, void *a, void *b, int c, void *d, int e)
219     {
220     void (*__mcrypt_set_key_stream) (void *, void *, int, void *, int);
221     void (*__mcrypt_set_key_block) (void *, void *, int);
222     const char *error;
223     char *s;
224    
225     s = td->algorithm_handle;
226     if (mcrypt_enc_is_block_algorithm(td) == 0) {
227     /* stream */
228     __mcrypt_set_key_stream = lt_dlsym(s, "_mcrypt_set_key");
229     if ((error = lt_dlerror())) {
230 nmav 1.4 if (error!=NULL) fputs(error, stderr);
231 nmav 1.1 fputs("\n", stderr);
232     return;
233     }
234     __mcrypt_set_key_stream(a, b, c, d, e);
235     } else {
236     __mcrypt_set_key_block = lt_dlsym(s, "_mcrypt_set_key");
237     if ((error = lt_dlerror())) {
238 nmav 1.4 if (error!=NULL) fputs(error, stderr);
239 nmav 1.1 fputs("\n", stderr);
240     return;
241     }
242     __mcrypt_set_key_block(a, b, c);
243     }
244     }
245    
246 nmav 1.5 WIN32DLL_DEFINE
247 nmav 1.2 int mcrypt_enc_set_state(MCRYPT td, void *iv, int size)
248     {
249     int (*__mcrypt_set_state) (void *, void *, int);
250     const char *error;
251     char *s;
252    
253     s = td->mode_handle;
254    
255     __mcrypt_set_state = lt_dlsym(s, "_mcrypt_set_state");
256     if ((error = lt_dlerror())) {
257 nmav 1.4 if (error!=NULL) fputs(error, stderr);
258 nmav 1.2 fputs("\n", stderr);
259     return MCRYPT_UNKNOWN_ERROR;
260     }
261     return __mcrypt_set_state(td->abuf, iv, size);
262     }
263    
264 nmav 1.5 WIN32DLL_DEFINE
265 nmav 1.1 int mcrypt_enc_get_block_size(MCRYPT td)
266     {
267     int (*_mcrypt_get_block_size) (void);
268    
269     _mcrypt_get_block_size = td->a_block_size;
270     return _mcrypt_get_block_size();
271     }
272    
273 nmav 1.5 WIN32DLL_DEFINE
274 nmav 1.1 int mcrypt_get_algo_iv_size(MCRYPT td)
275     {
276     int (*_mcrypt_get_algo_iv_size) (void);
277     char *s;
278    
279     s = td->algorithm_handle;
280    
281     _mcrypt_get_algo_iv_size = lt_dlsym(s, "_mcrypt_get_algo_iv_size");
282     return _mcrypt_get_algo_iv_size();
283     }
284    
285 nmav 1.5 WIN32DLL_DEFINE
286 nmav 1.1 int mcrypt_enc_get_iv_size(MCRYPT td)
287     {
288     if (mcrypt_enc_is_block_algorithm_mode(td) == 1) {
289     return mcrypt_enc_get_block_size(td);
290     } else {
291     return mcrypt_get_algo_iv_size(td);
292     }
293     }
294    
295 nmav 1.5 WIN32DLL_DEFINE
296 nmav 1.1 int mcrypt_enc_get_key_size(MCRYPT td)
297     {
298     int (*_mcrypt_get_key_size) (void);
299     char *s;
300    
301     s = td->algorithm_handle;
302    
303     _mcrypt_get_key_size = lt_dlsym(s, "_mcrypt_get_key_size");
304     return _mcrypt_get_key_size();
305     }
306    
307 nmav 1.5 WIN32DLL_DEFINE
308 nmav 1.1 int *mcrypt_enc_get_supported_key_sizes(MCRYPT td, int *len)
309     {
310     int *(*_mcrypt_get_key_sizes) (int *);
311     char *s;
312     int *size;
313    
314     s = td->algorithm_handle;
315    
316     _mcrypt_get_key_sizes =
317     lt_dlsym(s, "_mcrypt_get_supported_key_sizes");
318     size = _mcrypt_get_key_sizes(len);
319    
320     return size;
321     }
322    
323 nmav 1.5 WIN32DLL_DEFINE
324 nmav 1.1 int mcrypt_enc_is_block_algorithm(MCRYPT td)
325     {
326     int (*_is_block_algorithm) (void);
327     char *s;
328    
329     s = td->algorithm_handle;
330    
331     _is_block_algorithm = lt_dlsym(s, "_is_block_algorithm");
332     return _is_block_algorithm();
333     }
334    
335 nmav 1.5 WIN32DLL_DEFINE
336 nmav 1.1 char *mcrypt_enc_get_algorithms_name(MCRYPT td)
337     {
338     char *(*_mcrypt_get_algorithms_name) (void);
339     char *s;
340    
341     s = td->algorithm_handle;
342    
343     _mcrypt_get_algorithms_name =
344     lt_dlsym(s, "_mcrypt_get_algorithms_name");
345     return _mcrypt_get_algorithms_name();
346     }
347    
348 nmav 1.5 WIN32DLL_DEFINE
349 nmav 1.1 void mcrypt_block_encrypt(MCRYPT td, void *b)
350     {
351     void (*_mcrypt_block_encrypt) (void *, void *);
352     char *a;
353    
354     a = td->akey;
355     _mcrypt_block_encrypt = td->a_encrypt;
356    
357     _mcrypt_block_encrypt(a, b);
358     }
359    
360 nmav 1.5 WIN32DLL_DEFINE
361 nmav 1.1 void mcrypt_block_decrypt(MCRYPT td, void *b)
362     {
363     void (*_mcrypt_block_decrypt) (void *, void *);
364     char *a;
365    
366     a = td->akey;
367     _mcrypt_block_decrypt = td->a_decrypt;
368     _mcrypt_block_decrypt(a, b);
369     }
370    
371 nmav 1.5 WIN32DLL_DEFINE
372 nmav 1.1 void mcrypt_stream_encrypt(MCRYPT td, void *b, int c)
373     {
374     void (*_mcrypt_stream_encrypt) (void *, void *, int);
375     char *a;
376    
377     a = td->akey;
378     _mcrypt_stream_encrypt = td->a_encrypt;
379     _mcrypt_stream_encrypt(a, b, c);
380     }
381    
382 nmav 1.5 WIN32DLL_DEFINE
383 nmav 1.1 void mcrypt_stream_decrypt(MCRYPT td, void *b, int c)
384     {
385     void (*_mcrypt_stream_decrypt) (void *, void *, int);
386     char *a;
387    
388     a = td->akey;
389     _mcrypt_stream_decrypt = td->a_decrypt;
390     _mcrypt_stream_decrypt(a, b, c);
391     }
392    
393 nmav 1.5 WIN32DLL_DEFINE
394 nmav 1.1 int init_mcrypt(MCRYPT td, void *buf, void *a, int b, void *c)
395     {
396     int (*_init_mcrypt) (void *, void *, int, void *, int);
397     char *s;
398    
399     s = td->mode_handle;
400     _init_mcrypt = lt_dlsym(s, "_init_mcrypt");
401     return _init_mcrypt(buf, a, b, c, mcrypt_enc_get_block_size(td));
402     }
403    
404 nmav 1.5 WIN32DLL_DEFINE
405 nmav 1.1 int end_mcrypt(MCRYPT td, void *buf)
406     {
407     int (*_end_mcrypt) (void *);
408     char *s;
409    
410     s = td->mode_handle;
411     _end_mcrypt = lt_dlsym(s, "_end_mcrypt");
412     return _end_mcrypt(buf);
413     }
414    
415 nmav 1.5 WIN32DLL_DEFINE
416 nmav 1.1 int mcrypt(MCRYPT td, void *buf, void *a, int b)
417     {
418     int (*_mcrypt) (void *, void *, int, int, void *, void *, void*);
419     _mcrypt = td->m_encrypt;
420    
421     return _mcrypt(buf, a, b, mcrypt_enc_get_block_size(td), td->akey,
422     td->a_encrypt, td->a_decrypt);
423     }
424    
425 nmav 1.5 WIN32DLL_DEFINE
426 nmav 1.1 int mdecrypt(MCRYPT td, void *buf, void *a, int b)
427     {
428     int (*_mdecrypt) (void *, void *, int, int, void *, void *, void*);
429    
430     _mdecrypt = td->m_decrypt;
431     return _mdecrypt(buf, a, b, mcrypt_enc_get_block_size(td),
432     td->akey, td->a_encrypt, td->a_decrypt);
433     }
434    
435 nmav 1.5 WIN32DLL_DEFINE
436 nmav 1.1 char *mcrypt_enc_get_modes_name(MCRYPT td)
437     {
438     char *(*_mcrypt_get_modes_name) (void);
439     char *s;
440    
441     s = td->mode_handle;
442    
443     _mcrypt_get_modes_name = lt_dlsym(s, "_mcrypt_get_modes_name");
444     return _mcrypt_get_modes_name();
445     }
446    
447 nmav 1.5 WIN32DLL_DEFINE
448 nmav 1.1 int mcrypt_enc_is_block_mode(MCRYPT td)
449     {
450     int (*_is_block_mode) (void);
451     char *s;
452    
453     s = td->mode_handle;
454    
455     _is_block_mode = lt_dlsym(s, "_is_block_mode");
456     return _is_block_mode();
457     }
458    
459 nmav 1.5 WIN32DLL_DEFINE
460 nmav 1.1 int mcrypt_enc_mode_has_iv(MCRYPT td)
461     {
462     int (*_has_iv) (void);
463     char *s;
464    
465     s = td->mode_handle;
466    
467     _has_iv = lt_dlsym(s, "_has_iv");
468     return _has_iv();
469     }
470    
471 nmav 1.5 WIN32DLL_DEFINE
472 nmav 1.1 int mcrypt_enc_is_block_algorithm_mode(MCRYPT td)
473     {
474     int (*_is_a_block_mode) (void);
475     char *s;
476    
477     s = td->mode_handle;
478    
479     _is_a_block_mode = lt_dlsym(s, "_is_block_algorithm_mode");
480     return _is_a_block_mode();
481     }
482    
483 nmav 1.5 WIN32DLL_DEFINE
484 nmav 1.1 int mcrypt_enc_self_test(MCRYPT td)
485     {
486     int (*_self_test) (void);
487     char *s;
488    
489     s = td->algorithm_handle;
490    
491     _self_test = lt_dlsym(s, "_mcrypt_self_test");
492    
493     return _self_test();
494     }
495    
496 nmav 1.5 WIN32DLL_DEFINE
497 nmav 1.1 int mcrypt_module_self_test(char *algorithm, char *a_directory)
498     {
499     int i;
500     lt_dlhandle *_handle;
501     int (*_self_test) (void);
502 nmav 1.4 char* error;
503 nmav 1.1
504    
505     if (lt_dlinit() != 0) {
506     return MCRYPT_UNKNOWN_ERROR;
507     }
508     /* LTDL_SET_PRELOADED_SYMBOLS(); */
509    
510 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
511 nmav 1.1
512     if (!_handle) {
513 nmav 1.4 error=lt_dlerror();
514     if (error!=NULL) fputs( error, stderr);
515 nmav 1.1 fputs("\n", stderr);
516     return MCRYPT_UNKNOWN_ERROR;
517     }
518    
519     _self_test = lt_dlsym(_handle, "_mcrypt_self_test");
520    
521     i = _self_test();
522    
523     lt_dlclose(_handle);
524     lt_dlexit();
525     return i;
526     }
527    
528 nmav 1.5 WIN32DLL_DEFINE
529 nmav 1.1 int mcrypt_module_algorithm_version(char *algorithm, char *a_directory)
530     {
531     int i;
532     lt_dlhandle _handle;
533     int (*_version) (void);
534 nmav 1.4 char* error;
535 nmav 1.1
536     if (lt_dlinit() != 0) {
537     return MCRYPT_UNKNOWN_ERROR;
538     }
539     /* LTDL_SET_PRELOADED_SYMBOLS(); */
540    
541 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
542 nmav 1.1 if (!_handle) {
543 nmav 1.4 error=lt_dlerror();
544     if (error!=NULL) fputs( error, stderr);
545 nmav 1.1 fputs("\n", stderr);
546     return MCRYPT_UNKNOWN_ERROR;
547     }
548    
549     _version = lt_dlsym(_handle, "_mcrypt_algorithm_version");
550    
551     i = _version();
552    
553     lt_dlclose(_handle);
554     lt_dlexit();
555    
556     return i;
557     }
558    
559 nmav 1.5 WIN32DLL_DEFINE
560 nmav 1.1 int mcrypt_module_mode_version(char *mode, char *m_directory)
561     {
562     int i;
563     lt_dlhandle *_handle;
564     int (*_version) (void);
565 nmav 1.4 char* error;
566 nmav 1.1
567     if (lt_dlinit() != 0) {
568     return MCRYPT_UNKNOWN_ERROR;
569     }
570     /* LTDL_SET_PRELOADED_SYMBOLS(); */
571    
572 nmav 1.2 _handle = mcrypt_dlopen(m_directory, NULL, mode);
573 nmav 1.1 if (!_handle) {
574 nmav 1.4 error=lt_dlerror();
575     if(error!=NULL) fputs(error, stderr);
576 nmav 1.1 fputs("\n", stderr);
577     return MCRYPT_UNKNOWN_ERROR;
578     }
579    
580     _version = lt_dlsym(_handle, "_mcrypt_mode_version");
581    
582     i = _version();
583    
584     lt_dlclose(_handle);
585     lt_dlexit();
586    
587     return i;
588     }
589    
590 nmav 1.5 WIN32DLL_DEFINE
591 nmav 1.1 int mcrypt_module_is_block_algorithm(char *algorithm, char *a_directory)
592     {
593     int i;
594     lt_dlhandle _handle;
595     int (*_is_block_algorithm) (void);
596 nmav 1.4 char* error;
597    
598 nmav 1.1 if (lt_dlinit() != 0) {
599     return MCRYPT_UNKNOWN_ERROR;
600     }
601     /* LTDL_SET_PRELOADED_SYMBOLS(); */
602    
603 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
604    
605 nmav 1.1 if (!_handle) {
606 nmav 1.4 error=lt_dlerror();
607     if(error!=NULL) fputs( error, stderr);
608 nmav 1.1 fputs("\n", stderr);
609     return MCRYPT_UNKNOWN_ERROR;
610     }
611    
612     _is_block_algorithm = lt_dlsym(_handle, "_is_block_algorithm");
613    
614     i = _is_block_algorithm();
615    
616     lt_dlclose(_handle);
617     lt_dlexit();
618    
619     return i;
620     }
621    
622 nmav 1.5 WIN32DLL_DEFINE
623 nmav 1.1 int mcrypt_module_is_block_algorithm_mode(char *mode, char *m_directory)
624     {
625     int i;
626     lt_dlhandle *_handle;
627     int (*_is_a_block_mode) (void);
628 nmav 1.4 char* error;
629 nmav 1.1
630     if (lt_dlinit() != 0) {
631     return MCRYPT_UNKNOWN_ERROR;
632     }
633     /* LTDL_SET_PRELOADED_SYMBOLS(); */
634    
635 nmav 1.2 _handle = mcrypt_dlopen(m_directory, NULL, mode);
636 nmav 1.1 if (!_handle) {
637 nmav 1.4 error=lt_dlerror();
638     if(error!=NULL) fputs( error, stderr);
639 nmav 1.1 fputs("\n", stderr);
640     return MCRYPT_UNKNOWN_ERROR;
641     }
642    
643     _is_a_block_mode = lt_dlsym(_handle, "_is_block_algorithm_mode");
644    
645     i = _is_a_block_mode();
646    
647     lt_dlclose(_handle);
648     lt_dlexit();
649    
650     return i;
651     }
652    
653 nmav 1.5 WIN32DLL_DEFINE
654 nmav 1.1 int mcrypt_module_is_block_mode(char *mode, char *m_directory)
655     {
656     int i;
657     lt_dlhandle *_handle;
658     int (*_is_block_mode) (void);
659 nmav 1.4 char* error;
660 nmav 1.1
661     if (lt_dlinit() != 0) {
662     return MCRYPT_UNKNOWN_ERROR;
663     }
664     /* LTDL_SET_PRELOADED_SYMBOLS(); */
665    
666 nmav 1.2 _handle = mcrypt_dlopen(m_directory, NULL, mode);
667 nmav 1.1 if (!_handle) {
668 nmav 1.4 error=lt_dlerror();
669     if(error!=NULL) fputs( error, stderr);
670 nmav 1.1 fputs("\n", stderr);
671     return MCRYPT_UNKNOWN_ERROR;
672     }
673    
674     _is_block_mode = lt_dlsym(_handle, "_is_block_mode");
675    
676     i = _is_block_mode();
677    
678     lt_dlclose(_handle);
679     lt_dlexit();
680    
681     return i;
682     }
683    
684 nmav 1.5 WIN32DLL_DEFINE
685 nmav 1.1 int mcrypt_module_get_algo_block_size(char *algorithm, char *a_directory)
686     {
687     int i;
688     lt_dlhandle _handle;
689     int (*_get_block_size) (void);
690 nmav 1.4 char* error;
691 nmav 1.1
692     if (lt_dlinit() != 0) {
693     return MCRYPT_UNKNOWN_ERROR;
694     }
695     /* LTDL_SET_PRELOADED_SYMBOLS(); */
696    
697 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
698 nmav 1.1 if (!_handle) {
699 nmav 1.4 error=lt_dlerror();
700     if(error!=NULL) fputs( error, stderr);
701 nmav 1.1 fputs("\n", stderr);
702     return MCRYPT_UNKNOWN_ERROR;
703     }
704    
705     _get_block_size = lt_dlsym(_handle, "_mcrypt_get_block_size");
706    
707     i = _get_block_size();
708    
709     lt_dlclose(_handle);
710     lt_dlexit();
711    
712     return i;
713     }
714    
715 nmav 1.5 WIN32DLL_DEFINE
716 nmav 1.1 int mcrypt_module_get_algo_key_size(char *algorithm, char *a_directory)
717     {
718     int i;
719     lt_dlhandle _handle;
720     int (*_get_key_size) (void);
721 nmav 1.4 char* error;
722 nmav 1.1
723     if (lt_dlinit() != 0) {
724     return MCRYPT_UNKNOWN_ERROR;
725     }
726     /* LTDL_SET_PRELOADED_SYMBOLS(); */
727    
728 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
729 nmav 1.1 if (!_handle) {
730 nmav 1.4 error=lt_dlerror();
731     if(error!=NULL) fputs( error, stderr);
732 nmav 1.1 fputs("\n", stderr);
733     return MCRYPT_UNKNOWN_ERROR;
734     }
735    
736     _get_key_size = lt_dlsym(_handle, "_mcrypt_get_key_size");
737    
738     i = _get_key_size();
739    
740     lt_dlclose(_handle);
741     lt_dlexit();
742    
743     return i;
744     }
745    
746 nmav 1.5 WIN32DLL_DEFINE
747 nmav 1.1 int *mcrypt_module_get_algo_supported_key_sizes(char *algorithm,
748     char *a_directory,
749     int *len)
750     {
751     lt_dlhandle _handle;
752     int *(*_mcrypt_get_key_sizes) (int *);
753     int *size;
754 nmav 1.4 char* error;
755 nmav 1.1
756     if (lt_dlinit() != 0) {
757     *len = 0;
758     return NULL;
759     }
760     /* LTDL_SET_PRELOADED_SYMBOLS(); */
761    
762 nmav 1.2 _handle = mcrypt_dlopen(a_directory, NULL, algorithm);
763 nmav 1.1 if (!_handle) {
764 nmav 1.4 error=lt_dlerror();
765     if(error!=NULL) fputs( error, stderr);
766 nmav 1.1 fputs("\n", stderr);
767     *len = 0;
768     return NULL;
769     }
770    
771     _mcrypt_get_key_sizes =
772     lt_dlsym(_handle, "_mcrypt_get_supported_key_sizes");
773    
774     size = _mcrypt_get_key_sizes(len);
775    
776     lt_dlclose(_handle);
777     lt_dlexit();
778    
779     return size;
780     }

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26