Changeset 4164 for trunk/src/win32k/ldr

Timestamp:

Sep 2, 2000, 11:08:23 PM (25 years ago)

Author:

bird

Message:

Merged in the Grace branch. New Win32k!

Location:

trunk/src/win32k/ldr

Files:

• ModuleBase.cpp (modified) (6 diffs)
• calltab.asm (modified) (4 diffs)
• ldr.cpp (modified) (9 diffs)
• myLDRLoadExe.cpp (deleted)
• myLDRQAppType.cpp (modified) (4 diffs)
• myldrClose.cpp (modified) (5 diffs)
• myldrCreateMte.cpp (deleted)
• myldrEnum32bitRelRecs.cpp (modified) (3 diffs)
• myldrGetMte.cpp (deleted)
• myldrGetResource.cpp (deleted)
• myldrOpen.cpp (modified) (8 diffs)
• myldrOpenNewExe.cpp (deleted)
• myldrOpenPath.cpp (modified) (4 diffs)
• myldrRead.cpp (modified) (4 diffs)
• mytkExecPgm.asm (modified) (8 diffs)
• mytkStartProcess.asm (added)

trunk/src/win32k/ldr/ModuleBase.cpp

@@ -1 @@
-/* $Id: ModuleBase.cpp,v 1.3 2000-02-27 02:17:06 bird Exp $
+/* $Id: ModuleBase.cpp,v 1.4 2000-09-02 21:08:06 bird Exp $
  *
  * ModuleBase - Implementetation.
@@ -12 +12 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-#define INCL_DOSERRORS                      /* DOS Error codes. */
+#define INCL_DOSERRORS                  /* DOS Error codes. */
 #ifdef RING0
-    #define INCL_NOAPI                      /* RING0: No apis. */
+    #define INCL_NOAPI                  /* RING0: No apis. */
 #else /*RING3*/
-    #define INCL_DOSFILEMGR                 /* RING3: DOS File api. */
+    #define INCL_DOSFILEMGR             /* RING3: DOS File api. */
 #endif
 
@@ -23 +23 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include <os2.h>                            /* OS/2 header file. */
-
-#include "malloc.h"                         /* win32k malloc. Not C library! */
-
-#include <string.h>                         /* C library string.h. */
-#include <stdarg.h>                         /* C library stdarg.h. */
-
-#include "vprintf.h"                        /* win32k printf and vprintf. Not C library! */
-#include "dev32.h"                          /* 32-Bit part of the device driver. (SSToDS) */
-#include "OS2Krnl.h"                        /* kernel structs.  (SFN) */
-#include "modulebase.h"                     /* ModuleBase class definitions, ++. */
+#include <os2.h>                        /* OS/2 header file. */
+
+#include "devSegDf.h"                   /* Win32k segment definitions. */
+#include "malloc.h"                     /* Win32k malloc. Not C library! */
+
+#include <string.h>                     /* C library string.h. */
+#include <stdarg.h>                     /* C library stdarg.h. */
+
+#include "vprintf.h"                    /* win32k printf and vprintf. Not C library! */
+#include "dev32.h"                      /* 32-Bit part of the device driver. (SSToDS) */
+#include "OS2Krnl.h"                    /* kernel structs.  (SFN) */
+#include "ldrCalls.h"                   /* ldrOpenPath and ldrlv_t. */
+#include "modulebase.h"                 /* ModuleBase class definitions, ++. */
 
 
@@ -159 +161 @@
 }
 
+
+/**
+ * openPath - opens file eventually searching loader specific paths.
+ *
+ * This base implementation simply calls ldrOpenPath.
+ * This method is only called for DLLs. DosLoadModule and Imports.
+ *
+ * @returns   OS2 return code.
+ *            pLdrLv->lv_sfn  is set to filename handle.
+ * @param     pachFilename  Pointer to filename. Not zero terminated!
+ * @param     cchFilename   Filename length.
+ * @param     pLdrLv        Loader local variables? (Struct from KERNEL.SDF)
+ * @param     pful          Pointer to flags which are passed on to ldrOpen.
+ * @sketch
+ * This is roughly what the original ldrOpenPath does:
+ *      if !CLASS_GLOBAL or miniifs then
+ *          ldrOpen(pachModName)
+ *      else
+ *          loop until no more libpath elements
+ *              get next libpath element and add it to the modname.
+ *              try open the modname
+ *              if successfull then break the loop.
+ *          endloop
+ *      endif
+ */
+ULONG  ModuleBase::openPath(PCHAR pachFilename, USHORT cchFilename, ldrlv_t *pLdrLv, PULONG pful) /* (ldrOpenPath) */
+{
+    #ifdef RING0
+    printf("ModuleBase::openPath:\n");
+    return ldrOpenPath(pachFilename, cchFilename, pLdrLv, pful);
+    #else
+    NOREF(pachFilename);
+    NOREF(cchFilename);
+    NOREF(pLdrLv);
+    NOREF(pful);
+    return ERROR_NOT_SUPPORTED;
+    #endif
+}
 
 
@@ -232 +272 @@
 
 /**
+ * Gets the fullpath filename.
+ * @returns     Const ("Readonly") pointer to the filename.
+ * @author      knut st. osmundsen (knut.stange.osmundsen@mynd.no)
+ */
+PCSZ ModuleBase::getFilename()
+{
+    return pszFilename;
+}
+
+
+/**
+ * Gets the modulename.
+ * @returns     Const ("Readonly") pointer to the module name.
+ * @author      knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ * @remark      Modulename is filename without path and extention.
+ */
+PCSZ ModuleBase::getModuleName()
+{
+    return pszModuleName;
+}
+
+
+/**
  * Output function for Modules.
  * @param     pszFormat    Pointer to format string.
@@ -273 +336 @@
         rc = DosRead(hFile, pvBuffer, cbToRead, &cbRead);
     else
-        printErr(("DosSetFilePtr(hfile, %#8x(%d),..) failed with rc = %d.",
+        printErr(("DosSetFilePtr(hfile, %#8x(%d),..) failed with rc = %d.\n",
                   ulOffset, ulOffset, rc));
 

trunk/src/win32k/ldr/calltab.asm

@@ -1 @@
-; $Id: calltab.asm,v 1.12 2000-04-17 01:56:49 bird Exp $
-;
-; callTab - Call back again table - table with entry for each function which is overrided.
-;           It holds the part of the prolog which was replaced by a jmp instruction.
-;
-; Copyright (c) 1998-1999 knut st. osmundsen
+; $Id: calltab.asm,v 1.13 2000-09-02 21:08:06 bird Exp $
+;
+; callTab - Call back again table - table with entry for each function or
+;           variable which is overrided.
+;           It holds the part of the prolog which was replaced by the jmp
+;           instruction (overridden functions).
+;
+; Copyright (c) 1998-2000 knut st. osmundsen
 ;
 ; Project Odin Software License can be found in LICENSE.TXT
@@ -35 +37 @@
     public _VMGetOwner@8
     public _g_tkExecPgm
+    public _tkStartProcess
     public _f_FuStrLenZ
     public _f_FuBuff
 
+    public _VMObjHandleInfo@12
+    public _ldrASMpMTEFromHandle@4
+    public _ldrOpenPath@16
+    public _LDRClearSem@0
+    public _ldrFindModule@16
+    public _KSEMRequestMutex@8
+    public _KSEMReleaseMutex@4
+    public _KSEMQueryMutex@8
+    public _KSEMInit@12
+
+    public pLDRSem
+    public LDRSem_offObject
+    public _fpLDRSem
+    public LDRSem_sel
+
+    public pLDRLibPath
+    public LDRLibPath_offObject
+    public _fpLDRLibPath
+    public LDRLibPath_sel
+
+    public _TKSuBuff@16
+    public _TKFuBuff@16
+    public _TKFuBufLen@20
+    public _ldrValidateMteHandle@4
+
+    public ppTCBCur
+    public pTCBCur_offObject
+    public _fppTCBCur
+    public pTCBCur_sel
+
+    public ppPTDACur
+    public pPTDACur_offObject
+    public _fppPTDACur
+    public pPTDACur_sel
+
+    public pptda_start
+    public ptda_start_offObject
+    public _fpptda_start
+    public ptda_start_sel
+
+    public pptda_environ
+    public ptda_environ_offObject
+    public _fpptda_environ
+    public ptda_environ_sel
+
+    public pptda_ptdasem
+    public ptda_ptdasem_offObject
+    public _fpptda_ptdasem
+    public ptda_ptdasem_sel
+
+    public pptda_module
+    public ptda_module_offObject
+    public _fpptda_module
+    public ptda_module_sel
+
+    public pptda_pBeginLIBPATH
+    public ptda_pBeginLIBPATH_offObject
+    public _fpptda_pBeginLIBPATH
+    public pptda_pBeginLIBPATH_sel
+
+    public pldrpFileNameBuf
+    public pldrpFileNameBuf_offObject
+    public _fpldrpFileNameBuf
+    public pldrpFileNameBuf_sel
+
+    public SecPathFromSFN
+
 
 ;
@@ -47 +117 @@
 
 CALLTAB segment
-    assume cs:CALLTAB, ds:flat, ss:nothing
+    ;assume cs:CALLTAB, ds:flat, ss:nothing
+    assume ds:flat, ss:nothing
 ;
 ; callTab is an array of evt. function prologs with a jump to the real function.
@@ -56 +127 @@
 ;
 callTab:
+
+; 0
 _ldrRead@24 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _ldrRead@24 ENDP
 
+; 1
 _ldrOpen@12 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _ldrOpen@12 ENDP
 
+; 2
 _ldrClose@4 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _ldrClose@4 ENDP
 
+; 3
 _LDRQAppType@8 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _LDRQAppType@8 ENDP
 
+; 4
 _ldrEnum32bitRelRecs@24 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _ldrEnum32bitRelRecs@24 ENDP
 
-
+; 5
 _IOSftOpen@20 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _IOSftOpen@20 ENDP
 
+; 6
 _IOSftClose@4 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _IOSftClose@4 ENDP
 
+; 7
 _IOSftTransPath@4 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _IOSftTransPath@4 ENDP
 
+; 8
 _IOSftReadAt@20 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _IOSftReadAt@20 ENDP
 
+; 9
 _IOSftWriteAt@20 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _IOSftWriteAt@20 ENDP
 
+; 10
 _SftFileSize@8 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _SftFileSize@8 ENDP
 
-
+; 11
 _VMAllocMem@36 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _VMAllocMem@36 ENDP
 
+; 12
 _VMGetOwner@8 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _VMGetOwner@8 ENDP
 
+; 13
 _g_tkExecPgm PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _g_tkExecPgm ENDP
 
-
+; 14
+_tkStartProcess PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_tkStartProcess ENDP
+
+; 15
 _f_FuStrLenZ PROC FAR
     db MAXSIZE_PROLOG dup(0cch)
 _f_FuStrLenZ ENDP
 
+; 16
 _f_FuStrLen PROC FAR
     db MAXSIZE_PROLOG dup(0cch)
 _f_FuStrLen ENDP
 
+; 17
 _f_FuBuff PROC FAR
     db MAXSIZE_PROLOG dup(0cch)
 _f_FuBuff ENDP
 
+; 18
 _VMObjHandleInfo@12 PROC NEAR
     db MAXSIZE_PROLOG dup(0cch)
 _VMObjHandleInfo@12 ENDP
 
+; 19
+_ldrASMpMTEFromHandle@4 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_ldrASMpMTEFromHandle@4 ENDP
+
+; 20
+_ldrOpenPath@16 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_ldrOpenPath@16 ENDP
+
+; 21
+_LDRClearSem@0 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_LDRClearSem@0 ENDP
+
+; 22
+_ldrFindModule@16 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_ldrFindModule@16 ENDP
+
+; 23
+_KSEMRequestMutex@8 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_KSEMRequestMutex@8 ENDP
+
+; 24
+_KSEMReleaseMutex@4 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_KSEMReleaseMutex@4 ENDP
+
+; 25
+_KSEMQueryMutex@8 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_KSEMQueryMutex@8 ENDP
+
+; 26
+_KSEMInit@12 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_KSEMInit@12 ENDP
+
+; 27
+pLDRSem          dd  0
+LDRSem_offObject dd  0
+_fpLDRSem        dd  0
+LDRSem_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+
+; 28
+pLDRLibPath          dd  0
+LDRLibPath_offObject dd  0
+_fpLDRLibPath        dd  0
+LDRLibPath_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 29
+_TKSuBuff@16 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_TKSuBuff@16 ENDP
+
+; 30
+_TKFuBuff@16 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_TKFuBuff@16 ENDP
+
+; 31
+_TKFuBufLen@20 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_TKFuBufLen@20 ENDP
+
+; 32
+_ldrValidateMteHandle@4 PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+_ldrValidateMteHandle@4 ENDP
+
+; 33
+ppTCBCur           dd  0
+pTCBCur_offObject  dd  0
+_fppTCBCur         dd  0
+pTCBCur_sel        dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 34
+ppPTDACur          dd  0
+pPTDACur_offObject dd  0
+_fppPTDACur        dd  0
+pPTDACur_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 35
+pptda_start          dd  0
+ptda_start_offObject dd  0
+_fpptda_start        dd  0
+ptda_start_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 36
+pptda_environ          dd  0
+ptda_environ_offObject dd  0
+_fpptda_environ        dd  0
+ptda_environ_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 37
+pptda_ptdasem          dd  0
+ptda_ptdasem_offObject dd  0
+_fpptda_ptdasem        dd  0
+ptda_ptdasem_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 38
+pptda_module          dd  0
+ptda_module_offObject dd  0
+_fpptda_module        dd  0
+ptda_module_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 39
+pptda_pBeginLIBPATH           dd  0
+ptda_pBeginLIBPATH_offObject  dd  0
+_fpptda_pBeginLIBPATH         dd  0
+pptda_pBeginLIBPATH_sel       dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 40
+pldrpFileNameBuf              dd  0
+pldrpFileNameBuf_offObject    dd  0
+_fpldrpFileNameBuf            dd  0
+pldrpFileNameBuf_sel          dw  0
+    db (MAXSIZE_PROLOG - 14) dup(0cch)
+
+; 41
+SecPathFromSFN PROC NEAR
+    db MAXSIZE_PROLOG dup(0cch)
+SecPathFromSFN ENDP
+
+
 CALLTAB ENDS
 

trunk/src/win32k/ldr/ldr.cpp

@@ -1 @@
-/* $Id: ldr.cpp,v 1.7 2000-01-22 18:21:01 bird Exp $
+/* $Id: ldr.cpp,v 1.8 2000-09-02 21:08:06 bird Exp $
  *
  * ldr.cpp - Loader helpers.
@@ -14 +14 @@
 #define INCL_DOSERRORS
 #define INCL_NOPMAPI
-
+#define INCL_OS2KRNL_SEM
+#define INCL_OS2KRNL_PTDA
 
 /*******************************************************************************
@@ -21 +22 @@
 #include <os2.h>
 
+#include "devSegDf.h"
 #include "malloc.h"
 #include "new.h"
@@ -26 +28 @@
 #include <stdlib.h>
 #include <stddef.h>
+#include <string.h>
 
 #include "log.h"
+#include "avl.h"
 #include <peexe.h>
 #include <exe386.h>
 #include "OS2Krnl.h"
+#include "ldr.h"
+#include "ldrCalls.h"
 #include "ModuleBase.h"
 #include "pe2lx.h"
-#include "avl.h"
-#include "ldr.h"
 #include "options.h"
 
@@ -41 +45 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-PAVLNODECORE    pSFNRoot = NULL;
-PAVLNODECORE    pMTERoot = NULL;
-
+static PAVLNODECORE    pSFNRoot = NULL;
+static PAVLNODECORE    pMTERoot = NULL;
+
+
+/*
+ * Loader State. (See ldr.h for more info.)
+ */
+ULONG          ulLdrState = LDRSTATE_UNKNOWN;
+
+
+/*
+ * Pointer to the executable module being loaded.
+ * This pointer is set by ldrOpen and cleared by tkExecPgm.
+ * It's hence only valid at tkExecPgm time. (isLdrStateExecPgm() == TRUE).
+ */
+PMODULE         pExeModule = NULL;
+
+
+/*
+ * Filehandle bitmap.
+ */
 unsigned char   achHandleStates[MAX_FILE_HANDLES/8];
