libmcrypt/lib/mcrypt_extra.c

/* 
 * Copyright (C) 1998,1999 Nikos Mavroyanopoulos 
 *
 * This library is free software; you can redistribute it and/or modify it under the terms of the
 * GNU Library General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any
 * later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/* $Id: mcrypt_extra.c,v 1.5 2000/10/12 21:06:31 nmav Exp $ */

#ifndef LIBDEFS_H
#define LIBDEFS_H
#include <libdefs.h>
#endif
#include <bzero.h>
#include <xmemory.h>
#include <mcrypt_internal.h>

#if 0
extern int preloaded_symbols;
#endif

int mcrypt_algorithm_module_ok(const char *file, const char *directory);
int mcrypt_mode_module_ok(const char *file, const char *directory);
#ifndef USE_LTDL
void *mcrypt_dlopen_ext(const char *filename);
#endif
void *mcrypt_dlopen(const char *a_directory, const char *m_directory,
                    const char *filename);

#define MAXPATHLEN 256
WIN32DLL_DEFINE char *mcrypt_readdir(DIR * dirstream)
{

        char *result;
        struct dirent *ret = NULL;
#ifdef HAVE_READDIR_R
        struct dirent ret2[sizeof(struct dirent)+MAXPATHLEN];
#endif

#ifdef DT_REG
        do {
#endif

#ifdef HAVE_READDIR_R
                readdir_r(dirstream, ret2, &ret);
                if (ret==NULL) return NULL;
#else
                ret = readdir(dirstream);
#endif

                result = calloc(1, strlen(ret->d_name) + 1);
                if (result == NULL) {
                        return NULL;
                }
                strcpy(result, ret->d_name);
#ifdef DT_REG
        }
        while ((ret->d_type != DT_REG) && (ret->d_type != DT_UNKNOWN)
               && (ret != NULL));
#endif

        return result;

}

WIN32DLL_DEFINE char **mcrypt_list_algorithms(char *libdir, int *size)
{
        DIR *pdir;
        char directory[512];
        char *dirname;
        char **filename = NULL, *ptr;
        int tmpsize;

        *size = 0;

        if (libdir == NULL) {
                strcpy(directory, LIBDIR);
        } else {
                strcpy(directory, libdir);
        }

        pdir = opendir(directory);
        if (pdir == NULL) {
                fprintf(stderr, "Unable to open directory %s.\n",
                        directory);
                return NULL;
        }

        for (;;) {
                dirname = mcrypt_readdir(pdir);
                if (dirname != NULL) {
                        tmpsize = strlen(dirname);
                        if (tmpsize > 3) {
                                if (mcrypt_algorithm_module_ok
                                    (dirname, directory) > 0) {
                                        filename =
                                            realloc(filename,
                                                    (*size +
                                                     1) * sizeof(char *));
                                        filename[*size] =
                                            calloc(1, tmpsize + 1);
                                        strcpy(filename[*size], dirname);

                                        ptr =
                                            strrchr(filename[*size], '.');
                                        if (ptr != NULL)
                                                *ptr = '\0';
                                        (*size)++;
                                }
                        }
                } else {
                        break;
                }

        }


        closedir(pdir);

        return filename;

}

WIN32DLL_DEFINE char **mcrypt_list_modes(char *libdir, int *size)
{
        DIR *pdir;
        char directory[512];
        char *dirname;
        char **filename = NULL, *ptr;
        int tmpsize;

        if (libdir == NULL) {
                strcpy(directory, LIBDIR);
        } else {
                strcpy(directory, libdir);
        }

        pdir = opendir(directory);
        if (pdir == NULL) {
                fprintf(stderr, "Unable to open directory %s.\n",
                        directory);
                return NULL;
        }

        *size = 0;
        for (;;) {

                dirname = mcrypt_readdir(pdir);
                if (dirname != NULL) {
                        tmpsize = strlen(dirname);
                        if (tmpsize > 3) {
                                if (mcrypt_mode_module_ok
                                    (dirname, directory) > 0) {
                                        filename =
                                            realloc(filename,
                                                    (*size +
                                                     1) * sizeof(char *));
                                        filename[*size] =
                                            calloc(1, tmpsize + 1);
                                        strcpy(filename[*size], dirname);
                                        ptr =
                                            strrchr(filename[*size], '.');
                                        if (ptr != NULL)
                                                *ptr = '\0';
                                        (*size)++;
                                }
                        }
                        free(dirname);
                } else {
                        break;
                }

        }

        closedir(pdir);
        return filename;
}

