loader/library.c

   1 /*
   2  *        Module & Library functions
   3 static char Copyright[] = "Copyright 1993, 1994 Martin Ayotte, Robert J. Amstadt, Erik Bos";
   4 */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <fcntl.h>
  12 #include <unistd.h>
  13 #include "neexe.h"
  14 #include "dlls.h"
  15 #include "if1632.h"
  16 #include "wineopts.h"
  17 #include "arch.h"
  18 #include "options.h"
  19 #include "dos_fs.h"
  20 #include "windows.h"
  21 #include "task.h"
  22 #include "toolhelp.h"
  23 #include "selectors.h"
  24 #include "stddebug.h"
  25 #include "debug.h"
  26 #include "prototypes.h"
  27 #include "library.h"
  28 #include "ne_image.h"
  29 #include "pe_image.h"
  30
  31 struct w_files *wine_files = NULL;
  32 static char *DLL_Extensions[] = { "dll", NULL };
  33 static char *EXE_Extensions[] = { "exe", NULL };
  34
  35 #define IS_BUILTIN_DLL(handle) ((handle >> 8) == 0xff)
  36
  37 /**********************************************************************/
  38
  39 void ExtractDLLName(char *libname, char *temp)
  40 {
  41     int i;
  42
  43     strcpy(temp, libname);
  44     if (strchr(temp, '\\') || strchr(temp, '/'))
  45         for (i = strlen(temp) - 1; i ; i--)
  46                 if (temp[i] == '\\' || temp[i] == '/') {
  47                         strcpy(temp, temp + i + 1);
  48                         break;
  49                 }
  50     for (i = strlen(temp) - 1; i ; i--)
  51         if (temp[i] == '.') {
  52                 temp[i] = 0;
  53                 break;
  54         }
  55 }
  56
  57 struct w_files *GetFileInfo(unsigned short instance)
  58 {
  59     register struct w_files *w = wine_files;
  60
  61     while (w && w->hinstance != instance)
  62         w = w->next;
  63
  64     return w;
  65 }
  66 \f
  67 int IsDLLLoaded(char *name)
  68 {
  69         struct w_files *wpnt;
  70
  71         if(FindDLLTable(name))
  72                 return 1;
  73
  74         for(wpnt = wine_files; wpnt; wpnt = wpnt->next)
  75                 if(strcmp(wpnt->name, name) == 0)
  76                         return 1;
  77
  78         return 0;
  79 }
  80
  81 void InitDLL(struct w_files *wpnt)
  82 {
  83         if (wpnt->ne)
  84                 NE_InitDLL(wpnt);
  85         else
  86                 PE_InitDLL(wpnt);
  87 }
  88
  89 void InitializeLoadedDLLs(struct w_files *wpnt)
  90 {
  91     static flagReadyToRun = 0;
  92     struct w_files *final_wpnt;
  93
  94     dprintf_module(stddeb,"InitializeLoadedDLLs(%p)\n", wpnt);
  95
  96     if (wpnt == NULL)
  97     {
  98         flagReadyToRun = 1;
  99         dprintf_module(stddeb,"Initializing DLLs\n");
 100     }
 101
 102     if (!flagReadyToRun)
 103         return;
 104
 105 #if 1
 106     if (wpnt != NULL)
 107         dprintf_module(stddeb,"Initializing %s\n", wpnt->name);
 108 #endif
 109
 110     /*
 111      * Initialize libraries
 112      */
 113     if (!wpnt)
 114     {
 115         wpnt = wine_files;
 116         final_wpnt = NULL;
 117     }
 118     else
 119     {
 120         final_wpnt = wpnt->next;
 121     }
 122
 123     for( ; wpnt != final_wpnt; wpnt = wpnt->next)
 124         InitDLL(wpnt);
 125 }
 126
 127 /**********************************************************************
 128  *                      LoadImage
 129  * Load one executable into memory
 130  */
 131 HINSTANCE LoadImage(char *module, int filetype, int change_dir)
 132 {
 133     HINSTANCE handle;
 134     struct w_files *wpnt, *wpnt1;
 135     char buffer[256], header[2], modulename[64], *fullname;
 136
 137     ExtractDLLName(module, modulename);
 138     dprintf_module(stddeb,"LoadImage [%s]\n", module);
 139     /* built-in one ? */
 140     if (FindDLLTable(modulename)) {
 141         return GetModuleHandle(modulename);
 142     }
 143
 144     /* already loaded ? */
 145     for (wpnt = wine_files ; wpnt ; wpnt = wpnt->next)
 146         if (strcasecmp(wpnt->name, modulename) == 0)
 147                 return wpnt->hinstance;
 148
 149     /*
 150      * search file
 151      */
 152     fullname = DOS_FindFile(buffer, sizeof(buffer), module,
 153                         (filetype == EXE ? EXE_Extensions : DLL_Extensions),
 154                         WindowsPath);
 155     if (fullname == NULL)
 156     {
 157         fprintf(stderr, "LoadImage: I can't find %s.dll | %s.exe !\n",
 158                 module, module);
 159         return 2;
 160     }
 161
 162     fullname = DOS_GetDosFileName(fullname);
 163
 164     dprintf_module(stddeb,"LoadImage: loading %s (%s)\n           [%s]\n",
 165             module, buffer, fullname);
 166
 167     if (change_dir && fullname)
 168     {
 169         char dirname[256];
 170         char *p;
 171
 172         strcpy(dirname, fullname);
 173         p = strrchr(dirname, '\\');
 174         *p = '\0';
 175
 176         DOS_SetDefaultDrive(dirname[0] - 'A');
 177         DOS_ChangeDir(dirname[0] - 'A', dirname + 2);
 178     }
 179
 180     /* First allocate a spot to store the info we collect, and add it to
 181      * our linked list if we could load the file.
 182      */
 183
 184     wpnt = (struct w_files *) malloc(sizeof(struct w_files));
 185
 186     /*
 187      * Open file for reading.
 188      */
 189     wpnt->fd = open(buffer, O_RDONLY);
 190     if (wpnt->fd < 0)
 191         return 2;
 192
 193     /*
 194      * Establish header pointers.
 195      */
 196     wpnt->filename = strdup(buffer);
 197     wpnt->name = strdup(modulename);
 198
 199     /* read mz header */
 200     wpnt->mz_header = (struct mz_header_s *) malloc(sizeof(struct mz_header_s));;
 201     lseek(wpnt->fd, 0, SEEK_SET);
 202     if (read(wpnt->fd, wpnt->mz_header, sizeof(struct mz_header_s)) !=
 203         sizeof(struct mz_header_s))
 204     {
 205         fprintf(stderr, "Unable to read MZ header from file '%s'\n", buffer);
 206         exit(1);
 207     }
 208
 209       /* This field is ignored according to "Windows Internals", p.242 */
 210 #if 0
 211     if (wpnt->mz_header->must_be_0x40 != 0x40)
 212         myerror("This is not a Windows program");
 213 #endif
 214
 215     /* read first two bytes to determine filetype */
 216     lseek(wpnt->fd, wpnt->mz_header->ne_offset, SEEK_SET);
 217     read(wpnt->fd, &header, sizeof(header));
 218
 219     handle = 0;
 220
 221     /*
 222      * Stick this file into the list of loaded files so we don't try to reload
 223      * it again if another module references this module.  Do this before
 224      * calling NE_LoadImage because we might get back here before NE_loadImage
 225      * returns.
 226      */
 227     if(wine_files == NULL)
 228        wine_files = wpnt;
 229     else {
 230          wpnt1 = wine_files;
 231          while(wpnt1->next)
 232             wpnt1 = wpnt1->next;
 233          wpnt1->next = wpnt;
 234     }
 235     wpnt->next = NULL;
 236
 237     if (header[0] == 'N' && header[1] == 'E')
 238         handle = NE_LoadImage(wpnt);
 239     if (header[0] == 'P' && header[1] == 'E')
 240         handle = PE_LoadImage(wpnt);
 241     wpnt->hinstance = handle;
 242
 243     if (handle > 32) {
 244         return handle;
 245     } else {
 246         fprintf(stderr, "wine: (%s) unknown fileformat !\n", wpnt->filename);
 247
 248         /* Remove this module from the list of loaded modules */
 249         if (wine_files == wpnt)
 250             wine_files = NULL;
 251         else
 252             wpnt1->next = NULL;
 253         close(wpnt->fd);
 254         free(wpnt->filename);
 255         free(wpnt->name);
 256         free(wpnt);
 257
 258         return 14;
 259     }
 260 }
 261
 262 /**********************************************************************
 263  *                              GetModuleHandle [KERNEL.47]
 264  */
 265 HANDLE GetModuleHandle(LPSTR lpModuleName)
 266 {
 267         register struct w_files *w = wine_files;
 268         int     i;
 269         char dllname[256];
 270
 271         if ((int) lpModuleName & 0xffff0000)
 272                 ExtractDLLName(lpModuleName, dllname);
 273
 274         if ((int) lpModuleName & 0xffff0000)
 275                 dprintf_module(stddeb,"GetModuleHandle('%s');\n", lpModuleName);
 276         else
 277                 dprintf_module(stddeb,"GetModuleHandle('%p');\n", lpModuleName);
 278
 279 /*      dprintf_module(stddeb,"GetModuleHandle // searching in builtin libraries\n");*/
 280         for (i = 0; i < N_BUILTINS; i++) {
 281                 if (dll_builtin_table[i].dll_name == NULL) break;
 282                 if (!dll_builtin_table[i].dll_is_used){
 283                         dprintf_module(stddeb,"Skipping builtin %s\n",
 284                         dll_builtin_table[i].dll_name);
 285                         continue;
 286                 }
 287                 if (((int) lpModuleName & 0xffff0000) == 0) {
 288                         if (0xFF00 + i == (int) lpModuleName) {
 289                                 dprintf_module(stddeb,"GetModuleHandle('%s') return %04X \n",
 290                                        lpModuleName, 0xff00 + i);
 291                                 return 0xFF00 + i;
 292                                 }
 293                         }
 294                 else if (strcasecmp(dll_builtin_table[i].dll_name, dllname) == 0) {
 295                         dprintf_module(stddeb,"GetModuleHandle('%p') return %04X \n",
 296                                                         lpModuleName, 0xFF00 + i);
 297                         return (0xFF00 + i);
 298                         }
 299                 }
 300
 301         dprintf_module(stddeb,"GetModuleHandle // searching in loaded modules\n");
 302         while (w) {
 303 /*              dprintf_module(stddeb,"GetModuleHandle // '%x' \n", w->name);  */
 304                 if (((int) lpModuleName & 0xffff0000) == 0) {
 305                         if (w->hinstance == (int) lpModuleName) {
 306                                 dprintf_module(stddeb,"GetModuleHandle('%p') return %04X \n",
 307                                        lpModuleName, w->hinstance);
 308                                 return w->hinstance;
 309                                 }
 310                         }
 311                 else if (strcasecmp(w->name, dllname) == 0) {
 312                         dprintf_module(stddeb,"GetModuleHandle('%s') return %04X \n",
 313                                                         lpModuleName, w->hinstance);
 314                         return w->hinstance;
 315                         }
 316                 w = w->next;
 317                 }
 318         printf("GetModuleHandle('%p') not found !\n", lpModuleName);
 319         return 0;
 320 }
 321
 322
 323 /**********************************************************************
 324  *                              GetModuleUsage  [KERNEL.48]
 325  */
 326 int GetModuleUsage(HANDLE hModule)
 327 {
 328         struct w_files *w;
 329
 330         dprintf_module(stddeb,"GetModuleUsage(%04X);\n", hModule);
 331
 332         /* built-in dll ? */
 333         if (IS_BUILTIN_DLL(hModule))
 334                 return 2;
 335
 336         w = GetFileInfo(hModule);
 337 /*      return w->Usage; */
 338         return 1;
 339 }
 340
 341
 342 /**********************************************************************
 343  *                              GetModuleFilename [KERNEL.49]
 344  */
 345 int GetModuleFileName(HANDLE hModule, LPSTR lpFileName, short nSize)
 346 {
 347     struct w_files *w;
 348     LPSTR str;
 349     char windir[256], temp[256];
 350
 351     dprintf_module(stddeb,"GetModuleFileName(%04X, %p, %d);\n", hModule, lpFileName, nSize);
 352
 353     if (lpFileName == NULL) return 0;
 354     if (nSize < 1) return 0;
 355
 356     /* built-in dll ? */
 357     if (IS_BUILTIN_DLL(hModule)) {
 358         GetWindowsDirectory(windir, sizeof(windir));
 359         sprintf(temp, "%s\\%s.DLL", windir, dll_builtin_table[hModule & 0x00ff].dll_name);
 360         ToDos(temp);
 361         strncpy(lpFileName, temp, nSize);
 362         dprintf_module(stddeb,"GetModuleFileName copied '%s' (internal dll) return %d \n", lpFileName, nSize);
 363         return strlen(lpFileName);
 364     }
 365
 366     /* check loaded dlls */
 367     if ((w = GetFileInfo(hModule)) == NULL)
 368         return 0;
 369     str = DOS_GetDosFileName(w->filename);
 370     if (nSize > strlen(str)) nSize = strlen(str) + 1;
 371     strncpy(lpFileName, str, nSize);
 372     dprintf_module(stddeb,"GetModuleFileName copied '%s' return %d \n", lpFileName, nSize);
 373     return nSize - 1;
 374 }
 375
 376
 377 /**********************************************************************
 378  *                              LoadLibrary     [KERNEL.95]
 379  */
 380 HANDLE LoadLibrary(LPSTR libname)
 381 {
 382         HANDLE h;
 383
 384         if ((h = LoadImage(libname, DLL, 0)) < 32)
 385                 return h;
 386
 387         if (!IS_BUILTIN_DLL(h))
 388                 InitDLL(GetFileInfo(h));
 389
 390         return h;
 391 }
 392
 393 /**********************************************************************
 394  *                              FreeLibrary     [KERNEL.96]
 395  */
 396 void FreeLibrary(HANDLE hLib)
 397 {
 398         dprintf_module(stddeb,"FreeLibrary(%04X);\n", hLib);
 399
 400         /* built-in dll ? */
 401         if (IS_BUILTIN_DLL(hLib) || hLib == 0 || hLib == hSysRes)
 402                 return;
 403
 404 /*
 405         while (lpMod != NULL) {
 406                 if (lpMod->hInst == hLib) {
 407                         if (lpMod->Count == 1) {
 408                                 wpnt = GetFileInfo(hLib);
 409                                 if (wpnt->ne)
 410                                         NE_UnloadImage(wpnt);
 411                                 else
 412                                         PE_UnloadImage(wpnt);
 413                                 if (hLib != (HANDLE)NULL) GlobalFree(hLib);
 414                                 if (lpMod->ModuleName != NULL) free(lpMod->ModuleName);
 415                                 if (lpMod->FileName != NULL) free(lpMod->FileName);
 416                                 GlobalFree(lpMod->hModule);
 417                                 dprintf_module(stddeb,"FreeLibrary // freed !\n");
 418                                 return;
 419                                 }
 420                         lpMod->Count--;
 421                         dprintf_module(stddeb,"FreeLibrary // Count decremented !\n");
 422                         return;
 423                         }
 424                 lpMod = lpMod->lpNextModule;
 425                 }
 426 */
 427 }
 428
 429
 430 /**********************************************************************
 431  *                                      GetProcAddress  [KERNEL.50]
 432  */
 433 FARPROC GetProcAddress(HANDLE hModule, char *proc_name)
 434 {
 435 #ifdef WINELIB
 436     WINELIB_UNIMP ("GetProcAddress");
 437 #else
 438     int         addr, ret;
 439     WORD        sel;
 440     register struct w_files *w = wine_files;
 441     int         ordinal, len;
 442     char        * cpnt;
 443     char        C[128];
 444     HTASK       hTask;
 445     LPTASKENTRY lpTask;
 446
 447     /* built-in dll ? */
 448     if (IS_BUILTIN_DLL(hModule))
 449     {
 450         if ((int) proc_name & 0xffff0000)
 451         {
 452             dprintf_module(stddeb,"GetProcAddress: builtin %#04X, '%s'\n",
 453                    hModule, proc_name);
 454             if (GetEntryDLLName(dll_builtin_table[hModule - 0xFF00].dll_name,
 455                                 proc_name, &sel, &addr))
 456             {
 457                 printf("Address not found !\n");
 458             }
 459         }
 460         else
 461         {
 462             dprintf_module(stddeb,"GetProcAddress: builtin %#04X, %d\n",
 463                    hModule, (int)proc_name);
 464             if (GetEntryDLLOrdinal(dll_builtin_table[hModule-0xFF00].dll_name,
 465                                    (int)proc_name & 0x0000FFFF, &sel, &addr))
 466             {
 467                 printf("Address not found !\n");
 468             }
 469         }
 470         ret = MAKELONG(addr, sel);
 471         dprintf_module(stddeb,"GetProcAddress // ret=%08X sel=%04X addr=%04X\n",
 472                ret, sel, addr);
 473         return (FARPROC)ret;
 474     }
 475     if (hModule == 0)
 476     {
 477         hTask = GetCurrentTask();
 478         dprintf_module(stddeb,"GetProcAddress // GetCurrentTask()=%04X\n", hTask);
 479         lpTask = (LPTASKENTRY) GlobalLock(hTask);
 480         if (lpTask == NULL)
 481         {
 482             printf("GetProcAddress: can't find current module handle !\n");
 483             return NULL;
 484         }
 485         hModule = lpTask->hInst;
 486         dprintf_module(stddeb,"GetProcAddress: current module=%04X instance=%04X!\n",
 487                lpTask->hModule, lpTask->hInst);
 488         GlobalUnlock(hTask);
 489     }
 490     while (w && w->hinstance != hModule)
 491         w = w->next;
 492     if (w == NULL)
 493         return NULL;
 494     dprintf_module(stddeb,"GetProcAddress // Module Found ! w->filename='%s'\n", w->filename);
 495     if ((int)proc_name & 0xFFFF0000)
 496     {
 497         AnsiUpper(proc_name);
 498         dprintf_module(stddeb,"GetProcAddress: %04X, '%s'\n", hModule, proc_name);
 499         cpnt = w->ne->nrname_table;
 500         while(TRUE)
 501         {
 502             if (((int) cpnt)  - ((int)w->ne->nrname_table) >
 503                 w->ne->ne_header->nrname_tab_length)  return NULL;
 504             len = *cpnt++;
 505             strncpy(C, cpnt, len);
 506             C[len] = '\0';
 507             dprintf_module(stddeb,"pointing Function '%s' ordinal=%d !\n",
 508                    C, *((unsigned short *)(cpnt +  len)));
 509             if (strncmp(cpnt, proc_name, len) ==  0)
 510             {
 511                 ordinal =  *((unsigned short *)(cpnt +  len));
 512                 break;
 513             }
 514             cpnt += len + 2;
 515         }
 516         if (ordinal == 0)
 517         {
 518             printf("GetProcAddress // function '%s' not found !\n", proc_name);
 519             return NULL;
 520         }
 521     }
 522     else
 523     {
 524         dprintf_module(stddeb,"GetProcAddress: %#04x, %d\n", hModule, (int) proc_name);
 525         ordinal = (int)proc_name;
 526     }
 527     ret = GetEntryPointFromOrdinal(w, ordinal);
 528     if (ret == -1)
 529     {
 530         printf("GetProcAddress // Function #%d not found !\n", ordinal);
 531         return NULL;
 532     }
 533     addr  = ret & 0xffff;
 534     sel = (ret >> 16);
 535     dprintf_module(stddeb,"GetProcAddress // ret=%08X sel=%04X addr=%04X\n", ret, sel, addr);
 536     return (FARPROC) ret;
 537 #endif /* WINELIB */
 538 }
 539
 540 /* internal dlls */
 541 static void
 542 FillModStructBuiltIn(MODULEENTRY *lpModule, struct dll_name_table_entry_s *dll)
 543 {
 544         lpModule->dwSize = dll->dll_table_length * 1024;
 545         strcpy(lpModule->szModule, dll->dll_name);
 546         lpModule->hModule = 0xff00 + dll->dll_number;
 547         lpModule->wcUsage = GetModuleUsage(lpModule->hModule);
 548         GetModuleFileName(lpModule->hModule, lpModule->szExePath, MAX_PATH + 1);
 549         lpModule->wNext = 0;
 550 }
 551
 552 /* loaded dlls */
 553 static void
 554 FillModStructLoaded(MODULEENTRY *lpModule, struct w_files *dll)
 555 {
 556         lpModule->dwSize = 16384;
 557         strcpy(lpModule->szModule, dll->name);
 558         lpModule->hModule = dll->hinstance;
 559         lpModule->wcUsage = GetModuleUsage(lpModule->hModule);
 560         GetModuleFileName(lpModule->hModule, lpModule->szExePath, MAX_PATH + 1);
 561         lpModule->wNext = 0;
 562 }
 563
 564 /**********************************************************************
 565  *              ModuleFirst [TOOLHELP.59]
 566  */
 567 BOOL ModuleFirst(MODULEENTRY *lpModule)
 568 {
 569         dprintf_module(stddeb,"ModuleFirst(%08X)\n", (int) lpModule);
 570
 571         FillModStructBuiltIn(lpModule, &dll_builtin_table[0]);
 572         return TRUE;
 573 }
 574
 575 /**********************************************************************
 576  *              ModuleNext [TOOLHELP.60]
 577  */
 578 BOOL ModuleNext(MODULEENTRY *lpModule)
 579 {
 580         struct w_files *w;
 581
 582         dprintf_module(stddeb,"ModuleNext(%08X)\n", (int) lpModule);
 583
 584         if (IS_BUILTIN_DLL(lpModule->hModule))
 585         {
 586                 int builtin_no=lpModule->hModule & 0xff;
 587                 do{
 588                         /* last built-in ? */
 589                         if (builtin_no == (N_BUILTINS - 1) ) {
 590                                 if (wine_files) {
 591                                         FillModStructLoaded(lpModule, wine_files);
 592                                         return TRUE;
 593                                 } else
 594                                         return FALSE;
 595                         }
 596                         builtin_no++;
 597                 }while(!dll_builtin_table[builtin_no].dll_is_used);
 598
 599                 FillModStructBuiltIn(lpModule, &dll_builtin_table[builtin_no]);
 600                 return TRUE;
 601         }
 602         w = GetFileInfo(lpModule->hModule);
 603         if (w->next) {
 604                 FillModStructLoaded(lpModule, w->next);
 605                 return TRUE;
 606         }
 607         return FALSE;
 608 }
 609
 610 /**********************************************************************
 611  *              ModuleFindHandle [TOOLHELP.62]
 612  */
 613 HMODULE ModuleFindHandle(MODULEENTRY *lpModule, HMODULE hModule)
 614 {
 615         struct w_files *w;
 616
 617         dprintf_module(stddeb,"ModuleFindHandle(%08X, %04X)\n", (int) lpModule, (int)hModule);
 618
 619         /* built-in dll ? */
 620         if (IS_BUILTIN_DLL(hModule)) {
 621                 FillModStructBuiltIn(lpModule, &dll_builtin_table[hModule & 0xff]);
 622                 return hModule;
 623         }
 624
 625         /* check loaded dlls */
 626         if ((w = GetFileInfo(hModule)) == NULL)
 627                 return (HMODULE) NULL;
 628
 629         FillModStructLoaded(lpModule, w);
 630         return w->hinstance;
 631 }
 632
 633 /**********************************************************************
 634  *              ModuleFindName [TOOLHELP.61]
 635  */
 636 HMODULE ModuleFindName(MODULEENTRY *lpModule, LPCSTR lpstrName)
 637 {
 638         return (ModuleFindHandle(lpModule, GetModuleHandle((char*)lpstrName)));
 639 }
 640