Changeset 4422

Timestamp:

Oct 4, 2000, 9:36:26 PM (25 years ago)

Author:

sandervl

Message:

added forwarder support for PE loader

Location:

trunk/src/kernel32

Files:

• KERNEL32.CPP (modified) (2 diffs)
• winimagepeldr.cpp (modified) (12 diffs)
• winimagepeldr.h (modified) (2 diffs)
• wprocess.cpp (modified) (2 diffs)

trunk/src/kernel32/KERNEL32.CPP ¶

@@ -1 @@
-/* $Id: KERNEL32.CPP,v 1.55 2000-10-02 13:38:55 sandervl Exp $ */
+/* $Id: KERNEL32.CPP,v 1.56 2000-10-04 19:36:24 sandervl Exp $ */
 
 /*
@@ -121 +121 @@
 
   rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
-  dprintf(("KERNEL32:  IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
+  dprintf(("KERNEL32:  IsBadReadPtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
   return(rc);
 #else

trunk/src/kernel32/winimagepeldr.cpp ¶

@@ -1 @@
-/* $Id: winimagepeldr.cpp,v 1.54 2000-10-03 17:28:31 sandervl Exp $ */
+/* $Id: winimagepeldr.cpp,v 1.55 2000-10-04 19:36:25 sandervl Exp $ */
 
 /*
@@ -11 +11 @@
  * TODO: Check psh[i].Characteristics for more than only the code section
  * TODO: Make resource section readonly when GDI32 is fixed
+ * TODO: Loading of forwarder dlls before handling imports might not be correct
+ *       (circular dependencies; have to check what NT does)
  *
  * NOTE: RSRC_LOAD is a special flag to only load the resource directory
@@ -106 +108 @@
     imageVirtBase(-1), realBaseAddress(0), imageVirtEnd(0),
     nrNameExports(0), nrOrdExports(0), nameexports(NULL), ordexports(NULL),
-    memmap(NULL), pFixups(NULL), dwFixupSize(0)
+    memmap(NULL), pFixups(NULL), dwFixupSize(0), curnameexport(NULL), curordexport(NULL)
 {
  HFILE  dllfile;
@@ -1125 +1127 @@
  ULONG *ptrNames, *ptrAddress;
  USHORT *ptrOrd;
+ BOOL fForwarder;
  int i;
 
@@ -1144 +1147 @@
     int   ord, RVAExport;
     char *name;
-    for(i=0;i<ped->NumberOfNames;i++) {
-        ord       = ptrOrd[i] + ped->Base;
-        name      = (char *)((ULONG)ptrNames[i] + (ULONG)win32file);
-        RVAExport = ptrAddress[ptrOrd[i]];
-#ifdef FORWARDERS
-        if(RVAExport < sh.VirtualAddress || RVAExport > sh.VirtualAddress + sh.SizeOfRawData) {
-#endif
+    for(i=0;i<ped->NumberOfNames;i++) 
+    {
+        fForwarder = FALSE;
+        ord        = ptrOrd[i] + ped->Base;
+        name       = (char *)((ULONG)ptrNames[i] + (ULONG)win32file);
+        RVAExport  = ptrAddress[ptrOrd[i]];
+
+        /* forwarder? ulRVA within export directory. */
+        if(RVAExport > oh.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress &&
+           RVAExport < oh.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress
+                       + oh.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size) 
+        {
+            fForwarder = AddForwarder(oh.ImageBase + RVAExport, name, ord);
+        }
+        if(!fForwarder) {
             //points to code (virtual address relative to oh.ImageBase
             AddNameExport(oh.ImageBase + RVAExport, name, ord);
-            dprintf((LOG, "address 0x%x %s @%d", RVAExport, name, ord));
-#ifdef FORWARDERS
-
-        }
-        else {//forwarder
-            char *forward = (char *)((ULONG)RVAExport + (ULONG)win32file);
-            fout << RVAExport << " ", name << " @", ord << " is forwarder to ", (int)forward ));
-        }
-#endif
+            dprintf((LOG, "address 0x%x %s @%d (0x%08x)", RVAExport, name, ord, realBaseAddress + RVAExport));
+        }
     }