WIN32DLL_DEFINE void mcrypt_free_p(char **p, int size)
{
        int i;

        for (i = 0; i < size; i++) {
                free(p[i]);
        }
        free(p);
}

WIN32DLL_DEFINE
    int mcrypt_algorithm_module_ok(const char *file, const char *directory)
{
        word32 ret;
        lt_dlhandle *_handle;
        int (*_version) (void);

        if (file == NULL && directory == NULL) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }


/*      LTDL_SET_PRELOADED_SYMBOLS(); */

        _handle = mcrypt_dlopen(directory, NULL, file);

        if (!_handle) {
/*              fputs(lt_dlerror(), stderr);
 *              fputs("\n", stderr);
 */
                lt_dlexit();
                return MCRYPT_UNKNOWN_ERROR;
        }


        _version = lt_dlsym(_handle, "_mcrypt_algorithm_version");

        if (_version == NULL) {
                lt_dlclose(_handle);
                lt_dlexit();
                return MCRYPT_UNKNOWN_ERROR;
        }

        ret = _version();

        lt_dlclose(_handle);
        lt_dlexit();

        return ret;

}

WIN32DLL_DEFINE
    int mcrypt_mode_module_ok(const char *file, const char *directory)
{
        word32 ret;
        lt_dlhandle *_handle;
        int (*_version) (void);

        if (file == NULL && directory == NULL) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }
