mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-19 11:38:30 +00:00
829fe323e4
Sat Jul 25 19:45:45 1998 Juergen Schmied <juergen.schmied@metronet.de> * [include/shlobj.h][misc/shell.c][misc/shellord.c][ole/folders.c] [shell32.spec] Added SHFILEOPSTRUCT32[A|W] and constants, prototypes. Implemented SHGetSpecialFolderLocation, SHGetPathFromIDList32[A]. Many IShellFolder, pidl, shell -related changes. SHChangeNotifyRegister, SHChangeNotifyDeregister, SHShellFolderView_Message, SHMapPIDLToSystemImageListIndex, SHAddToRecentDocs32, SHFileOperation, SHChangeNotify, SHCreateShellFolderViewEx stubs. Sat Jul 25 17:16:25 1998 Huw D M Davies <daviesh@abacus.physics.ox.ac.uk> * [files/profile.c] Fix return value of PROFILE_GetSection(). Fri Jul 24 22:45:19 1998 Ove Kaaven <ovek@isflak.arcticnet.no> * [controls/edit.c] Killed the modified flag on WM_SETTEXT. Eudora should no longer bother asking whether you want to save an unchanged message. Fri Jul 24 21:21:35 1998 Andreas Mohr <100.30936@germany.net> * [controls/menu.c] Fixed bug in GetMenuState32. Doesn't fix Free Agent 32 :(( * [documentation/debugging] Hints added. * [files/dos_fs.c] [include/msdos.h] [msdos/int21.c] Enhanced DOS device support. * [if1632/Makefile.in] [if1632/builtin.c] [if1632/rasapi16.spec] [relay32/Makefile.in] [relay32/builtin32.c] [relay32/rasapi32.spec] Added RASAPI16/32.DLL. * [misc/aspi.c] [relay32/wnaspi32.spec] Implemented GetASPI32SupportInfo. * [multimedia/mmsystem.c] Implemented mmTaskCreate. Fri Jul 24 20:55:31 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de> * [controls/toolbar.c] Fixed some bugs and added new features. * [controls/tooltips.c][include/tooltips.h] Added more messages and started display code. * [misc/shell.c][misc/shellord.c][relay32/shell.spec] Fixed StrToOleStrN (SHELL32_79) and added OleStrToStrN (SHELL32_78). Added some new stubs. * [objects/cursoricon.c][misc/imagelist.c][include/windows.h] Fixed GetIconInfo and removed the GetIconInfo hack from the image list code. * [controls/pager.c][include/pager.h][controls/treeview.c] [include/treeview.h] Added some messages. * [misc/tweak.c][winows/nonclient.c][documentation/win95look] Removed unused tweak variables. * [documentation/common_controls] Updated. Fri Jul 24 18:36:32 1998 James Moody <013263m@dragon.acadiau.ca> * [objects/font.c] Fixed a bug in GetTextFace. Fri Jul 24 17:09:33 1998 Marcus Meissner <marcus@jet.franken.de> * [misc/commdlg.c] Fixed stacksmashing bug due to invalid specified function pointers. * [files/dos_fs.c] Small change in case handling... be able to create files with uppercase in them (like Program Files/). * [graphics/ddraw.c] XF86DGA support made threadsafe, added more Xlib dependent stuff (create Window using CreateWindow(), draw into it). xlib support is not satisfying. * [scheduler/critsection.c] Don't recurse on HeapLock with semaphore id 0. * [win32/user32.c][windows/message.c][windows/event.c] Moved win32 *Message functions where they belong. Removed some potential races between XPending and XNextEvent by a bit more locking. Fri Jul 24 13:58:19 1998 Alexandre Julliard <julliard@lrc.epfl.ch> * [loader/pe_image.c] [loader/ne/segment.c] Use bogus pointer value instead of NULL for unresolved externals. * [memory/selector.c] Clear saved_fs on selector free. * [msdos/cdrom.c] [configure.in] Added check for linux/ucdrom.h. * [scheduler/client.c] [server/socket.c] Fix for missing struct cmsghdr. Attempt to support msg_accrights fd passing (completely untested). * [windows/event.c] Do not grab the pointer in SetCapture (Win32 behavior). Tue Jul 21 22:28:13 1998 James Juran <jrj120@psu.edu> * [Make.rules.in] Changed $(MKDIR) macro to use -p option (make parent directories if they don't already exist. This fixes an error in 'make install' if /usr/local/include doesn't already exist. Tue Jul 21 13:37:04 Rein Klazes <rklazes@casema.net> * [include/heap.h] Replaced macro SEGPTR_GET by inline function to avoid *lots* of wrong use of this macro. * [relay32/comdlg32.spec] Corrected GetSaveFileNameW entry. * [relay32/advapi32.spec] [win32/advapi.c] [relay32/ole32.spec] [ ole/moniker.c] Added stubs for SetFileSecurity[AW] and CreateFileMoniker32 * [graphics/x11drv/graphics.c] Finished implementation of bezier drawing code. Tue Jul 21 11:00:51 1998 Claus Fischer <cfischer@td2cad.intel.com> * [files/drive.c] Remove label trailing blanks in GetVolumeInformation32A. * [documentation/cdrom-labels] Added documentation on how to find out a CD-ROM label. Sun Jul 19 23:16:41 1998 Pascal Cuoq <pcuoq@ens-lyon.fr> * [include/windows.h] Added some DM_* and DISP_CHANGE_* flags. * [relay32/user32.spec] [windows/user.c] Added stub for ChangeDisplaySettingA. * [ole/ole2nls.c] is_punctuation: reuse information from another table. Sun Jul 19 22:04:46 1998 Douglas Ridgway <ridgway@winehq.com> * [Make.rules.in] Updated automatic documentation rules. * [graphics/path.c] [misc/aspi.c] [misc/ntdll.c] [misc/winsock_dns.c] [ole/ole2dsp.c] [relay32/user32.spec] Comment format futzing to keep c2man happy. * [documentation/README.documentation] Updated description of automatic documentation. Wed Jul 15 19:10:09 1998 Andrew M. Bishop <amb@gedanken.demon.co.uk> * [files/profile.c] Cache the 10 most recently used .ini files. Tue May 20 19:20:23 1997 Pablo Saratxaga <srtxg@chanae.alphanet.ch> * [misc/commdlg.c] Makes PrintDlg32A() return TRUE even if it is an empty stub, so most programs are happy and run anyway instead of aborting at startup. * [graphics/x11drv/xfont.c] Increased the maximum font families as (X11) font aliases eated up a lot of families causing wine to stop reading fonts.
791 lines
23 KiB
C
791 lines
23 KiB
C
/*
|
|
* Selector manipulation functions
|
|
*
|
|
* Copyright 1995 Alexandre Julliard
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "windows.h"
|
|
#include "ldt.h"
|
|
#include "miscemu.h"
|
|
#include "selectors.h"
|
|
#include "stackframe.h"
|
|
#include "debug.h"
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocSelectorArray (KERNEL.206)
|
|
*/
|
|
WORD WINAPI AllocSelectorArray( WORD count )
|
|
{
|
|
WORD i, sel, size = 0;
|
|
ldt_entry entry;
|
|
|
|
if (!count) return 0;
|
|
for (i = FIRST_LDT_ENTRY_TO_ALLOC; i < LDT_SIZE; i++)
|
|
{
|
|
if (!IS_LDT_ENTRY_FREE(i)) size = 0;
|
|
else if (++size >= count) break;
|
|
}
|
|
if (i == LDT_SIZE) return 0;
|
|
sel = i - size + 1;
|
|
|
|
entry.base = 0;
|
|
entry.type = SEGMENT_DATA;
|
|
entry.seg_32bit = FALSE;
|
|
entry.read_only = FALSE;
|
|
entry.limit_in_pages = FALSE;
|
|
entry.limit = 1; /* avoid 0 base and limit */
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
/* Mark selector as allocated */
|
|
ldt_flags_copy[sel + i] |= LDT_FLAGS_ALLOCATED;
|
|
LDT_SetEntry( sel + i, &entry );
|
|
}
|
|
return ENTRY_TO_SELECTOR( sel );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocSelector (KERNEL.175)
|
|
*/
|
|
WORD WINAPI AllocSelector( WORD sel )
|
|
{
|
|
WORD newsel, count, i;
|
|
|
|
count = sel ? ((GET_SEL_LIMIT(sel) >> 16) + 1) : 1;
|
|
newsel = AllocSelectorArray( count );
|
|
TRACE(selector, "(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
if (!sel) return newsel; /* nothing to copy */
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(newsel) + i, &entry );
|
|
}
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FreeSelector (KERNEL.176)
|
|
*/
|
|
WORD WINAPI FreeSelector( WORD sel )
|
|
{
|
|
if (IS_SELECTOR_FREE(sel)) return sel; /* error */
|
|
SELECTOR_FreeBlock( sel, 1 );
|
|
return 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_SetEntries
|
|
*
|
|
* Set the LDT entries for an array of selectors.
|
|
*/
|
|
static void SELECTOR_SetEntries( WORD sel, const void *base, DWORD size,
|
|
enum seg_type type, BOOL32 is32bit,
|
|
BOOL32 readonly )
|
|
{
|
|
ldt_entry entry;
|
|
WORD i, count;
|
|
|
|
/* The limit for the first selector is the whole */
|
|
/* block. The next selectors get a 64k limit. */
|
|
entry.base = (unsigned long)base;
|
|
entry.type = type;
|
|
entry.seg_32bit = is32bit;
|
|
entry.read_only = readonly;
|
|
entry.limit_in_pages = (size > 0x100000);
|
|
if (entry.limit_in_pages) entry.limit = ((size + 0xfff) >> 12) - 1;
|
|
else entry.limit = size - 1;
|
|
/* Make sure base and limit are not 0 together if the size is not 0 */
|
|
if (!base && !entry.limit && size) entry.limit = 1;
|
|
count = (size + 0xffff) / 0x10000;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
entry.base += 0x10000;
|
|
/* Apparently the next selectors should *not* get a 64k limit. */
|
|
/* Can't remember where I read they should... --AJ */
|
|
entry.limit -= entry.limit_in_pages ? 0x10 : 0x10000;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_AllocBlock
|
|
*
|
|
* Allocate selectors for a block of linear memory.
|
|
*/
|
|
WORD SELECTOR_AllocBlock( const void *base, DWORD size, enum seg_type type,
|
|
BOOL32 is32bit, BOOL32 readonly )
|
|
{
|
|
WORD sel, count;
|
|
|
|
if (!size) return 0;
|
|
count = (size + 0xffff) / 0x10000;
|
|
sel = AllocSelectorArray( count );
|
|
if (sel) SELECTOR_SetEntries( sel, base, size, type, is32bit, readonly );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_MoveBlock
|
|
*
|
|
* Move a block of selectors in linear memory.
|
|
*/
|
|
void SELECTOR_MoveBlock( WORD sel, const void *new_base )
|
|
{
|
|
WORD i, count = (GET_SEL_LIMIT(sel) >> 16) + 1;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
entry.base = (unsigned long)new_base;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_FreeBlock
|
|
*
|
|
* Free a block of selectors.
|
|
*/
|
|
void SELECTOR_FreeBlock( WORD sel, WORD count )
|
|
{
|
|
WORD i, nextsel;
|
|
ldt_entry entry;
|
|
STACK16FRAME *frame;
|
|
|
|
TRACE(selector, "(%04x,%d)\n", sel, count );
|
|
sel &= ~(__AHINCR - 1); /* clear bottom bits of selector */
|
|
nextsel = sel + (count << __AHSHIFT);
|
|
|
|
#ifdef __i386__
|
|
{
|
|
/* Check if we are freeing current %fs or %gs selector */
|
|
|
|
WORD fs, gs;
|
|
GET_FS(fs);
|
|
if ((fs >= sel) && (fs < nextsel))
|
|
{
|
|
WARN(selector, "Freeing %%fs selector (%04x), not good.\n", fs );
|
|
SET_FS( 0 );
|
|
}
|
|
fs = THREAD_Current()->saved_fs;
|
|
if ((fs >= sel) && (fs < nextsel)) THREAD_Current()->saved_fs = 0;
|
|
GET_GS(gs);
|
|
if ((gs >= sel) && (gs < nextsel)) SET_GS( 0 );
|
|
}
|
|
#endif /* __i386__ */
|
|
|
|
memset( &entry, 0, sizeof(entry) ); /* clear the LDT entries */
|
|
for (i = SELECTOR_TO_ENTRY(sel); count; i++, count--)
|
|
{
|
|
LDT_SetEntry( i, &entry );
|
|
ldt_flags_copy[i] &= ~LDT_FLAGS_ALLOCATED;
|
|
}
|
|
|
|
/* Clear the saved 16-bit selector */
|
|
frame = CURRENT_STACK16;
|
|
while (frame && frame->frame32)
|
|
{
|
|
if ((frame->ds >= sel) && (frame->ds < nextsel)) frame->ds = 0;
|
|
if ((frame->es >= sel) && (frame->es < nextsel)) frame->es = 0;
|
|
frame = PTR_SEG_TO_LIN( frame->frame32->frame16 );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_ReallocBlock
|
|
*
|
|
* Change the size of a block of selectors.
|
|
*/
|
|
WORD SELECTOR_ReallocBlock( WORD sel, const void *base, DWORD size,
|
|
enum seg_type type, BOOL32 is32bit, BOOL32 readonly)
|
|
{
|
|
WORD i, oldcount, newcount;
|
|
|
|
if (!size) size = 1;
|
|
oldcount = (GET_SEL_LIMIT(sel) >> 16) + 1;
|
|
newcount = (size + 0xffff) >> 16;
|
|
|
|
if (oldcount < newcount) /* We need to add selectors */
|
|
{
|
|
/* Check if the next selectors are free */
|
|
if (SELECTOR_TO_ENTRY(sel) + newcount > LDT_SIZE) i = oldcount;
|
|
else
|
|
for (i = oldcount; i < newcount; i++)
|
|
if (!IS_LDT_ENTRY_FREE(SELECTOR_TO_ENTRY(sel)+i)) break;
|
|
|
|
if (i < newcount) /* they are not free */
|
|
{
|
|
SELECTOR_FreeBlock( sel, oldcount );
|
|
sel = AllocSelectorArray( newcount );
|
|
}
|
|
else /* mark the selectors as allocated */
|
|
{
|
|
for (i = oldcount; i < newcount; i++)
|
|
ldt_flags_copy[SELECTOR_TO_ENTRY(sel)+i] |=LDT_FLAGS_ALLOCATED;
|
|
}
|
|
}
|
|
else if (oldcount > newcount) /* We need to remove selectors */
|
|
{
|
|
SELECTOR_FreeBlock( ENTRY_TO_SELECTOR(SELECTOR_TO_ENTRY(sel)+newcount),
|
|
oldcount - newcount );
|
|
}
|
|
if (sel) SELECTOR_SetEntries( sel, base, size, type, is32bit, readonly );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* PrestoChangoSelector (KERNEL.177)
|
|
*/
|
|
WORD WINAPI PrestoChangoSelector( WORD selSrc, WORD selDst )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY( selSrc ), &entry );
|
|
entry.type ^= SEGMENT_CODE; /* toggle the executable bit */
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY( selDst ), &entry );
|
|
return selDst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocCStoDSAlias (KERNEL.170)
|
|
*/
|
|
WORD WINAPI AllocCStoDSAlias( WORD sel )
|
|
{
|
|
WORD newsel;
|
|
ldt_entry entry;
|
|
|
|
newsel = AllocSelectorArray( 1 );
|
|
TRACE(selector, "(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.type = SEGMENT_DATA;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(newsel), &entry );
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocDStoCSAlias (KERNEL.171)
|
|
*/
|
|
WORD WINAPI AllocDStoCSAlias( WORD sel )
|
|
{
|
|
WORD newsel;
|
|
ldt_entry entry;
|
|
|
|
newsel = AllocSelectorArray( 1 );
|
|
TRACE(selector, "(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.type = SEGMENT_CODE;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(newsel), &entry );
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* LongPtrAdd (KERNEL.180)
|
|
*/
|
|
void WINAPI LongPtrAdd( DWORD ptr, DWORD add )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(SELECTOROF(ptr)), &entry );
|
|
entry.base += add;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(SELECTOROF(ptr)), &entry );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetSelectorBase (KERNEL.186)
|
|
*/
|
|
DWORD WINAPI GetSelectorBase( WORD sel )
|
|
{
|
|
DWORD base = GET_SEL_BASE(sel);
|
|
|
|
/* if base points into DOSMEM, assume we have to
|
|
* return pointer into physical lower 1MB */
|
|
|
|
return DOSMEM_MapLinearToDos( (LPVOID)base );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetSelectorBase (KERNEL.187)
|
|
*/
|
|
WORD WINAPI SetSelectorBase( WORD sel, DWORD base )
|
|
{
|
|
ldt_entry entry;
|
|
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
|
|
entry.base = (DWORD)DOSMEM_MapDosToLinear(base);
|
|
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetSelectorLimit (KERNEL.188)
|
|
*/
|
|
DWORD WINAPI GetSelectorLimit( WORD sel )
|
|
{
|
|
return GET_SEL_LIMIT(sel);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetSelectorLimit (KERNEL.189)
|
|
*/
|
|
WORD WINAPI SetSelectorLimit( WORD sel, DWORD limit )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.limit_in_pages = (limit >= 0x100000);
|
|
if (entry.limit_in_pages) entry.limit = limit >> 12;
|
|
else entry.limit = limit;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SelectorAccessRights (KERNEL.196)
|
|
*/
|
|
WORD WINAPI SelectorAccessRights( WORD sel, WORD op, WORD val )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if (op == 0) /* get */
|
|
{
|
|
return 0x01 | /* accessed */
|
|
0x10 | /* not system */
|
|
0x60 | /* DPL 3 */
|
|
0x80 | /* present */
|
|
((entry.read_only == 0) << 1) |
|
|
(entry.type << 2) |
|
|
(entry.seg_32bit << 14) |
|
|
(entry.limit_in_pages << 15);
|
|
}
|
|
else /* set */
|
|
{
|
|
entry.read_only = ((val & 2) == 0);
|
|
entry.type = (val >> 2) & 3;
|
|
entry.seg_32bit = val & 0x4000;
|
|
entry.limit_in_pages = val & 0x8000;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadCodePtr16 (KERNEL.336)
|
|
*/
|
|
BOOL16 WINAPI IsBadCodePtr16( SEGPTR lpfn )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(lpfn);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if (entry.type != SEGMENT_CODE) return TRUE;
|
|
if (OFFSETOF(lpfn) > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadStringPtr16 (KERNEL.337)
|
|
*/
|
|
BOOL16 WINAPI IsBadStringPtr16( SEGPTR ptr, UINT16 size )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if ((entry.type == SEGMENT_CODE) && entry.read_only) return TRUE;
|
|
if (strlen(PTR_SEG_TO_LIN(ptr)) < size) size = strlen(PTR_SEG_TO_LIN(ptr));
|
|
if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadHugeReadPtr16 (KERNEL.346)
|
|
*/
|
|
BOOL16 WINAPI IsBadHugeReadPtr16( SEGPTR ptr, DWORD size )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if ((entry.type == SEGMENT_CODE) && entry.read_only) return TRUE;
|
|
if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadHugeWritePtr16 (KERNEL.347)
|
|
*/
|
|
BOOL16 WINAPI IsBadHugeWritePtr16( SEGPTR ptr, DWORD size )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if ((entry.type == SEGMENT_CODE) || entry.read_only) return TRUE;
|
|
if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IsBadReadPtr16 (KERNEL.334)
|
|
*/
|
|
BOOL16 WINAPI IsBadReadPtr16( SEGPTR ptr, UINT16 size )
|
|
{
|
|
return IsBadHugeReadPtr16( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadWritePtr16 (KERNEL.335)
|
|
*/
|
|
BOOL16 WINAPI IsBadWritePtr16( SEGPTR ptr, UINT16 size )
|
|
{
|
|
return IsBadHugeWritePtr16( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MemoryRead (TOOLHELP.78)
|
|
*/
|
|
DWORD WINAPI MemoryRead( WORD sel, DWORD offset, void *buffer, DWORD count )
|
|
{
|
|
if (IS_SELECTOR_FREE(sel)) return 0;
|
|
if (offset > GET_SEL_LIMIT(sel)) return 0;
|
|
if (offset + count > GET_SEL_LIMIT(sel) + 1)
|
|
count = GET_SEL_LIMIT(sel) + 1 - offset;
|
|
memcpy( buffer, ((char *)GET_SEL_BASE(sel)) + offset, count );
|
|
return count;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MemoryWrite (TOOLHELP.79)
|
|
*/
|
|
DWORD WINAPI MemoryWrite( WORD sel, DWORD offset, void *buffer, DWORD count )
|
|
{
|
|
if (IS_SELECTOR_FREE(sel)) return 0;
|
|
if (offset > GET_SEL_LIMIT(sel)) return 0;
|
|
if (offset + count > GET_SEL_LIMIT(sel) + 1)
|
|
count = GET_SEL_LIMIT(sel) + 1 - offset;
|
|
memcpy( ((char *)GET_SEL_BASE(sel)) + offset, buffer, count );
|
|
return count;
|
|
}
|
|
|
|
/************************************* Win95 pointer mapping functions *
|
|
*
|
|
*/
|
|
|
|
/***********************************************************************
|
|
* MapSL (KERNEL32.523)
|
|
*
|
|
* Maps fixed segmented pointer to linear.
|
|
*/
|
|
LPVOID WINAPI MapSL( SEGPTR sptr )
|
|
{
|
|
return (LPVOID)PTR_SEG_TO_LIN(sptr);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MapSLFix (KERNEL32.524)
|
|
*
|
|
* FIXME: MapSLFix and UnMapSLFixArray should probably prevent
|
|
* unexpected linear address change when GlobalCompact() shuffles
|
|
* moveable blocks.
|
|
*/
|
|
|
|
LPVOID WINAPI MapSLFix( SEGPTR sptr )
|
|
{
|
|
return (LPVOID)PTR_SEG_TO_LIN(sptr);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnMapSLFixArray (KERNEL32.701)
|
|
*/
|
|
|
|
void WINAPI UnMapSLFixArray( SEGPTR sptr[], INT32 length )
|
|
{
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MapLS (KERNEL32.522)
|
|
*
|
|
* Maps linear pointer to segmented.
|
|
*/
|
|
SEGPTR WINAPI MapLS( LPVOID ptr )
|
|
{
|
|
if (!HIWORD(ptr))
|
|
return (SEGPTR)ptr;
|
|
else
|
|
{
|
|
WORD sel = SELECTOR_AllocBlock( ptr, 0x10000, SEGMENT_DATA, FALSE, FALSE );
|
|
return PTR_SEG_OFF_TO_SEGPTR( sel, 0 );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* UnMapLS (KERNEL32.700)
|
|
*
|
|
* Free mapped selector.
|
|
*/
|
|
void WINAPI UnMapLS( SEGPTR sptr )
|
|
{
|
|
if (SELECTOROF(sptr))
|
|
SELECTOR_FreeBlock( SELECTOROF(sptr), 1 );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* GetThreadSelectorEntry (KERNEL32)
|
|
* FIXME: add #ifdef i386 for non x86
|
|
*/
|
|
BOOL32 WINAPI GetThreadSelectorEntry( HANDLE32 hthread, DWORD sel,
|
|
LPLDT_ENTRY ldtent)
|
|
{
|
|
ldt_entry ldtentry;
|
|
|
|
LDT_GetEntry(SELECTOR_TO_ENTRY(sel),&ldtentry);
|
|
ldtent->BaseLow = ldtentry.base & 0x0000ffff;
|
|
ldtent->HighWord.Bits.BaseMid = (ldtentry.base & 0x00ff0000) >> 16;
|
|
ldtent->HighWord.Bits.BaseHi = (ldtentry.base & 0xff000000) >> 24;
|
|
ldtent->LimitLow = ldtentry.limit & 0x0000ffff;
|
|
ldtent->HighWord.Bits.LimitHi = (ldtentry.limit & 0x00ff0000) >> 16;
|
|
ldtent->HighWord.Bits.Dpl = 3;
|
|
ldtent->HighWord.Bits.Sys = 0;
|
|
ldtent->HighWord.Bits.Pres = 1;
|
|
ldtent->HighWord.Bits.Type = 0x10|(ldtentry.type << 2);
|
|
if (ldtentry.read_only)
|
|
ldtent->HighWord.Bits.Type|=0x2;
|
|
ldtent->HighWord.Bits.Granularity = ldtentry.limit_in_pages;
|
|
ldtent->HighWord.Bits.Default_Big = ldtentry.seg_32bit;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* SMapLS* (KERNEL32)
|
|
* These functions map linear pointers at [EBP+xxx] to segmented pointers
|
|
* and return them.
|
|
* Win95 uses some kind of alias structs, which it stores in [EBP+x] to
|
|
* unravel them at SUnMapLS. We just store the segmented pointer there.
|
|
*/
|
|
static void
|
|
x_SMapLS_IP_EBP_x(CONTEXT *context,int argoff) {
|
|
DWORD val,ptr;
|
|
|
|
val =*(DWORD*)(EBP_reg(context)+argoff);
|
|
if (val<0x10000) {
|
|
ptr=val;
|
|
*(DWORD*)(EBP_reg(context)+argoff) = 0;
|
|
} else {
|
|
ptr = MapLS((LPVOID)val);
|
|
*(DWORD*)(EBP_reg(context)+argoff) = ptr;
|
|
}
|
|
EAX_reg(context) = ptr;
|
|
}
|
|
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_8) {x_SMapLS_IP_EBP_x(context,8);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_12) {x_SMapLS_IP_EBP_x(context,12);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_16) {x_SMapLS_IP_EBP_x(context,16);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_20) {x_SMapLS_IP_EBP_x(context,20);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_24) {x_SMapLS_IP_EBP_x(context,24);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_28) {x_SMapLS_IP_EBP_x(context,28);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_32) {x_SMapLS_IP_EBP_x(context,32);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_36) {x_SMapLS_IP_EBP_x(context,36);}
|
|
REGS_ENTRYPOINT(SMapLS_IP_EBP_40) {x_SMapLS_IP_EBP_x(context,40);}
|
|
|
|
REGS_ENTRYPOINT(SMapLS)
|
|
{
|
|
if (EAX_reg(context)>=0x10000) {
|
|
EAX_reg(context) = MapLS((LPVOID)EAX_reg(context));
|
|
EDX_reg(context) = EAX_reg(context);
|
|
} else {
|
|
EDX_reg(context) = 0;
|
|
}
|
|
}
|
|
|
|
REGS_ENTRYPOINT(SUnMapLS)
|
|
{
|
|
if (EAX_reg(context)>=0x10000)
|
|
UnMapLS((SEGPTR)EAX_reg(context));
|
|
}
|
|
|
|
static void
|
|
x_SUnMapLS_IP_EBP_x(CONTEXT *context,int argoff) {
|
|
if (*(DWORD*)(EBP_reg(context)+argoff))
|
|
UnMapLS(*(DWORD*)(EBP_reg(context)+argoff));
|
|
*(DWORD*)(EBP_reg(context)+argoff)=0;
|
|
}
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_8) { x_SUnMapLS_IP_EBP_x(context,12); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_12) { x_SUnMapLS_IP_EBP_x(context,12); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_16) { x_SUnMapLS_IP_EBP_x(context,16); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_20) { x_SUnMapLS_IP_EBP_x(context,20); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_24) { x_SUnMapLS_IP_EBP_x(context,24); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_28) { x_SUnMapLS_IP_EBP_x(context,28); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_32) { x_SUnMapLS_IP_EBP_x(context,32); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_36) { x_SUnMapLS_IP_EBP_x(context,36); }
|
|
REGS_ENTRYPOINT(SUnMapLS_IP_EBP_40) { x_SUnMapLS_IP_EBP_x(context,40); }
|
|
|
|
/**********************************************************************
|
|
* AllocMappedBuffer (KERNEL32.38)
|
|
*
|
|
* This is a undocumented KERNEL32 function that
|
|
* SMapLS's a GlobalAlloc'ed buffer.
|
|
*
|
|
* Input: EDI register: size of buffer to allocate
|
|
* Output: EDI register: pointer to buffer
|
|
*
|
|
* Note: The buffer is preceeded by 8 bytes:
|
|
* ...
|
|
* edi+0 buffer
|
|
* edi-4 SEGPTR to buffer
|
|
* edi-8 some magic Win95 needs for SUnMapLS
|
|
* (we use it for the memory handle)
|
|
*
|
|
* The SEGPTR is used by the caller!
|
|
*/
|
|
|
|
REGS_ENTRYPOINT(AllocMappedBuffer)
|
|
{
|
|
HGLOBAL32 handle = GlobalAlloc32(0, EDI_reg(context) + 8);
|
|
DWORD *buffer = (DWORD *)GlobalLock32(handle);
|
|
SEGPTR ptr = 0;
|
|
|
|
if (buffer)
|
|
if (!(ptr = MapLS(buffer + 2)))
|
|
{
|
|
GlobalUnlock32(handle);
|
|
GlobalFree32(handle);
|
|
}
|
|
|
|
if (!ptr)
|
|
EAX_reg(context) = EDI_reg(context) = 0;
|
|
else
|
|
{
|
|
buffer[0] = handle;
|
|
buffer[1] = ptr;
|
|
|
|
EAX_reg(context) = (DWORD) ptr;
|
|
EDI_reg(context) = (DWORD)(buffer + 2);
|
|
}
|
|
}
|
|
|
|
/**********************************************************************
|
|
* FreeMappedBuffer (KERNEL32.39)
|
|
*
|
|
* Free a buffer allocated by AllocMappedBuffer
|
|
*
|
|
* Input: EDI register: pointer to buffer
|
|
*/
|
|
|
|
REGS_ENTRYPOINT(FreeMappedBuffer)
|
|
{
|
|
if (EDI_reg(context))
|
|
{
|
|
DWORD *buffer = (DWORD *)EDI_reg(context) - 2;
|
|
|
|
UnMapLS(buffer[1]);
|
|
|
|
GlobalUnlock32(buffer[0]);
|
|
GlobalFree32(buffer[0]);
|
|
}
|
|
}
|
|
|
|
/**********************************************************************
|
|
* WOWGetVDMPointer (KERNEL32.55)
|
|
* Get linear from segmented pointer. (MSDN lib)
|
|
*/
|
|
LPVOID WINAPI WOWGetVDMPointer(DWORD vp,DWORD nrofbytes,BOOL32 protected)
|
|
{
|
|
/* FIXME: add size check too */
|
|
if (protected)
|
|
return PTR_SEG_TO_LIN(vp);
|
|
else
|
|
return DOSMEM_MapRealToLinear(vp);
|
|
}
|
|
|
|
/**********************************************************************
|
|
* GetVDMPointer32W (KERNEL.516)
|
|
*/
|
|
LPVOID WINAPI GetVDMPointer32W(DWORD vp,DWORD mode)
|
|
{
|
|
return WOWGetVDMPointer(vp,0,mode);
|
|
}
|
|
|
|
/**********************************************************************
|
|
* WOWGetVDMPointerFix (KERNEL32.55)
|
|
* Dito, but fix heapsegment (MSDN lib)
|
|
*/
|
|
LPVOID WINAPI WOWGetVDMPointerFix(DWORD vp,DWORD nrofbytes,BOOL32 protected)
|
|
{
|
|
/* FIXME: fix heapsegment */
|
|
return WOWGetVDMPointer(vp,nrofbytes,protected);
|
|
}
|
|
|
|
/**********************************************************************
|
|
* WOWGetVDMPointerUnFix (KERNEL32.56)
|
|
*/
|
|
void WINAPI WOWGetVDMPointerUnfix(DWORD vp)
|
|
{
|
|
/* FIXME: unfix heapsegment */
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UTSelectorOffsetToLinear (WIN32S16.48)
|
|
*
|
|
* rough guesswork, but seems to work (I had no "reasonable" docu)
|
|
*/
|
|
LPVOID WINAPI UTSelectorOffsetToLinear(SEGPTR sptr)
|
|
{
|
|
return PTR_SEG_TO_LIN(sptr);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UTLinearToSelectorOffset (WIN32S16.49)
|
|
*
|
|
* FIXME: I don't know if that's the right way to do linear -> segmented
|
|
*/
|
|
SEGPTR WINAPI UTLinearToSelectorOffset(LPVOID lptr)
|
|
{
|
|
return (SEGPTR)lptr;
|
|
}
|