-    for(i=0;i<max(ped->NumberOfNames,ped->NumberOfFunctions);i++) {
+    for(i=0;i<max(ped->NumberOfNames,ped->NumberOfFunctions);i++) 
+    {
+        fForwarder = FALSE;
         ord = ped->Base + i;  //Correct??
         RVAExport = ptrAddress[i];
-#ifdef FORWARDERS
-        if(RVAExport < sh.VirtualAddress || RVAExport > sh.VirtualAddress + sh.SizeOfRawData) {
-#endif
-            if(RVAExport) {
-              //points to code (virtual address relative to oh.ImageBase
-              dprintf((LOG, "ord %d at 0x%x", ord, RVAExport));
-              AddOrdExport(oh.ImageBase + RVAExport, ord);
-            }
-#ifdef FORWARDERS
-        }
-        else {//forwarder or empty
-            char *forward = (char *)((ULONG)RVAExport + (ULONG)win32file);
-            dprintf((LOG, "ord ", ord << " at 0x";
-            fout << RVAExport << " is forwarder to 0x", (int)forward ));
-        }
-#endif
+        /* forwarder? ulRVA within export directory. */
+        if(RVAExport > oh.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress &&
+           RVAExport < oh.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress
+                       + oh.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size) 
+        {
+            fForwarder = AddForwarder(oh.ImageBase + RVAExport, NULL, ord);
+        }
+        if(!fForwarder && RVAExport) {
+            //points to code (virtual address relative to oh.ImageBase
+            dprintf((LOG, "ord %d at 0x%08x (0x%08x)", ord, RVAExport, realBaseAddress + RVAExport));
+            AddOrdExport(oh.ImageBase + RVAExport, ord);
+        }
     }
   }
@@ -1188 +1190 @@
 //******************************************************************************
 //******************************************************************************
-void Win32PeLdrImage::AddNameExport(ULONG virtaddr, char *apiname, ULONG ordinal)
+void Win32PeLdrImage::AddNameExport(ULONG virtaddr, char *apiname, ULONG ordinal, BOOL fAbsoluteAddress)
 {
  ULONG nsize;
@@ -1206 +1208 @@
         free(tmp);
   }
-  curnameexport->virtaddr = realBaseAddress + (virtaddr - oh.ImageBase);
+  if(fAbsoluteAddress) {//forwarders use absolute address
+        curnameexport->virtaddr = virtaddr;
+  }
+  else  curnameexport->virtaddr = realBaseAddress + (virtaddr - oh.ImageBase);
   curnameexport->ordinal  = ordinal;
   *(ULONG *)curnameexport->name = 0;
@@ -1219 +1224 @@
 //******************************************************************************
 //******************************************************************************