+
+
 
 
@@ -64 +88 @@
  * Gets a module by the MTE.
  * @returns   Pointer to module node. If not found NULL.
- * @param     pMTE  Pointer an Module Table Entry.
+ * @param     pMTE  Pointer a Module Table Entry.
  * @sketch    Try find it in the MTE tree.
  *            IF not found THEN
@@ -124 +148 @@
 
 /**
+ * Gets a module by the hMTE.
+ * @returns   Pointer to module node. If not found NULL.
+ * @param     hMTE  Handle to a Module Table Entry.
+ * @sketch    Convert hMte to an pMTE (pointer to MTE).
+ *            Call getModuleByMTE with MTE pointer.
+ * @status    completely implemented.
+ * @author    knut st. osmundsen
+ */
+PMODULE     getModuleByhMTE(HMTE hMTE)
+{
+    PMTE pMTE;
+
+    pMTE = ldrValidateMteHandle(hMTE);
+    if (pMTE != NULL)
+        return getModuleByMTE(pMTE);
+
+    return NULL;
+}
+
+
+/**
  * Get a module by filename.
  * @returns   Pointer to module node. If not found NULL.
@@ -236 +281 @@
             delete pMod->Data.pPe2Lx;
             break;
-
+/*
         case MOD_TYPE_ELF2LX:
-        case MOD_TYPE_SCRIPT:
-        case MOD_TYPE_PE:
+            break;
+*/
+#ifdef DEBUG
         default:
             kprintf(("removeModule: Unknown type, %#x\n", pMod->fFlags & MOD_TYPE_MASK));
+#endif
     }
 
@@ -248 +295 @@
 
     return NO_ERROR;
+}
+
+
+/**
+ * Gets the path of the executable being executed.
+ * @returns     Pointer to pszPath on success. Path has _NOT_ a trailing slash.
+ *              NULL pointer on error.
+ * @param       pszPath     Pointer to path buffer. Expects CCHMAXPATH length.
+ * @param       fExecChild  Use hMTE of the PTDAExecChild if present.
+ * @sketch
+ * @status      completely implemented.
+ * @author      knut st. osmundsen (knut.stange.osmundsen@mynd.no)
+ * @remark      The path from the pExeModule might not be fully qualified.
+ */
+PSZ ldrGetExePath(PSZ pszPath, BOOL fExecChild)
+{
+    PCSZ    pszFilename;
+    PCSZ    psz;
+
+    #if 0 /* getFilename not implemented */
+    if (pExeModule != NULL)
+        /*
+         * We have the executable object pointer. Let's use it!
+         */
+        pszFilename = pExeModule->Data.pModule->getFilename();
+    else
+    #endif
+    {
+        /*
+         * Get the hMTE for the executable using the pPTDAExecChild
+         * Then get the pMTE, and access the smte_path to get a pointer to the executable path.
+         */
+        PPTDA   pPTDACur;               /* Pointer to the current (system context) PTDA */
+        PPTDA   pPTDA;                  /* PTDA in question. */
+        HMTE    hMTE = NULLHANDLE;      /* Modulehandle of the executable module. */
+        PMTE    pMTE;                   /* Pointer to ModuleTableEntry of the executable module. */
+
+        /*
+         *  Get the current PTDA. (Fail if this call failes.)
+         *  IF pPTDAExecChild isn't NULL THEN get hMTE for that.
+         *  IF no pPTDAExecChild THEN  get hMte for the current PTDA.
+         */
+        pPTDACur = ptdaGetCur();
+        if (pPTDACur != NULL)
+        {
+            pPTDA = ptdaGet_pPTDAExecChild(pPTDACur);
+            if (pPTDA != NULL && fExecChild)
+                hMTE = ptdaGet_ptda_module(pPTDA);
+            if (hMTE == NULLHANDLE)
+                hMTE = ptdaGet_ptda_module(pPTDACur);
+        }
+        else
+        {   /* Not called at task time? No current task! */
+            kprintf(("ldrGetExePath: Failed to get current PTDA.\n"));
+            return NULL;
+        }
+
+        /* fail if hMTE is NULLHANDLE ie. not found / invalid */
+        if (hMTE == NULLHANDLE)
+        {
+            kprintf(("ldrGetExePath: Failed to get hMTE from the PTDAs.\n"));
+            return NULL;
+        }
+
+        /* get the pMTE for this hMTE */
+        pMTE = ldrASMpMTEFromHandle(hMTE);
+        if (pMTE == NULL)
+        {
+            kprintf(("ldrGetExePath: ldrASMpMTEFromHandle failed for hMTE=0x%04.\n", hMTE));
+            return NULL;
+        }
+        if (pMTE->mte_swapmte == NULL) /* paranoia */
+        {
+            kprintf(("ldrGetExePath: mte_swapmte is NULL.\n"));
+            return NULL;
+        }
+
+        /* take the filename from the swappable MTE */
+        pszFilename = pMTE->mte_swapmte->smte_path;
+        if (pszFilename == NULL)
+        {
+            kprintf(("ldrGetExePath: smte_path is NULL.\n"));
+            return NULL;
+        }
+    }
+
+    /* paranoia... */
+    if (*pszFilename == '\0')
+    {
+        kprintf(("ldrGetExePath: pszFilename is empty!\n"));
+        return NULL;
+    }
+
+    /*
+     * Skip back over the filename. (stops pointing at the slash or ':')
+     */
+    psz = pszFilename + strlen(pszFilename)-1;
+    while (psz >= pszFilename && *psz != '\\' && *psz != '/' && *psz != ':')
+        psz--;
+
+    /*
+     * If no path the fail.
+     */
+    if (psz <= pszFilename)
+    {
+        kprintf(("ldrGetExePath: Exepath is empty.\n"));
+        return NULL;
+    }
+
+    /*
+     * Copy path and return.
+     */
+    memcpy(pszPath, pszFilename, psz - pszFilename);
+    pszPath[psz - pszFilename] = '\0';
+    return pszPath;
 }
 

trunk/src/win32k/ldr/myLDRQAppType.cpp

@@ -1 @@
-/* $Id: myLDRQAppType.cpp,v 1.3 2000-01-22 18:21:02 bird Exp $
+/* $Id: myLDRQAppType.cpp,v 1.4 2000-09-02 21:08:07 bird Exp $
  *
  * _myLDRQAppType - _LDRQAppType overload.
@@ -15 +15 @@
 #define INCL_NOPMAPI
 
+#define INCL_OS2KRNL_PTDA
+#define INCL_OS2KRNL_SEM
+
 /*******************************************************************************
 *   Header Files                                                               *
@@ -20 +23 @@
 #include <os2.h>
 
+#include "devSegDf.h"                   /* Win32k segment definitions. */
 #include "OS2Krnl.h"
+#include "avl.h"
+#include "ldr.h"
 #include "ldrCalls.h"
 #include "log.h"
 
-BOOL fQAppType = FALSE;
 
 /**
- * LDRQAppType - Loader Query Application Type.
- * We set a flag while we're executing this function. Just to speed up processing.
- * If a PE file is queried, a dummy LX header is presented.
+ * LDRQAppType - Loader Query Application Type - DosQueryAppType worker.
+ *
+ * We overrides this be able to determin if a convertion is only for a
+ * LDRQAppType call.
+ *
+ * isLdrStateQAppType() returns TRUE when this procedure is on the stack.
+ *
  * @returns   return code.
  * @param     p1
@@ -38 +47 @@
     APIRET rc;
 
-    kprintf(("_LDRQAppType: entry\n"));
-    fQAppType = 1;
+    kprintf(("myLDRQAppType: entry\n"));
+    rc = KSEMRequestMutex(ptda_ptda_ptdasem(ptdaGetCur()), KSEM_INDEFINITE_WAIT);
+    if (rc != NO_ERROR)
+    {
+        kprintf(("myLDRQAppType: failed to get intra-process semaphore.\n"));
+        return rc;
+    }
+    rc = LDRRequestSem();
+    if (rc != NO_ERROR)
+    {
+        kprintf(("myLDRQAppType: failed to get loader semaphore.\n"));
+        return rc;
+    }
+
+    ASSERT_LdrStateUnknown("myLDRQAppType")
+    setLdrStateQAppType();
 
     rc = LDRQAppType(p1, p2);
 
-    fQAppType = 0;
-    kprintf(("_LDRQAppType: exit\n"));
+    ASSERT_LdrStateQAppType("myLDRQAppType")
+    setLdrStateUnknown();
+
+    LDRClearSem();
+    KSEMReleaseMutex(ptda_ptda_ptdasem(ptdaGetCur()));
+    kprintf(("myLDRQAppType: exit\n"));
 
     return rc;

trunk/src/win32k/ldr/myldrClose.cpp

@@ -1 @@
-/* $Id: myldrClose.cpp,v 1.5 2000-01-22 18:21:02 bird Exp $
+/* $Id: myldrClose.cpp,v 1.6 2000-09-02 21:08:07 bird Exp $
  *
  * myldrClose - ldrClose
@@ -23 +23 @@
 #include <stdlib.h>
 
+#include "devSegDf.h"                   /* Win32k segment definitions. */
 #include "log.h"
+#include "avl.h"
 #include <peexe.h>
 #include <exe386.h>
 #include "OS2Krnl.h"
-#include "avl.h"
-#include "ModuleBase.h"
 #include "ldr.h"
 #include "ldrCalls.h"
+#include "ModuleBase.h"
+#include "Pe2Lx.h"
 
 
@@ -42 +44 @@
 {
     /* closes handle */
-    kprintf(("ldrClose: hFile = %.4x\n", hFile));
+    kprintf(("myldrClose: hFile = %.4x\n", hFile));
     if (GetState(hFile) == HSTATE_OUR)
     {
@@ -52 +54 @@
             pMod->Data.pModule->dumpVirtualLxFile();
         else
-            kprintf(("ldrClose: getModuleBySFN failed!!!"));
+            kprintf(("myldrClose: getModuleBySFN failed!!!"));
         #endif
 
         rc = removeModule(hFile);
         if (rc != NO_ERROR)
-            kprintf(("ldrClose: removeModule retured rc=%d\n", rc));
+            kprintf(("myldrClose: removeModule retured rc=%d\n", rc));
 
         #pragma info(notrd)
@@ -63 +65 @@
         #pragma info(restore)
     }
+    /*
+     * Invalidate the odin32path if kernel32 is closed.
+     *  (Might possible not be needed as Pe2Lx does invalides
+     *   the odin32path on object destruction.)
+     */
+    else if (Pe2Lx::getKernel32SFN() == hFile)
+        Pe2Lx::invalidateOdin32Path();
 
+    /*
+     * Finally call the real close function.
+     */
     return ldrClose(hFile);
 }

trunk/src/win32k/ldr/myldrEnum32bitRelRecs.cpp

@@ -1 @@
-/* $Id: myldrEnum32bitRelRecs.cpp,v 1.2 2000-01-27 23:43:07 bird Exp $
+/* $Id: myldrEnum32bitRelRecs.cpp,v 1.3 2000-09-02 21:08:08 bird Exp $
  *
  * myldrEnum32bitRelRecs - ldrEnum32bitRelRecs
@@ -24 +24 @@
 #include <stdlib.h>
 
+#include "devSegDf.h"                   /* Win32k segment definitions. */
+#include "avl.h"
 #include "log.h"
 #include <peexe.h>
 #include <exe386.h>
 #include "OS2Krnl.h"
-#include "avl.h"
-#include "ModuleBase.h"
 #include "ldr.h"
 #include "ldrCalls.h"
+#include "ModuleBase.h"
 
 
@@ -63 +64 @@
         APIRET rc;
         #if 1