/*      LTDL_SET_PRELOADED_SYMBOLS(); */

        _handle = mcrypt_dlopen(directory, NULL, file);

        if (!_handle) {
                lt_dlexit();
                return MCRYPT_UNKNOWN_ERROR;
        }


        _version = lt_dlsym(_handle, "_mcrypt_mode_version");

        if (_version == NULL) {
                lt_dlclose(_handle);
                lt_dlexit();
                return MCRYPT_UNKNOWN_ERROR;
        }

        ret = _version();

        lt_dlclose(_handle);
        lt_dlexit();

        return ret;

}
1	nmav	1.1	/*
2			* Copyright (C) 1998,1999 Nikos Mavroyanopoulos
3			*
4			* 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
6			* Foundation; either version 2 of the License, or (at your option) any
7			* 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	nmav	1.6	/* $Id: mcrypt_extra.c,v 1.5 2000/10/12 21:06:31 nmav Exp $ */
21	nmav	1.1
22			#ifndef LIBDEFS_H
23			#define LIBDEFS_H
24			#include <libdefs.h>
25			#endif
26			#include <bzero.h>
27			#include <xmemory.h>
28			#include <mcrypt_internal.h>
29
30			#if 0
31			extern int preloaded_symbols;
32	nmav	1.3	#endif
33	nmav	1.1
34	nmav	1.3	int mcrypt_algorithm_module_ok(const char file, const char directory);
35			int mcrypt_mode_module_ok(const char file, const char directory);
36	nmav	1.2	#ifndef USE_LTDL
37	nmav	1.3	void mcrypt_dlopen_ext(const char filename);
38	nmav	1.2	#endif
39	nmav	1.6	void mcrypt_dlopen(const char a_directory, const char *m_directory,
40			const char *filename);
41	nmav	1.3
42	nmav	1.6	#define MAXPATHLEN 256
43			WIN32DLL_DEFINE char mcrypt_readdir(DIR dirstream)
44	nmav	1.3	{
45	nmav	1.2
46	nmav	1.6	char *result;
47	nmav	1.3	struct dirent *ret = NULL;
48	nmav	1.6	#ifdef HAVE_READDIR_R
49			struct dirent ret2[sizeof(struct dirent)+MAXPATHLEN];
50			#endif
51
52			#ifdef DT_REG
53			do {
54			#endif
55	nmav	1.2
56			#ifdef HAVE_READDIR_R
57	nmav	1.6	readdir_r(dirstream, ret2, &ret);
58			if (ret==NULL) return NULL;
59	nmav	1.2	#else
60	nmav	1.6	ret = readdir(dirstream);
61	nmav	1.2	#endif
62	nmav	1.6
63			result = calloc(1, strlen(ret->d_name) + 1);
64			if (result == NULL) {
65			return NULL;
66			}
67			strcpy(result, ret->d_name);
68			#ifdef DT_REG
69	nmav	1.3	}
70	nmav	1.6	while ((ret->d_type != DT_REG) && (ret->d_type != DT_UNKNOWN)
71			&& (ret != NULL));
72			#endif
73	nmav	1.3
74			return result;
75
76	nmav	1.2	}
77	nmav	1.1
78	nmav	1.6	WIN32DLL_DEFINE char *mcrypt_list_algorithms(char libdir, int *size)
79	nmav	1.1	{
80			DIR *pdir;
81	nmav	1.2	char directory[512];
82	nmav	1.6	char *dirname;
83	nmav	1.1	char *filename = NULL, ptr;
84			int tmpsize;
85
86			*size = 0;
87
88			if (libdir == NULL) {
89			strcpy(directory, LIBDIR);
90			} else {
91			strcpy(directory, libdir);
92			}
93
94			pdir = opendir(directory);
95			if (pdir == NULL) {
96			fprintf(stderr, "Unable to open directory %s.\n",
97			directory);
98			return NULL;
99			}
100
101			for (;;) {
102	nmav	1.2	dirname = mcrypt_readdir(pdir);
103	nmav	1.1	if (dirname != NULL) {
104	nmav	1.6	tmpsize = strlen(dirname);
105	nmav	1.3	if (tmpsize > 3) {
106	nmav	1.6	if (mcrypt_algorithm_module_ok
107			(dirname, directory) > 0) {
108			filename =
109			realloc(filename,
110			(*size +
111			1) * sizeof(char *));
112			filename[*size] =
113			calloc(1, tmpsize + 1);
114			strcpy(filename[*size], dirname);
115	nmav	1.3
116	nmav	1.6	ptr =
117			strrchr(filename[*size], '.');
118	nmav	1.3	if (ptr != NULL)
119			*ptr = '\0';
120			(*size)++;
121	nmav	1.1	}
122	nmav	1.3	}
123	nmav	1.1	} else {
124			break;
125			}
126
127			}
128
129
130	nmav	1.3	closedir(pdir);
131	nmav	1.1
132			return filename;
133
134			}
135
136	nmav	1.6	WIN32DLL_DEFINE char *mcrypt_list_modes(char libdir, int *size)
137	nmav	1.1	{
138			DIR *pdir;
139	nmav	1.2	char directory[512];
140	nmav	1.6	char *dirname;
141	nmav	1.1	char *filename = NULL, ptr;
142			int tmpsize;
143
144			if (libdir == NULL) {
145			strcpy(directory, LIBDIR);
146			} else {
147			strcpy(directory, libdir);
148			}
149
150			pdir = opendir(directory);
151			if (pdir == NULL) {
152			fprintf(stderr, "Unable to open directory %s.\n",
153			directory);
154			return NULL;
155			}
156
157			*size = 0;
158			for (;;) {
159
160	nmav	1.2	dirname = mcrypt_readdir(pdir);
161	nmav	1.1	if (dirname != NULL) {
162	nmav	1.6	tmpsize = strlen(dirname);
163			if (tmpsize > 3) {
164			if (mcrypt_mode_module_ok
165			(dirname, directory) > 0) {
166			filename =
167			realloc(filename,
168			(*size +
169			1) * sizeof(char *));
170			filename[*size] =
171			calloc(1, tmpsize + 1);
172			strcpy(filename[*size], dirname);
173			ptr =
174			strrchr(filename[*size], '.');
175			if (ptr != NULL)
176			*ptr = '\0';
177			(*size)++;
178	nmav	1.1	}
179			}
180	nmav	1.6	free(dirname);
181	nmav	1.1	} else {
182			break;
183			}
184
185			}
186
187			closedir(pdir);
188			return filename;
189			}
190
191	nmav	1.6	WIN32DLL_DEFINE void mcrypt_free_p(char **p, int size)
192	nmav	1.3	{
193			int i;
194	nmav	1.1
195	nmav	1.3	for (i = 0; i < size; i++) {
196	nmav	1.1	free(p[i]);
197			}
198			free(p);
199			}
200
201	nmav	1.5	WIN32DLL_DEFINE
202	nmav	1.6	int mcrypt_algorithm_module_ok(const char file, const char directory)
203	nmav	1.1	{
204			word32 ret;
205			lt_dlhandle *_handle;
206			int (*_version) (void);
207
208	nmav	1.3	if (file == NULL && directory == NULL) {
209	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
210			}
211	nmav	1.4
212	nmav	1.3	if (lt_dlinit() != 0) {
213	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
214			}
215	nmav	1.4
216	nmav	1.3
217	nmav	1.2	/* LTDL_SET_PRELOADED_SYMBOLS(); */
218	nmav	1.3
219	nmav	1.2	_handle = mcrypt_dlopen(directory, NULL, file);
220	nmav	1.1
221			if (!_handle) {
222			/* fputs(lt_dlerror(), stderr);
223			* fputs("\n", stderr);
224			*/
225			lt_dlexit();
226			return MCRYPT_UNKNOWN_ERROR;
227			}
228
229
230			_version = lt_dlsym(_handle, "_mcrypt_algorithm_version");
231
232	nmav	1.3	if (_version == NULL) {
233	nmav	1.1	lt_dlclose(_handle);
234			lt_dlexit();
235			return MCRYPT_UNKNOWN_ERROR;
236			}
237
238			ret = _version();
239
240			lt_dlclose(_handle);
241			lt_dlexit();
242
243			return ret;
244
245			}
246
247	nmav	1.5	WIN32DLL_DEFINE
248	nmav	1.6	int mcrypt_mode_module_ok(const char file, const char directory)
249	nmav	1.1	{
250			word32 ret;
251			lt_dlhandle *_handle;
252			int (*_version) (void);
253
254	nmav	1.3	if (file == NULL && directory == NULL) {
255	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
256			}
257
258	nmav	1.3	if (lt_dlinit() != 0) {
259	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
260	nmav	1.3	}
261	nmav	1.1	/* LTDL_SET_PRELOADED_SYMBOLS(); */
262	nmav	1.3
263	nmav	1.2	_handle = mcrypt_dlopen(directory, NULL, file);
264	nmav	1.3
265	nmav	1.1	if (!_handle) {
266			lt_dlexit();
267			return MCRYPT_UNKNOWN_ERROR;
268			}
269	nmav	1.3
270	nmav	1.1
271			_version = lt_dlsym(_handle, "_mcrypt_mode_version");
272
273	nmav	1.3	if (_version == NULL) {
274	nmav	1.1	lt_dlclose(_handle);
275			lt_dlexit();
276			return MCRYPT_UNKNOWN_ERROR;
277			}
278	nmav	1.3
279	nmav	1.1	ret = _version();
280
281			lt_dlclose(_handle);
282			lt_dlexit();
283
284			return ret;
285
286			}