Add functions to set ECDSA_METHOD structure.
[openssl.git] / crypto / dso / dso_win32.c
1 /* dso_win32.c -*- mode:C; c-file-style: "eay" -*- */
2 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
3  * project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #include <stdio.h>
60 #include <string.h>
61 #include "cryptlib.h"
62 #include <openssl/dso.h>
63
64 #if !defined(DSO_WIN32)
65 DSO_METHOD *DSO_METHOD_win32(void)
66         {
67         return NULL;
68         }
69 #else
70
71 #ifdef _WIN32_WCE
72 # if _WIN32_WCE < 300
73 static FARPROC GetProcAddressA(HMODULE hModule,LPCSTR lpProcName)
74         {
75         WCHAR lpProcNameW[64];
76         int i;
77
78         for (i=0;lpProcName[i] && i<64;i++)
79                 lpProcNameW[i] = (WCHAR)lpProcName[i];
80         if (i==64) return NULL;
81         lpProcNameW[i] = 0;
82
83         return GetProcAddressW(hModule,lpProcNameW);
84         }
85 # endif
86 # undef GetProcAddress
87 # define GetProcAddress GetProcAddressA
88
89 static HINSTANCE LoadLibraryA(LPCSTR lpLibFileName)
90         {
91         WCHAR *fnamw;
92         size_t len_0=strlen(lpLibFileName)+1,i;
93
94 #ifdef _MSC_VER
95         fnamw = (WCHAR *)_alloca (len_0*sizeof(WCHAR));
96 #else
97         fnamw = (WCHAR *)alloca (len_0*sizeof(WCHAR));
98 #endif
99         if (fnamw == NULL)
100                 {
101                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
102                 return NULL;
103                 }
104
105 #if defined(_WIN32_WCE) && _WIN32_WCE>=101
106         if (!MultiByteToWideChar(CP_ACP,0,lpLibFileName,len_0,fnamw,len_0))
107 #endif
108                 for (i=0;i<len_0;i++) fnamw[i]=(WCHAR)lpLibFileName[i];
109
110         return LoadLibraryW(fnamw);
111         }
112 #endif
113
114 /* Part of the hack in "win32_load" ... */
115 #define DSO_MAX_TRANSLATED_SIZE 256
116
117 static int win32_load(DSO *dso);
118 static int win32_unload(DSO *dso);
119 static void *win32_bind_var(DSO *dso, const char *symname);
120 static DSO_FUNC_TYPE win32_bind_func(DSO *dso, const char *symname);
121 #if 0
122 static int win32_unbind_var(DSO *dso, char *symname, void *symptr);
123 static int win32_unbind_func(DSO *dso, char *symname, DSO_FUNC_TYPE symptr);
124 static int win32_init(DSO *dso);
125 static int win32_finish(DSO *dso);
126 static long win32_ctrl(DSO *dso, int cmd, long larg, void *parg);
127 #endif
128 static char *win32_name_converter(DSO *dso, const char *filename);
129 static char *win32_merger(DSO *dso, const char *filespec1,
130         const char *filespec2);
131 static int win32_pathbyaddr(void *addr,char *path,int sz);
132 static void *win32_globallookup(const char *name);
133
134 static const char *openssl_strnchr(const char *string, int c, size_t len);
135
136 static DSO_METHOD dso_meth_win32 = {
137         "OpenSSL 'win32' shared library method",
138         win32_load,
139         win32_unload,
140         win32_bind_var,
141         win32_bind_func,
142 /* For now, "unbind" doesn't exist */
143 #if 0
144         NULL, /* unbind_var */
145         NULL, /* unbind_func */
146 #endif
147         NULL, /* ctrl */
148         win32_name_converter,
149         win32_merger,
150         NULL, /* init */
151         NULL, /* finish */
152         win32_pathbyaddr,
153         win32_globallookup
154         };
155
156 DSO_METHOD *DSO_METHOD_win32(void)
157         {
158         return(&dso_meth_win32);
159         }
160
161 /* For this DSO_METHOD, our meth_data STACK will contain;
162  * (i) a pointer to the handle (HINSTANCE) returned from
163  *     LoadLibrary(), and copied.
164  */
165
166 static int win32_load(DSO *dso)
167         {
168         HINSTANCE h = NULL, *p = NULL;
169         /* See applicable comments from dso_dl.c */
170         char *filename = DSO_convert_filename(dso, NULL);
171
172         if(filename == NULL)
173                 {
174                 DSOerr(DSO_F_WIN32_LOAD,DSO_R_NO_FILENAME);
175                 goto err;
176                 }
177         h = LoadLibraryA(filename);
178         if(h == NULL)
179                 {
180                 DSOerr(DSO_F_WIN32_LOAD,DSO_R_LOAD_FAILED);
181                 ERR_add_error_data(3, "filename(", filename, ")");
182                 goto err;
183                 }
184         p = (HINSTANCE *)OPENSSL_malloc(sizeof(HINSTANCE));
185         if(p == NULL)
186                 {
187                 DSOerr(DSO_F_WIN32_LOAD,ERR_R_MALLOC_FAILURE);
188                 goto err;
189                 }
190         *p = h;
191         if(!sk_void_push(dso->meth_data, p))
192                 {
193                 DSOerr(DSO_F_WIN32_LOAD,DSO_R_STACK_ERROR);
194                 goto err;
195                 }
196         /* Success */
197         dso->loaded_filename = filename;
198         return(1);
199 err:
200         /* Cleanup !*/
201         if(filename != NULL)
202                 OPENSSL_free(filename);
203         if(p != NULL)
204                 OPENSSL_free(p);
205         if(h != NULL)
206                 FreeLibrary(h);
207         return(0);
208         }
209
210 static int win32_unload(DSO *dso)
211         {
212         HINSTANCE *p;
213         if(dso == NULL)
214                 {
215                 DSOerr(DSO_F_WIN32_UNLOAD,ERR_R_PASSED_NULL_PARAMETER);
216                 return(0);
217                 }
218         if(sk_void_num(dso->meth_data) < 1)
219                 return(1);
220         p = sk_void_pop(dso->meth_data);
221         if(p == NULL)
222                 {
223                 DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_NULL_HANDLE);
224                 return(0);
225                 }
226         if(!FreeLibrary(*p))
227                 {
228                 DSOerr(DSO_F_WIN32_UNLOAD,DSO_R_UNLOAD_FAILED);
229                 /* We should push the value back onto the stack in
230                  * case of a retry. */
231                 sk_void_push(dso->meth_data, p);
232                 return(0);
233                 }
234         /* Cleanup */
235         OPENSSL_free(p);
236         return(1);
237         }
238
239 /* Using GetProcAddress for variables? TODO: Check this out in
240  * the Win32 API docs, there's probably a variant for variables. */
241 static void *win32_bind_var(DSO *dso, const char *symname)
242         {
243         HINSTANCE *ptr;
244         void *sym;
245
246         if((dso == NULL) || (symname == NULL))
247                 {
248                 DSOerr(DSO_F_WIN32_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
249                 return(NULL);
250                 }
251         if(sk_void_num(dso->meth_data) < 1)
252                 {
253                 DSOerr(DSO_F_WIN32_BIND_VAR,DSO_R_STACK_ERROR);
254                 return(NULL);
255                 }
256         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
257         if(ptr == NULL)
258                 {
259                 DSOerr(DSO_F_WIN32_BIND_VAR,DSO_R_NULL_HANDLE);
260                 return(NULL);
261                 }
262         sym = GetProcAddress(*ptr, symname);
263         if(sym == NULL)
264                 {
265                 DSOerr(DSO_F_WIN32_BIND_VAR,DSO_R_SYM_FAILURE);
266                 ERR_add_error_data(3, "symname(", symname, ")");
267                 return(NULL);
268                 }
269         return(sym);
270         }
271
272 static DSO_FUNC_TYPE win32_bind_func(DSO *dso, const char *symname)
273         {
274         HINSTANCE *ptr;
275         void *sym;
276
277         if((dso == NULL) || (symname == NULL))
278                 {
279                 DSOerr(DSO_F_WIN32_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
280                 return(NULL);
281                 }
282         if(sk_void_num(dso->meth_data) < 1)
283                 {
284                 DSOerr(DSO_F_WIN32_BIND_FUNC,DSO_R_STACK_ERROR);
285                 return(NULL);
286                 }
287         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
288         if(ptr == NULL)
289                 {
290                 DSOerr(DSO_F_WIN32_BIND_FUNC,DSO_R_NULL_HANDLE);
291                 return(NULL);
292                 }
293         sym = GetProcAddress(*ptr, symname);
294         if(sym == NULL)
295                 {
296                 DSOerr(DSO_F_WIN32_BIND_FUNC,DSO_R_SYM_FAILURE);
297                 ERR_add_error_data(3, "symname(", symname, ")");
298                 return(NULL);
299                 }
300         return((DSO_FUNC_TYPE)sym);
301         }
302
303 struct file_st
304         {
305         const char *node; int nodelen;
306         const char *device; int devicelen;
307         const char *predir; int predirlen;
308         const char *dir; int dirlen;
309         const char *file; int filelen;
310         };
311
312 static struct file_st *win32_splitter(DSO *dso, const char *filename,
313         int assume_last_is_dir)
314         {
315         struct file_st *result = NULL;
316         enum { IN_NODE, IN_DEVICE, IN_FILE } position;
317         const char *start = filename;
318         char last;
319
320         if (!filename)
321                 {
322                 DSOerr(DSO_F_WIN32_SPLITTER,DSO_R_NO_FILENAME);
323                 /*goto err;*/
324                 return(NULL);
325                 }
326
327         result = OPENSSL_malloc(sizeof(struct file_st));
328         if(result == NULL)
329                 {
330                 DSOerr(DSO_F_WIN32_SPLITTER,
331                         ERR_R_MALLOC_FAILURE);
332                 return(NULL);
333                 }
334
335         memset(result, 0, sizeof(struct file_st));
336         position = IN_DEVICE;
337
338         if((filename[0] == '\\' && filename[1] == '\\')
339                 || (filename[0] == '/' && filename[1] == '/'))
340                 {
341                 position = IN_NODE;
342                 filename += 2;
343                 start = filename;
344                 result->node = start;
345                 }
346
347         do
348                 {
349                 last = filename[0];
350                 switch(last)
351                         {
352                 case ':':
353                         if(position != IN_DEVICE)
354                                 {
355                                 DSOerr(DSO_F_WIN32_SPLITTER,
356                                         DSO_R_INCORRECT_FILE_SYNTAX);
357                                 /*goto err;*/
358                                 OPENSSL_free(result);
359                                 return(NULL);
360                                 }
361                         result->device = start;
362                         result->devicelen = (int)(filename - start);
363                         position = IN_FILE;
364                         start = ++filename;
365                         result->dir = start;
366                         break;
367                 case '\\':
368                 case '/':
369                         if(position == IN_NODE)
370                                 {
371                                 result->nodelen = (int)(filename - start);
372                                 position = IN_FILE;
373                                 start = ++filename;
374                                 result->dir = start;
375                                 }
376                         else if(position == IN_DEVICE)
377                                 {
378                                 position = IN_FILE;
379                                 filename++;
380                                 result->dir = start;
381                                 result->dirlen = (int)(filename - start);
382                                 start = filename;
383                                 }
384                         else
385                                 {
386                                 filename++;
387                                 result->dirlen += (int)(filename - start);
388                                 start = filename;
389                                 }
390                         break;
391                 case '\0':
392                         if(position == IN_NODE)
393                                 {
394                                 result->nodelen = (int)(filename - start);
395                                 }
396                         else
397                                 {
398                                 if(filename - start > 0)
399                                         {
400                                         if (assume_last_is_dir)
401                                                 {
402                                                 if (position == IN_DEVICE)
403                                                         {
404                                                         result->dir = start;
405                                                         result->dirlen = 0;
406                                                         }
407                                                 result->dirlen +=
408                                                         (int)(filename - start);
409                                                 }
410                                         else
411                                                 {
412                                                 result->file = start;
413                                                 result->filelen =
414                                                         (int)(filename - start);
415                                                 }
416                                         }
417                                 }
418                         break;
419                 default:
420                         filename++;
421                         break;
422                         }
423                 }
424         while(last);
425
426         if(!result->nodelen) result->node = NULL;
427         if(!result->devicelen) result->device = NULL;
428         if(!result->dirlen) result->dir = NULL;
429         if(!result->filelen) result->file = NULL;
430
431         return(result);
432         }
433
434 static char *win32_joiner(DSO *dso, const struct file_st *file_split)
435         {
436         int len = 0, offset = 0;
437         char *result = NULL;
438         const char *start;
439
440         if(!file_split)
441                 {
442                 DSOerr(DSO_F_WIN32_JOINER,
443                                 ERR_R_PASSED_NULL_PARAMETER);
444                 return(NULL);
445                 }
446         if(file_split->node)
447                 {
448                 len += 2 + file_split->nodelen; /* 2 for starting \\ */
449                 if(file_split->predir || file_split->dir || file_split->file)
450                         len++;  /* 1 for ending \ */
451                 }
452         else if(file_split->device)
453                 {
454                 len += file_split->devicelen + 1; /* 1 for ending : */
455                 }
456         len += file_split->predirlen;
457         if(file_split->predir && (file_split->dir || file_split->file))
458                 {
459                 len++;  /* 1 for ending \ */
460                 }
461         len += file_split->dirlen;
462         if(file_split->dir && file_split->file)
463                 {
464                 len++;  /* 1 for ending \ */
465                 }
466         len += file_split->filelen;
467
468         if(!len)
469                 {
470                 DSOerr(DSO_F_WIN32_JOINER, DSO_R_EMPTY_FILE_STRUCTURE);
471                 return(NULL);
472                 }
473
474         result = OPENSSL_malloc(len + 1);
475         if (!result)
476                 {
477                 DSOerr(DSO_F_WIN32_JOINER,
478                         ERR_R_MALLOC_FAILURE);
479                 return(NULL);
480                 }
481
482         if(file_split->node)
483                 {
484                 strcpy(&result[offset], "\\\\"); offset += 2;
485                 strncpy(&result[offset], file_split->node,
486                         file_split->nodelen); offset += file_split->nodelen;
487                 if(file_split->predir || file_split->dir || file_split->file)
488                         {
489                         result[offset] = '\\'; offset++;
490                         }
491                 }
492         else if(file_split->device)
493                 {
494                 strncpy(&result[offset], file_split->device,
495                         file_split->devicelen); offset += file_split->devicelen;
496                 result[offset] = ':'; offset++;
497                 }
498         start = file_split->predir;
499         while(file_split->predirlen > (start - file_split->predir))
500                 {
501                 const char *end = openssl_strnchr(start, '/',
502                         file_split->predirlen - (start - file_split->predir));
503                 if(!end)
504                         end = start
505                                 + file_split->predirlen
506                                 - (start - file_split->predir);
507                 strncpy(&result[offset], start,
508                         end - start); offset += (int)(end - start);
509                 result[offset] = '\\'; offset++;
510                 start = end + 1;
511                 }
512 #if 0 /* Not needed, since the directory converter above already appeneded
513          a backslash */
514         if(file_split->predir && (file_split->dir || file_split->file))
515                 {
516                 result[offset] = '\\'; offset++;
517                 }
518 #endif
519         start = file_split->dir;
520         while(file_split->dirlen > (start - file_split->dir))
521                 {
522                 const char *end = openssl_strnchr(start, '/',
523                         file_split->dirlen - (start - file_split->dir));
524                 if(!end)
525                         end = start
526                                 + file_split->dirlen
527                                 - (start - file_split->dir);
528                 strncpy(&result[offset], start,
529                         end - start); offset += (int)(end - start);
530                 result[offset] = '\\'; offset++;
531                 start = end + 1;
532                 }
533 #if 0 /* Not needed, since the directory converter above already appeneded
534          a backslash */
535         if(file_split->dir && file_split->file)
536                 {
537                 result[offset] = '\\'; offset++;
538                 }
539 #endif
540         strncpy(&result[offset], file_split->file,
541                 file_split->filelen); offset += file_split->filelen;
542         result[offset] = '\0';
543         return(result);
544         }
545
546 static char *win32_merger(DSO *dso, const char *filespec1, const char *filespec2)
547         {
548         char *merged = NULL;
549         struct file_st *filespec1_split = NULL;
550         struct file_st *filespec2_split = NULL;
551
552         if(!filespec1 && !filespec2)
553                 {
554                 DSOerr(DSO_F_WIN32_MERGER,
555                                 ERR_R_PASSED_NULL_PARAMETER);
556                 return(NULL);
557                 }
558         if (!filespec2)
559                 {
560                 merged = OPENSSL_malloc(strlen(filespec1) + 1);
561                 if(!merged)
562                         {
563                         DSOerr(DSO_F_WIN32_MERGER,
564                                 ERR_R_MALLOC_FAILURE);
565                         return(NULL);
566                         }
567                 strcpy(merged, filespec1);
568                 }
569         else if (!filespec1)
570                 {
571                 merged = OPENSSL_malloc(strlen(filespec2) + 1);
572                 if(!merged)
573                         {
574                         DSOerr(DSO_F_WIN32_MERGER,
575                                 ERR_R_MALLOC_FAILURE);
576                         return(NULL);
577                         }
578                 strcpy(merged, filespec2);
579                 }
580         else
581                 {
582                 filespec1_split = win32_splitter(dso, filespec1, 0);
583                 if (!filespec1_split)
584                         {
585                         DSOerr(DSO_F_WIN32_MERGER,
586                                 ERR_R_MALLOC_FAILURE);
587                         return(NULL);
588                         }
589                 filespec2_split = win32_splitter(dso, filespec2, 1);
590                 if (!filespec2_split)
591                         {
592                         DSOerr(DSO_F_WIN32_MERGER,
593                                 ERR_R_MALLOC_FAILURE);
594                         OPENSSL_free(filespec1_split);
595                         return(NULL);
596                         }
597
598                 /* Fill in into filespec1_split */
599                 if (!filespec1_split->node && !filespec1_split->device)
600                         {
601                         filespec1_split->node = filespec2_split->node;
602                         filespec1_split->nodelen = filespec2_split->nodelen;
603                         filespec1_split->device = filespec2_split->device;
604                         filespec1_split->devicelen = filespec2_split->devicelen;
605                         }
606                 if (!filespec1_split->dir)
607                         {
608                         filespec1_split->dir = filespec2_split->dir;
609                         filespec1_split->dirlen = filespec2_split->dirlen;
610                         }
611                 else if (filespec1_split->dir[0] != '\\'
612                         && filespec1_split->dir[0] != '/')
613                         {
614                         filespec1_split->predir = filespec2_split->dir;
615                         filespec1_split->predirlen = filespec2_split->dirlen;
616                         }
617                 if (!filespec1_split->file)
618                         {
619                         filespec1_split->file = filespec2_split->file;
620                         filespec1_split->filelen = filespec2_split->filelen;
621                         }
622
623                 merged = win32_joiner(dso, filespec1_split);
624                 }
625         OPENSSL_free(filespec1_split);
626         OPENSSL_free(filespec2_split);
627         return(merged);
628         }
629
630 static char *win32_name_converter(DSO *dso, const char *filename)
631         {
632         char *translated;
633         int len, transform;
634
635         len = strlen(filename);
636         transform = ((strstr(filename, "/") == NULL) &&
637                         (strstr(filename, "\\") == NULL) &&
638                         (strstr(filename, ":") == NULL));
639         if(transform)
640                 /* We will convert this to "%s.dll" */
641                 translated = OPENSSL_malloc(len + 5);
642         else
643                 /* We will simply duplicate filename */
644                 translated = OPENSSL_malloc(len + 1);
645         if(translated == NULL)
646                 {
647                 DSOerr(DSO_F_WIN32_NAME_CONVERTER,
648                                 DSO_R_NAME_TRANSLATION_FAILED); 
649                 return(NULL);   
650                 }
651         if(transform)
652                 sprintf(translated, "%s.dll", filename);
653         else
654                 sprintf(translated, "%s", filename);
655         return(translated);
656         }
657
658 static const char *openssl_strnchr(const char *string, int c, size_t len)
659         {
660         size_t i;
661         const char *p;
662         for (i = 0, p = string; i < len && *p; i++, p++)
663                 {
664                 if (*p == c)
665                         return p;
666                 }
667         return NULL;
668         }
669
670 #include <tlhelp32.h>
671 #ifdef _WIN32_WCE
672 # define DLLNAME "TOOLHELP.DLL"
673 #else
674 # ifdef MODULEENTRY32
675 # undef MODULEENTRY32   /* unmask the ASCII version! */
676 # endif
677 # define DLLNAME "KERNEL32.DLL"
678 #endif
679
680 typedef HANDLE (WINAPI *CREATETOOLHELP32SNAPSHOT)(DWORD, DWORD);
681 typedef BOOL (WINAPI *CLOSETOOLHELP32SNAPSHOT)(HANDLE);
682 typedef BOOL (WINAPI *MODULE32)(HANDLE, MODULEENTRY32 *);
683
684 static int win32_pathbyaddr(void *addr,char *path,int sz)
685         {
686         HMODULE dll;
687         HANDLE hModuleSnap = INVALID_HANDLE_VALUE; 
688         MODULEENTRY32 me32; 
689         CREATETOOLHELP32SNAPSHOT create_snap;
690         CLOSETOOLHELP32SNAPSHOT  close_snap;
691         MODULE32 module_first, module_next;
692  
693         if (addr == NULL)
694                 {
695                 union   { int(*f)(void*,char*,int); void *p; } t =
696                         { win32_pathbyaddr };
697                 addr = t.p;
698                 }
699
700         dll = LoadLibrary(TEXT(DLLNAME));
701         if (dll == NULL)
702                 {
703                 DSOerr(DSO_F_WIN32_PATHBYADDR,DSO_R_UNSUPPORTED);
704                 return -1;
705                 }
706
707         create_snap = (CREATETOOLHELP32SNAPSHOT)
708                 GetProcAddress(dll,"CreateToolhelp32Snapshot");
709         if (create_snap == NULL)
710                 {
711                 FreeLibrary(dll);
712                 DSOerr(DSO_F_WIN32_PATHBYADDR,DSO_R_UNSUPPORTED);
713                 return -1;
714                 }
715         /* We take the rest for granted... */
716 #ifdef _WIN32_WCE
717         close_snap = (CLOSETOOLHELP32SNAPSHOT)
718                 GetProcAddress(dll,"CloseToolhelp32Snapshot");
719 #else
720         close_snap = (CLOSETOOLHELP32SNAPSHOT)CloseHandle;
721 #endif
722         module_first = (MODULE32)GetProcAddress(dll,"Module32First");
723         module_next  = (MODULE32)GetProcAddress(dll,"Module32Next");
724
725         hModuleSnap = (*create_snap)(TH32CS_SNAPMODULE,0); 
726         if( hModuleSnap == INVALID_HANDLE_VALUE ) 
727                 { 
728                 FreeLibrary(dll);
729                 DSOerr(DSO_F_WIN32_PATHBYADDR,DSO_R_UNSUPPORTED);
730                 return -1;
731                 } 
732  
733         me32.dwSize = sizeof(me32); 
734  
735         if(!(*module_first)(hModuleSnap,&me32)) 
736                 { 
737                 (*close_snap)(hModuleSnap);
738                 FreeLibrary(dll);
739                 DSOerr(DSO_F_WIN32_PATHBYADDR,DSO_R_FAILURE);
740                 return -1;
741                 }
742  
743         do      { 
744                 if ((BYTE *)addr >= me32.modBaseAddr &&
745                     (BYTE *)addr <  me32.modBaseAddr+me32.modBaseSize)
746                         {
747                         (*close_snap)(hModuleSnap);
748                         FreeLibrary(dll);
749 #ifdef _WIN32_WCE
750 # if _WIN32_WCE >= 101
751                         return WideCharToMultiByte(CP_ACP,0,me32.szExePath,-1,
752                                                         path,sz,NULL,NULL);
753 # else
754                         {
755                         int i,len = (int)wcslen(me32.szExePath);
756                         if (sz <= 0) return len+1;
757                         if (len >= sz) len=sz-1;
758                         for(i=0;i<len;i++)
759                                 path[i] = (char)me32.szExePath[i];
760                         path[len++] = 0;
761                         return len;
762                         }
763 # endif
764 #else
765                         {
766                         int len = (int)strlen(me32.szExePath);
767                         if (sz <= 0) return len+1;
768                         if (len >= sz) len=sz-1;
769                         memcpy(path,me32.szExePath,len);
770                         path[len++] = 0;
771                         return len;
772                         }
773 #endif
774                         } 
775                 } while((*module_next)(hModuleSnap, &me32)); 
776  
777         (*close_snap)(hModuleSnap); 
778         FreeLibrary(dll);
779         return 0;
780         }
781
782 static void *win32_globallookup(const char *name)
783         {
784         HMODULE dll;
785         HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
786         MODULEENTRY32 me32;
787         CREATETOOLHELP32SNAPSHOT create_snap;
788         CLOSETOOLHELP32SNAPSHOT  close_snap;
789         MODULE32 module_first, module_next;
790         FARPROC ret=NULL;
791
792         dll = LoadLibrary(TEXT(DLLNAME));
793         if (dll == NULL)
794                 {
795                 DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);
796                 return NULL;
797                 }
798
799         create_snap = (CREATETOOLHELP32SNAPSHOT)
800                 GetProcAddress(dll,"CreateToolhelp32Snapshot");
801         if (create_snap == NULL)
802                 {
803                 FreeLibrary(dll);
804                 DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);
805                 return NULL;
806                 }
807         /* We take the rest for granted... */
808 #ifdef _WIN32_WCE
809         close_snap = (CLOSETOOLHELP32SNAPSHOT)
810                 GetProcAddress(dll,"CloseToolhelp32Snapshot");
811 #else
812         close_snap = (CLOSETOOLHELP32SNAPSHOT)CloseHandle;
813 #endif
814         module_first = (MODULE32)GetProcAddress(dll,"Module32First");
815         module_next  = (MODULE32)GetProcAddress(dll,"Module32Next");
816
817         hModuleSnap = (*create_snap)(TH32CS_SNAPMODULE,0);
818         if( hModuleSnap == INVALID_HANDLE_VALUE )
819                 {
820                 FreeLibrary(dll);
821                 DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);
822                 return NULL;
823                 }
824
825         me32.dwSize = sizeof(me32);
826
827         if (!(*module_first)(hModuleSnap,&me32))
828                 {
829                 (*close_snap)(hModuleSnap);
830                 FreeLibrary(dll);
831                 return NULL;
832                 }
833
834         do      {
835                 if ((ret = GetProcAddress(me32.hModule,name)))
836                         {
837                         (*close_snap)(hModuleSnap);
838                         FreeLibrary(dll);
839                         return ret;
840                         }
841                 } while((*module_next)(hModuleSnap,&me32));
842
843         (*close_snap)(hModuleSnap); 
844         FreeLibrary(dll);
845         return NULL;
846         }
847 #endif /* DSO_WIN32 */