mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1415 lines
44 KiB
1415 lines
44 KiB
#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 );
|
|
}
|
|
|
|
|
|
|