#include #define INCL_OS2V20_TASKING #define INCL_OS2V20_MEMORY #define INCL_OS2V20_FILESYS #define INCL_DOSERRORS #include "bseerr.h" #include #include "os2defp.h" #include "mi.h" #define FOR_EXEHDR 1 #include "newexe.h" #include "exe386.h" #include "ldrvars.h" #include #include #include #include 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 // // 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 ); }