-void Win32PeLdrImage::AddOrdExport(ULONG virtaddr, ULONG ordinal)
+void Win32PeLdrImage::AddOrdExport(ULONG virtaddr, ULONG ordinal, BOOL fAbsoluteAddress)
 {
   if(ordexports == NULL) {
@@ -1225 +1230 @@
         curordexport = ordexports;
   }
-  curordexport->virtaddr = realBaseAddress + (virtaddr - oh.ImageBase);
+  if(fAbsoluteAddress) {//forwarders use absolute address
+        curordexport->virtaddr = virtaddr;
+  }
+  else  curordexport->virtaddr = realBaseAddress + (virtaddr - oh.ImageBase);
   curordexport->ordinal  = ordinal;
   curordexport++;
+}
+//******************************************************************************
+//******************************************************************************
+BOOL Win32PeLdrImage::AddForwarder(ULONG virtaddr, char *apiname, ULONG ordinal)
+{
+ char         *forward = (char *)(realBaseAddress + (virtaddr - oh.ImageBase));
+ char         *forwarddll, *forwardapi;
+ Win32DllBase *WinDll;
+ DWORD         exportaddr;
+ int           forwardord;
+  
+  forwarddll = strdup(forward);
+  if(forwarddll == NULL) {
+        return FALSE;
+  }
+  forwardapi = strchr(forwarddll, '.');
+  if(forwardapi == NULL) {
+        goto fail;
+  }
+  *forwardapi++ = 0;
+  if(strlen(forwarddll) == 0 || strlen(forwardapi) == 0) {
+        goto fail;
+  }
+  WinDll = Win32DllBase::findModule(forwarddll);
+  if(WinDll == NULL) {
+        WinDll = loadDll(forwarddll);
+        if(WinDll == NULL) {
+                dprintf((LOG, "ERROR: couldn't find forwarder %s.%s", forwarddll, forwardapi));
+                goto fail;
+        }
+  }
+  //check if name or ordinal forwarder
+  forwardord = 0;
+  if(*forwardapi >= '0' && *forwardapi <= '9') {
+        forwardord = atoi(forwardapi);
+  }
+  if(forwardord != 0 || (strlen(forwardapi) == 1 && *forwardapi == '0')) {
+        exportaddr = WinDll->getApi(forwardord);
+  }
+  else  exportaddr = WinDll->getApi(forwardapi);
+
+  if(apiname) {
+        dprintf((LOG, "address 0x%x %s @%d (0x%08x) forwarder %s.%s", virtaddr - oh.ImageBase, apiname, ordinal, virtaddr, forwarddll, forwardapi));
+        AddNameExport(exportaddr, apiname, ordinal, TRUE);
+  }
+  else {
+        dprintf((LOG, "address 0x%x @%d (0x%08x) forwarder %s.%s", virtaddr - oh.ImageBase, ordinal, virtaddr, forwarddll, forwardapi));
+        AddOrdExport(exportaddr, ordinal, TRUE);
+  }
+  free(forwarddll);
+  return TRUE;
+
+fail:
+  free(forwarddll);
+  return FALSE;
+}
+//******************************************************************************
+//******************************************************************************
+Win32DllBase *Win32PeLdrImage::loadDll(char *pszCurModule)
+{
+ Win32DllBase *WinDll = NULL;
+ char modname[CCHMAXPATH];
+
+        strcpy(modname, pszCurModule);
+        //rename dll if necessary (i.e. OLE32 -> OLE32OS2)
+        Win32DllBase::renameDll(modname);
+
+        if(isPEImage(modname) != ERROR_SUCCESS_W)
+        {//LX image, so let OS/2 do all the work for us
+                APIRET rc;
+                char   szModuleFailure[CCHMAXPATH] = "";
+                ULONG  hInstanceNewDll;
+                Win32LxDll *lxdll;
+
+                char *dot = strchr(modname, '.');
+                if(dot) {
+                        *dot = 0;
+                }
+                strcat(modname, ".DLL");
+                rc = DosLoadModule(szModuleFailure, sizeof(szModuleFailure), modname, (HMODULE *)&hInstanceNewDll);
+                if(rc) {
+                        dprintf((LOG, "DosLoadModule returned %X for %s\n", rc, szModuleFailure));
+                        sprintf(szErrorModule, "%s.DLL", szModuleFailure);
+                        errorState = rc;
+                        return NULL;
+                }
+                lxdll = Win32LxDll::findModuleByOS2Handle(hInstanceNewDll);
+                if(lxdll == NULL) {//shouldn't happen!
+                        dprintf((LOG, "Just loaded the dll, but can't find it anywhere?!!?"));
+                        errorState = ERROR_INTERNAL;
+                        return NULL;
+                }
+                lxdll->setDllHandleOS2(hInstanceNewDll);
+                if(lxdll->AddRef() == -1) {//-1 -> load failed (attachProcess)
+                        dprintf((LOG, "Dll %s refused to be loaded; aborting", modname));
+                        delete lxdll;
+                        errorState = ERROR_INTERNAL;
+                        return NULL;
+                }
+                WinDll = (Win32DllBase*)lxdll;
+        }
+        else {
+         Win32PeLdrDll *pedll;
+
+                pedll = new Win32PeLdrDll(modname, this);
+                if(pedll == NULL) {
+                    dprintf((LOG, "pedll: Error allocating memory" ));
+                    WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, szMemErrorMsg, szErrorTitle, 0, MB_OK | MB_ERROR | MB_MOVEABLE);
+                    errorState = ERROR_INTERNAL;
+                    return NULL;
+                }
+                dprintf((LOG, "**********************************************************************" ));
+                dprintf((LOG, "**********************     Loading Module        *********************" ));
+                dprintf((LOG, "**********************************************************************" ));
+                if(pedll->init(0) == FALSE) {
+                    dprintf((LOG, "Internal WinDll error ", pedll->getError() ));
+                    delete pedll;
+                    return NULL;
+                }
+#ifdef DEBUG
+                pedll->AddRef(getModuleName());
+#else
+                pedll->AddRef();
+#endif
+                if(pedll->attachProcess() == FALSE) {
+                    dprintf((LOG, "attachProcess failed!" ));
+                    delete pedll;
+                    errorState = ERROR_INTERNAL;
+                    return NULL;
+                }
+                WinDll = (Win32DllBase*)pedll;
+        }
+
+        dprintf((LOG, "**********************************************************************" ));
+        dprintf((LOG, "**********************  Finished Loading Module %s ", modname ));
+        dprintf((LOG, "**********************************************************************" ));
+
+        return WinDll;
 }
 //******************************************************************************
