libmcrypt/lib/mcrypt_extra.c

/* 
 * Copyright (C) 1998,1999,2001 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.25 2002/12/16 09:50:50 nmav Exp $ */

#include <libdefs.h>
#include <bzero.h>
#include <xmemory.h>
#include <mcrypt_internal.h>

int mcrypt_algorithm_module_ok(const char *file, const char *directory);
int mcrypt_mode_module_ok(const char *file, const char *directory);

void *mcrypt_dlopen(mcrypt_dlhandle * handle, const char *a_directory,
                    const char *m_directory, const char *filename);

#ifdef HAVE_READDIR_R
# define MAXPATHLEN 256
#endif

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 HAVE_READDIR_R
        readdir_r(dirstream, ret2, &ret);
#else
        ret = readdir(dirstream);
#endif
        if (ret == NULL)
                return NULL;

        result = strdup(ret->d_name);
        if (result == NULL) {
                return NULL;
        }

        return result;

}

extern const mcrypt_preloaded mps[];

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


        *size = 0;

        while (mps[i].name != 0 || mps[i].address != 0) {
                if (mps[i].name != NULL && mps[i].address == NULL) {
                        if (mcrypt_algorithm_module_ok(mps[i].name, NULL) >
                            0) {
                                filename =
                                    realloc(filename,
                                            ((*size) +
                                             1) * sizeof(char *));
                                if (filename == NULL) {
                                        goto freeall;
                                }
                                filename[*size] = strdup(mps[i].name);
                                if (filename[*size] == NULL)
                                        goto freeall;
                                (*size)++;
                        }
                }
                i++;
        }

#ifdef USE_LTDL

        if (libdir == NULL) {
                strncpy(directory, LIBDIR, sizeof(directory)-1);
        } else {
                strncpy(directory, libdir, sizeof(directory)-1);
        }
        directory[ sizeof(directory)-1] = 0;

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

        for (;;) {
                dirname = mcrypt_readdir(pdir);
                if (dirname != NULL) {
                        tmpsize = strlen(dirname);
                        if (tmpsize > 3) {

                                if (mcrypt_algorithm_module_ok
                                    (dirname, directory) > 0) {
                                        ptr = strrchr(dirname, '.');
                                        if (ptr != NULL) {
                                                *ptr = '\0';
                                                tmpsize = strlen(dirname);
                                        }

                                        if (_mcrypt_search_symlist_lib
                                            (dirname) != NULL) {
                                                free(dirname);
                                                continue;       /* it's already in the list,
                                                                 * since it's included in the lib.
                                                                 */
                                        }

                                        filename =
                                            realloc(filename,
                                                    (*size +
                                                     1) * sizeof(char *));
                                        if (filename == NULL) {
                                                free(dirname);
                                                goto freeall;
                                        }

                                        filename[*size] = strdup(dirname);
                                        if (filename[*size] == NULL) {
                                                free(dirname);
                                                goto freeall;
                                        }
                                        (*size)++;
                                }
                        }
                        free(dirname);
                } else break;
        }


        closedir(pdir);

#endif

        return filename;

      freeall:
        for (i = 0; i < (*size); i++) {
                free(filename[i]);
        }
        free(filename);
        return NULL;
}

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

        *size = 0;

        while (mps[i].name != 0 || mps[i].address != 0) {
                if (mps[i].name != NULL && mps[i].address == NULL) {
                        if (mcrypt_mode_module_ok(mps[i].name, NULL) > 0) {
                                filename =
                                    realloc(filename,
                                            (*size + 1) * sizeof(char *));
                                if (filename == NULL) {
                                        goto freeall;
                                }
                                filename[*size] = strdup(mps[i].name);
                                if (filename[*size] == NULL)
                                        goto freeall;
                                (*size)++;
                        }
                }
                i++;
        }