-        kprintf(("ldrEnum32BitRelRecs: pMTE=0x%08x iObject=0x%02x iPageTable=0x%03x pvPage=0x%08x\n"
+        kprintf(("myldrEnum32BitRelRecs: pMTE=0x%08x iObject=0x%02x iPageTable=0x%03x pvPage=0x%08x\n"
                  "                     ulPageAddress=0x%08x pvPTDA=0x%08x\n",
                  pMTE, iObject, iPageTable, pvPage, ulPageAddress, pvPTDA

trunk/src/win32k/ldr/myldrOpen.cpp

@@ -1 @@
-/* $Id: myldrOpen.cpp,v 1.10 2000-02-21 09:24:01 bird Exp $
+/* $Id: myldrOpen.cpp,v 1.11 2000-09-02 21:08:09 bird Exp $
  *
  * myldrOpen - ldrOpen.
  *
- * Copyright (c) 1998-1999 knut st. osmundsen
+ * Copyright (c) 1998-2000 knut st. osmundsen
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -17 +17 @@
 
 #define INCL_OS2KRNL_IO
+#define INCL_OS2KRNL_TCB
+#define INCL_OS2KRNL_SEM
+#define INCL_OS2KRNL_SEC
 
 /*******************************************************************************
@@ -23 +26 @@
 #include <os2.h>
 
+#include "devSegDf.h"                   /* Win32k segment definitions. */
 #include "rmalloc.h"
 #include "malloc.h"
@@ -28 +32 @@
 #include <stdlib.h>
 #include <string.h>
+#include <stdarg.h>
 
 #include "log.h"
+#include "avl.h"
+#include "options.h"
 #include <peexe.h>
 #include <exe386.h>
+#include "elf.h"
 #include "OS2Krnl.h"
 #include "dev32.h"
+#include "ldr.h"
+#include "ldrCalls.h"
 #include "ModuleBase.h"
 #include "pe2lx.h"
-#include "elf.h"
-#include "avl.h"
-#include "ldr.h"
-#include "ldrCalls.h"
-#include "options.h"
 #include "myExecPgm.h"
-
-/*******************************************************************************
-*   Global Variables                                                           *
-*******************************************************************************/
-extern BOOL fQAppType;                  /* From LDRQAppType */
+#include "env.h"
+#include "vprintf.h"                    /* Make 100% sure we have va_start.  */
+
+
 
 /*******************************************************************************
 *   Internal Functions                                                         *
 *******************************************************************************/
-static unsigned getArgsLength(const char *pachArgs);
+/* static */ APIRET     AddArgsToFront(int cArgs,  ...);
+/* static */ APIRET     SetExecName(const char *pszExeName);
+/* static */ APIRET     OpenPATH(PSFN phFile, char *pszFilename, PULONG pfl);
 
 
@@ -59 +65 @@
  * @param     phFile       Pointer to file handler. Holds filehandle on output.
  * @param     pszFilename  Pointer to filename.
- * @parma     param3       Probably some flags.
+ * @parma     pfl          Pointer to some flags.
  */
-ULONG LDRCALL myldrOpen(PSFN phFile, char *pszFilename, ULONG param3)
+ULONG LDRCALL myldrOpen(PSFN phFile, PSZ pszFilename, PULONG pfl)
 {
-    ULONG rc;
-
-    /*
-     * Try open the file (thats why this function is called anyway)
+    static  int cNesting = 0;           /* This is an variable which hold the nesting */
+                                        /* level of this function. This is useful     */
+                                        /* when we call it recurcively.               */
+                                        /* The maximum nesting level is currently 3.  */
+                                        /* When the maximum depth has been reached    */
+                                        /* we'll not intercept loading any longer!    */
+    ULONG rc;                           /* Return value. */
+
+    /** @sketch
+     * Try open the file (that's why this function is called anyway)
      */
-    rc = ldrOpen(phFile, pszFilename, param3);
-
-    /* log sucesses */
+    rc = ldrOpen(phFile, pszFilename, pfl);
     if (rc == NO_ERROR)
-        kprintf(("ldrOpen:  phFile=%#.4x, flags=%#.8x, pszFn=%s\n", *phFile, param3, pszFilename));
-
-    /*
+        kprintf(("myldrOpen-%d:  phFile=%#.4x, flags=%#.8x, pszFn=%s\n", cNesting, *phFile, pfl, pszFilename));
+
+
+    /** @sketch
      * Are we to intercept the loading?
-     * - Only if open were succesful and one of the loaders are enabled.
+     * - If open were successful.
+     * - And Not too deep nesting.
+     * - And that this isn't an unsupported load.
+     * - And one of the loaders are enabled.
      */
-    if (rc == NO_ERROR && (options.fElf || options.fPE != FLAGS_PE_NOT || options.fScript))
-    {
-        char               *pszBuffer = (char*)rmalloc(640);        /* Read buffer. */
-        PIMAGE_DOS_HEADER   pMzHdr = (PIMAGE_DOS_HEADER)pszBuffer;  /* Pointer to the buffer as it were a dosheader. */
-        PIMAGE_NT_HEADERS   pNtHdrs = (PIMAGE_NT_HEADERS)pszBuffer; /* Pointer to the buffer as if it were an NT header. */
-        char               *pach = pszBuffer;                       /* Finally an pointer to the buffer as if it were chars.. (which it is!) */
-        PEXECPGMBUFFER      pBuffer;                                /* Pointer to a buffer containing the programname and arguments. */
-                                                                    /* For scripts and PE.EXE this has to be changed to have correct */
-                                                                    /* parameters sendt in to the program. */
-        unsigned            cchRead = sizeof(IMAGE_DOS_HEADER);     /* Amount of the buffer which contains valid data. */
-        unsigned            cbFile;                                 /* Filesize (0xffffffff if call to SftFileSize failed - should _never_ happen though)  */
-
-        /*
-         * Verify that rmalloc completed successfully.
-         */
-        if (pszBuffer == NULL)
+    if (rc == NO_ERROR
+        && cNesting < 3
+        && !isLdrStateLoadingUnsupported()
+        && isAnyLoaderEnabled()
+        )
+    {
+        union _u_ReadBufferPointers         /* Read buffer pointer(s). */
         {
-            kprintf(("ldrOpen: rmalloc(1024) failed\n"));
-            return NO_ERROR;
+            char               *pach;       /* Pointer to the buffer as char. */
+            unsigned long      *pul;        /* Pointer to the buffer as unsigned long. */
+            PIMAGE_DOS_HEADER   pMzHdr;     /* Use the buffer as a dosheader. */
+            PIMAGE_NT_HEADERS   pNtHdrs;    /* Use the buffer as a NT header. */
+        } u1;
+        unsigned            cbFile;         /* Filesize (0xffffffff if call to SftFileSize failed - should _never_ happen though) */
+        unsigned            cbRead;         /* Amount of the buffer which contains valid data. */
+        char *              psz;            /* Multipurpose string pointer no.1. */
+        char *              psz2;           /* Multipurpose string pointer no.2. */
+        char *              psz3;           /* Multipurpose string pointer no.3. */
+
+        /** @sketch
+         * Allocate read buffer from resident heap.
+         * IF this fails THEN we'll simply return NO_ERROR.
+         */
+        u1.pach = (char*)rmalloc(640);
+        if (u1.pach == NULL)
+        {
+            kprintf(("myldrOpen-%d: rmalloc(640) failed\n", cNesting));
+            goto ret;
         }
 
-        /*
-         * Try get the filesize
+
+        /** @sketch
+         * Increment nesting level.
+         */
+        cNesting++;
+
+
+        /** @sketch
+         * Get the filesize. On failure filesize is set to ~0.
          */
         rc = SftFileSize(*phFile, (PULONG)SSToDS(&cbFile));
         if (rc != NO_ERROR)
         {
-            kprintf(("ldrOpen: SftFileSize failed with rc=%d\n", rc));
+            kprintf(("myldrOpen-%d: SftFileSize failed with rc=%d\n", cNesting, rc));
             cbFile = (unsigned)~0;
         }
 
-        /*
-         * See if this is an recognizable module format.
-         * This costs up to two disk reads!
-         */
-        rc = ldrRead(*phFile, 0UL, pMzHdr, 0UL, cchRead, NULL);
-        if (rc == NO_ERROR)
+
+        /** @sketch
+         *  Read the size of a DOS (ie. MZ) header.
+         *  IF successful and more stuff in file THEN
+         *      See if this is an recognizable module binary format:
+         */
+        cbRead = min(sizeof(IMAGE_DOS_HEADER), cbFile);
+        rc = ldrRead(*phFile, 0UL, u1.pMzHdr, 0UL, cbRead, NULL);
+        if (rc == NO_ERROR && cbRead < cbFile)
         {
-            /*
-             * PE header?
-             *  - If DOS Magic is found AND a valid e_lfanew (offset of NE/LX/LE/PE header) is found
-             *  - OR if PE siganture is found.
+            /** @sketch
+             * If LX header just give up at once.
              */
-            if ((pMzHdr->e_magic == IMAGE_DOS_SIGNATURE &&
-                 pMzHdr->e_lfanew > sizeof(IMAGE_DOS_HEADER) && pMzHdr->e_lfanew < 0x04000000UL) /* Larger than 64 bytes and less that 64MB. */
-                || *(PULONG)pach == IMAGE_NT_SIGNATURE)
-            {   /*
-                 * MZ or PE header found
+            if (u1.pMzHdr->e_magic == E32MAGIC)
+                goto cleanup;
+
+            /** @sketch
+             * IF PE or MZ header THEN
+             */
+            if (u1.pMzHdr->e_magic == IMAGE_DOS_SIGNATURE
+                || u1.pNtHdrs->Signature == IMAGE_NT_SIGNATURE)
+            {
+                ULONG   offPe;          /* Offset to PE header. */
+
+                /** @sketch
+                 * ---
+                 * We now known that this is file has a MZ or a PE header. If it's
+                 * a MZ header, we might end up with no "New" header or the "New"
+                 * header might turn out to be a NE, LE, or LX header. I any of
+                 * these non PE headers occur OS/2 will take care of it, we'll do nothing.
+                 * ---
+                 * IF PE loading is disable or MZ header and e_lfanew is invalid THEN
+                 *     return (successfully) to the caller.
+                 * ENDIF
+                 * (Find the offset of the PE header while testing (offPe).)
                  */
-
-                /* if PE loading is diable return to the caller */
-                if (options.fPE == FLAGS_PE_NOT)
+                if (isPELoaderDisabled())
+                    goto cleanup;
+                if (u1.pMzHdr->e_magic == IMAGE_DOS_SIGNATURE)
                 {
-                    rfree(pszBuffer);
-                    return NO_ERROR;
+                    offPe = u1.pMzHdr->e_lfanew;
+                    if (offPe < sizeof(IMAGE_DOS_HEADER) || offPe > 0x04000000UL)
+                        goto cleanup;
                 }
-
-                /*
-                 * Read the PE header if it isn't what we allready have!
+                else
+                    offPe = 0;
+
+
+                /** @sketch
+                 * Read the PE header.
+                 * If the read failes or not PE signature, there isn't anything for us to do.
                  */
-                cchRead = sizeof(IMAGE_NT_HEADERS);
-                if (*(PULONG)pach != IMAGE_NT_SIGNATURE)
-                    rc = ldrRead(*phFile, pMzHdr->e_lfanew, pach, 0UL, cchRead, NULL);
-                else
-                    rc = ldrRead(*phFile, 0UL, pach, 0UL, cchRead, NULL);
-
-                /*
-                 * If successfully read, and a PE signature is present the continue and try load it!
-                 * Else don't do anything, simply return NO_ERROR to the caller. (probably NE or LX exec)
+                rc = ldrRead(*phFile, offPe, u1.pach, 0UL, sizeof(IMAGE_NT_HEADERS), NULL);
+                if (rc != NO_ERROR || u1.pNtHdrs->Signature != IMAGE_NT_SIGNATURE)
+                    goto cleanup_noerror;
+
+
+                /** @sketch
+                 * PE signature found!
                  */
-                if (rc == NO_ERROR && *(PULONG)pach == IMAGE_NT_SIGNATURE)
-                {   /*
-                     * PE signature found.
-                     */
-                    kprintf(("ldrOpen: PE executable...\n"));
-
-                    /*
-                     * PE2LX?
-                     *  - When PE2LX flag is set
-                     *  - OR when the MIXED flag is set and the image is with the first 64MB of memory.
-                     */
-                    if (options.fPE == FLAGS_PE_PE2LX
-                        || (options.fPE == FLAGS_PE_MIXED
-                            && !((pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL == 0UL)
-                                 && pNtHdrs->OptionalHeader.ImageBase >= 0x04000000UL /* 64MB */
-                                 )
+                kprintf(("myldrOpen-%d: PE executable...\n", cNesting));
+
+
+                /** @sketch
+                 * Use Pe2Lx?
+                 *  - When Pe2Lx flag is set
+                 *  - When the MIXED flag is set and the image isn't an executable
+                 *    above the first 64MB private limit without relocations
+                 */
+                if (isPe2LxLoaderEnabled()
+                    || (isMixedPeLoaderEnabled()
+                        && ((u1.pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL)
+                            || !(u1.pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_RELOCS_STRIPPED)
+                            || u1.pNtHdrs->OptionalHeader.ImageBase < 0x04000000UL /* 64MB */
                             )
                         )
-                    {   /*
-                         * Pe2Lx (Ring0 of course)
-                         * - Create a Pe2Lx class,
-                         * - initiate it
-                         * - Add the module to the module tree so we may find it later...
-                         * - Set the handle state to 'our'.
-                         */
-                        Pe2Lx * pPe2Lx = new Pe2Lx(*phFile);
-                        if (pPe2Lx != NULL)
+                    )
+                {   /** @sketch
+                     *  Pe2Lx (Ring0 of course)
+                     *      - Create a Pe2Lx class,
+                     *      - initiate it
+                     *      - Add the module to the module tree so we may find it later...
+                     *      - Set the (file)handle state to 'our'.
+                     *      - Set pExeModule to module pointer and loaderstate to our exe.
+                     */
+                    Pe2Lx * pPe2Lx = new Pe2Lx(*phFile);
+                    if (pPe2Lx != NULL)
+                    {
+                        rc = pPe2Lx->init(pszFilename);
+                        if (rc == NO_ERROR)
                         {
-                            rc = pPe2Lx->init(pszFilename);
+                            kprintf(("myldrOpen-%d: Successfully init of Pe2Lx object.\n", cNesting));
+                            rc = addModule(*phFile, NULL, MOD_TYPE_PE2LX, pPe2Lx);
                             if (rc == NO_ERROR)
                             {
-                                kprintf(("ldrOpen: Successfully init of Pe2Lx object.\n"));
-                                rc = addModule(*phFile, NULL, MOD_TYPE_PE2LX, pPe2Lx);
-                                if (rc == NO_ERROR)
-                                    #pragma info(notrd)
-                                    SetState(*phFile, HSTATE_OUR);
-                                    #pragma info(restore)
-                                else
-                                    kprintf(("ldrOpen: Failed to add the module. rc=%d\n"));
+                                #pragma info(notrd)
+                                SetState(*phFile, HSTATE_OUR);
+                                #pragma info(restore)
+                                if (pPe2Lx->isExe())
+                                {
+                                    setLdrStateLoadingOurEXE();
+                                    pExeModule = getModuleBySFN(*phFile);
+                                    #ifdef DEBUG
+                                    if (pExeModule == NULL)
+                                        kprintf(("myldrOpen-%d: getModuleBySFN failed when setting pExeModule! FATAL!\n", cNesting));
+                                    #endif
+                                }
                             }
                             else
-                                kprintf(("ldrOpen: Failed to init Pe2Lx object. rc=%d\n"));
-                            if (rc != NO_ERROR)
-                                delete pPe2Lx;
+                                kprintf(("myldrOpen-%d: Failed to add the module. rc=%d\n", cNesting));
                         }
                         else
-                            kprintf(("ldrOpen: Failed to allocate Pe2Lx object.\n"));
+                            kprintf(("myldrOpen-%d: Failed to init Pe2Lx object. rc=%d\n", cNesting));
+                        if (rc != NO_ERROR)
+                            delete pPe2Lx;
                     }
                     else
                     {
-                        /*
-                         * Starting of PE.EXE enable?
+                        kprintf(("myldrOpen-%d: Failed to allocate Pe2Lx object.\n", cNesting));
+                        rc = ERROR_NOT_ENOUGH_MEMORY;
+                    }
+
+                    goto cleanup;
+                }
+
+
+                /** @sketch
+                 *  Using PE.EXE to start EXE?
+                 *      - When the file is an EXE file and PE.EXE is enabled.
+                 */
+                if ((u1.pNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL) == 0UL
+                    && (options.fPE == FLAGS_PE_PE || options.fPE == FLAGS_PE_MIXED)
+                    && (isLdrStateExecPgm() || isLdrStateQAppType())
+                    )
+                {
+                    /** @sketch
+                     * PE.EXE:
+                     * Find pe.exe - look in current directory and thru the PATH.
+                     * Note! We use the read buffer (u1.p*) as a storage for the
+                     * pe.exe filename and path.
+                     */
+                    kprintf(("myldrOpen-%d: pe.exe - opening\n", cNesting));
+                    ldrClose(*phFile);
+                    strcpy(u1.pach, "PE.EXE");
+                    rc = ldrOpen(phFile, u1.pach, pfl); /* This isn't recusive! */
+                    if (rc != NO_ERROR)
+                        rc = OpenPATH(phFile, u1.pach, pfl);
+                    if (rc == NO_ERROR)
+                    {
+                        /** @sketch
+                         * If we're in tkExecPgm state we'll have to shuffle the parameters
+                         * and executable filename tkExecPgm were called with.
+                         * If not tkExecPgm we can't do anything about parameters (and there is
+                         * probably nothing to do either).
                          */
-                        if (options.fPE == FLAGS_PE_PE || options.fPE == FLAGS_PE_MIXED)
-                        {   /*
-                             * pe.exe - need the path!
-                             */
-                            kprintf(("ldrOpen: pe.exe - opening\n"));
-                            ldrClose(*phFile);
-                            rc = ldrOpen(phFile, "pe.exe", param3);  /* path....! problems! */
-                            kprintf(("ldrOpen: pe.exe - open returned with rc = %d\n", rc));
-                            rfree(pszBuffer);
-                            return rc;
+                        kprintf(("myldrOpen-%d: pe.exe - %s\n", cNesting, u1.pach));
+                        if (isLdrStateExecPgm() && fTkExecPgm)
+                        {
+                            rc = AddArgsToFront(2, ldrpFileNameBuf, achTkExecPgmFilename);
+                            if (rc == NO_ERROR)
+                            {
+                                rc = SetExecName(ldrpFileNameBuf);
+                                if (rc != NO_ERROR)
+                                    kprintf(("myldrOpen-%d: pe.exe - failed to set pe.exe as execname. rc=%d\n", cNesting));
+                            }
+                            else
+                                kprintf(("myldrOpen-%d: pe.exe - failed to add programname as argument. rc=%d\n", cNesting, rc));
+                            goto cleanup_noerror;
                         }
                     }
+                    else
+                        kprintf(("myldrOpen-%d: pe.exe - couldn't find/open pe.exe\n", cNesting));
                 }
-                rfree(pszBuffer);
-                return NO_ERROR;
+                goto cleanup;
             }
-            else
+            /** @sketch End of PE Loading. */
+
+
+            /** @sketch
+             * ELF image?
+             */
+            if (*u1.pul == ELFMAGICLSB)
             {
+                if (isELFDisabled())
+                    goto cleanup_noerror;
+
                 /*
-                 * ELF image?
+                 * ELF signature found.
                  */
-                if (pach[0] == ELFMAG0 && pach[1] == ELFMAG1 && pach[2] == ELFMAG2 && pach[3] == ELFMAG3)
+                kprintf(("myldrOpen-%d: ELF image! - not implemented yet!\n", cNesting));
+
+                /*
+                 * Do nothing more yet. NEED AN ELF LOADER!!!
+                 */
+                goto cleanup;
+            }
+
+
+            /** @sketch
+             * Java image?
+             */
+            if (*u1.pul == 0xBEBAFECAUL) //CAh FEh BAh BEh
+            {
+                char *pszName = NULL;
+                int   cchName;
+
+                if (isJAVADisabled())
+                    goto cleanup_noerror;
+
+                /** @sketch
+                 * Java signature found.
+                 * Copy the name to a temporary buffer. (only if necessary)
+                 * Remove the extention (.class) and insert a space between the name and the path.
+                 *  (This is the needed processing of the class filename to make it a classpath
+                 *   entry (path) and a class name (filename).)
+                 * Try find the java executor in current dir or PATH: java.exe
+                 */
+                kprintf(("myldrOpen-%d: Jave image!\n", cNesting));
+
+                if (isLdrStateExecPgm() && fTkExecPgm)
                 {
-                    /*
-                     * ELF signature found.
+                    /* Ooops we had to get the file name from the MFT. ldrpFileNameBuf is allways uppercased... */
+                    /* MFT seems to hold uppercased filenames! ARG! But (by pure luck?) achTkExecPgmArguments is
+                     * not uppercased (yet). Nothing could be simpler!
                      */
-                    kprintf(("ldrOpen: ELF executable! - not implemented yet!\n"));
-
-                    /*
-                     * Do nothing more yet. NEED AN ELF LOADER!!!
+                    #if 1
+                    psz3 = achTkExecPgmArguments;
+                    #elif 0
+                    psz3 = SecPathFromSFN(*phFile);
+                    if (psz3 == NULL)
+                        psz3 = ldrpFileNameBuf;
+                    #else
+                    psz3 = ldrpFileNameBuf;
+                    #endif
+                    cchName = strlen(psz3);
+                    pszName = (char*)rmalloc(cchName + 2);
+                    if (pszName == NULL)
+                    {
+                        rc = ERROR_NOT_ENOUGH_MEMORY;
+                        goto cleanup;
+                    }
+                    memcpy(pszName, psz3, cchName+1);
+
+                    psz = pszName + strlen(pszName) - 1;
+                    while (psz > pszName && *psz != '.' && *psz != '\\' && *psz != '/')
+                        psz--;
+                    if (*psz == '.')
+                    {
+                        cchName = psz - pszName;
+                        *psz-- = '\0';
+                        while (psz > pszName && *psz != '\\' && *psz != '/')
+                            psz--;
+
+                        /* check for root and evt. make room for an extra slash. */
+                        if (psz - pszName == 2)
+                        {
+                            memmove(psz + 1, psz, cchName - 1);
+                            *psz++ = '\\';
+                        }
+                    }
+                    /* check if no path */
+                    if (psz == pszName)
+                        memmove(pszName + 1, pszName, cchName + 1);
+                    *psz = ' ';
+                }
+
+                ldrClose(*phFile);
+                rc = ldrOpen(phFile, ".\\JAVA.EXE", pfl);
+                if (rc != NO_ERROR)
+                    rc = OpenPATH(phFile, "JAVA.EXE", pfl);
+                if (rc == NO_ERROR)
+                {
+                    kprintf(("myldrOpen-%d: java - %s\n", cNesting, ldrpFileNameBuf));
+
+                    /** @sketch
+                     * To be able to execute any given class name we'll have to pass in the
+                     * directory as -classpath. But -classpath seems to override the default
+                     * and environmental CLASSPATHs. So, we'll have to pass in the value of
+                     * the CLASSPATH env.var. or generate the default class path (what ever that is).
+                     *
                      */
-                    rfree(pszBuffer);
-                    return NO_ERROR;
+                    if (isLdrStateExecPgm() && fTkExecPgm)
+                    {
+                        psz = u1.pach;
+
+                        /*
+                         * Get classpath and add it as a parameter
+                         */
+                        strcpy(u1.pach, "-classpath ");
+                        psz = u1.pach + strlen(u1.pach);
+
+                        psz3 = (char*)ScanEnv(GetEnv(TRUE), "CLASSPATH");
+                        if (psz3 != NULL)
+                        {   /* environment variable set */
+                            if (strlen(psz3) > 640 - 11 - 1 - cchName) //check for overflow
+                            {   // TODO? should reallocate...
+                                memcpy(psz, psz3, 640 - 11 - 1 - cchName);
+                                psz[640 - 11 - 1 - cchName] = '\0';
+                            }
+                            else
+                                strcpy(psz, psz3);
+                            psz += strlen(psz);
+                        }
+                        else
+                        {
+                            /* Make default classpath by taking the java.exe path + '..\lib\classes.zip' */
+                            strcpy(psz, ldrpFileNameBuf);
+                            psz3 = psz + strlen(psz) - 1;
+                            while (psz3 > psz && *psz3 != '\\' && *psz3 != '/')
+                                psz3--;
+                            strcpy(++psz3, "..\\lib\\classes.zip");
+                            psz = psz3 + strlen(psz3);
+                        }
+
+                        /*
+                         * Add the class directory (as the last classpath entry) and the class name.
+                         * (Note. I may happen that there is no directory, but that don't matter
+                         *        a space is allways preceding the class name.)
+                         */
+                        *psz++ = ';';
+                        strcpy(psz, pszName);
+                        if (pszName != NULL)
+                            rfree(pszName);
+
+                        /*
+                         * Setup JAVA.EXE as executable with the parameters we've build.
+                         */
+                        rc = AddArgsToFront(2, ldrpFileNameBuf, u1.pach);
+                        kprintf(("myldrOpen-%d: java - Exe: %s  Args: %s\n", cNesting, ldrpFileNameBuf, u1.pach));
+                        if (rc == NO_ERROR)
+                        {
+                            rc = SetExecName(ldrpFileNameBuf);
+                            if (rc != NO_ERROR)
+                                kprintf(("myldrOpen-%d: java - failed to set java.exe as execname. rc=%d\n", cNesting, rc));
+                        }
+                        else
+                            kprintf(("myldrOpen-%d: java - failed to setup the parameters. rc=%d\n", cNesting, rc));
+
+                        goto cleanup_noerror;
+                    }
                 }
+                else
+                    kprintf(("myldrOpen-%d: java - couldn't find/open java.exe\n", cNesting));
+
+
+                /** @sketch
+                 *  End of Java loading. (return)
+                 */
+                if (pszName != NULL)
+                    rfree(pszName);
+                goto cleanup;
             }
+
         }
+        else
+        {
+            /** @sketch
+             *  ELSE - the reading size of a DOS header failed or file is smaller than the dos header.
+             *      IF read failed or filesize is less than 4 bytes THEN
+             *          return no_error to the caller.
+             *      ENDIF
+             */
+            #ifdef DEBUG
+            if (rc != NO_ERROR)
+            {
+                kprintf(("myldrOpen-%d: ldrRead failed cbRead=%d, cbFile=%d,  rc=%d\n", cNesting, cbRead, cbFile, rc));
+                goto cleanup_noerror;
+            }
+            if (cbRead < 4)
+            {
+                kprintf(("myldrOpen-%d: File too small! cbFile=%d\n", cNesting, cbFile));
+                goto cleanup_noerror;
+            }
+            #else
+            if (rc != NO_ERROR || cbRead < 4) //just forget files less than 4 bytes!
+                goto cleanup_noerror;
+            #endif
+        }
+        /** @sketch ENDIF (dos header read) */
+
+
 
         /*
-         * Only unreconized files and readerror passes this point!
+         * Only unreconized files passes this point!
          *
          * * Fileformats with lower priority should reside here. *
@@ -245 +528 @@
          */
 
-        /*
-         * If the initial readoperation failed try to read a smaller amount, in case it is a small script...
-         * 4 bytes is a small amount isn't it?
-         */
-        if (rc != NO_ERROR)
+        /** @sketch
+         *  UNIX styled script?
+         *      - Starts with a hash (#)
+         *      - And we're loading an EXE
+         *      - And we're either in QAppType or ExecPgm state.
+         *      - And that a bang (!) is the first char after the hash (ignoring blanks).
+         */
+        if (*u1.pach == '#'
+            && isLdrStateLoadingEXE()
+            && (isLdrStateQAppType() || isLdrStateExecPgm())
+            )
         {
-            kprintf(("ldrOpen: first ldrread failed with rc=%d. tries to read 4 byte.\n", rc));
-            cchRead = 4;
-            if ((rc = ldrRead(*phFile, 0UL, pach, 0UL, cchRead, NULL)) != NO_ERROR)
-                kprintf(("ldrOpen: second ldrread failed with rc=%d.\n ", rc));
-        }
-
-        /*
-         * Now we'll try again, UNIX styled script?
-         */
-        if (rc == NO_ERROR && *pach == '#' && pach[1] == '!')
-        {
+            if (isUNIXScriptDisabled())
+                goto cleanup_noerror;
             /*
-             * UNIX styled script?
-             * FIXME! Must be more than 64 bytes long?
-             *        No options!
-             *        Firstline < 64 bytes!
+             * Look for a bang (!). Tabs and spaces are skipped, anything else result in error.
              */
-            kprintf(("ldrOpen: unix script?\n"));
-            cchRead = min(cbFile, 256);
-            rc = ldrRead(*phFile, 0UL, pach, 0UL, cchRead, NULL);
-            if (rc == NO_ERROR)
+            psz = u1.pach + 1;
+            while ((*psz == ' ' || *psz == '\t') && psz - u1.pach < cbRead)
+                psz++;
+            if (*psz == '!')
             {
-                char *pszStart = pach+2;
-                kprintf(("ldrOpen: script debug 1\n"));
-
-                /* Make sure we don't read to much... */
-                pszBuffer[cchRead] = '\0';
-
-                /*
-                 * Skip blanks
+                /** @sketch Found UNIX styled script! */
+
+                /** @sketch
+                 * Read more of the script if necessary. (max is 256 chars (- Linux max is 127))
+                 * Terminate the string read from the file to make sure with stop somewhere!
                  */
-                pszStart = pszBuffer + 2; /* skips the "#!" stuff. */
-                while (*pszStart != '\0' && (*pszStart == ' ' || *pszStart == '\t'))
-                    pszStart++;
-                kprintf(("ldrOpen: script debug 2\n"));
-
-                /* anything left on the line? */
-                if (*pszStart != '\0' && *pszStart != '\r' && *pszStart != '\n')
+                if (cbRead < cbFile /*&& cbRead != 256*/)
                 {
-                    char *      pszEnd;         /* Pointer to the end of the string(s) when the next step is finished. */
-                    unsigned    cchToAdd = 1;   /* Chars to add */
-                    BOOL        fFirst = TRUE;  /* Set if a '\0' has not been set yet.
-                                                 * If this is clear, there are one or more parameters after the interpreter name. */
-
-                    /*
-                     * find linesize and make parameters ready for copying
+                    cbRead = min(256, cbFile);
+                    rc = ldrRead(*phFile, 0UL, u1.pach, 0UL, cbRead, NULL);
+                }
+                u1.pach[cbRead] = '\0';
+
+                if (rc == NO_ERROR)
+                {
+                    /** @sketch
+                     * Parse out filename and optional arguments (if any).
+                     * The result of the parsing is that:
+                     *      psz will point at the executable name.
+                     *      psz2 will point at the arguments.
+                     *  Both strings are trimmed.
                      */
-                    pszEnd = pszStart;
-                    kprintf(("ldrOpen: script debug 3\n"));
-                    while (*pszEnd != '\0' && *pszEnd != '\r' && *pszEnd != '\n')
+                    psz++;                                                  /* psz points to the bang, skip it. */
+                    while (*psz == ' ' || *psz == '\t')                     /* skip blanks after bang */
+                        psz++;
+                    if (*psz == '\r' || *psz == '\n' || *psz == '\0')       /* End-of-line? */
                     {
-                        if (fFirst && (*pszEnd == ' ' || *pszEnd == '\t'))
+                        kprintf(("myldrOpen-%d: script no executable name.\n", cNesting));
+                        goto cleanup_noerror; /* other error code? */
+                    }
+                    psz2 = psz + 1;                                         /* Not end-of-line, so add 1 before searching for args. */
+                    while (*psz2 != '\0' && *psz2 != '\n' && *psz2 != '\r'  /* skip executable name. */
+                           && *psz2 != ' ' && *psz2 != '\t')
+                        psz2++;
+                    while (*psz2 == ' ' || *psz2 == '\t')                    /* skip blanks after executable - pad them with '\0'! */
+                        *psz2++ = '\0';
+
+                    psz3 = psz2;
+                    while (*psz3 != '\n' && *psz3 != '\r' && *psz3 != '\0') /* find end of parameters and terminate the string. */
+                        psz3++;
+                    *psz3 = '\0';
+                    while (psz3 >= psz2 && (*psz3 == '\0' || *psz3 == ' ' || *psz3 == '\t')) /* trim args */
+                        *psz3-- = '\0';
+
+
+                    /** @sketch
+                     *  IF tkExecPgm THEN
+                     *      Correct parameters - ie. add exec name (as argv[0]),
+                     *        arguments (psz2) as argv[1+], old exec name, and finally
+                     *        the existing parameters (current argv[1+]).
+                     *      Set the executable name.
+                     *  ENDIF
+                     *  Open the new executable file recursively. (psz)
+                     */
+                    if (isLdrStateExecPgm())
+                    {
+                        if (*psz2)
+                           rc = AddArgsToFront(3, psz, psz2, achTkExecPgmFilename);
+                        else
+                           rc = AddArgsToFront(2, psz, achTkExecPgmFilename);
+                        if (rc != NO_ERROR)
                         {
-                            *pszEnd = '\0';
-                            fFirst = FALSE;
-                            if (pszEnd[1] == '\0' || pszEnd[1] == '\r' || pszEnd[1] == '\n')
-                                fFirst = TRUE;
+                            kprintf(("myldrOpen-%d: AddArgsToFront failed with rc=%d\n", cNesting));
+                            goto cleanup_noerror;
                         }
-
-                        /* next */
-                        pszEnd++;
-                        cchToAdd++;
+                        rc = SetExecName(psz);
+                        if (rc != NO_ERROR)
+                            kprintf(("myldrOpen-%d: SetExecName failed with rc=%d\n", cNesting));
                     }
-                    *pszEnd = '\0';
-                    kprintf(("ldrOpen: script debug 4\n"));
-
-                    /*
-                     * If ldrQueryApp type we don't have any ExecPgm buffer we need to mess with.
-                     * We'll simply try open the the interpreter.
-                     */
-                    if (fQAppType)
+                    ldrClose(*phFile);
+                    rc = myldrOpen(phFile, psz, pfl);
+                    if (rc != NO_ERROR)
                     {
-                        rc = ldrClose(*phFile);
-                        rc = ldrOpen(phFile, pszStart, param3); /* FIXME, recusion! check that name not equal! Use flags to prevent race? */
-                    }
-                    else
-                    {
-                        /*
-                         * Find the ExecPgm buffer.
-                         */
-                        pBuffer = QueryBufferPointerFromFilename(pszFilename);
-                        kprintf(("ldrOpen: script debug 5\n"));
-                        if (pBuffer != NULL)
+                        psz2 = psz + strlen(psz);
+                        if (psz + 4 >= psz2 || strcmp(psz2 - 4, ".EXE") != 0)
                         {
-                            unsigned cchArguments = getArgsLength(pBuffer->achArgs); /* minus the first argument. */
-                            unsigned cchScriptnameDelta = strlen(pBuffer->szFilename) - strlen(pBuffer->achArgs); /* scriptname size difference. */
-
-                            kprintf(("ldrOpen: script debug 6\n"));
-
-                            /*
-                             * Is there enough space in the struct?
-                             */
-                            if (cchArguments + cchToAdd + cchScriptnameDelta < sizeof(pBuffer->achArgs))
-                            {
-                                kprintf(("ldrOpen: script debug 7\n"));
-                                /*
-                                 * Open the interpreter.
-                                 */
-                                rc = ldrClose(*phFile);
-                                rc = ldrOpen(phFile, pszStart, param3); /* FIXME, recusion! check that name not equal! Use flags to prevent race? */
-                                if (rc == NO_ERROR)
-                                {
-                                    kprintf(("ldrOpen: script debug 8\n"));
-                                    /* Make space for the addition arguments. */
-                                    #ifdef DEBUG
-                                    char *psz = &pBuffer->achArgs[0];
-                                    int   i = 0;
-                                    while (*psz != '\0')
-                                    {
-                                        kprintf(("Arg %d: %s\n", i++, psz));
-                                        psz += 1 + strlen(psz);
-                                    }
-                                    #endif
-                                    memmove(&pBuffer->achArgs[cchToAdd + cchScriptnameDelta],
-                                            &pBuffer->achArgs[0], cchArguments);
-
-                                    /*
-                                     * Copy the arguments.
-                                     */
-                                    kprintf(("ldrOpen: script debug 8\n"));
-                                    memcpy(&pBuffer->achArgs[0], pszStart, cchToAdd); /* Interpreter with arguments */
-                                    if (!fFirst)
-                                        pBuffer->achArgs[cchToAdd - 1] = ' ';
-                                    strcpy(&pBuffer->achArgs[cchToAdd], pszFilename); /* Scriptname */
-                                    kprintf(("ldrOpen: script debug a\n"));
-
-                                    #ifdef DEBUG
-                                    psz = &pBuffer->achArgs[0];
-                                    i = 0;
-                                    while (*psz != '\0')
-                                    {
-                                        kprintf(("Arg %d: %s\n", i++, psz));
-                                        psz += 1 + strlen(psz);
-                                    }
-                                    #endif
-                                }
-                                else
-                                    kprintf(("ldrOpen: failed to open interpreter (%s), rc=%d\n", pszStart, rc));
-                            }
-                            else
-                            {
-                                kprintf(("ldrOpen: Argument buffer too small, %d\n", cchArguments + cchToAdd));
-                                rc = ERROR_BAD_EXE_FORMAT;
-                            }
+                            strcpy(psz2, ".EXE");
+                            rc = myldrOpen(phFile, psz, pfl);
+                            *psz2 = '\0';
                         }
                         else
+                            psz2 = NULL;
+
+                        //should we search the PATH??? For a starting, we'll do it.
+                        if (rc != NO_ERROR
+                            && (rc = OpenPATH(phFile, psz, pfl)) != NO_ERROR
+                            && psz2 != NULL)
                         {
-                            kprintf(("ldrOpen: QueryBufferPointerFromFilename failed.\n"));
-                            rc = ERROR_BAD_EXE_FORMAT; /*?*/
+                            *psz2 = '.';
+                            rc = OpenPATH(phFile, psz, pfl);
                         }
                     }
@@ -405 +645 @@
                 else
                 {
-                    kprintf(("ldrOpen: no interpereter on the first line.\n"));
-                    rc = ERROR_BAD_EXE_FORMAT; /*?*/
+                    kprintf(("myldrOpen-%d: script - failed to read more of the script!, rc=%d cbRead=%d cbFile=%d.\n",
+                             cNesting, rc, cbRead, cbFile));
                 }
+
+                goto cleanup;
             }
             else
             {
-                kprintf(("ldrOpen: read of min(cbFile, 256) = %d failed, rc = %d\n", cchRead, rc));
+                kprintf(("myldrOpen-%d: script - hash found but no bang (!).\n", cNesting));
             }
-        } /* else inn other formats here. */
-        rfree(pszBuffer);
-    }
+        } /**@sketch ENDIF - UNIX styled script. */
+
+
+
+        /** @sketch
+         *  REXX script?
+         *      - Starts with a REXX start comment ('/','*')
+         *      - And we're loading an EXE
+         *      - And we're either in QAppType or ExecPgm state.
+         *      - Extention:
+         *          .RX and .REX are known to be pure REXX scripts.
+         *          While .CMD has to invoked used the commandline OS2_SHELL or COMSPEC variable.
+         */
+        psz2 = pszFilename + strlen(pszFilename) - 1;
+        while (psz2 > pszFilename && *psz2 != '.')
+            psz2--;
+        if (*psz2 == '.'
+            && *u1.pach == '/' && u1.pach[1] == '*'
+            && isLdrStateLoadingEXE()
+            && (isLdrStateQAppType() || isLdrStateExecPgm())
+            && (stricmp(psz2, ".RX") == 0 || stricmp(psz2, ".REX") == 0)
+            )
+        {
+            if (isREXXScriptDisabled())
+                goto cleanup_noerror;
+
+            /** @sketch
+             * Found REXX styled script!
+             * Find the REXX interpreter. We'll use kRx.exe to execute the REXX scripts.
+             * (This interpreter could be embedded as a child of ModuleBase as it turned out
+             * to be quite small about 700 bytes.)
+             */
+            kprintf(("myldrOpen-%d: Found REXX script\n", cNesting));
+            ldrClose(*phFile);
+            psz = "KRX.EXE";
+            rc = ldrOpen(phFile, psz, pfl);
+            if (rc != NO_ERROR)
+                rc = OpenPATH(phFile, psz, pfl);
+
+            /** @sketch
+             *  IF tkExecPgm THEN
+             *      Correct parameters - ie. add exec name (as argv[0]), old exec name,
+             *        and finally the existing parameters (current argv[1+]).
+             *      Set the executable name.
+             *  ENDIF
+             */
+             if (rc == NO_ERROR && isLdrStateExecPgm())
+             {
+                 rc = AddArgsToFront(2, ldrpFileNameBuf, achTkExecPgmFilename);
+                 if (rc != NO_ERROR)
+                 {
+                     kprintf(("myldrOpen-%d: AddArgsToFront failed with rc=%d\n", cNesting));
+                     goto cleanup_noerror;
+                 }
+                 rc = SetExecName(ldrpFileNameBuf);
+                 if (rc != NO_ERROR)
+                     kprintf(("myldrOpen-%d: SetExecName failed with rc=%d\n", cNesting));
+
+                 goto cleanup_noerror;
+             }
+             goto cleanup;
+        } /**@sketch ENDIF - REXX styled script. */
+
+
+        /*
+         * Cleanup with rc set to NO_ERROR.
+         */
+    cleanup_noerror:
+        rc = NO_ERROR;
+
+        /*
+         * Cleanup without having rc set to NO_ERROR.
+         * Decrement the nesting count.
+         */
+    cleanup:
+        rfree(u1.pach);
+        cNesting--;
+    }
+    #ifdef DEBUG
+    else if (cNesting >= 3)
+        kprintf(("myldrOpen-%d: cNesting = %d, which is too deep!\n", cNesting, cNesting));
+    #endif
+
+ret:
+    /** @sketch
+     *  Return rc.
+     */
     return rc;
 }
@@ -421 +747 @@
 
 /**
- * Get the lenght of the arguments.
- * @returns   Lenght in char, includes the two '\0's.
- * @param     pachArgs  Pointer to the ASCIIZs which makes up the arguments.
- * @status    completely implemented.
+ * Adds new arguments to the front of the startup arguments for the program about to be
+ * executed.
+ *
+ * @returns   OS/2 return code.
+ * @param     cArgs     Count of arguments to add. At least 1!!!
+ * @param     ...       Pointers to the arguments to add.
+ *                      The first argument have to be the executable name. This have to the
+ *                        the only argument in the first string.
+ *                      The other arguements are space separated, so you could add a bunch
+ *                        of arguments in a single string!
+ *                      The last argument should be the old first parameter if this is to be
+ *                        preserved. The old first parameter is overwritten since it's
+ *                        normally the executable name.
+ *
+ * @status    completly implemented.
  * @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ * @remark    Implementation note:
+ *  The arguments convention is as follows:
+ *      First argument, which should be the executable name, is terminated with a '\0'.
+ *        It starts at offset 0 into the argument buffer, of course.
+ *      All other arguemnts are separated by a space and follows the immediately after the
+ *        first argument.
+ *      The arguments are terminated by a double nulltermination: '\0\0'.
  */
-static unsigned getArgsLength(const char *pachArgs)
+APIRET AddArgsToFront(int cArgs,  ...)
 {
-    unsigned    cch = 1;
-    const char *psz = pachArgs;
-
+    va_list     vaarg;                  /* Variable length argument list. */
+    int         cchOldArgs;             /* Length of the old arguments (including the first argument). */
+                                        /* cchOldArgs = 1 means no arguments. It don't include the very last '\0' */
+                                        /* (remember argumets are terminated with two '\0's). */
+    int         iSecondArg;             /* Index of the second argument. (Used to skip the first argument.) */
+                                        /* Used first on the original arguments and them when adding the first */
+                                        /* new argument. */
+    int         cchNewArgs;             /* Length of the new arguments to be inserted. */
+    int         i;                      /* Loop variable. Current function argument. */
+    char *      psz;                    /* General string pointer. */
+
+
+    /** @sketch
+     *  Assert that we're in the right state.
+     *  Calc the length of the existing parameters.
+     *  Calc the length of the new arguments to determin.
+     *  Assert that the new arguments have length > 0.
+     */
+    #ifdef DEBUG
+    if (!isLdrStateExecPgm())
+    {
+        kprintf(("AddArgsToFront: not in tkExecPgm state.\n"));
+        return ERROR_INVALID_PARAMETER;
+    }
+    #endif
+    if (!fTkExecPgm)
+    {
+        kprintf(("AddArgsToFront: called when not in tkExecPgm data is invalid!\n"));
+        return ERROR_INVALID_PARAMETER;
+    }
+
+    iSecondArg = strlen(&achTkExecPgmArguments[0]) + 1;
+    psz = &achTkExecPgmArguments[iSecondArg];
     while (*psz != '\0')
-    {
-        register unsigned cch2 = strlen(psz);
-        cch += cch2;
-        psz += cch2 + 1;
-    }
-
-    return cch;
+        psz += strlen(psz) + 1;
+    cchOldArgs = psz - &achTkExecPgmArguments[iSecondArg];
+
+    va_start(vaarg, cArgs);
+    for (cchNewArgs = i = 0; i < cArgs; i++)
+        cchNewArgs += strlen(va_arg(vaarg, char *)) + 1; /* 1 is for space or '\0'. */
+    va_end(vaarg);
+    #ifdef DEBUG
+    if (cchNewArgs == 0)
+    {
+        kprintf(("AddArgsToFront: the size of the arguments to add is zero!\n"));
+        return ERROR_INVALID_PARAMETER;
+    }
+    #endif
+
+
+    /** @sketch
+     *  Check if we have enough room for the new arguments. Fail if not enough.
+     *  Move the existing arguments to make room for the new ones.
+     *    !IMPORTANT! The first existing arguments (executable name) is skipped !IMPORTANT!
+     *    !IMPORTANT! in this move as this have to be re-added in this call!    !IMPORTANT!
+     */
+    if (cchOldArgs + cchNewArgs + 1 > CCHARGUMENTS)
+    {
+        kprintf(("AddArgsToFront: argument buffer is too small to hold the arguments to add, cchOldArgs=%d, cchNewArgs=%d\n",
+                 cchOldArgs, cchNewArgs));
+        return ERROR_BAD_ARGUMENTS;
+    }
+
+    if (cchOldArgs > 0)
+    {
+        memmove(&achTkExecPgmArguments[cchNewArgs], &achTkExecPgmArguments[iSecondArg],
+                cchOldArgs + 1);
+    }
+    else
+        achTkExecPgmArguments[cchNewArgs] = '\0';
+
+
+    /** @sketch
+     *  Copy new arguments.
+     *  Since the first argument is special case we'll do it separately. (Uses '\0' as separator.)
+     *    We assume that the entire first argument passed into this function should be the first argument!
+     *    (This don't have to be true for the other arguments since these are space separated. You could
+     *     pass in more than argument in a single string.)
+     *  Loop thru the rest of the new arguments and add them with space as separator.
+     */
+    va_start(vaarg, cArgs);
+    psz = va_arg(vaarg, char *);
+    memcpy(&achTkExecPgmArguments[0], psz, (i = strlen(psz) + 1));
+    psz = &achTkExecPgmArguments[i];
+
+    for (i = 1; i < cArgs; i++)
+    {
+        if (i > 1) *psz++ = ' ';    //Add space if not second argument.
+        strcpy(psz, va_arg(vaarg, char *));
+        psz += strlen(psz);
+    }
+    va_end(vaarg);
+    if (cchOldArgs > 0) *psz++ = ' ';    //Add space if old arguments
+
+    #ifdef DEBUG /* assertion */
+    if (psz != &achTkExecPgmArguments[cchNewArgs])
+    {
+        kprintf(("AddArgsToFront: !Assertion failed! psz didn't end up where it should! (psz -> %d should be %d)\n",
+                 psz - &achTkExecPgmArguments[0], cchNewArgs));
+        if (cchOldArgs <= 1)
+            psz[0] = psz[1] = '\0';
+    }
+    #endif
+
+    return NO_ERROR;
 }
+
+
+/**
+ * Sets the executable name of the module.
+ * This function is normally invoked after a different executable than the one requested was
+ * opened. It does _NOT_ set the new executable name as the first argument, since it is more
+ * convenient to this while calling AddArgsToFront to add other arguments.
+ *
+ * @returns   OS/2 return code.
+ * @param     pszExecName   Pointer to new executable name.
+ * @status    completly implemented.
+ * @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ * @remark    .
+ */
+APIRET SetExecName(const char *pszExecName)
+{
+    #ifdef DEBUG
+    int cch;
+    cch = strlen(pszExecName);
+    if (cch > CCHMAXPATH)
+    {
+        kprintf(("ChangeExecName: filename is too long! cch=%d. name=%s\n", cch, pszExecName));
+        return ERROR_FILENAME_EXCED_RANGE;
+    }
+    if (!isLdrStateExecPgm())
+    {
+        kprintf(("ChangeExecName: called when not in tkExecPgm state!!! FATAL ERROR!\n"));
+        return ERROR_INVALID_PARAMETER;
+    }
+    #endif
+    if (!fTkExecPgm)
+    {
+        kprintf(("ChangeExecName: called when not in tkExecPgm data is invalid!!! FATAL ERROR!\n"));
+        return ERROR_INVALID_PARAMETER;
+    }
+
+    strcpy(achTkExecPgmFilename, pszExecName);
+
+    return 0;
+}
+
+
+/**
+ * Opens a file using the PATH environment variable of the current process.
+ * @returns   OS2 return code.
+ * @param     phFile        Pointer to filehandle. The filehandle is set to the SFN for the opened
+ *                          file on successful return.
+ *                          The filehandle is 0 on failure.
+ * @param     pszFilename   Pointer to filename buffer. This will hold the filename on input.
+ *                          On successful return it holds the filepath found.
+ *                          On failiure it's undefined.
+ * @param     pfl           Some flags set by ldrOpen.
+ * @sketch    stub
+ * @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ * @remark
+ */
+APIRET OpenPATH(PSFN phFile, char *pszFilename, PULONG pfl)
+{
+    APIRET      rc;
+    USHORT      TCBFailErr_save;
+    int         cchFile;                /* Filename length + 1. */
+    const char *pszFile;                /* Pointer to filename portion. */
+    const char *pszPath = ScanEnv(GetEnv(FALSE), "PATH"); /* Current Process environment? */
+
+    /**@sketch
+     *  No PATH environment.
+     */
+    if (pszPath == NULL)
+        return ERROR_FILE_NOT_FOUND;
+
+    /**@sketch
+     * Skip any paths in the filename.
+     */
+    pszFile = pszFilename + (cchFile = strlen(pszFilename));
+    while (pszFile >= pszFilename && *pszFile != '\\' && *pszFile != '/')
+        pszFile--;
+    cchFile -= pszFile - pszFilename;
+    pszFile++;
+
+    /**@sketch
+     * We'll have to save the TCBFailErr since we don't want to cause
+     * Hard Errors while searching invalid paths, etc. (ldrOpenPath does this!)
+     */
+    TCBFailErr_save = tcbGetTCBFailErr(tcbGetCur());
+
+    /**@ sketch
+     *  Loop thru the PATH trying to open the specified file in each
+     *  directory.
+     */
+    while (*pszPath != '\0')
+    {
+        const char *  pszNext;
+        int           cchPath;
+        char          chEnd;
+        register char ch;
+
+        /*
+         * Find end of this path.
+         */
+        while (*pszPath == ' ') pszPath++; //skip leading spaces.
+        if (*pszPath == '"')
+        {
+            chEnd = '"';
+            pszPath++;
+        }
+        else
+            chEnd = ';';
+        pszNext = pszPath;
+        while ((ch = *pszNext) != chEnd && ch != '\0')
+            pszNext++;
+
+        cchPath = pszNext - pszPath;
+        if (chEnd == '"')
+        {
+            /* Skip anything between the " and the ; or string end. */
+            while ((ch = *pszNext) != ';' && ch != '\0')
+                pszNext++;
+        }
+        else
+        {
+            /* Trim the string. */
+            while (cchPath > 0 && pszPath[cchPath-1] == ' ') //??
+                cchPath--;
+        }
+
+        /*
+         *  No length? No Path! Or path'\'filename too long? => Next
+         */
+        if (cchPath > 0 && cchPath + cchFile + 1 < CCHMAXPATH)
+        {
+            static char     achFilename[CCHMAXPATH];
+            /*
+             * Build filename
+             */
+            memcpy(achFilename, pszPath, cchPath);
+            if ((ch = achFilename[cchPath - 1]) == '\\' || ch == '/')
+                cchPath--;
+            else
+                achFilename[cchPath] = '\\';
+             memcpy(&achFilename[cchPath + 1], pszFile, cchFile); /* cchFile = length + 1; hence we copy the terminator too. */
+
+            /*
+             * Try open the file.
+             */
+            rc = myldrOpen(phFile, achFilename, pfl);
+            switch (rc)
+            {
+                case ERROR_FILE_NOT_FOUND:          case ERROR_PATH_NOT_FOUND:          case ERROR_ACCESS_DENIED:           case ERROR_INVALID_ACCESS:
+                case ERROR_INVALID_DRIVE:           case ERROR_NOT_DOS_DISK:            case ERROR_REM_NOT_LIST:            case ERROR_BAD_NETPATH:
+                case ERROR_NETWORK_BUSY:            case ERROR_DEV_NOT_EXIST:           case ERROR_TOO_MANY_CMDS:           case ERROR_ADAP_HDW_ERR:
+                case ERROR_UNEXP_NET_ERR:           case ERROR_BAD_REM_ADAP:            case ERROR_NETNAME_DELETED:         case ERROR_BAD_DEV_TYPE:
+                case ERROR_NETWORK_ACCESS_DENIED:   case ERROR_BAD_NET_NAME:            case ERROR_TOO_MANY_SESS:           case ERROR_REQ_NOT_ACCEP:
+                case ERROR_INVALID_PASSWORD:        case ERROR_OPEN_FAILED:             case ERROR_INVALID_NAME:            case ERROR_FILENAME_EXCED_RANGE:
+                case ERROR_VC_DISCONNECTED:
+                    break;
+
+                case NO_ERROR:
+                    strcpy(pszFilename, achFilename);
+                default:
+                    tcbSetTCBFailErr(tcbGetCur(), TCBFailErr_save);
+                    return rc;
+            }
+        }
+        #ifdef DEBUG
+        else if (cchPath > 0)   kprintf(("OpenPATH: Path component is too long\n"));
+        #endif
+
+        /*
+         * Next
+         */
+        if (*pszNext == '\0')
+            break;
+        pszPath = pszNext + 1;
+    }
+
+
+    /*
+     * File is not found.
+     */
+    *phFile = 0;
+    tcbSetTCBFailErr(tcbGetCur(), TCBFailErr_save);
+    return ERROR_FILE_NOT_FOUND;
+}

trunk/src/win32k/ldr/myldrOpenPath.cpp

@@ -1 @@
-/* $Id: myldrOpenPath.cpp,v 1.1 2000-07-16 22:21:16 bird Exp $
+/* $Id: myldrOpenPath.cpp,v 1.2 2000-09-02 21:08:10 bird Exp $
  *
  * myldrOpenPath - ldrOpenPath used to open executables we'll override
@@ -16 +16 @@
 #define INCL_NOPMAPI
 #define INCL_OS2KRNL_TCB
+#define INCL_OS2KRNL_PTDA
 
 /*******************************************************************************
@@ -25 +26 @@
 #include <stdlib.h>
 
+#include "devSegDf.h"                   /* Win32k segment definitions. */
 #include "log.h"
 #include "dev32.h"
@@ -134 +136 @@
         else
         {
-            struct InfoSegLDT *pInfoSeg;
-            pInfoSeg = (struct InfoSegLDT *)D32Hlp_GetDOSVar(DHGETDOSV_SYSINFOSEG, 0);
-            if (pInfoSeg == NULL)
+            PPTDA   pPTDA = ptdaGetCur();
+            if (pPTDA)
             {
-                pExe = getModuleByhMTE(pInfoSeg->LIS_DI); /* LIS_DI is the same as hmod in LINFOSEG from bsedos16.h.  */
+                pExe = getModuleByhMTE(ptdaGet_ptda_module(pPTDA));
                 #ifdef DEBUG            /* While testing! */
-                kprintf(("myldrOpenPath: getModuleByhMTE returned 0x%x08 for hmod=0x%04\n",
-                         pExe, pInfoSeg->LIS_DI));
+                kprintf(("myldrOpenPath: getModuleByhMTE returned 0x%08x for hmod=0x%04x\n",
+                         pExe, ptdaGet_ptda_module(pPTDA)));
                 #endif
             }
-            #ifdef DEBUG                /* While testing! */
-            else
-                dprintf(("myldrOpenPath: D32Hlp_GetDOSVar(DHGETDOSV_SYSINFOSEG) failed.\n"));
-            #endif
         }
 

trunk/src/win32k/ldr/myldrRead.cpp

@@ -1 @@
-/* $Id: myldrRead.cpp,v 1.6 2000-01-22 18:21:02 bird Exp $
+/* $Id: myldrRead.cpp,v 1.7 2000-09-02 21:08:10 bird Exp $
  *
  * myldrRead - ldrRead.
  *
- * Copyright (c) 1998-1999 knut st. osmundsen
+ * Copyright (c) 1998-2000 knut st. osmundsen (knut.stange.osmundsen@mynd.no)
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -23 +23 @@
 #include <stdlib.h>
 
+#include "devSegDf.h"                   /* Win32k segment definitions. */
 #include "log.h"
+#include "avl.h"
 #include "dev32.h"
 #include <peexe.h>
 #include <exe386.h>
 #include "OS2Krnl.h"
+#include "ldrCalls.h"
+#include "ldr.h"
 #include "ModuleBase.h"
 #include "pe2lx.h"
-#include "avl.h"
-#include "ldrCalls.h"
-#include "ldr.h"
 
 
+/**
+ * Overloads ldrRead.
+ * @returns   OS/2 return code.
+ * @param     hFile     Filehandle to read from.
+ * @param     pvBuffer  Buffer to read into.
+ * @param     fpBuffer  This is not flags as I first though, but probably a far 16-bit pointer
+ *                      to the buffer.
+ * @param     cbToRead  Count of bytes to read.
+ * @param     pMTE
+ * @sketch    IF it's our module THEN
+ *                Get module pointer. (complain if this failes and backout to ldrRead.)
+ *                Currently - verify that it's a Pe2Lx module. (complain and fail if not.)
+ *                Invoke the read method of the module do the requested read operation.
+ *                Save pMTE if present and not save allready.
+ *            ENDIF
+ *            - backout or not our module -
+ *            forward request to the original ldrRead.
+ * @status    Completely implemented.
+ * @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ */
 ULONG LDRCALL myldrRead(
-                       SFN hFile,
-                       ULONG ulOffset,
-                       PVOID pBuffer,
-                       ULONG ulFlags ,
-                       ULONG ulBytesToRead,
-                       PMTE pMTE
-                       )
+    SFN     hFile,
+    ULONG   ulOffset,
+    PVOID   pvBuffer,
+    ULONG   fpBuffer,
+    ULONG   cbToRead,
+    PMTE    pMTE
+    )
 {
     ULONG   rc;
@@ -50 +71 @@
     {
         PMODULE pMod;
-        kprintf(("ldrRead+: hF=%+04x off=%+08x pB=%+08x fl=%+08x cb=%+04x pMTE=%+08x\n",hFile,ulOffset,pBuffer,ulFlags,ulBytesToRead,pMTE));
+        kprintf(("myldrRead: hF=%+04x off=%+08x pB=%+08x fp=%+08x cb=%+04x pMTE=%+08x\n",
+                 hFile, ulOffset, pvBuffer, fpBuffer, cbToRead, pMTE));
 
         pMod = getModuleBySFN(hFile);
@@ -59 +81 @@
                 pMod->pMTE = pMTE;
 
-            /* debug */
-            if (ulFlags != 0)
-                kprintf(("ldrRead: Warning ulFlags = 0x%x (!= 0)\n", ulFlags));
-
             if ((pMod->fFlags & MOD_TYPE_MASK) == MOD_TYPE_PE2LX)
-                rc = pMod->Data.pModule->read(ulOffset, pBuffer, ulBytesToRead, ulFlags, pMTE);
+                rc = pMod->Data.pModule->read(ulOffset, pvBuffer, fpBuffer, cbToRead, pMTE);
             else
             {
-                kprintf(("ldrRead: Invalid module type, %#x\n", pMod->fFlags & MOD_TYPE_MASK));
+                kprintf(("myldrRead: Invalid module type, %#x\n", pMod->fFlags & MOD_TYPE_MASK));
                 rc = ERROR_READ_FAULT;
             }
-            return rc;
         }
         else
-            kprintf(("ldrRead:  DON'T PANIC! - but I can't get Node ptr! - This is really an IPE!\n"));
+        {
+            kprintf(("myldrRead:  DON'T PANIC! - but I can't get Node ptr! - This is really an IPE!\n"));
+            rc = ERROR_READ_FAULT;
+        }
     }
-
-    rc = ldrRead(hFile, ulOffset, pBuffer, ulFlags, ulBytesToRead, pMTE);
-
+    else
+    {
+        rc = ldrRead(hFile, ulOffset, pvBuffer, fpBuffer, cbToRead, pMTE);
+    }
     #if 0
-    kprintf(("ldrRead:  hF=%+04x off=%+08x pB=%+08x fl=%+08x cb=%+04x pMTE=%+08x rc=%d\n",
-             hFile,ulOffset,pBuffer,ulFlags,ulBytesToRead,pMTE,rc));
+    kprintf(("myldrRead:  hF=%+04x off=%+08x pB=%+08x fp=%+08x cb=%+04x pMTE=%+08x rc=%d\n",
+             hFile, ulOffset, pvBuffer, fpBuffer, cbToRead, pMTE, rc));
     #endif
 

trunk/src/win32k/ldr/mytkExecPgm.asm

@@ -1 @@
-; $Id: mytkExecPgm.asm,v 1.10 2000-02-23 16:53:04 bird Exp $
+; $Id: mytkExecPgm.asm,v 1.11 2000-09-02 21:08:10 bird Exp $
 ;
 ; mytkExecPgm - tkExecPgm overload
@@ -10 +10 @@
 
 ;
+;   Defined Constants And Macros
+;
+CCHFILENAME     EQU 261                 ; The size of the filename buffer
+CCHARGUMENTS    EQU 1536                ; The size of the argument buffer
+CCHMAXPATH      EQU CCHFILENAME - 1     ; Max path length
+
+;
 ;   Include files
 ;
     include devsegdf.inc
 
-;
-;   Imported Functions
+
+;
+;   Imported Functions and variables.
 ;
     extrn  _g_tkExecPgm:PROC
-    extrn  AcquireBuffer:PROC
-    extrn  ReleaseBuffer:PROC
-    extrn  QueryBufferSegmentOffset:PROC
 
     ; Scans strings until empy-string is reached.
@@ -45 +50 @@
     extrn  _f_FuBuff:PROC
 
+
+    ; 32-bit memcpy. (see OS2KTK.h)
+    extrn _TKFuBuff@16:PROC
+
+    ;
+    ; LDR semaphore
+    ;
+    extrn pLdrSem:DWORD
+    extrn _LDRClearSem@0:PROC
+    extrn _KSEMRequestMutex@8:PROC
+    extrn _KSEMQueryMutex@8:PROC
+
+    ;
+    ; Loader State
+    ;
+    extrn ulLDRState:DWORD
+
+    ;
+    ; Pointer to current executable module.
+    ;
+    extrn pExeModule:DWORD
+
+    ;
+    ; DevHlp32
+    ;
+    extrn D32Hlp_VirtToLin:PROC
+
+    ;
+    ; TKSSBase (32-bit)
+    ;
+    extrn pulTKSSBase32:DWORD
+
 ;
 ;   Exported symbols
 ;
     public mytkExecPgm
-
+    public tkExecPgmCopyEnv
+
+    public fTkExecPgm
+    public achTkExecPgmFilename
+    public achTkExecPgmArguments
+
+
+
+;
+; Global data
+;
+
+; Filename and arguments buffers + environment pointer
+; from the tkExecPgm call.
+;
+; This data is only valid at isLdrStateExecPgm time
+; (and you'll have to be behind the loader semaphore of course!)
+DATA16 SEGMENT
+fTkExecPgm              db 0            ; 0 - achTkExecPgmFilename and achTkExecPgmArguments is INVALID
+                                        ; 1 - achTkExecPgmFilename and achTkExecPgmArguments is VALID.
+achTkExecPgmFilename    db CCHFILENAME dup (0)  ; The filename  passed in to tkExecPgm if (fTkExec is TRUE)
+achTkExecPgmArguments   db CCHARGUMENTS dup (0) ; The arguments passed in to tkExecPgm if (fTkExec is TRUE)
+fpachTkExecPgmEnv       dd 0            ; Far pointer to environment passed in to tkExecPgm.
+                                        ; Valid at isLdrStateExecPgm time.
+                                        ; NOTE! User data, don't touch it directly!
+DATA16 ENDS
 
 
 CODE32 SEGMENT
-
 ;;
-;
+; New implementation.
 ; @returns   same as tkExecPgm: eax, edx and carry flag
 ; @param     ax     Exec flag
@@ -65 +126 @@
 ;            may modify later if this is a UNIX shellscript or
 ;            a PE-file started by pe.exe.
-; @status
+; @status    completely implemented.
 ; @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
-; @remark
-;
-;   The buffer we are using is a C struct as follows.
-;   struct Buffer
-;   {
-;       char szFilename[261];  /* offset 0   */
-;       char achArg[1536-261]; /* offset 261 */
-;   };
+;
 ;
 mytkExecPgm PROC FAR
-pBuffer     = dword ptr -04h
-SegBuffer   = -08h
-OffBuffer   = -0Ch
-cchFilename = dword ptr -10h
-cchArgs     = dword ptr -14h
-;usExecFlag  = -18h
-;SegFilename = -1ch
-;OffFilename = -1eh
-;SegEnv      = -20h
-;OffEnv      = -22h
-;SegArg      = -24h
-;OffArg      = -26h
-
-    ASSUME CS:CODE32, DS:NOTHING, SS:NOTHING
-;    int     3
-    push    ebp
-    mov     ebp, esp
-    lea     esp, [ebp + cchArgs]
-
-    push    eax
-    push    ecx
-    push    ds
-    push    es
-    push    edi
-
-    ; parameter validations
-    mov     ax, ds                      ; pointer to filename
-    cmp     ax, 4
-    jb      mytkExecPgm_CalltkExecPgm_X1
-
-    ;
-    ; filename length
-    ;
-    mov     ax, ds
-    mov     es, ax
-    pushad
-    push    es
-    push    ds
-    mov     bx, ds
-    mov     di, dx                      ; es:di is now filename address (ds:dx).
-    push    cs                          ; Problem calling far into the calltab segement.
-    call    near ptr FLAT:_f_FuStrLen
-    movzx   ecx, cx
-    mov     [ebp+cchFilename], ecx
-    pop     ds
-    pop     es
-    popad
-    jc      mytkExecPgm_CalltkExecPgm_X1; If the FuStrLen call failed we bail out!
-
-    ;
-    ; if filename length is more that CCHMAXPATH then we don't do anything!.
-    ;
-    cmp     [ebp+cchFilename], 260
-    jae     mytkExecPgm_CalltkExecPgm_X1; length >= 260
-
-    ;
-    ; args length
-    ; Note: the arguments are a series of ASCIIZs ended by an empty string (ie. '\0').
-    ;
-    pop     edi
-    push    edi
-    xor     ecx, ecx
-    cmp     di, 4                       ; The argument might me a invalid pointer...
-    jb      mytkExecPgm_CalltkExecPgm_1
-
-    pushad
-    push    es
-    push    ds
-    mov     bx, di                      ;
-    mov     di, si                      ; bx:di -> arguments
-    push    cs                          ; Problem calling far into the calltab segement.
-    call    near ptr FLAT:_f_FuStrLenZ
-    movzx   ecx, cx
-    mov     [ebp+cchArgs], ecx
-    pop     ds
-    pop     es
-    popad
-    jc      mytkExecPgm_CalltkExecPgm_X1
-
-mytkExecPgm_CalltkExecPgm_1:
-    mov     ecx, [ebp+cchArgs]
-    add     ecx, [ebp+cchFilename]      ; filename
-    add     ecx, 3 + 260                ;  260 = new argument from a scrip file or something.
-                                        ;    3 = two '\0's and a space after added argument.
-    cmp     ecx, 1536                   ; 1536 = Buffersize.  FIXME! Define this!!!
-    jae     mytkExecPgm_CalltkExecPgm_X1; jmp if argument + file + new file > buffer size
-
-    ;
-    ; Aquire a buffer
-    ;
-    call    AcquireBuffer
-    or      eax, eax
-    jz      mytkExecPgm_CalltkExecPgm_X1; Failed to get buffer.
-    mov     [ebp+pBuffer], eax
-
-    ;
-    ; Get Segment and offset for the buffer
-    ;
-    call    QueryBufferSegmentOffset
-    mov     cx, es
-    mov     [ebp+OffBuffer], ax
-    mov     [ebp+SegBuffer], es
-    test    eax, 000570000h
-    jnz     mytkExecPgm_CalltkExecPgm_X2
-
-    ;
-    ; Copy filename to pBuffer.
-    ;
-    pushad
-    push    es
-    push    ds
-    mov     di, ax                      ; es:di  pBuffer
-    mov     si, dx
-    mov     bx, ds                      ; bx:si  Filename pointer (input ds:dx)
-    mov     ecx, [ebp+cchFilename]
-    push    cs                          ; Problem calling far into the calltab segement.
-    call    near ptr FLAT:_f_FuBuff
-    pop     ds
-    pop     es
-    popad
-    jc      mytkExecPgm_CalltkExecPgm_X2
-
-    ;
-    ; Copy Args to pBuffer + 261
-    ;
-    ; stack: edi, es, ds, ecx, eax
-    pop     edi
-    push    edi
-    add     eax, 261                    ; we'll use eax in the branch
-    cmp     di, 4
-    jb      mytkExecPgm_CalltkExecPgm_2
-    pushad
-    push    es
-    push    ds
-    mov     ecx, [ebp+cchArgs]
-    mov     bx, di                      ; ds:si -> arguments
-    mov     di, ax                      ; es:di -> buffer + 261
-    push    cs                          ; Problem calling far into the calltab segement.
-    call    near ptr FLAT:_f_FuBuff
-    pop     ds
-    pop     es
-    popad
-    jc      mytkExecPgm_CalltkExecPgm_X2
-    jmp     mytkExecPgm_CalltkExecPgm_3
-
-mytkExecPgm_CalltkExecPgm_2:
-    mov     word ptr es:[eax], 0        ; Terminate the empty string!
-
-    ;
-    ; Restore variables pushed on the stack
-    ;
-    ; stack: edi, es, ds, ecx, eax
-mytkExecPgm_CalltkExecPgm_3:
-    pop     edi
-    pop     es
-    pop     ds
-    pop     ecx
-    pop     eax
-
-    ;
-    ; Set new input parameters (call _g_tkExecPgm)
-    ;
-    ; ds:dx is to become SegBuffer:OffBuffer
-    ; di:si is to become SegBuffer:OffBuffer+261
-    ;
-    ; The some of the old values are stored on the stack (for the time being)
-    push    ds
-    push    edi
-    push    esi
-
-    mov     di, [ebp+SegBuffer]
-    mov     ds, di
-    mov     si, [ebp+OffBuffer]
-    mov     dx, si                      ; ds:dx  SegBuffer:OffBuffer
-    add     si, 261                     ; di:si  SegBuffer:OffBuffer+261
-
-    ;
-    ; Call _g_tkExecPgm
-    ;
-    push    cs                          ; Problem calling far into the calltab segement.
-    call    near ptr FLAT:_g_tkExecPgm
-    pushfd
-
-    ;
-    ; Release buffer
-    ;
-    push    eax
-    mov     eax, [ebp + pBuffer]
-    call    ReleaseBuffer
-    mov     [ebp + pBuffer], 0
-    pop     eax
-
-    ;
-    ; Return
-    ;
-    popfd
-    pop     esi
-    pop     edi
-    pop     ds
-    leave
-    retf
-
-mytkExecPgm_CalltkExecPgm_X2:
-    ;
-    ; Release buffer
-    ;
-    mov     eax, [ebp + pBuffer]
-    call    ReleaseBuffer
-    mov     [ebp + pBuffer], 0
-
-mytkExecPgm_CalltkExecPgm_X1:
-    pop     edi
-    pop     es
-    pop     ds
-    pop     ecx
-    pop     eax
-
-mytkExecPgm_CalltkExecPgm:
-    push    cs
-    call    near ptr FLAT:_g_tkExecPgm
-    leave
-    retf
-mytkExecPgm ENDP
-
-
-
-CODE32 ENDS
-
-if 0 ; alternate implementation.
-mytkExecPgm PROC FAR
-pBuffer     = dword ptr -04h
-SegBuffer   = -08h
-OffBuffer   = -0Ch
-cchFilename = -10h
-cchArgs     = -14h
-usExecFlag  = -18h
-SegFilename = -1ch
-OffFilename = -1eh
-SegEnv      = -20h
-OffEnv      = -22h
-SegArg      = -24h
-OffArg      = -26h
+cchFilename = -4h
+cchArgs     = -08h
+usExecFlag  = -0ch
+SegFilename = -10h
+OffFilename = -12h
+SegEnv      = -14h
+OffEnv      = -16h
+SegArg      = -18h
+OffArg      = -1ah
 
     ASSUME CS:CODE32, DS:NOTHING, SS:NOTHING
@@ -325 +146 @@
     lea     esp, [ebp + OffArg]
 
-    ; save input parameters
+    ;
+    ; Save input parameters
+    ;
     mov     [ebp + usExecFlag], ax
     mov     ax, es
@@ -332 +155 @@
     mov     [ebp + SegArg], di
     mov     [ebp + OffArg], si
-    mov     ax, ds
-    mov     [ebp + SegFilename], ax
+    mov     bx, ds
+    mov     [ebp + SegFilename], bx
     mov     [ebp + OffFilename], dx
 
-    ; parameter validations
-    cmp     ax, 4                       ; pointer to filename
-    jb      mytkExecPgm_CalltkExecPgm_X1
-
-    ;
-    ; filename length
-    ;
-    mov     bx, ax
+    ;
+    ; Parameter validations - if any of these fail we'll just pass on to
+    ; the real tkExecPgm without setting up any buffers stuff.
+    ; 1) validate the file pointer.
+    ; 2) validate the file name length < 260
+    ; 3) validate that the arguments aren't larger than the buffer.
+    ;
+
+    ; Validate filename pointer
+    ;
+    cmp     bx, 4                       ; pointer to filename
+    jb      tkepgm_backout
+
+    ; Validate filename length
+    ;
     mov     di, dx                      ; bx:di is now filename address
     push    cs                          ; Problem calling far into the calltab segement.
     call    near ptr FLAT:_f_FuStrLen
-    jc      mytkExecPgm_CalltkExecPgm_X1; If the FuStrLen call failed we bail out!
-
-    ;
+    jc      tkepgm_backout              ; If the FuStrLen call failed we bail out!
+
     ; if filename length is more that CCHMAXPATH then we don't do anything!.
-    ;
-    cmp     cx, 260
-    jae     mytkExecPgm_CalltkExecPgm_X1; length >= 260
-    mov     [ebp+cchFilename], cx
+    cmp     cx, CCHMAXPATH
+    jae     tkepgm_backout              ; length >= CCHMAXPATH
+    mov     [ebp + cchFilename], cx
 
     ;
@@ -360 +188 @@
     ; Note: the arguments are a series of ASCIIZs ended by an empty string (ie. '\0').
     ;
-    mov     bx, [ebp+SegArg]
+    xor     cx, cx                      ; Set length to zero.
+    mov     bx, [ebp + SegArg]
     cmp     bx, 4                       ; The argument might me an NULL pointer
-    xor     cx, cx
-    jb      mytkExecPgm_CalltkExecPgm_1
-
-    mov     di, [ebp+OffArg]            ; bx:di -> arguments
+    jb      tkepgm1
+
+    mov     di, [ebp + OffArg]          ; bx:di -> arguments
     push    cs                          ; Problem calling far into the calltab segement.
     call    near ptr FLAT:_f_FuStrLenZ
-    mov     [ebp+cchArgs], cx
-    jc      mytkExecPgm_CalltkExecPgm_X1
-
-mytkExecPgm_CalltkExecPgm_1:
-    add     cx, [ebp+cchFilename]       ; filename length
-    add     cx, 3 + 260                 ;  260 = new argument from a scrip file or something.
+    jc      tkepgm_backout
+
+tkepgm1:
+    mov     [ebp + cchArgs], cx
+    add     cx, [ebp + cchFilename]     ; filename length
+    add     cx, 3 + 260                 ;  260 = additional arguments from a script file or something.
                                         ;    3 = two '\0's and a space after added argument.
-    cmp     ecx, 1536                   ; 1536 = Buffersize.  FIXME! Define this!!!
-    jae     mytkExecPgm_CalltkExecPgm_X1; jmp if argument + file + new file > buffer size
-
-    ;
-    ; Aquire a buffer
-    ;
-    call    AcquireBuffer
-    mov     [ebp+pBuffer], eax
-    or      eax, eax
-    jz      mytkExecPgm_CalltkExecPgm_X1; Failed to get buffer.
-
-    ;
-    ; Get Segment and offset for the buffer
-    ;
-    call    QueryBufferSegmentOffset
-    mov     cx, es
-    mov     [ebp+OffBuffer], ax
-    mov     [ebp+SegBuffer], es
-    test    eax, 000570000h
-    jnz     mytkExecPgm_CalltkExecPgm_X2
-
-    ;
-    ; Copy filename to pBuffer.
-    ;
-    mov     di, ax                      ; es:di  pBuffer
-    mov     si, dx
-    mov     bx, ds                      ; bx:si  Filename pointer (input ds:dx)
-    mov     cx, [ebp+cchFilename]       ; cx = length of area to copy
+    cmp     cx, CCHARGUMENTS            ; argument Buffersize.
+    jae     tkepgm_backout              ; jmp if argument + file + additional arguments >= buffer size
+
+
+    ;
+    ; Aquire the OS/2 loader semaphore
+    ;   Since parameters looks good, we're ready for getting the loader semaphore.
+    ;   We use the loader semaphore to serialize access to the win32k.sys loader
+    ;   subsystem.
+    ;   Before we can get the loader semaphore, we'll need to set ds and es to
+    ;   flat R0 context.
+    ;   The loader semaphore is later requested by the original tkExecPgm so
+    ;   this shouldn't break anything.
+    ;
+    mov     ax, seg FLAT:DATA32
+    mov     ds, ax
+    mov     es, ax
+    ASSUME  DS:FLAT, ES:FLAT
+
+    mov     eax, pLdrSem                ; Get pointer to the loader semaphore.
+    or      eax, eax                    ; Check if null. (paranoia)
+    jz      tkepgm_backout              ; Fail if null.
+
+    push    0ffffffffh                  ; Wait indefinitely.
+    push    eax                         ; Push LdrSem address (which is the handle).
+    call    near ptr FLAT:_KSEMRequestMutex@8
+    or      eax, eax                    ; Check if failed.
+    jnz     tkepgm_backout              ; Backout on failure.
+
+
+    ;
+    ; From here on we won't backout to the tkepgm_backout lable but
+    ; the tkepgm_backout2 lable. (This will restore the parameters
+    ; and jump in at the call to tkExecPgm behind the Loader Sem.)
+    ;
+
+
+    ;
+    ; Set global data:
+    ;   Zeros pointer to exemodule to NULL (a bit paranoia).
+    ;   Mark global data valid.
+    ;   Store Environment pointer.
+    ;   Set loader state.
+    ;
+    mov     pExeModule, 0               ; Sets the exemodule pointer to NULL.
+    mov     fTkExecPgm, 1               ; Optimistic, mark the global data valid.
+    mov     eax, [ebp + OffEnv]         ; Environment FAR pointer.
+    mov     fpachTkExecPgmEnv, eax      ; Store the Environment pointer. This will
+                                        ; later permit us to get the passed in
+                                        ; environment in for ex. ldrOpenPath.
+    mov     ulLDRState, 1               ; Set the loader state to LDRSTATE_TKEXECPGM!
+    ASSUME  DS:NOTHING, ES:NOTHING
+
+
+    ;
+    ; Copy filename to achBuffer.
+    ;
+    mov     di, seg achTkExecPgmFilename
+    mov     es, di
+    mov     edi, offset achTkExecPgmFilename
+                                        ; es:(e)di -> &achTkExecPgmFilename[0]
+    mov     si, [ebp + OffFilename]
+    mov     bx, [ebp + SegFilename]     ; bx:si  Filename pointer (input ds:dx)
+    ASSUME DS:NOTHING
+    mov     cx, [ebp + cchFilename]     ; cx = length of area to copy
     push    cs                          ; Problem calling far into the calltab segement.
     call    near ptr FLAT:_f_FuBuff
-    jc      mytkExecPgm_CalltkExecPgm_X2
-
-    ;
-    ; Copy Args to pBuffer + 261
-    ;
-    mov     si, [ebp+SegArg]
-    cmp     si, 4
-    jb      mytkExecPgm_CalltkExecPgm_2
-    mov     ds, si
-    mov     si, [ebp+OffArg]            ; ds:si -> arguments
-    mov     di, [ebp+SegBuffer]
+    jc      tkepgm_backout2             ; In case of error back (quite unlikely).
+
+
+    ;
+    ; Copy Args to achTkExecPgmArguments
+    ;
+    mov     di, seg achTkExecPgmArguments
     mov     es, di
-    mov     di, [ebp+OffBuffer]
-    add     di, 261                     ; es:di -> buffer + 261
-    mov     cx, [ebp+cchArgs]           ; cx = length of area to copy
+    mov     edi, offset achTkExecPgmArguments
+                                        ; es:(e)di -> &achTkExecPgmArguments[0]
+    mov     word ptr es:[edi], 0        ; Terminate the argument string in case
+                                        ; there aren't any arguments.('\0\0')
+                                        ; (We're just about to find that out.)
+    mov     bx, [ebp + SegArg]
+    cmp     bx, 4                       ; Is the argument pointer a null-pointer?
+    jb      tkepgm_setup_parms          ; Skip copy if null pointer.
+                                        ; Argument string is '\0\0'.
+    mov     si, [ebp + OffArg]          ; bx:si -> arguments
+    mov     cx, [ebp + cchArgs]         ; cx = length of area to copy
     push    cs                          ; Problem calling far into the calltab segement.
     call    near ptr FLAT:_f_FuBuff
-    jc      mytkExecPgm_CalltkExecPgm_X2
-    jmp     mytkExecPgm_CalltkExecPgm_3
-
-mytkExecPgm_CalltkExecPgm_2:
-    mov     word ptr es:[eax], 0        ; Terminate the empty string!
-
-    ;
-    ; Set new input parameters (call _g_tkExecPgm)
-    ;
-    ; ds:dx is to become SegBuffer:OffBuffer
-    ; di:si is to become SegBuffer:OffBuffer+261
-    ;
-mytkExecPgm_CalltkExecPgm_3:
-    mov     di, [ebp+SegBuffer]
-    mov     ds, di
-    mov     si, [ebp+OffBuffer]
-    mov     dx, si                      ; ds:dx  SegBuffer:OffBuffer
-    add     si, 261                     ; di:si  SegBuffer:OffBuffer+261
-    mov     bx, [ebp+SegEnv]
+    jc      tkepgm_backout2             ; In case of error back (quite unlikely).
+
+
+    ;
+    ; Setup new input parameters (call _g_tkExecPgm)
+    ;
+    ; ds:dx is to become &achTkExecPgmFilename[0]
+    ; di:si is to become &achTkExecPgmArguments[0]
+    ;
+tkepgm_setup_parms:
+    mov     ax, [ebp + usExecFlag]
+    mov     di, seg achTkExecPgmArguments
+    mov     esi, offset achTkExecPgmArguments ; di:si  &achTkExecPgmArguments[0]
+    mov     ds, di                            ; Assumes same segment (which of course is true).
+    mov     edx, offset achTkExecPgmFilename  ; ds:dx  &achTkExecPgmFilename[0]
+    mov     bx, [ebp + SegEnv]
     mov     es, bx
-    mov     bx, [ebp+SegEnv]
+    mov     bx, [ebp + OffEnv]                ; es:bx  Environment
+
 
     ;
     ; Call _g_tkExecPgm
     ;
+tkepgm_callbehind:
     push    cs                          ; Problem calling far into the calltab segement.
     call    near ptr FLAT:_g_tkExecPgm
-    pushfd
-
-    ;
-    ; Release buffer
-    ;
-    push    eax
-    mov     eax, [ebp + pBuffer]
-    call    ReleaseBuffer
-    mov     [ebp + pBuffer], 0
-    pop     eax
-
-    ;
-    ; Return
-    ;
-    push    [ebp + SegFilename]
+    pushfd                              ; preserve flags
+    push    eax                         ; preserve result.
+    push    ecx                         ; preserve ecx just in case
+    push    edx                         ; preserve edx just in case
+    mov     ax, seg FLAT:DATA32
+    mov     ds, ax
+    mov     es, ax
+    ASSUME  ds:FLAT, es:FLAT            ; both ds and es are now FLAT
+
+
+    ;
+    ; Clear loader semaphore?
+    ; and clear loader state, current exe module and tkExecPgm global data flag.
+    ;
+    push    0                           ; Usage count variable.
+    mov     eax, pulTKSSBase32          ; Get TKSSBase
+    mov     eax, [eax]
+    add     eax, esp                    ; Added TKSSBase to the usage count pointer
+    push    eax                         ; Push address of usage count pointer.
+    push    pLdrSem                     ; Push pointer to loader semaphore ( = handle).
+    call    near ptr FLAT:_KSEMQueryMutex@8
+    or      eax, eax                    ; Check return code. (1 = our / free; 0 = not our but take)
+    pop     eax                         ; Pops usage count.
+    je      tkepgm_callbehindret        ; jmp if not taken by us (rc=FALSE).
+    or      eax, eax                    ; Check usage count.
+    jz      tkepgm_callbehindret        ; jmp if 0 (=free).
+    mov     ulLDRState, 0               ; Clears loaderstate. (LDRSTATE_UNKNOWN)
+    mov     pExeModule, 0               ; Sets the exemodule pointer to NULL.
+    mov     fTkExecPgm, 0               ; Marks global data invalid.
+    call    near ptr FLAT:_LDRClearSem@0
+
+    ;
+    ; Restore ds and es (probably unecessary but...) and Return
+    ;
+tkepgm_callbehindret:
+    push    dword ptr [ebp + SegFilename]
     pop     ds
-    push    [ebp + SegEnv]
+    push    dword ptr [ebp + SegEnv]
     pop     es
-    popfd
+    pop     edx                         ; restore edx
+    pop     ecx                         ; restore ecx
+    pop     eax                         ; restore result.
+    popfd                               ; restore flags
     leave
     retf
 
-mytkExecPgm_CalltkExecPgm_X2:
-    ;
-    ; Release buffer
-    ;
-    mov     eax, [ebp + pBuffer]
-    call    ReleaseBuffer
-    mov     [ebp + pBuffer], 0
-
-mytkExecPgm_CalltkExecPgm_X1:
-    pop     ds
+
+;
+; This is a backout were tkExecPgm probably will backout and we're
+; allready behind the loader semaphore.
+;
+tkepgm_backout2:
+    ;
+    ; Set Flat context and invalidate buffer.
+    ;
+    mov     ax, seg FLAT:DATA32
+    mov     ds, ax
+    ASSUME ds:FLAT
+    mov     fTkExecPgm, 0               ; Marks global data invalid.
+
+    ;
+    ; Restore parameters. and call the original tkExecPgm
+    ;
+    mov     ax, [ebp + usExecFlag]
+    mov     dx, [ebp + SegFilename]
+    mov     ds, dx
+    mov     dx, [ebp + OffFilename]
+    mov     bx, [ebp + SegEnv]
+    mov     es, bx
+    mov     bx, [ebp + OffEnv]
+    mov     di, [ebp + SegArg]
+    mov     si, [ebp + OffArg]
+    jmp     tkepgm_callbehind
+
+
+;
+; This is a backout were tkExecPgm too is exspected to back out.
+;
+tkepgm_backout:
+    ;
+    ; Restore parameters. and call the original tkExecPgm
+    ;
+    mov     ax, [ebp + usExecFlag]
+    mov     dx, [ebp + SegFilename]
+    mov     ds, dx
+    mov     dx, [ebp + OffFilename]
+    mov     bx, [ebp + SegEnv]
+    mov     es, bx
+    mov     bx, [ebp + OffEnv]
+    mov     di, [ebp + SegArg]
+    mov     si, [ebp + OffArg]
 
 mytkExecPgm_CalltkExecPgm:
-    push    cs
+    push    cs                          ; Problem calling far into the calltab segement.
     call    near ptr FLAT:_g_tkExecPgm
     leave
@@ -489 +416 @@
 mytkExecPgm ENDP
 
+
+
+;;
+; Function which copies the environment data passed into tkExecPgm
+; to a given buffer.
+; @cproto    ULONG _Optlink tkExecPgmCopyEnv(char *pachBuffer, unsigned cchBuffer);
+; @returns   OS/2 return code - NO_ERROR on success.
+;            0 on error or no data.
+; @param     pachBuffer     Pointer to buffer which the environment data is
+;                           to be copied to.
+;                           (eax)
+; @param     cchBuffer      Size of the buffer.
+;                           (edx)
+; @uses      eax, edx, ecx
+; @sketch
+; @status
+; @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+; @remark
+tkExecPgmCopyEnv PROC NEAR
+cchEnv  = -04h
+    ASSUME ds:FLAT, es:FLAT, ss:NOTHING
+    push    ebp
+    mov     ebp, esp
+    lea     esp, [ebp + cchEnv]
+
+    push    ebx
+    mov     ebx, eax                    ; ebx now holds the buffer pointer.
+
+    ;
+    ; Call tkExecPgmEnvLength to get length and check that pointer is valid.
+    ;
+    push    edx
+    call    tkExecPgmEnvLength
+    pop     ecx                         ; ecx now holds the buffer length.
+
+    cmp     eax, 0
+    ja      tkepce_ok1
+    mov     eax, 232                    ; ERROR_NO_DATA
+    jmp     tkepce_ret                  ; Fail if no data or any other error.
+
+tkepce_ok1:
+    cmp     eax, ecx                    ; (ecx is the buffer size.)
+    jbe     tkepce_ok2                  ; Fail if buffer too small.
+    mov     eax, 111                    ; ERROR_BUFFER_OVERFLOW
+    jmp     tkepce_ret
+
+tkepce_ok2:
+    mov     [ebp + cchEnv], eax         ; Save environment length.
+
+
+    ;
+    ; Thunk the environment 16-bit far pointer to 32-bit.
+    ;
+    mov     eax, fpachTkExecPgmEnv
+    call    D32Hlp_VirtToLin
+    or      eax, eax                    ; check if thunking were successful.
+    jnz     tkepce_ok3                  ; Jump if success.
+    mov     eax, edx                    ; A special feature for D32Hlp_VirtToLin is that edx
+                                        ; have the error code in case on failure.
+    jmp tkepce_ret
+
+tkepce_ok3:
+    ;
+    ; Copy the environment data.
+    ;
+    push    3                           ; Fatal if error.
+    push    dword ptr [ebp + cchEnv]    ; Number of bytes to copy
+    push    eax                         ; Source buffer pointer. (user)
+    push    ebx                         ; Target buffer pointer.
+    call    near ptr FLAT:_TKFuBuff@16
+
+tkepce_ret:
+    pop     ebx
+    leave
+    ret
+tkExecPgmCopyEnv ENDP
+
+
+
+;;
+; This function gets the length of the tkExecPgm environment data.
+; @cproto    ULONG _Optlink tkExecPgmEnvLength(void);
+; @returns   Environment data length in bytes.
+; @uses      eax, edx, ecx
+; @sketch
+; @status
+; @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+; @remark
+tkExecPgmEnvLength PROC NEAR
+    ASSUME ds:FLAT, es:FLAT, ss:NOTHING
+    push    ebp
+    mov     ebp, esp
+
+    ;
+    ; Push register which needs to be presered.
+    ;
+    push    es
+    push    ds
+    push    esi
+    push    edi
+    push    ebx
+
+
+    ;
+    ; Check that the data is valid.
+    ;
+    cmp     ulLDRState, 1               ; LDRSTATE_TKEXECPGM
+    jnz     tkepel_err_ret
+
+
+    ;
+    ; Check if the environment pointer is NULL.
+    ;
+    mov     ebx, fpachTkExecPgmEnv
+    ror     ebx, 16
+    cmp     bx, 4
+    jb      tkepel_err_ret
+
+
+tkepel1:
+    ;
+    ; Get the environment length
+    ;
+    mov     edi, ebx
+    ror     edi, 16                     ; bx:di -> [fpachTkExecPgmEnv]
+    xor     ecx, ecx
+    push    cs                          ; Problem calling far into the calltab segement.
+    call    near ptr FLAT:_f_FuStrLenZ
+    jc      tkepel_err_ret
+    movzx   eax, cx
+    jmp     tkepel_ret
+
+
+; Failure
+tkepel_err_ret:
+    xor     eax, eax
+
+
+; Return
+tkepel_ret:
+    pop     ebx                         ; restore registers
+    pop     edi
+    pop     esi
+    pop     ds
+    pop     es
+    leave
+    ret
+tkExecPgmEnvLength ENDP
+
+
+
+
+
 CODE32 ENDS
-endif