@@ -1331 +1477 @@
   {
     dprintf((LOG, "Module %s", pszCurModule ));
+    dprintf((LOG, "ForwarderChain: %x", pID[i].ForwarderChain));
     //  a) check that OriginalFirstThunk not is 0 and look for Borland-styled PE
     if (i == 0)
@@ -1373 +1520 @@
     if(WinDll == NULL)
     {  //not found, so load it
-        char modname[CCHMAXPATH];
-
-        strcpy(modname, pszCurModule);
-        //rename dll if necessary (i.e. OLE32 -> OLE32OS2)
-        Win32DllBase::renameDll(modname);
-
-        if(isPEImage(modname) != ERROR_SUCCESS_W)
-        {//LX image, so let OS/2 do all the work for us
-                APIRET rc;
-                char   szModuleFailure[CCHMAXPATH] = "";
-                ULONG  hInstanceNewDll;
-                Win32LxDll *lxdll;
-
-                char *dot = strchr(modname, '.');
-                if(dot) {
-                        *dot = 0;
-                }
-                strcat(modname, ".DLL");
-                rc = DosLoadModule(szModuleFailure, sizeof(szModuleFailure), modname, (HMODULE *)&hInstanceNewDll);
-                if(rc) {
-                        dprintf((LOG, "DosLoadModule returned %X for %s\n", rc, szModuleFailure));
-                        sprintf(szErrorModule, "%s.DLL", szModuleFailure);
-                        errorState = rc;
-                        return(FALSE);
-                }
-                lxdll = Win32LxDll::findModuleByOS2Handle(hInstanceNewDll);
-                if(lxdll == NULL) {//shouldn't happen!
-                        dprintf((LOG, "Just loaded the dll, but can't find it anywhere?!!?"));
-                        errorState = ERROR_INTERNAL;
-                        return(FALSE);
-                }
-                lxdll->setDllHandleOS2(hInstanceNewDll);
-                if(lxdll->AddRef() == -1) {//-1 -> load failed (attachProcess)
-                        dprintf((LOG, "Dll %s refused to be loaded; aborting", modname));
-                        delete lxdll;
-                        errorState = ERROR_INTERNAL;
-                        return(FALSE);
-                }
-                WinDll = (Win32DllBase*)lxdll;
-        }
-        else {
-         Win32PeLdrDll *pedll;
-
-                pedll = new Win32PeLdrDll(modname, this);
-                if(pedll == NULL) {
-                    dprintf((LOG, "pedll: Error allocating memory" ));
-                    WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, szMemErrorMsg, szErrorTitle, 0, MB_OK | MB_ERROR | MB_MOVEABLE);
-                    errorState = ERROR_INTERNAL;
-                    return(FALSE);
-                }
-                dprintf((LOG, "**********************************************************************" ));
-                dprintf((LOG, "**********************     Loading Module        *********************" ));
-                dprintf((LOG, "**********************************************************************" ));
-                if(pedll->init(0) == FALSE) {
-                    dprintf((LOG, "Internal WinDll error ", pedll->getError() ));
-                    delete pedll;
-                    return(FALSE);
-                }
-#ifdef DEBUG
-                pedll->AddRef(getModuleName());
-#else
-                pedll->AddRef();
-#endif
-                if(pedll->attachProcess() == FALSE) {
-                    dprintf((LOG, "attachProcess failed!" ));
-                    delete pedll;
-                    errorState = ERROR_INTERNAL;
-                    return(FALSE);
-                }
-                WinDll = (Win32DllBase*)pedll;
-        }
-
-        dprintf((LOG, "**********************************************************************" ));
-        dprintf((LOG, "**********************  Finished Loading Module  *********************" ));
-        dprintf((LOG, "**********************************************************************" ));
+        WinDll = loadDll(pszCurModule);
+        if(WinDll == NULL) {
+                return FALSE;
+        }
     }
     else {
@@ -1493 +1569 @@
             //KSO - Aug 6 1998 1:15am:this eases comparing...
             char *pszFunctionName = (char*)(pulImport[j] + (ULONG)win32file + 2);
-            dprintf((LOG, "0x%08x Imported function %s", ulCurFixup,  pszFunctionName ));
+            dprintf((LOG, "0x%08x Imported function %s (0x%08x)", ulCurFixup,  pszFunctionName, WinDll->getApi(pszFunctionName)));
             StoreImportByName(WinDll, pszFunctionName, ulCurFixup);
         }

