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.20 2002/01/31 01:13:58 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 DT_REG
        do {
#endif

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

                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;

}

extern const mcrypt_preloaded mps[];

WIN32DLL_DEFINE char **mcrypt_list_algorithms(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) {
                strcpy(directory, LIBDIR);
        } else {
                strcpy(directory, libdir);
        }

        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] = (char*)
                                            calloc(1, tmpsize + 1);
                                        if (filename[*size]==NULL) {
                                                free(dirname);
                                                goto freeall;
                                        }
                                        strcpy(filename[*size], dirname);
                                        
                                        (*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(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) {
                strcpy(directory, LIBDIR);
        } else {
                strcpy(directory, libdir);
        }

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