#ifdef USE_LTDL

        if (libdir == NULL) {
                strncpy(directory, LIBDIR, sizeof(directory)-1);
        } else {
                strncpy(directory, libdir, sizeof(directory)-1);
        }
        directory[ sizeof(directory)-1] = 0;

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

        for (;;) {

                dirname = mcrypt_readdir(pdir);
                if (dirname != NULL) {
                        tmpsize = strlen(dirname);
                        if (tmpsize > 3) {
                                if (mcrypt_mode_module_ok
                                    (dirname, directory) > 0) {

                                        ptr = strrchr(dirname, '.');
                                        if (ptr != NULL) {
                                                *ptr = '\0';
                                                tmpsize = strlen(dirname);
                                        }
                                        if (_mcrypt_search_symlist_lib
                                            (dirname) != NULL) {
                                                free(dirname);
                                                continue;       /* it's already in the list,
                                                                 * since it's included in the lib.
                                                                 */
                                        }
                                        filename =
                                            realloc(filename,
                                                    (*size +
                                                     1) * sizeof(char *));
                                        if (filename == NULL) {
                                                free(dirname);
                                                goto freeall;
                                        }

                                        filename[*size] = strdup(dirname);
                                        if (filename[*size] == NULL) {
                                                free(dirname);
                                                goto freeall;
                                        }
                                        (*size)++;
                                }
                        }
                        free(dirname);
                } else {
                        break;
                }

        }

        closedir(pdir);
#endif

        return filename;

      freeall:
        for (i = 0; i < (*size); i++) {
                free(filename[i]);
        }
        free(filename);
        return NULL;
}

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 = 1;
        mcrypt_dlhandle _handle;
        void *rr;
        int (*_version) (void);

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

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

        rr = mcrypt_dlopen(&_handle, directory, NULL, file);

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


        _version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version");

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

        ret = _version();

        mcrypt_dlclose(_handle);

        lt_dlexit();

        return ret;

}

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

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

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

        rr = mcrypt_dlopen(&_handle, directory, NULL, file);
        if (!rr) {
                lt_dlexit();
                return MCRYPT_UNKNOWN_ERROR;
        }


        _version = mcrypt_dlsym(_handle, "_mcrypt_mode_version");

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

        ret = _version();

        mcrypt_dlclose(_handle);
        lt_dlexit();

        return ret;

}

/* Taken from libgcrypt */

static const char *parse_version_number(const char *s, int *number)
{
        int val = 0;

        if (*s == '0' && isdigit(s[1]))
                return NULL;    /* leading zeros are not allowed */
        for (; isdigit(*s); s++) {
                val *= 10;
                val += *s - '0';
        }
        *number = val;
        return val < 0 ? NULL : s;
}


static const char *parse_version_string(const char *s, int *major,
                                        int *minor, int *micro)
{
        s = parse_version_number(s, major);
        if (!s || *s != '.')
                return NULL;
        s++;
        s = parse_version_number(s, minor);
        if (!s || *s != '.')
                return NULL;
        s++;
        s = parse_version_number(s, micro);
        if (!s)
                return NULL;
        return s;               /* patchlevel */
}

/****************
 * Check that the the version of the library is at minimum the requested one
 * and return the version string; return NULL if the condition is not
 * satisfied.  If a NULL is passed to this function, no check is done,
 * but the version string is simply returned.
 */