trunk/src/kernel32/winimagepeldr.h ¶

@@ -1 @@
-/* $Id: winimagepeldr.h,v 1.4 2000-06-27 12:20:46 sandervl Exp $ */
+/* $Id: winimagepeldr.h,v 1.5 2000-10-04 19:36:25 sandervl Exp $ */
 
 /*
@@ -118 +118 @@
 
         BOOL  processExports(char *win32file);
-        void  AddNameExport(ULONG virtaddr, char *apiname, ULONG ordinal);
-        void  AddOrdExport(ULONG virtaddr, ULONG ordinal);
+        void  AddNameExport(ULONG virtaddr, char *apiname, ULONG ordinal, BOOL fAbsoluteAddress=FALSE);
+        void  AddOrdExport(ULONG virtaddr, ULONG ordinal, BOOL fAbsoluteAddress=FALSE);
+        BOOL  AddForwarder(ULONG virtaddr, char *apiname, ULONG ordinal);
+
+Win32DllBase *loadDll(char *pszCurModule);
 
         IMAGE_OPTIONAL_HEADER oh;

trunk/src/kernel32/wprocess.cpp ¶

@@ -1 @@
-/* $Id: wprocess.cpp,v 1.100 2000-10-03 20:17:20 sandervl Exp $ */
+/* $Id: wprocess.cpp,v 1.101 2000-10-04 19:36:26 sandervl Exp $ */
 
 /*
@@ -1368 +1368 @@
 
     if (cch > 0)
-        dprintf(("KERNEL32:  GetModuleFileNameA(%x,...): %s %d\n", hModule, lpszPath, cch));
+        dprintf(("KERNEL32:  GetModuleFileNameA(%x %x): %s %d\n", hModule, lpszPath, lpszPath, cch));
     else
         dprintf(("KERNEL32:  WARNING: GetModuleFileNameA(%x,...) - not found!", hModule));