#include <string.h>
#define INCL_OS2V20_TASKING
#define INCL_OS2V20_MEMORY
#define INCL_OS2V20_FILESYS
#define INCL_DOSERRORS
#include "bseerr.h"
#include <os2ssrtl.h>
#include "os2defp.h"
#include "mi.h"
#define FOR_EXEHDR 1
#include "newexe.h"
#include "exe386.h"
#include "ldrvars.h"
#include <ldrxport.h>
#include <os2tile.h>
#include <os2file.h>
#include <os2ldr.h>
USHORT LDRDoscallsSel;
PVOID LDRNEHeap;
CHAR ldrLibPathBuf[1024];
PCHAR ldrpLibPath = ldrLibPathBuf;
ULONG SizeOfldrLibPathBuf = sizeof(ldrLibPathBuf);
char LdrBuf[MAXPATHLEN+14]; // 14 is for the '\OS2SS\DRIVES\'
char *pheaderbuf;
ldrmte_t *mte_h = NULL; /* head of linked mte list */
ldrmte_t *program_h = NULL; /* head of list of program modules */
ldrmte_t *program_l = NULL; /* tail of list of program modules */
ldrmte_t *global_h = NULL; /* head of list of global modules */
ldrmte_t *global_l = NULL; /* tail of list of global modules */
ldrmte_t *specific_h = NULL; /* head of list of specific modules */
ldrmte_t *specific_l = NULL; /* tail of list of specific modules */
ushort_t ldrInitCallGate; /* first selector of call gate obj */
ulong_t ldrMINSEGPACKCNT = 5;
ulong_t ldrMINPGPACKSIZE = 0xf00; /* 4k-256 */
ulong_t ldrMAXSEGPACKSIZE = 32768; /* 32K */
ldrlibi_t *pldrLibiRecord = NULL;
ULONG *pldrLibiCounter = NULL;
PUCHAR ldrSrcModNameBuf = NULL;
ushort_t ldrSrcModNameBufL = 0;
PUCHAR ldrTgtModNameBuf = NULL;
ushort_t ldrTgtModNameBufL = 0;
PUCHAR ldrProcNameBuf = NULL;
ushort_t ldrProcNameBufL = 0;
#if PMNT
PUCHAR ldrSaveSrcModNameBuf = NULL;
ushort_t ldrSaveSrcModNameBufL = 0;
PUCHAR ldrSaveTgtModNameBuf = NULL;
ushort_t ldrSaveTgtModNameBufL = 0;
PUCHAR ldrSaveProcNameBuf = NULL;
ushort_t ldrSaveProcNameBufL = 0;
int ldrSaveRc = 0;
#endif
HANDLE R2XferSegHandle;
PSTRING pErrText;
ldrmte_t acscallmte;
ldrsmte_t acscallsmte;
ldrmte_t kbdcallmte;
ldrsmte_t kbdcallsmte;
ldrmte_t maicallmte;
ldrsmte_t maicallsmte;
ldrmte_t moncallmte;
ldrsmte_t moncallsmte;
ldrmte_t moucallmte;
ldrsmte_t moucallsmte;
ldrmte_t msgcallmte;
ldrsmte_t msgcallsmte;
ldrmte_t namcallmte;
ldrsmte_t namcallsmte;
ldrmte_t apicallmte;
ldrsmte_t apicallsmte;
ldrmte_t oemcallmte;
ldrsmte_t oemcallsmte;
ldrmte_t nlscallmte;
ldrsmte_t nlscallsmte;
#ifndef PMNT
ldrmte_t pmscallmte;
ldrsmte_t pmscallsmte;
ldrmte_t pmwcallmte;
ldrsmte_t pmwcallsmte;
ldrmte_t os2smcallmte;
ldrsmte_t os2smcallsmte;
#endif
ldrmte_t quecallmte;
ldrsmte_t quecallsmte;
ldrmte_t sescallmte;
ldrsmte_t sescallsmte;
#ifdef PMNT
ldrmte_t pmntcallmte;
ldrsmte_t pmntcallsmte;
#endif
ldrmte_t viocallmte;
ldrsmte_t viocallsmte;
#ifdef DBCS
// MSKK Dec.15.1992 V-AkihiS
// Support IMMON API
ldrmte_t imdaemonmte;
ldrsmte_t imdaemonsmte;
#endif
//BUGBUG - used to assign selector's till LDT defined
ushort_t UserGDTSelector=0x93;
ulong_t LdrSaveStack;
/*
* this table is used to validate and update pointer in the MTE in
* mtevalidateptrs
* ******* NOTE: ********
* If the entry in the array for the resource table changes you need to
* also change the define rsrcvalidatetbl
*/
ushort_t validatetbl[] = {
FIELDOFFSET(ldrsmte_t, smte_expdir), /* export directory */
FIELDOFFSET(ldrsmte_t, smte_impdir), /* import directory */
FIELDOFFSET(ldrsmte_t, smte_fixtab), /* fixup table */
FIELDOFFSET(ldrsmte_t, smte_rsrctab), /* resource table */
FIELDOFFSET(ldrsmte_t, smte_iat), /* 16-bit imp proc table */
ENDMTETBL, /* MUST BE AT END OF TABLE */
};
/*
* This table is used to copy the linker EXE formated header to the loader
* Resident MTE format in place.
*/
struct etmt_s ExeToResMTETbl[] = {
{
FIELDOFFSET(struct e32_exe, e32_magic), /* Magic number and usecnt */
},
{
FIELDOFFSET(struct e32_exe, e32_mflags), /* Module flags */
},
{
(USHORT) SKIPCOPY, /* # entries in Imp Mod Tbl */
},
{
(USHORT) SKIPCOPY, /* mte_modptrs */
},
{
(USHORT) SKIPCOPY, /* mte_modname */
},
{
(USHORT) SKIPCOPY, /* mte_handle and mte_sfn */
},
{
(USHORT) SKIPCOPY, /* mte_link */
},
{
(USHORT) SKIPCOPY, /* mte_swapmte */
},
{
ENDMTETBL, /* MUST BE AT END OF TABLE */
}
};
/*
* This table is used to copy the linker EXE formated header to the
* (LE) loader Swappable MTE format.
*/
struct etmt_s ExeTo32SwapMTETbl[] = {
{
FIELDOFFSET(struct e32_exe, e32_entryrva), /* Extended IP */
},
{
(USHORT) SKIPCOPY, /* stack object */
},
{
FIELDOFFSET(struct e32_exe, e32_stackmax), /* committed stack */
},
{
FIELDOFFSET(struct e32_exe, e32_objtab), /* Object table offset */
},
{
FIELDOFFSET(struct e32_exe, e32_objcnt), /* Object table count */
},
{
(USHORT) SKIPCOPY, /* Offset of fixup page map */
},
{
FIELDOFFSET(struct e32_exe, e32_unit[EXP].rva),/* Offset of Export Tb */
},
{
FIELDOFFSET(struct e32_exe, e32_unit[IMP].rva),/* Offset of Import Tb */
},
{
FIELDOFFSET(struct e32_exe, e32_unit[FIX].rva),/* Offset of Fixup Tb */
},
{
FIELDOFFSET(struct e32_exe, e32_unit[RES].rva),/* Offset of resource Tb */
},
{
(USHORT) SKIPCOPY, /* Count of resources */
},
{
FIELDOFFSET(struct e32_exe, e32_filealign), /* Alignment factor */
},
{
FIELDOFFSET(struct e32_exe, e32_vbase), /* load address of module */
},
{
FIELDOFFSET(struct e32_exe, e32_heapmax), /* Maximum heap size */
},
{
(USHORT) SKIPCOPY, /* skip autods */
},
{
(USHORT) SKIPCOPY, /* skip iat pointer */
},
{
FIELDOFFSET(struct e32_exe, e32_unit[DEB].rva),/* Offset of Debug info */
},
{
FIELDOFFSET(struct e32_exe, e32_unit[DEB].size),/* Size of debug info */
},
{
(USHORT) SKIPCOPY, /* skip delta size */
},
{
(USHORT) SKIPCOPY, /* skip cache pointer */
},
{
(USHORT) SKIPCOPY, /* skip pathname pointer */
},
{
(USHORT) SKIPCOPY, /* skip pathname length */
}, /* and skip dyn trace count */
{
(USHORT) SKIPCOPY, /* skip semaphore count */
}, /* and skip semaphore owner */
{
(USHORT) SKIPCOPY, /* 16-bit non-res tb offset */
},
{
(USHORT) SKIPCOPY, /* 16-bit size of non-res table */
},
{
(USHORT) SKIPCOPY, /* 16-bit count of segs to pack */
},
{
(USHORT) SKIPCOPY, /* 16-bit size of obj for seg pack */
},
{
(USHORT) SKIPCOPY, /* 16-bit VA of seg packed obj */
},
{
(USHORT) SKIPCOPY, /* zero and skip copy of NEflags */
}, /* and smte_NEexpver */
{
(USHORT) SKIPCOPY, /* zero and skip copy of NEexetype */
}, /* and smte_NEflagsothers */
{
ENDMTETBL, /* MUST BE AT END OF TABLE */
}
};
/*
* This table is used to copy the linker EXE formated header to the
* (NE) loader Swappable MTE format.
*/
struct etmt_s ExeTo16SwapMTETbl[] = {
{
FIELDOFFSET(struct new_exe, ne_csip), /* Extended IP */
}, /* get offset only of starting address */
{
FIELDOFFSET(struct e32_exe, e32_res4)+2, /* Object # for stack ptr */
},
{
FIELDOFFSET(struct e32_exe, e32_res4), /* extended stack pointer */
},
{
FIELDOFFSET(struct new_exe, ne_segtab), /* Object table offset */
},
{
FIELDOFFSET(struct new_exe, ne_cseg), /* Object table count */
},
{
(USHORT) SKIPCOPY, /* Offset of fixup page map */
},
{
FIELDOFFSET(struct new_exe, ne_enttab), /* Offset of entry table */
},
{
FIELDOFFSET(struct new_exe, ne_imptab), /* Offset of Import Tb */
},
{
FIELDOFFSET(struct new_exe, ne_restab), /* Offset of resident name */
},
{
FIELDOFFSET(struct new_exe, ne_rsrctab), /* Offset of resource Tb */
},
{
FIELDOFFSET(struct new_exe, ne_cres), /* count of resources */
},
{
FIELDOFFSET(struct new_exe, ne_align), /* Alignment factor */
},
{
(USHORT) SKIPCOPY, /* vbase */
},
{
FIELDOFFSET(struct new_exe, ne_heap), /* Maximum heap size */
},
{
FIELDOFFSET(struct new_exe, ne_autodata), /* autods segment # */
},
{
FIELDOFFSET(struct new_exe, ne_modtab), /* Offset of module ref tb */
},
{
(USHORT) SKIPCOPY, /* debug info */
},
{
FIELDOFFSET(struct new_exe, ne_stack), /* Stack size */
},
{
FIELDOFFSET(struct new_exe, ne_csip)+2, /* Start object number */
},
{
(USHORT) SKIPCOPY, /* skip cache pointer */
},
{
(USHORT) SKIPCOPY, /* skip pathname pointer */
},
{
(USHORT) SKIPCOPY, /* skip pathname length */
}, /* and skip dyn trace count */
{
(USHORT) SKIPCOPY, /* skip semaphore count */
}, /* and skip semaphore owner */
{
FIELDOFFSET(struct new_exe, ne_nrestab),/* 16-bit non-resident tb off */
},
{
(USHORT) SKIPCOPY, /* 16-bit size of non-res */
}, /* This is a DWORD value copy later */
{
(USHORT) SKIPCOPY, /* 16-bit count of packed segments */
},
{
(USHORT) SKIPCOPY, /* 16-bit size of packed object */
},
{
(USHORT) SKIPCOPY, /* 16-bit pointer to packed object */
},
{
FIELDOFFSET(struct new_exe, ne_flags),/* copy of ne_flags */
}, /* and zero ne_expver */
{
FIELDOFFSET(struct new_exe, ne_exetyp),/* copy of ne_exetype */
}, /* and zero ne_flagsothers */
{
ENDMTETBL, /* MUST BE AT END OF TABLE */
}
};
/*
* This table is used to copy header info for the API DosQueryHeaderInfo
* function HEADER_EXEINFO, see VR32QueryHeaderInfo.
*/
struct hit_s HeaderInfoTbl[] = {
{
FIELDOFFSET(ldrsmte_t, smte_NEflags),/* Original flags from NE header */
sizeof(((ldrsmte_t *) 0)->smte_NEflags),/* number of bytes to copy */
},
{
FIELDOFFSET(ldrsmte_t, smte_NEflagsothers),/* fixup page table */
sizeof(((ldrsmte_t *) 0)->smte_NEflagsothers),/* number of bytes to copy */
},
{
FIELDOFFSET(ldrsmte_t, smte_NEexetype),/* exetyp from NE header */
sizeof(((ldrsmte_t *) 0)->smte_NEexetype),/* number of bytes to copy */
},
{
FIELDOFFSET(ldrsmte_t, smte_NEexpver),/* expver from NE header */
sizeof(((ldrsmte_t *) 0)->smte_NEexpver),/* number of bytes to copy */
},
{
0, /* special case for size of rsrc table */
2, /* copy 2 bytes */
},
{
ENDMTETBL, /* MUST BE AT END OF TABLE */
0, /* copy 0 bytes */
}
};
/*
* This table is used to copy header info for the API DosQueryHeaderInfo
* function HEADER_STE, see VR32QueryHeaderInfo.
*/
struct his_s HeaderInfoSTE[] = {
{
FIELDOFFSET(ldrste_t, ste_offset), /* file offset to segment data */
2, /* copy 2 bytes */
},
{
FIELDOFFSET(ldrste_t, ste_size), /* file data size */
2, /* copy 2 byte */
},
{
FIELDOFFSET(ldrste_t, ste_flags), /* type and attribute flags */
2, /* copy 2 byte */
},
{
FIELDOFFSET(ldrste_t, ste_minsiz), /* minimum allocation size */
2, /* copy 2 bytes */
},
{
ENDMTETBL, /* MUST BE AT END OF TABLE */
0, /* copy 0 bytes */
}
};
/*
* This structure is used to convert from Object type flags to the
* required VM flags needed for allocation of memory. See setVMflags()
* for use.
*/
struct objflags_s objflags[] =
{
{
OBJ_READ, /* Readable Object */
PAG_READ, /* Allocate as Readable */
},
{
OBJ_WRITE, /* Writeable Object */
PAG_WRITE, /* Allocate as Writeable */
},
{
OBJ_EXEC, /* Executable Object */
PAG_EXECUTE, /* Alloc as eXecutable and shared */
},
{
0, /* must have end of table entry */
0,
}
};
/*
* This sturcture is used to convert from Object type flags to the
* required SEL flags needed for allocation of memory. See setVMflags()
* for use.
*/
struct selflags_s selflags[] =
{
{
OBJ_READ, /* Readable Object */
0, /* Allocate as Readable */
},
{
OBJ_WRITE, /* Writeable Object */
0, /* Allocate as Writeable */
},
{
OBJ_EXEC, /* Executable Object */
0, /* Alloc as eXecutable and readable */
},
{
OBJ_CONFORM, /* Objects is conforming */
0,
},
{
0, /* must have end of table entry */
0,
}
};
#include <ldrtabs.h>
//
// The segtab structure below is overwritten by the segment values
// of the DOSCALLS.DLL module when it is first loaded.
//
ldrste_t segtab;
/* =
{
0,
0,
0x0c00,
0,
0,
FLATTOSEL(DOSCALLS_BASE),
0
};
*/
//
// Structures private to 16B handles allocation
//
// NUM_OF_COOKIES MUST be a power of 2
#define NUM_OF_COOKIES 4096
ULONG NextCookie = 1;
typedef struct _A16B_COOKIE {
ULONG value32;
ULONG cookie;
} A16B_COOKIE, *P16B_COOKIE;
A16B_COOKIE Cookies[NUM_OF_COOKIES];
NTSTATUS ldrCreateR2XferSeg();
extern PSZ Os2ServerSystemDirectory;
BOOLEAN ldrInit()
{
ULONG size;
CHAR SystemDir[260 + FILE_PREFIX_LENGTH];
#if DBG
ldrmte_t *pmte;
#endif
ULONG SizeOfSystemDir;
ULONG ModSize;
PCHAR DotDll = ".DLL";
strcpy(SystemDir, "\\OS2SS\\DRIVES\\");
SizeOfSystemDir = FILE_PREFIX_LENGTH;
size = strlen(Os2ServerSystemDirectory);
if( size > (sizeof(SystemDir) - FILE_PREFIX_LENGTH - 10))
{
#if DBG
DbgPrint("OS2LDR: ldrinit - system directory too long %ld\n", size);
ASSERT( FALSE );
#endif
return(FALSE);
}
strncpy(&SystemDir[SizeOfSystemDir],
Os2ServerSystemDirectory,
size);
_strupr(&SystemDir[SizeOfSystemDir]);
SizeOfSystemDir += size;
strcpy(&SystemDir[SizeOfSystemDir], "\\OS2\\DLL\\");
SizeOfSystemDir += 9;
/*
Ol2Heap = RtlCreateHeap( HEAP_GROWABLE,
NULL,
64 * 1024, // Initial size of heap is 64K
64 * 1024, // Commit for 64K
NULL,
0
);
if( Ol2Heap == NULL )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - cannot create Ol2Heap\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
*/
LDRNEHeap = RtlCreateHeap( HEAP_GROWABLE,
NULL,
64 * 1024, // Initial size of heap is 64K
64 * 1024, // Commit for 64K
NULL,
0
);
if ( LDRNEHeap == NULL )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - cannot create LDRNEHeap\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
/*
* Allocate a heap object of the size of one sector to hold the
* header of file into
*/
pheaderbuf = (char *) RtlAllocateHeap( LDRNEHeap, 0, 512 );
if ( pheaderbuf == NULL )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - cannot create pheaderbuf\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
if (!ldrCreateSelBitmap()) {
#if DBG
DbgPrint("OS2LDR: ldrinit - cannot allocate the segment bitmap\n");
#endif
return(FALSE);
}
// Mark the preallocated segments at the top of the tiled area
// as used so that they are not allocated by the loader.
ldrMarkAllocatedSel((_512M - (OD2MAXSEG_MEM - BASE_TILE)) / _64K, TRUE);
//
// Create an address space for the R2XFER segment (which is the second
// code segment of DOSCALLS.DLL).
// This segment needs to be pre-allocated because modules that contain
// ring 2 entry points may be allocated before DOSCALLS.DLL is allocated.
//
if (!NT_SUCCESS(ldrCreateR2XferSeg())) {
return(FALSE);
}
if (!ldrCreateCallGateBitmap()) {
#if DBG
DbgPrint("OS2LDR: ldrinit - cannot allocate the call gate bitmap\n");
#endif
return(FALSE);
}
// Mark pre-allocated call gates (which is the area reserved by the
// ring transfer code in client\thunk\r2xfer.asm) as used so that they
// are not allocated as call gates.
ldrMarkAllocatedCallGates(0x200/8);
acscallmte.mte_magic[0] = 'N';
acscallmte.mte_magic[1] = 'E';
acscallmte.mte_usecnt = 1;
acscallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
acscallmte.mte_swapmte = &acscallsmte;
acscallmte.mte_modname = (ULONG) &acsrestab;
acscallmte.mte_link = NULL;
Allocate16BHandle(&acscallmte.mte_handle, (ULONG) &acscallsmte);
acscallsmte.smte_restab = (ULONG) &acsrestab;
acscallsmte.smte_nrestab = (ULONG) &acsnrestab;
acscallsmte.smte_cbnrestab = 10;
acscallsmte.smte_enttab = (ULONG) &acsenttab;
acscallsmte.smte_objtab = (ULONG) &segtab;
acscallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)acscallmte.mte_modname;
acscallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(acscallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)acscallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)acscallsmte.smte_path + SizeOfSystemDir,
(PCHAR)acscallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)acscallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
acscallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
kbdcallmte.mte_magic[0] = 'N';
kbdcallmte.mte_magic[1] = 'E';
kbdcallmte.mte_usecnt = 1;
kbdcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
kbdcallmte.mte_swapmte = &kbdcallsmte;
kbdcallmte.mte_modname = (ULONG) &kbdrestab;
kbdcallmte.mte_link = &acscallmte;
Allocate16BHandle(&kbdcallmte.mte_handle, (ULONG) &kbdcallsmte);
kbdcallsmte.smte_restab = (ULONG) &kbdrestab;
kbdcallsmte.smte_nrestab = (ULONG) &kbdnrestab;
kbdcallsmte.smte_cbnrestab = 10;
kbdcallsmte.smte_enttab = (ULONG) &kbdenttab;
kbdcallsmte.smte_objtab = (ULONG) &segtab;
kbdcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)kbdcallmte.mte_modname;
kbdcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(kbdcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)kbdcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)kbdcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)kbdcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)kbdcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
kbdcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
maicallmte.mte_magic[0] = 'N';
maicallmte.mte_magic[1] = 'E';
maicallmte.mte_usecnt = 1;
maicallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
maicallmte.mte_swapmte = &maicallsmte;
maicallmte.mte_modname = (ULONG) &mairestab;
maicallmte.mte_link = &kbdcallmte;
Allocate16BHandle(&maicallmte.mte_handle, (ULONG) &maicallsmte);
maicallsmte.smte_restab = (ULONG) &mairestab;
maicallsmte.smte_nrestab = (ULONG) &mainrestab;
maicallsmte.smte_cbnrestab = 10;
maicallsmte.smte_enttab = (ULONG) &maienttab;
maicallsmte.smte_objtab = (ULONG) &segtab;
maicallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)maicallmte.mte_modname;
maicallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(maicallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)maicallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)maicallsmte.smte_path + SizeOfSystemDir,
(PCHAR)maicallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)maicallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
maicallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
moncallmte.mte_magic[0] = 'N';
moncallmte.mte_magic[1] = 'E';
moncallmte.mte_usecnt = 1;
moncallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
moncallmte.mte_swapmte = &moncallsmte;
moncallmte.mte_modname = (ULONG) &monrestab;
moncallmte.mte_link = &maicallmte;
Allocate16BHandle(&moncallmte.mte_handle, (ULONG) &moncallsmte);
moncallsmte.smte_restab = (ULONG) &monrestab;
moncallsmte.smte_nrestab = (ULONG) &monnrestab;
moncallsmte.smte_cbnrestab = 10;
moncallsmte.smte_enttab = (ULONG) &monenttab;
moncallsmte.smte_objtab = (ULONG) &segtab;
moncallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)moncallmte.mte_modname;
moncallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(moncallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)moncallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)moncallsmte.smte_path + SizeOfSystemDir,
(PCHAR)moncallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)moncallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
moncallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
moucallmte.mte_magic[0] = 'N';
moucallmte.mte_magic[1] = 'E';
moucallmte.mte_usecnt = 1;
moucallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
moucallmte.mte_swapmte = &moucallsmte;
moucallmte.mte_modname = (ULONG) &mourestab;
moucallmte.mte_link = &moncallmte;
Allocate16BHandle(&moucallmte.mte_handle, (ULONG) &moucallsmte);
moucallsmte.smte_restab = (ULONG) &mourestab;
moucallsmte.smte_nrestab = (ULONG) &mounrestab;
moucallsmte.smte_cbnrestab = 10;
moucallsmte.smte_enttab = (ULONG) &mouenttab;
moucallsmte.smte_objtab = (ULONG) &segtab;
moucallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)moucallmte.mte_modname;
moucallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(moucallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)moucallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)moucallsmte.smte_path + SizeOfSystemDir,
(PCHAR)moucallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)moucallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
moucallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
msgcallmte.mte_magic[0] = 'N';
msgcallmte.mte_magic[1] = 'E';
msgcallmte.mte_usecnt = 1;
msgcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
msgcallmte.mte_swapmte = &msgcallsmte;
msgcallmte.mte_modname = (ULONG) &msgrestab;
msgcallmte.mte_link = &moucallmte;
Allocate16BHandle(&msgcallmte.mte_handle, (ULONG) &msgcallsmte);
msgcallsmte.smte_restab = (ULONG) &msgrestab;
msgcallsmte.smte_nrestab = (ULONG) &msgnrestab;
msgcallsmte.smte_cbnrestab = 10;
msgcallsmte.smte_enttab = (ULONG) &msgenttab;
msgcallsmte.smte_objtab = (ULONG) &segtab;
msgcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)msgcallmte.mte_modname;
msgcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(msgcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)msgcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)msgcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)msgcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)msgcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
msgcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
namcallmte.mte_magic[0] = 'N';
namcallmte.mte_magic[1] = 'E';
namcallmte.mte_usecnt = 1;
namcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
namcallmte.mte_swapmte = &namcallsmte;
namcallmte.mte_modname = (ULONG) &namrestab;
namcallmte.mte_link = &msgcallmte;
Allocate16BHandle(&namcallmte.mte_handle, (ULONG) &namcallsmte);
namcallsmte.smte_restab = (ULONG) &namrestab;
namcallsmte.smte_nrestab = (ULONG) &namnrestab;
namcallsmte.smte_cbnrestab = 10;
namcallsmte.smte_enttab = (ULONG) &namenttab;
namcallsmte.smte_objtab = (ULONG) &segtab;
namcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)namcallmte.mte_modname;
namcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(namcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)namcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)namcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)namcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)namcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
namcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
apicallmte.mte_magic[0] = 'N';
apicallmte.mte_magic[1] = 'E';
apicallmte.mte_usecnt = 1;
apicallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
apicallmte.mte_swapmte = &apicallsmte;
apicallmte.mte_modname = (ULONG) &apirestab;
apicallmte.mte_link = &namcallmte;
Allocate16BHandle(&apicallmte.mte_handle, (ULONG) &apicallsmte);
apicallsmte.smte_restab = (ULONG) &apirestab;
apicallsmte.smte_nrestab = (ULONG) &apinrestab;
apicallsmte.smte_cbnrestab = 10;
apicallsmte.smte_enttab = (ULONG) &apienttab;
apicallsmte.smte_objtab = (ULONG) &segtab;
apicallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)apicallmte.mte_modname;
apicallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(apicallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)apicallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)apicallsmte.smte_path + SizeOfSystemDir,
(PCHAR)apicallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)apicallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
apicallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
oemcallmte.mte_magic[0] = 'N';
oemcallmte.mte_magic[1] = 'E';
oemcallmte.mte_usecnt = 1;
oemcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
oemcallmte.mte_swapmte = &oemcallsmte;
oemcallmte.mte_modname = (ULONG) &oemrestab;
oemcallmte.mte_link = &apicallmte;
Allocate16BHandle(&oemcallmte.mte_handle, (ULONG) &oemcallsmte);
oemcallsmte.smte_restab = (ULONG) &oemrestab;
oemcallsmte.smte_nrestab = (ULONG) &oemnrestab;
oemcallsmte.smte_cbnrestab = 10;
oemcallsmte.smte_enttab = (ULONG) &oementtab;
oemcallsmte.smte_objtab = (ULONG) &segtab;
oemcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)oemcallmte.mte_modname;
oemcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(oemcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)oemcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)oemcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)oemcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)oemcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
oemcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
nlscallmte.mte_magic[0] = 'N';
nlscallmte.mte_magic[1] = 'E';
nlscallmte.mte_usecnt = 1;
nlscallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
nlscallmte.mte_swapmte = &nlscallsmte;
nlscallmte.mte_modname = (ULONG) &nlsrestab;
nlscallmte.mte_link = &oemcallmte;
Allocate16BHandle(&nlscallmte.mte_handle, (ULONG) &nlscallsmte);
nlscallsmte.smte_restab = (ULONG) &nlsrestab;
nlscallsmte.smte_nrestab = (ULONG) &nlsnrestab;
nlscallsmte.smte_cbnrestab = 10;
nlscallsmte.smte_enttab = (ULONG) &nlsenttab;
nlscallsmte.smte_objtab = (ULONG) &segtab;
nlscallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)nlscallmte.mte_modname;
nlscallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(nlscallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)nlscallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)nlscallsmte.smte_path + SizeOfSystemDir,
(PCHAR)nlscallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)nlscallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
nlscallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
#ifndef PMNT
pmscallmte.mte_magic[0] = 'N';
pmscallmte.mte_magic[1] = 'E';
pmscallmte.mte_usecnt = 1;
pmscallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
pmscallmte.mte_swapmte = &pmscallsmte;
pmscallmte.mte_modname = (ULONG) &pmsrestab;
pmscallmte.mte_link = &nlscallmte;
Allocate16BHandle(&pmscallmte.mte_handle, (ULONG) &pmscallsmte);
pmscallsmte.smte_restab = (ULONG) &pmsrestab;
pmscallsmte.smte_nrestab = (ULONG) &pmsnrestab;
pmscallsmte.smte_cbnrestab = 10;
pmscallsmte.smte_enttab = (ULONG) &pmsenttab;
pmscallsmte.smte_objtab = (ULONG) &segtab;
pmscallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)pmscallmte.mte_modname;
pmscallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(pmscallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)pmscallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)pmscallsmte.smte_path + SizeOfSystemDir,
(PCHAR)pmscallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)pmscallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
pmscallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
pmwcallmte.mte_magic[0] = 'N';
pmwcallmte.mte_magic[1] = 'E';
pmwcallmte.mte_usecnt = 1;
pmwcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
pmwcallmte.mte_swapmte = &pmwcallsmte;
pmwcallmte.mte_modname = (ULONG) &pmwrestab;
pmwcallmte.mte_link = &pmscallmte;
Allocate16BHandle(&pmwcallmte.mte_handle, (ULONG) &pmwcallsmte);
pmwcallsmte.smte_restab = (ULONG) &pmwrestab;
pmwcallsmte.smte_nrestab = (ULONG) &pmwnrestab;
pmwcallsmte.smte_cbnrestab = 10;
pmwcallsmte.smte_enttab = (ULONG) &pmwenttab;
pmwcallsmte.smte_objtab = (ULONG) &segtab;
pmwcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)pmwcallmte.mte_modname;
pmwcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(pmwcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)pmwcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)pmwcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)pmwcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)pmwcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
pmwcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
os2smcallmte.mte_magic[0] = 'N';
os2smcallmte.mte_magic[1] = 'E';
os2smcallmte.mte_usecnt = 1;
os2smcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
os2smcallmte.mte_swapmte = &os2smcallsmte;
os2smcallmte.mte_modname = (ULONG) &os2restab;
os2smcallmte.mte_link = &pmwcallmte;
Allocate16BHandle(&os2smcallmte.mte_handle, (ULONG) &os2smcallsmte);
os2smcallsmte.smte_restab = (ULONG) &os2restab;
os2smcallsmte.smte_nrestab = (ULONG) &os2nrestab;
os2smcallsmte.smte_cbnrestab = 10;
os2smcallsmte.smte_enttab = (ULONG) &os2enttab;
os2smcallsmte.smte_objtab = (ULONG) &segtab;
os2smcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)os2smcallmte.mte_modname;
os2smcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(os2smcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)os2smcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)os2smcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)os2smcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)os2smcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
os2smcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
#endif /* ifndef PMNT */
quecallmte.mte_magic[0] = 'N';
quecallmte.mte_magic[1] = 'E';
quecallmte.mte_usecnt = 1;
quecallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
quecallmte.mte_swapmte = &quecallsmte;
quecallmte.mte_modname = (ULONG) &querestab;
#ifndef PMNT
quecallmte.mte_link = &os2smcallmte;
#else
quecallmte.mte_link = &nlscallmte;
#endif
Allocate16BHandle(&quecallmte.mte_handle, (ULONG) &quecallsmte);
quecallsmte.smte_restab = (ULONG) &querestab;
quecallsmte.smte_nrestab = (ULONG) &quenrestab;
quecallsmte.smte_cbnrestab = 10;
quecallsmte.smte_enttab = (ULONG) &queenttab;
quecallsmte.smte_objtab = (ULONG) &segtab;
quecallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)quecallmte.mte_modname;
quecallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(quecallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)quecallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)quecallsmte.smte_path + SizeOfSystemDir,
(PCHAR)quecallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)quecallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
quecallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
sescallmte.mte_magic[0] = 'N';
sescallmte.mte_magic[1] = 'E';
sescallmte.mte_usecnt = 1;
sescallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
sescallmte.mte_swapmte = &sescallsmte;
sescallmte.mte_modname = (ULONG) &sesrestab;
sescallmte.mte_link = &quecallmte;
Allocate16BHandle(&sescallmte.mte_handle, (ULONG) &sescallsmte);
sescallsmte.smte_restab = (ULONG) &sesrestab;
sescallsmte.smte_nrestab = (ULONG) &sesnrestab;
sescallsmte.smte_cbnrestab = 10;
sescallsmte.smte_enttab = (ULONG) &sesenttab;
sescallsmte.smte_objtab = (ULONG) &segtab;
sescallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)sescallmte.mte_modname;
sescallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(sescallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)sescallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)sescallsmte.smte_path + SizeOfSystemDir,
(PCHAR)sescallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)sescallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
sescallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
#ifdef PMNT
pmntcallmte.mte_magic[0] = 'N';
pmntcallmte.mte_magic[1] = 'E';
pmntcallmte.mte_usecnt = 1;
pmntcallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
pmntcallmte.mte_swapmte = &pmntcallsmte;
pmntcallmte.mte_modname = (ULONG) &pmnrestab;
pmntcallmte.mte_link = &sescallmte;
Allocate16BHandle(&pmntcallmte.mte_handle, (ULONG) &pmntcallsmte);
pmntcallsmte.smte_restab = (ULONG) &pmnrestab;
pmntcallsmte.smte_nrestab = (ULONG) &pmnnrestab;
pmntcallsmte.smte_cbnrestab = 10;
pmntcallsmte.smte_enttab = (ULONG) &pmnenttab;
pmntcallsmte.smte_objtab = (ULONG) &segtab;
pmntcallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)pmntcallmte.mte_modname;
pmntcallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(pmntcallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)pmntcallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)pmntcallsmte.smte_path + SizeOfSystemDir,
(PCHAR)pmntcallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)pmntcallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
pmntcallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
#endif
viocallmte.mte_magic[0] = 'N';
viocallmte.mte_magic[1] = 'E';
viocallmte.mte_usecnt = 1;
viocallmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
viocallmte.mte_swapmte = &viocallsmte;
viocallmte.mte_modname = (ULONG) &viorestab;
#ifdef PMNT
viocallmte.mte_link = &pmntcallmte;
#else
viocallmte.mte_link = &sescallmte;
#endif
viocallsmte.smte_path = (ULONG) &viorestab;
viocallsmte.smte_pathlen = (USHORT) 9;
Allocate16BHandle(&viocallmte.mte_handle, (ULONG) &viocallsmte);
viocallsmte.smte_restab = (ULONG) &viorestab;
viocallsmte.smte_nrestab = (ULONG) &vionrestab;
viocallsmte.smte_cbnrestab = 15;
viocallsmte.smte_enttab = (ULONG) &vioenttab;
viocallsmte.smte_objtab = (ULONG) &segtab;
viocallsmte.smte_objcnt = 1;
ModSize = *(PCHAR)viocallmte.mte_modname;
viocallsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(viocallsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)viocallsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)viocallsmte.smte_path + SizeOfSystemDir,
(PCHAR)viocallmte.mte_modname + 1, ModSize);
strcpy((PCHAR)viocallsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
viocallsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
#ifdef DBCS
// MSKK Dec.15.1992 V-AkihiS
imdaemonmte.mte_magic[0] = 'N';
imdaemonmte.mte_magic[1] = 'E';
imdaemonmte.mte_usecnt = 1;
imdaemonmte.mte_mflags = CLASS_GLOBAL | LIBRARYMOD | GINIDONE | DOSMOD | MTEPROCESSED;
imdaemonmte.mte_swapmte = &imdaemonsmte;
imdaemonmte.mte_modname = (ULONG) &imdrestab;
imdaemonmte.mte_link = &viocallmte;
Allocate16BHandle(&imdaemonmte.mte_handle, (ULONG) &imdaemonsmte);
imdaemonsmte.smte_restab = (ULONG) &imdrestab;
imdaemonsmte.smte_nrestab = (ULONG) &imdnrestab;
imdaemonsmte.smte_cbnrestab = 10;
imdaemonsmte.smte_enttab = (ULONG) &imdenttab;
imdaemonsmte.smte_objtab = (ULONG) &segtab;
imdaemonsmte.smte_objcnt = 1;
ModSize = *(PCHAR)imdaemonmte.mte_modname;
imdaemonsmte.smte_path =
(ULONG)RtlAllocateHeap(LDRNEHeap, 0, SizeOfSystemDir + ModSize + 5);
if ( !(imdaemonsmte.smte_path) )
{
#if DBG
DbgPrint("OS2LDR: ldrinit - out of heap memory\n");
ASSERT( FALSE );
#endif
return(FALSE);
}
memcpy((PVOID)imdaemonsmte.smte_path, SystemDir, SizeOfSystemDir);
memcpy((PCHAR)imdaemonsmte.smte_path + SizeOfSystemDir,
(PCHAR)imdaemonmte.mte_modname + 1, ModSize);
strcpy((PCHAR)imdaemonsmte.smte_path + SizeOfSystemDir + ModSize, DotDll);
imdaemonsmte.smte_pathlen = (USHORT)(SizeOfSystemDir + ModSize + 4);
mte_h = global_h = (ldrmte_t *)&imdaemonmte;
#else
mte_h = global_h = (ldrmte_t *)&viocallmte;
#endif
global_l = (ldrmte_t *)&acscallmte;
#if 0
//
// Preload the DOSCALLS dll (not implemented yet)
//
//
// Init the Library Intialization routines data structure to NULL
// in order to detect bugs
//
pldrLibiRecord = NULL;
pldrLibiCounter = NULL;
/*
* Point to ldrLibPathBuf to contain the environment string
*/
strcpy(ldrLibPathBuf, SystemDir);
rc = ldrGetModule("DOSCALLS",
8,
(char)EXT_LIBRARY,
CLASS_GLOBAL,
&pmte,
0);
if (rc != NO_ERROR) {
return(FALSE);
}
pmte->mte_usecnt = 1;
#endif
#if DBG
IF_OL2_DEBUG ( MTE ) {
DbgPrint("OS2LDR: List of LDR dlls:\n");
for (pmte = mte_h; pmte != NULL; pmte = pmte->mte_link) {
DbgPrint("%s, NameLen=%d, %s\n",
pmte->mte_swapmte->smte_path,
pmte->mte_swapmte->smte_pathlen,
(PCHAR)pmte->mte_modname + 1);
}
}
#endif
return(TRUE);
}
//
// Service routines to create and translate mapping between
// 32b Cruiser Handles and random 16b handles (not to confuse
// with OS2 1.X File Handles and Thread Handles which are
// not random)
//
APIRET
Allocate16BHandle(
OUT PUSHORT pusHandle,
IN ULONG h32bHandle
)
{
ULONG Entry;
ULONG LoopCounter = 0;
//
// Find a free entry in the cookie table
//
Entry = NextCookie & (NUM_OF_COOKIES - 1);
while (Cookies[Entry].cookie != 0) {
//
// Verify that we are not looping forever
//
LoopCounter++;
if (LoopCounter == NUM_OF_COOKIES) {
return(ERROR_NO_OBJECT);
}
NextCookie++;
if (NextCookie == _64K) {
NextCookie = 1;
}
Entry = NextCookie & (NUM_OF_COOKIES - 1);
}
Cookies[Entry].value32 = h32bHandle;
Cookies[Entry].cookie = NextCookie;
*pusHandle = (USHORT)NextCookie;
NextCookie++;
if (NextCookie == _64K) {
NextCookie = 1;
}
return(NO_ERROR);
}
APIRET
Free16BHandle(
IN USHORT usHandle
)
{
ULONG Entry;
//
// Find a free entry in the cookie table
//
Entry = usHandle & (NUM_OF_COOKIES - 1);
if (Cookies[Entry].cookie != (ULONG)usHandle) {
return(ERROR_INVALID_HANDLE);
}
Cookies[Entry].cookie = 0;
return(NO_ERROR);
}
NTSTATUS
ldrCreateR2XferSeg()
{
NTSTATUS Status;
LARGE_INTEGER SectionSize;
ULONG RegionSize = _64K;
PVOID BaseAddress;
SectionSize.LowPart = _64K;
SectionSize.HighPart = 0;
Status = NtCreateSection( &R2XferSegHandle,
SECTION_ALL_ACCESS,
NULL,
&SectionSize,
PAGE_EXECUTE_READWRITE,
SEC_COMMIT,
NULL
);
if (!NT_SUCCESS( Status )) {
#if DBG
KdPrint(("OS2LDR: unable to create the R2XFER section, Status=%x\n", Status));
#endif
return( Status );
}
BaseAddress = (PVOID)R2XFER_BASE;
Status = NtMapViewOfSection( R2XferSegHandle,
NtCurrentProcess(),
&BaseAddress,
0,
0,
NULL,
&RegionSize,
ViewUnmap,
0,
PAGE_READWRITE
);
if (!NT_SUCCESS( Status )) {
#if DBG
KdPrint(("OS2LDR: unable to Map View the R@XFER section, Status=%x\n", Status));
#endif
return( Status );
}
return( Status );
}