const char *mcrypt_check_version(const char *req_version)
{
        const char *ver = VERSION;
        int my_major, my_minor, my_micro;
        int rq_major, rq_minor, rq_micro;
        const char *my_plvl, *rq_plvl;

        if (!req_version)
                return ver;

        my_plvl =
            parse_version_string(ver, &my_major, &my_minor, &my_micro);
        if (!my_plvl)
                return NULL;    /* very strange our own version is bogus */
        rq_plvl = parse_version_string(req_version, &rq_major, &rq_minor,
                                       &rq_micro);
        if (!rq_plvl)
                return NULL;    /* req version string is invalid */

        if (my_major > rq_major
            || (my_major == rq_major && my_minor > rq_minor)
            || (my_major == rq_major && my_minor == rq_minor
                && my_micro > rq_micro)
            || (my_major == rq_major && my_minor == rq_minor
                && my_micro == rq_micro
                && strcmp(my_plvl, rq_plvl) >= 0)) {
                return ver;
        }
        return NULL;
}
1	nmav	1.1	/*
2	nmav	1.16	* Copyright (C) 1998,1999,2001 Nikos Mavroyanopoulos
3	nmav	1.1	*
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.26	/* $Id: mcrypt_extra.c,v 1.25 2002/12/16 09:50:50 nmav Exp $ */
21	nmav	1.1
22			#include <libdefs.h>
23			#include <bzero.h>
24			#include <xmemory.h>
25			#include <mcrypt_internal.h>
26
27	nmav	1.3	int mcrypt_algorithm_module_ok(const char file, const char directory);
28			int mcrypt_mode_module_ok(const char file, const char directory);
29	nmav	1.13
30	nmav	1.24	void mcrypt_dlopen(mcrypt_dlhandle handle, const char *a_directory,
31			const char m_directory, const char filename);
32	nmav	1.3
33	nmav	1.12	#ifdef HAVE_READDIR_R
34			# define MAXPATHLEN 256
35			#endif
36
37	nmav	1.6	WIN32DLL_DEFINE char mcrypt_readdir(DIR dirstream)
38	nmav	1.3	{
39	nmav	1.2
40	nmav	1.6	char *result;
41	nmav	1.3	struct dirent *ret = NULL;
42	nmav	1.6	#ifdef HAVE_READDIR_R
43	nmav	1.24	struct dirent ret2[sizeof(struct dirent) + MAXPATHLEN];
44	nmav	1.6	#endif
45
46	nmav	1.2	#ifdef HAVE_READDIR_R
47	nmav	1.22	readdir_r(dirstream, ret2, &ret);
48	nmav	1.2	#else
49	nmav	1.22	ret = readdir(dirstream);
50	nmav	1.2	#endif
51	nmav	1.24	if (ret == NULL)
52			return NULL;
53	nmav	1.6
54	nmav	1.24	result = strdup(ret->d_name);
55	nmav	1.22	if (result == NULL) {
56			return NULL;
57	nmav	1.3	}
58
59			return result;
60
61	nmav	1.2	}
62	nmav	1.1
63	nmav	1.14	extern const mcrypt_preloaded mps[];
64	nmav	1.13
65	nmav	1.24	WIN32DLL_DEFINE char *mcrypt_list_algorithms(const char libdir,
66			int *size)
67	nmav	1.1	{
68			DIR *pdir;
69	nmav	1.2	char directory[512];
70	nmav	1.6	char *dirname;
71	nmav	1.1	char *filename = NULL, ptr;
72	nmav	1.24	int tmpsize, i = 0;
73	nmav	1.1
74	nmav	1.13
75	nmav	1.1	*size = 0;
76
77	nmav	1.24	while (mps[i].name != 0 \|\| mps[i].address != 0) {
78			if (mps[i].name != NULL && mps[i].address == NULL) {
79			if (mcrypt_algorithm_module_ok(mps[i].name, NULL) >
80			0) {
81	nmav	1.14	filename =
82			realloc(filename,
83	nmav	1.24	((*size) +
84			1) * sizeof(char *));
85			if (filename == NULL) {
86	nmav	1.16	goto freeall;
87	nmav	1.14	}
88	nmav	1.24	filename[*size] = strdup(mps[i].name);
89			if (filename[*size] == NULL)
90			goto freeall;
91	nmav	1.14	(*size)++;
92			}
93			}
94			i++;
95	nmav	1.24	}
96	nmav	1.14
97	nmav	1.21	#ifdef USE_LTDL
98
99	nmav	1.1	if (libdir == NULL) {
100	nmav	1.25	strncpy(directory, LIBDIR, sizeof(directory)-1);
101	nmav	1.1	} else {
102	nmav	1.25	strncpy(directory, libdir, sizeof(directory)-1);
103	nmav	1.1	}
104	nmav	1.25	directory[ sizeof(directory)-1] = 0;
105	nmav	1.1
106			pdir = opendir(directory);
107			if (pdir == NULL) {
108	nmav	1.11	#ifdef DEBUG
109	nmav	1.1	fprintf(stderr, "Unable to open directory %s.\n",
110			directory);
111	nmav	1.11	#endif
112	nmav	1.17	return filename;
113	nmav	1.1	}
114
115			for (;;) {
116	nmav	1.2	dirname = mcrypt_readdir(pdir);
117	nmav	1.1	if (dirname != NULL) {
118	nmav	1.6	tmpsize = strlen(dirname);
119	nmav	1.3	if (tmpsize > 3) {
120	nmav	1.24
121	nmav	1.6	if (mcrypt_algorithm_module_ok
122			(dirname, directory) > 0) {
123	nmav	1.24	ptr = strrchr(dirname, '.');
124	nmav	1.16	if (ptr != NULL) {
125			*ptr = '\0';
126			tmpsize = strlen(dirname);
127			}
128	nmav	1.24
129			if (_mcrypt_search_symlist_lib
130			(dirname) != NULL) {
131	nmav	1.16	free(dirname);
132	nmav	1.24	continue; /* it's already in the list,
133			* since it's included in the lib.
134			*/
135	nmav	1.16	}
136	nmav	1.24
137	nmav	1.6	filename =
138			realloc(filename,
139			(*size +
140			1) * sizeof(char *));
141	nmav	1.24	if (filename == NULL) {
142	nmav	1.10	free(dirname);
143	nmav	1.16	goto freeall;
144	nmav	1.10	}
145	nmav	1.16
146	nmav	1.24	filename[*size] = strdup(dirname);
147			if (filename[*size] == NULL) {
148	nmav	1.16	free(dirname);
149			goto freeall;
150			}
151	nmav	1.3	(*size)++;
152	nmav	1.1	}
153	nmav	1.3	}
154	nmav	1.10	free(dirname);
155	nmav	1.24	} else break;
156	nmav	1.1	}
157
158
159	nmav	1.3	closedir(pdir);
160	nmav	1.1
161	nmav	1.21	#endif
162
163	nmav	1.1	return filename;
164
165	nmav	1.24	freeall:
166			for (i = 0; i < (*size); i++) {
167			free(filename[i]);
168			}
169			free(filename);
170			return NULL;
171	nmav	1.1	}
172
173	nmav	1.23	WIN32DLL_DEFINE char *mcrypt_list_modes(const char libdir, int *size)
174	nmav	1.1	{
175			DIR *pdir;
176	nmav	1.2	char directory[512];
177	nmav	1.6	char *dirname;
178	nmav	1.1	char *filename = NULL, ptr;
179			int tmpsize;
180	nmav	1.24	int i = 0;
181
182	nmav	1.14	*size = 0;
183	nmav	1.24
184			while (mps[i].name != 0 \|\| mps[i].address != 0) {
185			if (mps[i].name != NULL && mps[i].address == NULL) {
186			if (mcrypt_mode_module_ok(mps[i].name, NULL) > 0) {
187	nmav	1.14	filename =
188			realloc(filename,
189	nmav	1.24	(size + 1) sizeof(char *));
190			if (filename == NULL) {
191	nmav	1.16	goto freeall;
192	nmav	1.14	}
193	nmav	1.24	filename[*size] = strdup(mps[i].name);
194			if (filename[*size] == NULL)
195			goto freeall;
196	nmav	1.14	(*size)++;
197			}
198			}
199			i++;
200	nmav	1.24	}
201	nmav	1.1
202	nmav	1.21	#ifdef USE_LTDL
203
204	nmav	1.1	if (libdir == NULL) {
205	nmav	1.25	strncpy(directory, LIBDIR, sizeof(directory)-1);
206	nmav	1.1	} else {
207	nmav	1.25	strncpy(directory, libdir, sizeof(directory)-1);
208	nmav	1.1	}
209	nmav	1.25	directory[ sizeof(directory)-1] = 0;
210	nmav	1.1
211			pdir = opendir(directory);
212			if (pdir == NULL) {
213	nmav	1.11	#ifdef DEBUG
214	nmav	1.1	fprintf(stderr, "Unable to open directory %s.\n",
215			directory);
216	nmav	1.11	#endif
217	nmav	1.17	return filename;
218	nmav	1.1	}
219
220			for (;;) {
221
222	nmav	1.2	dirname = mcrypt_readdir(pdir);
223	nmav	1.1	if (dirname != NULL) {
224	nmav	1.6	tmpsize = strlen(dirname);
225			if (tmpsize > 3) {
226			if (mcrypt_mode_module_ok
227			(dirname, directory) > 0) {
228	nmav	1.16
229	nmav	1.24	ptr = strrchr(dirname, '.');
230	nmav	1.16	if (ptr != NULL) {
231			*ptr = '\0';
232			tmpsize = strlen(dirname);
233			}
234	nmav	1.24	if (_mcrypt_search_symlist_lib
235			(dirname) != NULL) {
236	nmav	1.16	free(dirname);
237	nmav	1.24	continue; /* it's already in the list,
238			* since it's included in the lib.
239			*/
240	nmav	1.16	}
241	nmav	1.6	filename =
242			realloc(filename,
243			(*size +
244			1) * sizeof(char *));
245	nmav	1.24	if (filename == NULL) {
246	nmav	1.10	free(dirname);
247	nmav	1.16	goto freeall;
248	nmav	1.10	}
249	nmav	1.24
250			filename[*size] = strdup(dirname);
251			if (filename[*size] == NULL) {
252	nmav	1.16	free(dirname);
253			goto freeall;
254			}
255	nmav	1.6	(*size)++;
256	nmav	1.1	}
257			}
258	nmav	1.6	free(dirname);
259	nmav	1.1	} else {
260			break;
261			}
262
263			}
264
265			closedir(pdir);
266	nmav	1.21	#endif
267
268	nmav	1.1	return filename;
269	nmav	1.16
270	nmav	1.24	freeall:
271			for (i = 0; i < (*size); i++) {
272			free(filename[i]);
273			}
274			free(filename);
275			return NULL;
276	nmav	1.1	}
277
278	nmav	1.6	WIN32DLL_DEFINE void mcrypt_free_p(char **p, int size)
279	nmav	1.3	{
280			int i;
281	nmav	1.1
282	nmav	1.3	for (i = 0; i < size; i++) {
283	nmav	1.1	free(p[i]);
284			}
285			free(p);
286			}
287
288	nmav	1.5	WIN32DLL_DEFINE
289	nmav	1.6	int mcrypt_algorithm_module_ok(const char file, const char directory)
290	nmav	1.1	{
291	nmav	1.24	word32 ret = 1;
292	nmav	1.13	mcrypt_dlhandle _handle;
293	nmav	1.24	void *rr;
294	nmav	1.1	int (*_version) (void);
295
296	nmav	1.3	if (file == NULL && directory == NULL) {
297	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
298			}
299	nmav	1.4
300	nmav	1.3	if (lt_dlinit() != 0) {
301	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
302			}
303	nmav	1.4
304	nmav	1.13	rr = mcrypt_dlopen(&_handle, directory, NULL, file);
305	nmav	1.1
306	nmav	1.13	if (!rr) {
307	nmav	1.1	lt_dlexit();
308			return MCRYPT_UNKNOWN_ERROR;
309			}
310
311
312	nmav	1.13	_version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version");
313	nmav	1.1
314	nmav	1.3	if (_version == NULL) {
315	nmav	1.13	mcrypt_dlclose(_handle);
316	nmav	1.1	lt_dlexit();
317			return MCRYPT_UNKNOWN_ERROR;
318			}
319
320			ret = _version();
321
322	nmav	1.13	mcrypt_dlclose(_handle);
323	nmav	1.24
324	nmav	1.1	lt_dlexit();
325
326			return ret;
327
328			}
329
330	nmav	1.5	WIN32DLL_DEFINE
331	nmav	1.6	int mcrypt_mode_module_ok(const char file, const char directory)
332	nmav	1.1	{
333			word32 ret;
334	nmav	1.13	mcrypt_dlhandle _handle;
335	nmav	1.24	void *rr;
336	nmav	1.1	int (*_version) (void);
337
338	nmav	1.3	if (file == NULL && directory == NULL) {
339	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
340			}
341
342	nmav	1.3	if (lt_dlinit() != 0) {
343	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
344	nmav	1.3	}
345
346	nmav	1.13	rr = mcrypt_dlopen(&_handle, directory, NULL, file);
347			if (!rr) {
348	nmav	1.1	lt_dlexit();
349			return MCRYPT_UNKNOWN_ERROR;
350			}
351	nmav	1.3
352	nmav	1.1
353	nmav	1.13	_version = mcrypt_dlsym(_handle, "_mcrypt_mode_version");
354	nmav	1.1
355	nmav	1.3	if (_version == NULL) {
356	nmav	1.13	mcrypt_dlclose(_handle);
357	nmav	1.1	lt_dlexit();
358			return MCRYPT_UNKNOWN_ERROR;
359			}
360	nmav	1.3
361	nmav	1.1	ret = _version();
362
363	nmav	1.13	mcrypt_dlclose(_handle);
364	nmav	1.1	lt_dlexit();
365
366			return ret;
367
368			}
369	nmav	1.8
370			/* Taken from libgcrypt */
371
372	nmav	1.24	static const char parse_version_number(const char s, int *number)
373	nmav	1.8	{
374	nmav	1.24	int val = 0;
375	nmav	1.8
376	nmav	1.24	if (*s == '0' && isdigit(s[1]))
377			return NULL; /* leading zeros are not allowed */
378			for (; isdigit(*s); s++) {
379			val *= 10;
380			val += *s - '0';
381			}
382			*number = val;
383			return val < 0 ? NULL : s;
384	nmav	1.8	}
385
386
387	nmav	1.24	static const char parse_version_string(const char s, int *major,
388			int minor, int micro)
389	nmav	1.8	{
390	nmav	1.24	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	nmav	1.8	}
403
404			/****************
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	nmav	1.24	const char mcrypt_check_version(const char req_version)
411	nmav	1.8	{
412	nmav	1.24	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	nmav	1.8	}