init();
fd_set readfds;
timeval tv;
- int fdsReady = 0;
tv.tv_sec = 20;
tv.tv_usec = 0;
if (dw)
{
LPVOID lpMsgBuf;
- LPVOID lpDisplayBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
(LPTSTR) &lpMsgBuf,
0, NULL );
- printf("Error: %s\nPress Enter..\n", lpMsgBuf);
+ _tprintf(_T("Error: %s\nPress Enter..\n"), (LPTSTR)lpMsgBuf);
getchar();
+
+ if(lpMsgBuf)
+ LocalFree(lpMsgBuf);
}
}
val = blksize;
req.blksize = val;
- sprintf(outPtr, "%u", val);
+ sprintf(outPtr, "%lu", val);
outPtr += strlen(outPtr) + 1;
}
else if (!strcasecmp(inPtr, "tsize"))
if (ftell(req.file) >= 0)
{
req.tsize = ftell(req.file);
- sprintf(outPtr, "%u", req.tsize);
+ sprintf(outPtr, "%lu", req.tsize);
outPtr += strlen(outPtr) + 1;
}
else
else
{
req.tsize = 0;
- sprintf(outPtr, "%u", req.tsize);
+ sprintf(outPtr, "%lu", req.tsize);
outPtr += strlen(outPtr) + 1;
}
}
req.timeout = val;
req.expiry = time(NULL) + req.timeout;
- sprintf(outPtr, "%u", val);
+ sprintf(outPtr, "%lu", val);
outPtr += strlen(outPtr) + 1;
}
continue;
errno = 0;
- req.bytesReady = (DWORD)outPtr - (DWORD)&req.mesout;
+ req.bytesReady = (DWORD_PTR)outPtr - (DWORD_PTR)&req.mesout;
//printf("Bytes Ready=%u\n", req.bytesReady);
send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
errno = WSAGetLastError();
}
else
{
- sprintf(req.serverError.errormessage, "%u Blocks Served", req.fblock - 1);
+ sprintf(req.serverError.errormessage, "%lu Blocks Served", req.fblock - 1);
logMess(&req, 2);
req.attempt = UCHAR_MAX;
break;
{
fclose(req.file);
req.file = 0;
- sprintf(req.serverError.errormessage, "%u Blocks Received", req.fblock);
+ sprintf(req.serverError.errormessage, "%lu Blocks Received", req.fblock);
logMess(&req, 2);
req.attempt = UCHAR_MAX;
break;
}
else
{
- sprintf(logBuff, "Section [HOME], alias name too large", name);
+ sprintf(logBuff, "Section [HOME], alias %s too large", name);
logMess(logBuff, 1);
}
}
if (lEvent == NULL)
{
- printf("CreateEvent error: %d\n", GetLastError());
+ printf("CreateEvent error: %lu\n", GetLastError());
exit(-1);
}
else if ( GetLastError() == ERROR_ALREADY_EXISTS )
if (tEvent == NULL)
{
- printf("CreateEvent error: %d\n", GetLastError());
+ printf("CreateEvent error: %lu\n", GetLastError());
exit(-1);
}
else if ( GetLastError() == ERROR_ALREADY_EXISTS )
if (sEvent == NULL)
{
- printf("CreateEvent error: %d\n", GetLastError());
+ printf("CreateEvent error: %lu\n", GetLastError());
exit(-1);
}
else if ( GetLastError() == ERROR_ALREADY_EXISTS )
if (cEvent == NULL)
{
- printf("CreateEvent error: %d\n", GetLastError());
+ printf("CreateEvent error: %lu\n", GetLastError());
exit(-1);
}
else if ( GetLastError() == ERROR_ALREADY_EXISTS )
{
WaitForSingleObject(lEvent, INFINITE);
- char tempbuff[256];
-
if (verbatim)
printf("%s\n", logBuff);
else if (cfig.logfile && logLevel <= cfig.logLevel)
[SourceDisksFiles]
acpi.sys=,,,,,,,,,,,,4
- atapi.sys=,,,,,,x,,,,,,4
+ uniata.sys=,,,,,,x,,,,,,4
buslogic.sys=,,,,,,x,,,,,,4
blue.sys=,,,,,,x,,,,,,4
bootvid.dll=,,,,,,,,,,,,4
ntfs.sys=,,,,,,,,,,,,4
pci.sys=,,,,,,,,,,,,4
scsiport.sys=,,,,,,x,,,,,,4
- uniata.sys=,,,,,,,,,,,,4
fastfat.sys=,,,,,,x,,,,,,4
-ramdisk.sys=,,,,,,x,,,,,,4
-ext2.sys=,,,,,,x,,,,,,4
+;ramdisk.sys=,,,,,,x,,,,,,4
+;ext2.sys=,,,,,,x,,,,,,4
[HardwareIdsDatabase]
*PNP0C08 = acpi
<include base="ntoskrnl">include</include>
<define name="_NTHAL_" />
<define name="FREELDR_REACTOS_SETUP" />
- <compilerflag>-ffreestanding</compilerflag>
- <compilerflag>-fno-builtin</compilerflag>
- <compilerflag>-fno-inline</compilerflag>
- <compilerflag>-fno-zero-initialized-in-bss</compilerflag>
- <compilerflag>-Os</compilerflag>
+ <group compilerset="gcc">
+ <compilerflag>-ffreestanding</compilerflag>
+ <compilerflag>-fno-builtin</compilerflag>
+ <compilerflag>-fno-inline</compilerflag>
+ <compilerflag>-fno-zero-initialized-in-bss</compilerflag>
+ <compilerflag>-Os</compilerflag>
+ </group>
<file>bootmgr.c</file>
<directory name="inffile">
<file>inffile.c</file>
<file>setupldr.c</file>
</directory>
<directory name="windows">
- <file>setupldr2.c</file>
+ <if property="ARCH" value="i386">
+ <file>setupldr2.c</file>
+ </if>
</directory>
</module>
<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
<module name="mesa32" type="win32dll" entrypoint="0" baseaddress="${BASEADDRESS_MESA32}" installbase="system32" installname="mesa32.dll" allowwarnings="true" crt="msvcrt">
<importlibrary definition="src/drivers/windows/icd/mesa.def" />
- <linkerflag>-enable-stdcall-fixup</linkerflag>
- <compilerflag>-w</compilerflag>
+ <linkerflag linkerset="ld">-enable-stdcall-fixup</linkerflag>
+ <compilerflag compilerset="gcc">-w</compilerflag>
<library>ntdll</library>
<library>kernel32</library>
<library>user32</library>
<define name="BUILD_GL32" />
<define name="WIN32" />
<define name="USE_EXTERNAL_DXTN_LIB=1" />
- <define name="USE_X86_ASM" />
- <define name="USE_MMX_ASM" />
- <define name="USE_SSE_ASM" />
+ <if property="ARCH" value="i386">
+ <define name="USE_X86_ASM" />
+ <define name="USE_MMX_ASM" />
+ <define name="USE_SSE_ASM" />
+ </if>
<define name="USE_3DNOW_ASM" />
+ <define name="GL_NO_STDCALL" />
<include base="mesa32">include</include>
<include base="mesa32">src</include>
<include base="mesa32">src/main</include>
<file>t_vertex.c</file>
<file>t_vertex_generic.c</file>
<file>t_vp_build.c</file>
- <file>t_vertex_sse.c</file>
+ <if property="ARCH" value="i386">
+ <file>t_vertex_sse.c</file>
+ </if>
</directory>
<directory name="vbo">
<file>vbo_context.c</file>
</directory>
</directory>
</directory>
- <directory name="x86">
- <directory name="rtasm">
- <file>x86sse.c</file>
+
+ <if property="ARCH" value="i386">
+ <directory name="x86">
+ <directory name="rtasm">
+ <file>x86sse.c</file>
+ </directory>
+ <file>3dnow.c</file>
+ <file>3dnow_normal.S</file>
+ <file>3dnow_xform1.S</file>
+ <file>3dnow_xform2.S</file>
+ <file>3dnow_xform3.S</file>
+ <file>3dnow_xform4.S</file>
+ <file>common_x86.c</file>
+ <file>common_x86_asm.S</file>
+ <file>glapi_x86.S</file>
+ <file>mmx_blend.S</file>
+ <file>read_rgba_span_x86.S</file>
+ <file>sse_normal.S</file>
+ <file>sse_xform1.S</file>
+ <file>sse_xform2.S</file>
+ <file>sse_xform3.S</file>
+ <file>sse_xform4.S</file>
+ <file>x86.c</file>
+ <file>x86_cliptest.S</file>
+ <file>x86_xform2.S</file>
+ <file>x86_xform3.S</file>
+ <file>x86_xform4.S</file>
+ <file>sse.c</file>
</directory>
- <file>3dnow.c</file>
- <file>3dnow_normal.S</file>
- <file>3dnow_xform1.S</file>
- <file>3dnow_xform2.S</file>
- <file>3dnow_xform3.S</file>
- <file>3dnow_xform4.S</file>
- <file>common_x86.c</file>
- <file>common_x86_asm.S</file>
- <file>glapi_x86.S</file>
- <file>mmx_blend.S</file>
- <file>read_rgba_span_x86.S</file>
- <file>sse_normal.S</file>
- <file>sse_xform1.S</file>
- <file>sse_xform2.S</file>
- <file>sse_xform3.S</file>
- <file>sse_xform4.S</file>
- <file>x86.c</file>
- <file>x86_cliptest.S</file>
- <file>x86_xform2.S</file>
- <file>x86_xform3.S</file>
- <file>x86_xform4.S</file>
- <file>sse.c</file>
- </directory>
- <directory name="x86-64">
- <file>x86-64.c</file>
+ </if>
+
+ <if property="ARCH" value="amd64">
+ <directory name="x86-64">
+ <file>x86-64.c</file>
+ <!-- file>glapi_x86-64.S</file -->
+ <file>xform4.S</file>
+ </directory>
+ </if>
+
</directory>
-</directory>
</module>
<?xml version="1.0"?>
<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
<module name="ddraw" type="win32dll" installbase="system32" installname="ddraw.dll" unicode="yes" crt="msvcrt">
- <importlibrary definition="ddraw.def" />
+ <importlibrary definition="ddraw.spec" />
<include base="ddraw">.</include>
<library>kernel32</library>
<library>user32</library>
<file>DirectD3D7_Vtable.c</file>
</directory>
<!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38054#c7 -->
- <compilerflag>-fno-unit-at-a-time</compilerflag>
+ <compilerflag compilerset="gcc">-fno-unit-at-a-time</compilerflag>
</module>
<directory name="amstream">
<xi:include href="amstream/amstream.rbuild" />
</directory>
+ <directory name="d3d8">
+ <xi:include href="d3d8/d3d8.rbuild" />
+ </directory>
<directory name="d3d8thk">
<xi:include href="d3d8thk/d3d8thk.rbuild" />
</directory>
+ <directory name="d3d9">
+ <xi:include href="d3d9/d3d9.rbuild" />
+ </directory>
+ <directory name="ddraw">
+ <xi:include href="ddraw/ddraw.rbuild" />
+ </directory>
<directory name="devenum">
<xi:include href="devenum/devenum.rbuild" />
</directory>
<directory name="dinput8">
<xi:include href="dinput8/dinput8.rbuild" />
</directory>
+ <directory name="dmusic">
+ <xi:include href="dmusic/dmusic.rbuild" />
+ </directory>
<directory name="dplay">
<xi:include href="dplay/dplay.rbuild" />
</directory>
<xi:include href="quartz/quartz.rbuild" />
</directory>
- <directory name="wine">
- <xi:include href="wine/wine.rbuild" />
- </directory>
</group>
<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
<module name="idndl" type="win32dll" installname="idndl.dll" entrypoint="0">
<library>kernel32</library>
- <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
- <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ <group compilerset="gcc">
+ <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
+ <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ </group>
<redefine name="WINVER">0x600</redefine>
<file>idndl.cpp</file>
- <importlibrary definition="idndl.def" />
+ <importlibrary definition="idndl-$(ARCH).def" />
</module>
InsertTailList(&Peb->Ldr->InLoadOrderModuleList,
&NtModule->InLoadOrderLinks);
InsertTailList(&Peb->Ldr->InInitializationOrderModuleList,
- &NtModule->InInitializationOrderModuleList);
+ &NtModule->InInitializationOrderLinks);
- #if defined(DBG) || defined(KDBG)
+ #if DBG || defined(KDBG)
LdrpLoadUserModuleSymbols(NtModule);
LdrpInitLoader();
- #if defined(DBG) || defined(KDBG)
+ #if DBG || defined(KDBG)
LdrpLoadUserModuleSymbols(ExeModule);
/* FUNCTIONS *****************************************************************/
- #if defined(DBG) || defined(KDBG)
+ #if DBG || defined(KDBG)
VOID
LdrpLoadUserModuleSymbols(PLDR_DATA_TABLE_ENTRY LdrModule)
ASSERT(Module);
memset(Module, 0, sizeof(LDR_DATA_TABLE_ENTRY));
Module->DllBase = (PVOID)ImageBase;
- Module->EntryPoint = (PVOID)NTHeaders->OptionalHeader.AddressOfEntryPoint;
+ Module->EntryPoint = (PVOID)(ULONG_PTR)NTHeaders->OptionalHeader.AddressOfEntryPoint;
if (Module->EntryPoint != 0)
Module->EntryPoint = (PVOID)((ULONG_PTR)Module->EntryPoint + (ULONG_PTR)Module->DllBase);
Module->SizeOfImage = LdrpGetResidentSize(NTHeaders);
? RVA(BaseAddress, ExFunctions[Ordinal - ExportDir->Base] )
: NULL);
- if (((ULONG)Function >= (ULONG)ExportDir) &&
- ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
+ if (((ULONG_PTR)Function >= (ULONG_PTR)ExportDir) &&
+ ((ULONG_PTR)Function < (ULONG_PTR)ExportDir + (ULONG_PTR)ExportDirSize))
{
DPRINT("Forward: %s\n", (PCHAR)Function);
Function = LdrFixupForward((PCHAR)Function);
{
Ordinal = ExOrdinals[Hint];
Function = RVA(BaseAddress, ExFunctions[Ordinal]);
- if (((ULONG)Function >= (ULONG)ExportDir) &&
- ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
+ if (((ULONG_PTR)Function >= (ULONG_PTR)ExportDir) &&
+ ((ULONG_PTR)Function < (ULONG_PTR)ExportDir + (ULONG_PTR)ExportDirSize))
{
DPRINT("Forward: %s\n", (PCHAR)Function);
Function = LdrFixupForward((PCHAR)Function);
{
Ordinal = ExOrdinals[mid];
Function = RVA(BaseAddress, ExFunctions[Ordinal]);
- if (((ULONG)Function >= (ULONG)ExportDir) &&
- ((ULONG)Function < (ULONG)ExportDir + (ULONG)ExportDirSize))
+ if (((ULONG_PTR)Function >= (ULONG_PTR)ExportDir) &&
+ ((ULONG_PTR)Function < (ULONG_PTR)ExportDir + (ULONG_PTR)ExportDirSize))
{
DPRINT("Forward: %s\n", (PCHAR)Function);
Function = LdrFixupForward((PCHAR)Function);
{
PIMAGE_DATA_DIRECTORY RelocationDDir;
PIMAGE_BASE_RELOCATION RelocationDir, RelocationEnd;
- ULONG Count, ProtectSize, OldProtect, OldProtect2;
+ ULONG Count, OldProtect, OldProtect2;
+ SIZE_T ProtectSize;
PVOID Page, ProtectPage, ProtectPage2;
PUSHORT TypeOffset;
ULONG_PTR Delta;
PVOID IATBase;
ULONG OldProtect;
ULONG Ordinal;
- ULONG IATSize;
+ SIZE_T IATSize;
if (ImportModuleDirectory == NULL || ImportModuleDirectory->Name == 0)
{
PVOID IATBase;
ULONG OldProtect;
ULONG Offset;
- ULONG IATSize;
+ SIZE_T IATSize;
PIMAGE_NT_HEADERS NTHeaders;
PCHAR Name;
ULONG Size;
DPRINT1("LdrFixupImports failed for %wZ, status=%x\n", &(*Module)->BaseDllName, Status);
return Status;
}
- #if defined(DBG) || defined(KDBG)
+ #if DBG || defined(KDBG)
LdrpLoadUserModuleSymbols(*Module);
#endif /* DBG || KDBG */
RtlEnterCriticalSection(NtCurrentPeb()->LoaderLock);
InsertTailList(&NtCurrentPeb()->Ldr->InInitializationOrderModuleList,
- &(*Module)->InInitializationOrderModuleList);
+ &(*Module)->InInitializationOrderLinks);
RtlLeaveCriticalSection (NtCurrentPeb()->LoaderLock);
}
return STATUS_SUCCESS;
Entry = ModuleListHead->Blink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
if (((UnloadAll && Module->LoadCount == LDRP_PROCESS_CREATION_TIME) || Module->LoadCount == 0) &&
Module->Flags & LDRP_ENTRY_PROCESSED &&
!(Module->Flags & LDRP_UNLOAD_IN_PROGRESS))
{
TRACE_LDR("Unload %wZ - Calling entry point at %x\n",
&Module->BaseDllName, Module->EntryPoint);
- LdrpCallDllEntry(Module, DLL_PROCESS_DETACH, (PVOID)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
+ LdrpCallDllEntry(Module, DLL_PROCESS_DETACH, (PVOID)(INT_PTR)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
}
else
{
Entry = ModuleListHead->Blink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
Entry = Entry->Blink;
if (Module->Flags & LDRP_UNLOAD_IN_PROGRESS &&
((UnloadAll && Module->LoadCount != LDRP_PROCESS_CREATION_TIME) || Module->LoadCount == 0))
{
/* remove the module entry from the list */
RemoveEntryList (&Module->InLoadOrderLinks);
- RemoveEntryList (&Module->InInitializationOrderModuleList);
+ RemoveEntryList (&Module->InInitializationOrderLinks);
NtUnmapViewOfSection (NtCurrentProcess (), Module->DllBase);
NtClose (Module->SectionPointer);
Entry = ModuleListHead->Flink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
if (!(Module->Flags & (LDRP_LOAD_IN_PROGRESS|LDRP_UNLOAD_IN_PROGRESS|LDRP_ENTRY_PROCESSED)))
{
Module->Flags |= LDRP_LOAD_IN_PROGRESS;
TRACE_LDR("%wZ loaded - Calling init routine at %x for process attaching\n",
&Module->BaseDllName, Module->EntryPoint);
- Result = LdrpCallDllEntry(Module, DLL_PROCESS_ATTACH, (PVOID)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
+ Result = LdrpCallDllEntry(Module, DLL_PROCESS_ATTACH, (PVOID)(INT_PTR)(Module->LoadCount == LDRP_PROCESS_CREATION_TIME ? 1 : 0));
if (!Result)
{
Status = STATUS_DLL_INIT_FAILED;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
if (Module->Flags & LDRP_PROCESS_ATTACH_CALLED &&
!(Module->Flags & LDRP_DONT_CALL_FOR_THREADS) &&
!(Module->Flags & LDRP_UNLOAD_IN_PROGRESS))
Entry = ModuleListHead->Blink;
while (Entry != ModuleListHead)
{
- Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
+ Module = CONTAINING_RECORD(Entry, LDR_DATA_TABLE_ENTRY, InInitializationOrderLinks);
if (Module->Flags & LDRP_PROCESS_ATTACH_CALLED &&
!(Module->Flags & LDRP_DONT_CALL_FOR_THREADS) &&
LongPtr = (PULONG)((ULONG_PTR)Address + Offset);
*LongPtr += Delta;
break;
+#ifdef _WIN64
+ case IMAGE_REL_BASED_DIR64:
+ LongPtr = (PULONG)((ULONG_PTR)Address + Offset);
+ *LongPtr += Delta;
+ break;
+#endif
case IMAGE_REL_BASED_HIGHADJ:
case IMAGE_REL_BASED_MIPS_JMPADDR:
#include <debug.h>
SIZE_T RtlpAllocDeallocQueryBufferSize = PAGE_SIZE;
+#define IMAGE_DOS_MAGIC 0x5a4d
+#define IMAGE_PE_MAGIC 0x00004550
/* FUNCTIONS ***************************************************************/
+#ifndef _M_AMD64
+// FIXME: Why "Not implemented"???
/*
* @implemented
*/
/* Not implemented for user-mode */
return 0;
}
+#endif
BOOLEAN
NTAPI
}
- #ifdef DBG
+ #if DBG
VOID FASTCALL
CHECK_PAGED_CODE_RTL(char *file, int line)
{
return TRUE;
}
+#ifdef _AMD64_
+VOID
+NTAPI
+RtlpGetStackLimits(
+ OUT PULONG_PTR LowLimit,
+ OUT PULONG_PTR HighLimit)
+{
+ *LowLimit = (ULONG_PTR)NtCurrentTeb()->Tib.StackLimit;
+ *HighLimit = (ULONG_PTR)NtCurrentTeb()->Tib.StackBase;
+ return;
+}
+#endif
+
/* RTL Atom Tables ************************************************************/
typedef struct _RTL_ATOM_HANDLE
return NULL;
}
+PVOID
+NTAPI
+RtlpLookupModuleBase(
+ PVOID Address)
+{
+ NTSTATUS Status;
+ MEMORY_BASIC_INFORMATION MemoryInformation;
+ ULONG_PTR Base, Limit;
+ PIMAGE_DOS_HEADER DosHeader;
+ PIMAGE_NT_HEADERS NtHeader;
+
+ Status = NtQueryVirtualMemory(NtCurrentProcess(),
+ Address,
+ MemoryBasicInformation,
+ &MemoryInformation,
+ sizeof(MEMORY_BASIC_INFORMATION),
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return NULL;
+ }
+
+ /* FIXME: remove these checks? */
+ Base = (ULONG_PTR)MemoryInformation.BaseAddress;
+ Limit = Base + MemoryInformation.RegionSize;
+ if ( ((ULONG_PTR)Address < Base) ||
+ ((ULONG_PTR)Address >= Limit) )
+ {
+ /* WTF? */
+ return NULL;
+ }
+
+ /* Check if we got the right kind of memory */
+ if ( (MemoryInformation.State != MEM_COMMIT) ||
+ (MemoryInformation.Type != MEM_IMAGE) )
+ {
+ return NULL;
+ }
+
+ /* Check DOS magic */
+ DosHeader = MemoryInformation.AllocationBase;
+ if (DosHeader->e_magic != IMAGE_DOS_MAGIC)
+ {
+ return NULL;
+ }
+
+ /* Check NT header */
+ NtHeader = (PVOID)((ULONG_PTR)DosHeader + DosHeader->e_lfanew);
+ if (NtHeader->Signature != IMAGE_PE_MAGIC)
+ {
+ return NULL;
+ }
+
+ return MemoryInformation.AllocationBase;
+}
+
/*
* Ldr Resource support code
static HANDLE ProcessHeap;
static BOOLEAN DefaultHandlesDisabled = FALSE;
static BOOLEAN DefaultHandleHKUDisabled = FALSE;
+ static BOOLEAN DllInitialized = FALSE; /* HACK */
/* PROTOTYPES ***************************************************************/
NtClose(Handle); \
}
#define IsPredefKey(HKey) \
- (((ULONG)(HKey) & 0xF0000000) == 0x80000000)
+ (((ULONG_PTR)(HKey) & 0xF0000000) == 0x80000000)
#define GetPredefKeyIndex(HKey) \
- ((ULONG)(HKey) & 0x0FFFFFFF)
+ ((ULONG_PTR)(HKey) & 0x0FFFFFFF)
static NTSTATUS OpenClassesRootKey(PHANDLE KeyHandle);
static NTSTATUS OpenLocalMachineKey (PHANDLE KeyHandle);
{
TRACE("RegInitialize()\n");
- ProcessHeap = RtlGetProcessHeap();
- RtlZeroMemory(DefaultHandleTable,
- MAX_DEFAULT_HANDLES * sizeof(HANDLE));
- RtlInitializeCriticalSection(&HandleTableCS);
+ /* Lazy init hack */
+ if (!DllInitialized)
+ {
+ ProcessHeap = RtlGetProcessHeap();
+ RtlZeroMemory(DefaultHandleTable,
+ MAX_DEFAULT_HANDLES * sizeof(HANDLE));
+ RtlInitializeCriticalSection(&HandleTableCS);
+
+ DllInitialized = TRUE;
+ }
return TRUE;
}
{
return STATUS_INVALID_PARAMETER;
}
-
+ RegInitialize(); /* HACK until delay-loading is implemented */
RtlEnterCriticalSection (&HandleTableCS);
if (Key == HKEY_CURRENT_USER)
CloseDefaultKeys(VOID)
{
ULONG i;
-
+ RegInitialize(); /* HACK until delay-loading is implemented */
RtlEnterCriticalSection(&HandleTableCS);
for (i = 0; i < MAX_DEFAULT_HANDLES; i++)
LONG WINAPI
RegDisablePredefinedCache(VOID)
{
+ RegInitialize(); /* HACK until delay-loading is implemented */
RtlEnterCriticalSection(&HandleTableCS);
DefaultHandleHKUDisabled = TRUE;
RtlLeaveCriticalSection(&HandleTableCS);
LONG WINAPI
RegDisablePredefinedCacheEx(VOID)
{
+ RegInitialize(); /* HACK until delay-loading is implemented */
RtlEnterCriticalSection(&HandleTableCS);
DefaultHandlesDisabled = TRUE;
DefaultHandleHKUDisabled = TRUE;
ASSERT(hNewHKey != NULL);
}
-
+ RegInitialize(); /* HACK until delay-loading is implemented */
RtlEnterCriticalSection(&HandleTableCS);
/* close the currently mapped handle if existing */
handle for example! */
return RtlNtStatusToDosError(Status);
}
-
+ RegInitialize(); /* HACK until delay-loading is implemented */
TokenUserData = RtlAllocateHeap(ProcessHeap,
0,
RequiredLength);
if (ErrorCode == ERROR_SUCCESS ||
ErrorCode == ERROR_MORE_DATA)
{
- if (lpType != NULL)
- {
- *lpType = Type;
- }
if ((Type == REG_SZ) || (Type == REG_MULTI_SZ) || (Type == REG_EXPAND_SZ))
{
}
}
+ if (lpType != NULL)
+ {
+ *lpType = Type;
+ }
+
if (ValueData.Buffer != NULL)
{
RtlFreeHeap(ProcessHeap, 0, ValueData.Buffer);
(count && data) ? *count : 0 );
if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
- //if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
status = MapDefaultKey(&hkey, hkeyorg);
if (!NT_SUCCESS(status))
if (count) *count = 0;
}
+ /* this matches Win9x behaviour - NT sets *type to a random value */
+ if (type) *type = REG_NONE;
+
status = NtQueryValueKey( hkey, &name_str, KeyValuePartialInformation,
buffer, total_size, &total_size );
if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
{
if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
+ {
+ ClosePredefKey(hkey);
return ERROR_NOT_ENOUGH_MEMORY;
+ }
info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
status = NtQueryValueKey( hkey, &name_str, KeyValuePartialInformation,
buf_ptr, total_size, &total_size );
*
* @implemented
*/
- LONG WINAPI
- RegQueryValueA(HKEY hKey,
- LPCSTR lpSubKey,
- LPSTR lpValue,
- PLONG lpcbValue)
+ LSTATUS WINAPI RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
{
- WCHAR SubKeyNameBuffer[MAX_PATH+1];
- UNICODE_STRING SubKeyName;
- UNICODE_STRING Value;
- ANSI_STRING AnsiString;
- LONG ValueSize;
- LONG ErrorCode;
+ DWORD ret;
+ HKEY subkey = hkey;
- TRACE("hKey 0x%X lpSubKey %s lpValue %p lpcbValue %d\n",
- hKey, lpSubKey, lpValue, lpcbValue ? *lpcbValue : 0);
+ TRACE("(%p,%s,%p,%d)\n", hkey, debugstr_a(name), data, count ? *count : 0 );
- if (lpValue != NULL &&
- lpcbValue == NULL)
+ if (name && name[0])
{
- return ERROR_INVALID_PARAMETER;
+ if ((ret = RegOpenKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
}
-
- RtlInitUnicodeString(&SubKeyName,
- NULL);
- RtlInitUnicodeString(&Value,
- NULL);
- if (lpSubKey != NULL &&
- strlen(lpSubKey) != 0)
+ ret = RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, (LPDWORD)count );
+ if (subkey != hkey) RegCloseKey( subkey );
+ if (ret == ERROR_FILE_NOT_FOUND)
{
- RtlInitAnsiString(&AnsiString,
- (LPSTR)lpSubKey);
- SubKeyName.Buffer = &SubKeyNameBuffer[0];
- SubKeyName.MaximumLength = sizeof(SubKeyNameBuffer);
- RtlAnsiStringToUnicodeString(&SubKeyName,
- &AnsiString,
- FALSE);
+ /* return empty string if default value not found */
+ if (data) *data = 0;
+ if (count) *count = 1;
+ ret = ERROR_SUCCESS;
}
-
- if (lpValue != NULL)
- {
- ValueSize = *lpcbValue * sizeof(WCHAR);
- Value.MaximumLength = ValueSize;
- Value.Buffer = RtlAllocateHeap(ProcessHeap,
- 0,
- ValueSize);
- if (Value.Buffer == NULL)
- {
- return ERROR_OUTOFMEMORY;
- }
- }
- else
- {
- ValueSize = 0;
- }
-
- ErrorCode = RegQueryValueW(hKey,
- (LPCWSTR)SubKeyName.Buffer,
- Value.Buffer,
- &ValueSize);
- if (ErrorCode == ERROR_SUCCESS)
- {
- if (lpValue != NULL)
- {
- Value.Length = ValueSize;
- RtlInitAnsiString(&AnsiString,
- NULL);
- AnsiString.Buffer = lpValue;
- AnsiString.MaximumLength = *lpcbValue;
- RtlUnicodeStringToAnsiString(&AnsiString,
- &Value,
- FALSE);
- *lpcbValue = ValueSize;
- }
- else if (lpcbValue != NULL)
- {
- *lpcbValue = ValueSize;
- }
- }
-
- if (Value.Buffer != NULL)
- {
- RtlFreeHeap(ProcessHeap,
- 0,
- Value.Buffer);
- }
-
- return ErrorCode;
+ return ret;
}
*
* @implemented
*/
- LONG WINAPI
- RegQueryValueW(HKEY hKey,
- LPCWSTR lpSubKey,
- LPWSTR lpValue,
- PLONG lpcbValue)
+ LSTATUS WINAPI RegQueryValueW( HKEY hkey, LPCWSTR name, LPWSTR data, LPLONG count )
{
- OBJECT_ATTRIBUTES ObjectAttributes;
- UNICODE_STRING SubKeyString;
- HANDLE KeyHandle;
- HANDLE RealKey;
- LONG ErrorCode;
- BOOL CloseRealKey;
- NTSTATUS Status;
+ DWORD ret;
+ HKEY subkey = hkey;
- TRACE("hKey 0x%X lpSubKey %S lpValue %p lpcbValue %d\n",
- hKey, lpSubKey, lpValue, lpcbValue ? *lpcbValue : 0);
- if (hKey == NULL)
+ TRACE("(%p,%s,%p,%d)\n", hkey, debugstr_w(name), data, count ? *count : 0 );
+ if (hkey == NULL)
{
return ERROR_INVALID_HANDLE;
}
- Status = MapDefaultKey(&KeyHandle,
- hKey);
- if (!NT_SUCCESS(Status))
- {
- return RtlNtStatusToDosError(Status);
- }
-
- if (lpSubKey != NULL &&
- wcslen(lpSubKey) != 0)
+ if (name && name[0])
{
- RtlInitUnicodeString(&SubKeyString,
- (LPWSTR)lpSubKey);
- InitializeObjectAttributes(&ObjectAttributes,
- &SubKeyString,
- OBJ_CASE_INSENSITIVE,
- KeyHandle,
- NULL);
- Status = NtOpenKey(&RealKey,
- KEY_QUERY_VALUE,
- &ObjectAttributes);
- if (!NT_SUCCESS(Status))
+ ret = RegOpenKeyW( hkey, name, &subkey);
+ if (ret != ERROR_SUCCESS)
{
- ErrorCode = RtlNtStatusToDosError(Status);
- goto Cleanup;
+ return ret;
}
-
- CloseRealKey = TRUE;
}
- else
+
+ ret = RegQueryValueExW( subkey, NULL, NULL, NULL, (LPBYTE)data, (LPDWORD)count );
+
+ if (subkey != hkey)
{
- RealKey = hKey;
- CloseRealKey = FALSE;
+ RegCloseKey( subkey );
}
- ErrorCode = RegQueryValueExW(RealKey,
- NULL,
- NULL,
- NULL,
- (LPBYTE)lpValue,
- (LPDWORD)lpcbValue);
- if (CloseRealKey)
+ if (ret == ERROR_FILE_NOT_FOUND)
{
- NtClose(RealKey);
+ /* return empty string if default value not found */
+ if (data)
+ *data = 0;
+ if (count)
+ *count = sizeof(WCHAR);
+ ret = ERROR_SUCCESS;
}
-
- Cleanup:
- ClosePredefKey(KeyHandle);
-
- return ErrorCode;
+ return ret;
}
{
DWORD ErrorCode;
- if (InterlockedCompareExchangePointer(&NtMarta,
+ if (InterlockedCompareExchangePointer((PVOID)&NtMarta,
NULL,
NULL) == NULL)
{
if (ErrorCode == ERROR_SUCCESS)
{
/* try change the NtMarta pointer */
- if (InterlockedCompareExchangePointer(&NtMarta,
+ if (InterlockedCompareExchangePointer((PVOID)&NtMarta,
&NtMartaStatic,
NULL) != NULL)
{
VOID
UnloadNtMarta(VOID)
{
- if (InterlockedExchangePointer(&NtMarta,
+ if (InterlockedExchangePointer((PVOID)&NtMarta,
NULL) != NULL)
{
FreeLibrary(NtMartaStatic.hDllInstance);
PACL *ppSacl,
PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
{
- UNICODE_STRING ObjectName;
- NTSTATUS Status;
- DWORD Ret;
+ DWORD len;
+ LPWSTR wstr = NULL;
+ DWORD r;
- Status = RtlCreateUnicodeStringFromAsciiz(&ObjectName,
- pObjectName);
- if (!NT_SUCCESS(Status))
+ TRACE("%s %d %d %p %p %p %p %p\n", pObjectName, ObjectType, SecurityInfo,
+ ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor);
+
+ if( pObjectName )
{
- return RtlNtStatusToDosError(Status);
+ len = MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, NULL, 0 );
+ wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR));
+ MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, wstr, len );
}
- Ret = GetNamedSecurityInfoW(ObjectName.Buffer,
- ObjectType,
- SecurityInfo,
- ppsidOwner,
- ppsidGroup,
- ppDacl,
- ppSacl,
- ppSecurityDescriptor);
+ r = GetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, ppsidOwner,
+ ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor );
- RtlFreeUnicodeString(&ObjectName);
+ HeapFree( GetProcessHeap(), 0, wstr );
- return Ret;
+ return r;
}
<?xml version="1.0"?>
<!DOCTYPE group SYSTEM "../../../tools/rbuild/project.dtd">
<group>
- <module name="kernel32_base" type="objectlibrary" crt="dll">
+ <module name="kernel32_base" type="objectlibrary" crt="dll" allowwarnings="true">
<include base="kernel32_base">.</include>
<include base="kernel32_base">include</include>
<include base="ReactOS">include/reactos/subsys</include>
<!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38269
<pch>k32.h</pch>
-->
- <!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38054#c7 -->
- <compilerflag>-fno-unit-at-a-time</compilerflag>
+ <group compilerset="gcc">
+ <!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38054#c7 -->
+ <compilerflag>-fno-unit-at-a-time</compilerflag>
+ <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
+ <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ </group>
<directory name="debug">
<file>debugger.c</file>
<file>output.c</file>
<file>handle.c</file>
<file>lang.c</file>
<file>ldr.c</file>
- <file>lzexpand_main.c</file>
+ <file>lzexpand.c</file>
<file>muldiv.c</file>
<file>nls.c</file>
<file>perfcnt.c</file>
<file>thread.S</file>
</directory>
</if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>fiber.S</file>
+ <file>thread.S</file>
+ </directory>
+ </if>
</directory>
- <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
- <compilerflag compiler="cxx">-fno-rtti</compilerflag>
-
<directory name="misc">
<file>icustubs.cpp</file>
</directory>
<library>normalize</library>
</module>
<module name="kernel32" type="win32dll" baseaddress="${BASEADDRESS_KERNEL32}" installbase="system32" installname="kernel32.dll" crt="dll">
- <importlibrary definition="kernel32.spec" />
+ <importlibrary definition="kernel32.pspec" />
<include base="kernel32">.</include>
<include base="kernel32" root="intermediate">.</include>
<include base="kernel32">include</include>
#include <k32.h>
#ifdef _M_IX86
#include "i386/ketypes.h"
+#elif defined _M_AMD64
+#include "amd64/ketypes.h"
#endif
#define NDEBUG
BasepFreeStack(HANDLE hProcess,
PINITIAL_TEB InitialTeb)
{
- ULONG Dummy = 0;
+ SIZE_T Dummy = 0;
/* Free the Stack */
NtFreeVirtualMemory(hProcess,
IN PVOID StackAddress,
IN ULONG ContextType)
{
-#ifdef _M_IX86
+#ifdef __i386__
DPRINT("BasepInitializeContext: %p\n", Context);
/* Setup the Initial Win32 Thread Context */
}
else if (ContextType == 2) /* For Fibers */
{
- //Context->Eip = (ULONG)BaseFiberStartup;
+ Context->Eip = (ULONG)BaseFiberStartup;
}
else /* For first thread in a Process */
{
/* Give it some room for the Parameter */
Context->Esp -= sizeof(PVOID);
+#elif defined(__x86_64__)
+ DPRINT("BasepInitializeContext: %p\n", Context);
+
+ /* Setup the Initial Win32 Thread Context */
+ Context->Rax = (ULONG_PTR)StartAddress;
+ Context->Rbx = (ULONG_PTR)Parameter;
+ Context->Rsp = (ULONG_PTR)StackAddress;
+ /* The other registers are undefined */
+
+ /* Setup the Segments */
+ Context->SegGs = KGDT_64_DATA | RPL_MASK;
+ Context->SegEs = KGDT_64_DATA | RPL_MASK;
+ Context->SegDs = KGDT_64_DATA | RPL_MASK;
+ Context->SegCs = KGDT_64_R3_CODE | RPL_MASK;
+ Context->SegSs = KGDT_64_DATA | RPL_MASK;
+ Context->SegFs = KGDT_32_R3_TEB;
+
+ /* Set the EFLAGS */
+ Context->EFlags = 0x3000; /* IOPL 3 */
+
+ if (ContextType == 1) /* For Threads */
+ {
+ Context->Rip = (ULONG_PTR)BaseThreadStartupThunk;
+ }
+ else if (ContextType == 2) /* For Fibers */
+ {
+ Context->Rip = (ULONG_PTR)BaseFiberStartup;
+ }
+ else /* For first thread in a Process */
+ {
+ Context->Rip = (ULONG_PTR)BaseProcessStartThunk;
+ }
+
+ /* Set the Context Flags */
+ Context->ContextFlags = CONTEXT_FULL;
+
+ /* Give it some room for the Parameter */
+ Context->Rsp -= sizeof(PVOID);
#else
#warning Unknown architecture
UNIMPLEMENTED;
RelativeName.Handle = NULL;
/* Find the application name */
- RtlDosPathNameToNtPathName_U(lpApplicationName,
- ApplicationName,
- NULL,
- &RelativeName);
+ if (!RtlDosPathNameToNtPathName_U(lpApplicationName,
+ ApplicationName,
+ NULL,
+ &RelativeName))
+ {
+ return STATUS_OBJECT_PATH_NOT_FOUND;
+ }
+
DPRINT("ApplicationName %wZ\n", ApplicationName);
DPRINT("RelativeName %wZ\n", &RelativeName.DosPath);
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to open file\n");
- SetLastErrorByStatus (Status);
+ SetLastErrorByStatus(Status);
return Status;
}
*/
BOOL WINAPI
GetProcessAffinityMask (HANDLE hProcess,
- LPDWORD lpProcessAffinityMask,
- LPDWORD lpSystemAffinityMask)
+ PDWORD_PTR lpProcessAffinityMask,
+ PDWORD_PTR lpSystemAffinityMask)
{
PROCESS_BASIC_INFORMATION ProcessInfo;
SYSTEM_BASIC_INFORMATION SystemInfo;
*/
BOOL WINAPI
SetProcessAffinityMask (HANDLE hProcess,
- DWORD dwProcessAffinityMask)
+ DWORD_PTR dwProcessAffinityMask)
{
NTSTATUS Status;
{
NTSTATUS Status;
+ if (hProcess == NULL)
+ {
+ return FALSE;
+ }
+
Status = NtTerminateProcess (hProcess, uExitCode);
if (NT_SUCCESS(Status))
{
{
NTSTATUS Status;
HANDLE DuplicatedHandle;
- ULONG Dummy;
+ SIZE_T Dummy;
DPRINT("BasepDuplicateAndWriteHandle. hProcess: %lx, Handle: %lx,"
"Address: %p\n", ProcessHandle, StandardHandle, Address);
&StartupInfo,
lpProcessInformation);
+ case STATUS_OBJECT_NAME_NOT_FOUND:
+ case STATUS_OBJECT_PATH_NOT_FOUND:
+ SetLastErrorByStatus(Status);
+ goto Cleanup;
+
default:
/* Invalid Image Type */
SetLastError(ERROR_BAD_EXE_FORMAT);
goto Cleanup;
}
- /* Set new class */
- Status = NtSetInformationProcess(hProcess,
- ProcessPriorityClass,
- &PriorityClass,
- sizeof(PROCESS_PRIORITY_CLASS));
- if(!NT_SUCCESS(Status))
+ if (PriorityClass.PriorityClass != PROCESS_PRIORITY_CLASS_INVALID)
{
- DPRINT1("Unable to set new process priority, status 0x%x\n", Status);
- SetLastErrorByStatus(Status);
- goto Cleanup;
+ /* Set new class */
+ Status = NtSetInformationProcess(hProcess,
+ ProcessPriorityClass,
+ &PriorityClass,
+ sizeof(PROCESS_PRIORITY_CLASS));
+ if(!NT_SUCCESS(Status))
+ {
+ DPRINT1("Unable to set new process priority, status 0x%x\n", Status);
+ SetLastErrorByStatus(Status);
+ goto Cleanup;
+ }
}
/* Set Error Mode */
IN DWORD dwSelector,
OUT LPLDT_ENTRY lpSelectorEntry)
{
+#ifdef _M_IX86
DESCRIPTOR_TABLE_ENTRY DescriptionTableEntry;
NTSTATUS Status;
*lpSelectorEntry = DescriptionTableEntry.Descriptor;
return TRUE;
+#else
+ DPRINT1("Calling GetThreadSelectorEntry!\n");
+ return FALSE;
+#endif
}
/*
return -1;
}
- return dwIdealProcessor;
+ return (DWORD)Status;
}
/*
#include <debug.h>
- #ifdef DBG
+ #if DBG
//DWORD DebugTraceLevel = DEBUG_ULTRA;
DWORD DebugTraceLevel = 0;
#endif /* DBG */
( writefds ? writefds->fd_count : 0 ) +
( exceptfds ? exceptfds->fd_count : 0 );
- if( HandleCount < 0 || nfds != 0 )
- HandleCount = nfds * 3;
+ if ( HandleCount == 0 )
+ {
+ AFD_DbgPrint(MAX_TRACE,("HandleCount: %d. Return SOCKET_ERROR\n",
+ HandleCount));
+ if (lpErrno) *lpErrno = WSAEINVAL;
+ return SOCKET_ERROR;
+ }
- PollBufferSize = sizeof(*PollInfo) + (HandleCount * sizeof(AFD_HANDLE));
+ PollBufferSize = sizeof(*PollInfo) + ((HandleCount - 1) * sizeof(AFD_HANDLE));
AFD_DbgPrint(MID_TRACE,("HandleCount: %d BufferSize: %d\n",
HandleCount, PollBufferSize));
struct sockaddr *SocketAddress,
int *SocketAddressLength,
LPCONDITIONPROC lpfnCondition,
- DWORD_PTR dwCallbackData,
+ DWORD dwCallbackData,
LPINT lpErrno)
{
IO_STATUS_BLOCK IOSB;
<module name="msvcrt" type="win32dll" baseaddress="${BASEADDRESS_MSVCRT}" mangledsymbols="true" installbase="system32" installname="msvcrt.dll" iscrt="yes">
- <importlibrary definition="msvcrt.def" />
+ <importlibrary definition="msvcrt-$(ARCH).def" />
<include base="msvcrt">.</include>
<include base="crt">include</include>
<define name="USE_MSVCRT_PREFIX" />
<define name="__NO_CTYPE_INLINES" />
<define name="_CTYPE_DISABLE_MACROS" />
<define name="_NO_INLINING" />
- <linkerflag>-enable-stdcall-fixup</linkerflag>
+ <linkerflag linkerset="ld">-enable-stdcall-fixup</linkerflag>
<!-- __MINGW_IMPORT needs to be defined differently because it's defined
as dllimport by default, which is invalid from GCC 4.1.0 on! -->
* License along with this library; if not, write to the Free Software\r
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
*/\r
-\r
-#define LARGEINT_PROTOS\r
-#define LargeIntegerDivide RtlLargeIntegerDivide\r
-#define ExtendedIntegerMultiply RtlExtendedIntegerMultiply\r
-#define ConvertUlongToLargeInteger RtlConvertUlongToLargeInteger\r
-#define LargeIntegerSubtract RtlLargeIntegerSubtract\r
#define MAX_PROPERTY_SHEET_PAGE 32\r
\r
#define WIN32_NO_STATUS\r
#include <windows.h>\r
#include <ndk/ntndk.h>\r
#include <fmifs/fmifs.h>\r
-#include <largeint.h>\r
\r
#include <precomp.h>\r
\r
LARGE_INTEGER\r
GetFreeBytesShare(LARGE_INTEGER TotalNumberOfFreeBytes, LARGE_INTEGER TotalNumberOfBytes)\r
{\r
- LARGE_INTEGER Temp, Result, Remainder;\r
+ LARGE_INTEGER Temp, Result;\r
\r
if (TotalNumberOfFreeBytes.QuadPart == 0LL)\r
{\r
- return ConvertUlongToLargeInteger(0);\r
+ Result.QuadPart = 1;\r
+ return Result;\r
}\r
\r
- Temp = LargeIntegerDivide(TotalNumberOfBytes, ConvertUlongToLargeInteger(100), &Remainder);\r
+ Temp.QuadPart = TotalNumberOfBytes.QuadPart / 100;\r
if (Temp.QuadPart >= TotalNumberOfFreeBytes.QuadPart)\r
{\r
- Result = ConvertUlongToLargeInteger(1);\r
+ Result.QuadPart = 1;\r
}else\r
{\r
- Result = LargeIntegerDivide(TotalNumberOfFreeBytes, Temp, &Remainder);\r
+ Result.QuadPart = TotalNumberOfFreeBytes.QuadPart / Temp.QuadPart;\r
}\r
\r
return Result;\r
FillRect(drawItem->hDC, &drawItem->rcItem, hBrush);\r
DeleteObject((HGDIOBJ)hBrush);\r
}\r
- }else if (drawItem->CtlID == 14014)\r
+ }\r
+ else if (drawItem->CtlID == 14014)\r
{\r
hBrush = CreateSolidBrush(RGB(255, 0, 255));\r
if (hBrush)\r
hBlueBrush = CreateSolidBrush(RGB(0, 0, 255));\r
hMagBrush = CreateSolidBrush(RGB(255, 0, 255));\r
\r
- SendDlgItemMessageW(hwndDlg, 14007, WM_GETTEXT, 20, (LPARAM)szBuffer);\r
+ SendDlgItemMessageW(hwndDlg, 14006, WM_GETTEXT, 20, (LPARAM)szBuffer);\r
Result.QuadPart = _wtoi(szBuffer);\r
\r
CopyRect(&rect, &drawItem->rcItem);\r
if (ret)\r
{\r
/* set volume label */\r
- SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szVolumeName);\r
+ SendDlgItemMessageW(hwndDlg, 14000, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szVolumeName);\r
\r
/* set filesystem type */\r
- SendDlgItemMessageW(hwndDlg, 14003, WM_SETTEXT, (WPARAM)NULL, (LPARAM)FileSystemName);\r
+ SendDlgItemMessageW(hwndDlg, 14002, WM_SETTEXT, (WPARAM)NULL, (LPARAM)FileSystemName);\r
\r
}\r
\r
{\r
ret = DeviceIoControl(hVolume, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, (LPVOID)&TotalNumberOfBytes, sizeof(ULARGE_INTEGER), &BytesReturned, NULL);\r
if (ret && StrFormatByteSizeW(LengthInformation.Length.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))\r
- SendDlgItemMessageW(hwndDlg, 14008, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
+ SendDlgItemMessageW(hwndDlg, 14007, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
\r
CloseHandle(hVolume);\r
}\r
TRACE("szResult %s hVOlume %p ret %d LengthInformation %ul Bytesreturned %d\n", debugstr_w(szResult), hVolume, ret, LengthInformation.Length.QuadPart, BytesReturned);\r
#else\r
if (ret && StrFormatByteSizeW(TotalNumberOfBytes.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))\r
- SendDlgItemMessageW(hwndDlg, 14008, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
+ SendDlgItemMessageW(hwndDlg, 14007, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
#endif\r
\r
if (StrFormatByteSizeW(TotalNumberOfBytes.QuadPart - FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))\r
- SendDlgItemMessageW(hwndDlg, 14004, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
+ SendDlgItemMessageW(hwndDlg, 14003, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
\r
if (StrFormatByteSizeW(FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))\r
- SendDlgItemMessageW(hwndDlg, 14006, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
+ SendDlgItemMessageW(hwndDlg, 14005, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);\r
\r
Result = GetFreeBytesShare(TotalNumberOfFreeBytes, TotalNumberOfBytes);\r
/* set free bytes percentage */\r
swprintf(szResult, L"%02d%%", Result.QuadPart);\r
- SendDlgItemMessageW(hwndDlg, 14007, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);\r
+ SendDlgItemMessageW(hwndDlg, 14006, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);\r
/* store used share amount */\r
- Result = LargeIntegerSubtract(ConvertUlongToLargeInteger(100), Result);\r
+ Result.QuadPart = 100 - Result.QuadPart;\r
swprintf(szResult, L"%02d%%", Result.QuadPart);\r
- SendDlgItemMessageW(hwndDlg, 14005, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);\r
- if (LoadStringW(shell32_hInstance, IDS_DRIVE_FIXED, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))\r
- SendDlgItemMessageW(hwndDlg, 14002, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);\r
- \r
+ SendDlgItemMessageW(hwndDlg, 14004, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);\r
+ if (DriveType == DRIVE_FIXED)\r
+ {\r
+ if (LoadStringW(shell32_hInstance, IDS_DRIVE_FIXED, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))\r
+ SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);\r
+ }\r
+ else /* DriveType == DRIVE_CDROM) */\r
+ {\r
+ if (LoadStringW(shell32_hInstance, IDS_DRIVE_CDROM, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))\r
+ SendDlgItemMessageW(hwndDlg, 14001, WM_SETTEXT, (WPARAM)0, (LPARAM)szBuffer);\r
+ }\r
}\r
}\r
/* set drive description */\r
- SendDlgItemMessageW(hwndDlg, 14010, WM_GETTEXT, (WPARAM)50, (LPARAM)szFormat);\r
+ SendDlgItemMessageW(hwndDlg, 14009, WM_GETTEXT, (WPARAM)50, (LPARAM)szFormat);\r
swprintf(szBuffer, szFormat, szDrive);\r
- SendDlgItemMessageW(hwndDlg, 14010, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szBuffer);\r
+ SendDlgItemMessageW(hwndDlg, 14009, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szBuffer);\r
}\r
\r
\r
}\r
\r
\r
-BOOL \r
+INT_PTR \r
CALLBACK \r
FormatDriveDlg(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)\r
{\r
static const IPersistFolder2Vtbl vt_NP_PersistFolder2;
-#define _IPersistFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
+#define _IPersistFolder2_Offset ((INT_PTR)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
#define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder2_Offset);
- #define _IUnknown_(This) (IUnknown*)&(This->lpVtbl)
- #define _IShellFolder_(This) (IShellFolder*)&(This->lpVtbl)
- #define _IPersistFolder2_(This) (IPersistFolder2*)&(This->lpVtblPersistFolder2)
+ #define _IUnknown_(This) ((IUnknown*)&(This)->lpVtbl)
+ #define _IShellFolder_(This) ((IShellFolder*)&(This)->lpVtbl)
+ #define _IPersistFolder2_(This) (&(This)->lpVtblPersistFolder2)
static shvheader NetworkPlacesSFHeader[] = {
{IDS_SHV_COLUMN8, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
if (pUnkOuter)
return CLASS_E_NOAGGREGATION;
- sf = (IGenericSFImpl *) HeapAlloc ( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (IGenericSFImpl));
+ sf = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (IGenericSFImpl));
if (!sf)
return E_OUTOFMEMORY;
sf->lpVtblPersistFolder2 = &vt_NP_PersistFolder2;
sf->pidlRoot = _ILCreateNetHood(); /* my qualified pidl */
- if (!SUCCEEDED (IUnknown_QueryInterface (_IUnknown_ (sf), riid, ppv)))
+ if (FAILED (IUnknown_QueryInterface (_IUnknown_ (sf), riid, ppv)))
{
IUnknown_Release (_IUnknown_ (sf));
return E_NOINTERFACE;
HRESULT hr = E_INVALIDARG;
TRACE ("(%p)->(hwnd=%p,%s,%p)\n", This,
- hwndOwner, shdebugstr_guid (riid), ppvOut);
+ hwndOwner, shdebugstr_guid (riid), ppvOut);
if (!ppvOut)
return hr;
*/
LONG WINAPI SHSetWindowBits(HWND hwnd, INT offset, UINT wMask, UINT wFlags)
{
- LONG ret = GetWindowLongPtrA(hwnd, offset);
+ LONG ret = GetWindowLongA(hwnd, offset);
LONG newFlags = (wFlags & wMask) | (ret & ~wFlags);
if (newFlags != ret)
- ret = SetWindowLongPtrA(hwnd, offset, newFlags);
+ ret = SetWindowLongA(hwnd, offset, newFlags);
return ret;
}
if (lpInt1 == lpInt2)
return TRUE;
- if (FAILED(IUnknown_QueryInterface(lpInt1, &IID_IUnknown, &lpUnknown1)))
+ if (FAILED(IUnknown_QueryInterface(lpInt1, &IID_IUnknown,
+ (LPVOID *)&lpUnknown1)))
return FALSE;
- if (FAILED(IUnknown_QueryInterface(lpInt2, &IID_IUnknown, &lpUnknown2)))
+ if (FAILED(IUnknown_QueryInterface(lpInt2, &IID_IUnknown,
+ (LPVOID *)&lpUnknown2)))
return FALSE;
if (lpUnknown1 == lpUnknown2)
if (IsEqualIID(riid, xmove->refid)) {
a_vtbl = (IUnknown*)(xmove->indx + (LPBYTE)w);
TRACE("matched, returning (%p)\n", a_vtbl);
- *ppv = a_vtbl;
+ *ppv = (LPVOID)a_vtbl;
IUnknown_AddRef(a_vtbl);
return S_OK;
}
if (IsEqualIID(riid, &IID_IUnknown)) {
a_vtbl = (IUnknown*)(x->indx + (LPBYTE)w);
TRACE("returning first for IUnknown (%p)\n", a_vtbl);
- *ppv = a_vtbl;
+ *ppv = (LPVOID)a_vtbl;
IUnknown_AddRef(a_vtbl);
return S_OK;
}
if (retval != ERROR_SUCCESS)
return 0;
- SHGetValueW(hKey, lpSubName, lpValue, NULL, &retval, &datsize);
+ SHGetValueW(hKey, lpSubName, lpValue, NULL, (LPBYTE)&retval, &datsize);
RegCloseKey(hKey);
return retval;
}
*ppv = NULL;
if(pUnk && pInner) {
- hret = IUnknown_QueryInterface(pInner, riid, ppv);
+ hret = IUnknown_QueryInterface(pInner, riid, (LPVOID*)ppv);
if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
}
TRACE("-- 0x%08x\n", hret);
return S_OK;
}
+ /*************************************************************************
+ * IConnectionPoint_InvokeWithCancel [SHLWAPI.283]
+ */
+ HRESULT WINAPI IConnectionPoint_InvokeWithCancel( IConnectionPoint* iCP,
+ DISPID dispId, DISPPARAMS* dispParams,
+ DWORD unknown1, DWORD unknown2 )
+ {
+ IID iid;
+ HRESULT result;
+
+ FIXME("(%p)->(0x%x %p %x %x) partial stub\n", iCP, dispId, dispParams, unknown1, unknown2);
+
+ result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
+ if (SUCCEEDED(result))
+ result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
+
+ return result;
+ }
+
+
/*************************************************************************
* @ [SHLWAPI.284]
*
{
IUnknown* lpUnk;
- if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, szSkipBinding, &lpUnk)))
+ if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)szSkipBinding, &lpUnk)))
{
CLSID clsid;
<module name="syssetup" type="win32dll" baseaddress="${BASEADDRESS_SYSSETUP}" installbase="system32" installname="syssetup.dll" unicode="yes" allowwarnings="true" crt="msvcrt">
- <importlibrary definition="syssetup.def" />
+ <importlibrary definition="syssetup.spec" />
<include base="syssetup">.</include>
<library>pseh</library>
<library>uuid</library>
<file>wizard.c</file>
<file>syssetup.rc</file>
<!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38054#c7 -->
- <compilerflag>-fno-unit-at-a-time</compilerflag>
+ <compilerflag compilerset="gcc">-fno-unit-at-a-time</compilerflag>
</module>
int i;
HBRUSH hbsave, hb, hb2;
HPEN hpsave, hp, hp2;
- int tri = 290*SmallDiam/1000 - 1;
int d46, d93;
// end scrollgripsize
switch(uFlags & 0xff)
if (hbr <= (HBRUSH)(COLOR_MENUBAR + 1))
{
- hbr = GetSysColorBrush((int)hbr - 1);
+ hbr = GetSysColorBrush(PtrToUlong(hbr) - 1);
}
if ((prevhbr = SelectObject(hDC, hbr)) == NULL)
{
<directory name="advpack">
<xi:include href="advpack/advpack.rbuild" />
</directory>
-<directory name="actxprxy">
+<!-- directory name="actxprxy">
<xi:include href="actxprxy/actxprxy.rbuild" />
-</directory>
+</directory -->
<directory name="atl">
<xi:include href="atl/atl.rbuild" />
</directory>
<directory name="ntdsapi">
<xi:include href="ntdsapi/ntdsapi.rbuild" />
</directory>
+ <directory name="ntlanman">
+ <xi:include href="ntlanman/ntlanman.rbuild" />
+ </directory>
<directory name="ntmarta">
<xi:include href="ntmarta/ntmarta.rbuild" />
</directory>
IN PDEVICE_OBJECT DeviceObject,
IN PVOID Key)
{
+ UNREFERENCED_PARAMETER(DeviceObject);
INFO_(I8042PRT, "Debug key: p\n", Key);
if (!Key)
DeviceExtension = (PI8042_KEYBOARD_EXTENSION)Context;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
/* See http://blogs.msdn.com/doronh/archive/2006/09/08/746961.aspx */
/* Register GUID_DEVICE_SYS_BUTTON interface and report capability */
if (DeviceExtension->NewCaps != DeviceExtension->ReportedCaps)
{
- WaitingIrp = InterlockedExchangePointer(&DeviceExtension->PowerIrp, NULL);
+ WaitingIrp = InterlockedExchangePointer((PVOID)&DeviceExtension->PowerIrp, NULL);
if (WaitingIrp)
{
/* Cancel the current power irp, as capability changed */
}
/* Directly complete the IOCTL_GET_SYS_BUTTON_EVENT Irp (if any) */
- WaitingIrp = InterlockedExchangePointer(&DeviceExtension->PowerIrp, NULL);
+ WaitingIrp = InterlockedExchangePointer((PVOID)&DeviceExtension->PowerIrp, NULL);
if (WaitingIrp)
{
PULONG pEvent = (PULONG)WaitingIrp->AssociatedIrp.SystemBuffer;
ULONG KeysInBufferCopy;
KIRQL Irql;
+ UNREFERENCED_PARAMETER(Dpc);
+ UNREFERENCED_PARAMETER(SystemArgument1);
+ UNREFERENCED_PARAMETER(SystemArgument2);
+
DeviceExtension = (PI8042_KEYBOARD_EXTENSION)DeferredContext;
PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
else
{
WaitingIrp = InterlockedCompareExchangePointer(
- &DeviceExtension->PowerIrp,
+ (PVOID)&DeviceExtension->PowerIrp,
Irp,
NULL);
/* Check if an Irp is already pending */
PowerKey = InterlockedExchange((PLONG)&DeviceExtension->LastPowerKey, 0);
if (PowerKey != 0)
{
- (VOID)InterlockedCompareExchangePointer(&DeviceExtension->PowerIrp, NULL, Irp);
+ (VOID)InterlockedCompareExchangePointer((PVOID)&DeviceExtension->PowerIrp, NULL, Irp);
*(PULONG)Irp->AssociatedIrp.SystemBuffer = PowerKey;
Status = STATUS_SUCCESS;
Irp->IoStatus.Status = Status;
Status = STATUS_SUCCESS;
break;
}
+ case IOCTL_KEYBOARD_QUERY_ATTRIBUTES:
+ {
+ DPRINT1("IOCTL_KEYBOARD_QUERY_ATTRIBUTES not implemented\n");
+ #if 0
+ /* FIXME: KeyboardAttributes are not initialized anywhere */
+ TRACE_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_KEYBOARD_QUERY_ATTRIBUTES\n");
+ if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(KEYBOARD_ATTRIBUTES))
+ {
+ Status = STATUS_BUFFER_TOO_SMALL;
+ break;
+ }
+
+ *(PKEYBOARD_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer = DeviceExtension->KeyboardAttributes;
+ Irp->IoStatus.Information = sizeof(KEYBOARD_ATTRIBUTES);
+ Status = STATUS_SUCCESS;
+ break;
+ #endif
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
+ case IOCTL_KEYBOARD_QUERY_TYPEMATIC:
+ {
+ DPRINT1("IOCTL_KEYBOARD_QUERY_TYPEMATIC not implemented\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
+ case IOCTL_KEYBOARD_SET_TYPEMATIC:
+ {
+ DPRINT1("IOCTL_KEYBOARD_SET_TYPEMATIC not implemented\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
case IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION:
{
TRACE_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION\n");
PPORT_DEVICE_EXTENSION PortDeviceExtension;
PKEYBOARD_INPUT_DATA InputData;
ULONG Counter;
- UCHAR PortStatus, Output;
+ UCHAR PortStatus = 0, Output = 0;
BOOLEAN ToReturn = FALSE;
NTSTATUS Status;
+ UNREFERENCED_PARAMETER(Interrupt);
+
DeviceExtension = (PI8042_KEYBOARD_EXTENSION)Context;
PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
InputData = DeviceExtension->KeyboardBuffer + DeviceExtension->KeysInBuffer;
if( !HandleArray[i].Handle ) continue;
if( NT_SUCCESS(Status) ) {
Status = ObReferenceObjectByHandle
- ( (PVOID)HandleArray[i].Handle,
+ ( (PVOID)(ULONG_PTR)HandleArray[i].Handle,
FILE_ALL_ACCESS,
NULL,
KernelMode,
for( i = 0; i < HandleCount; i++ ) {
if( HandleArray[i].Handle )
- ObDereferenceObject( (PVOID)HandleArray[i].Handle );
+ ObDereferenceObject( (PVOID)(ULONG_PTR)HandleArray[i].Handle );
}
ExFreePool( HandleArray );
}
VOID SocketStateUnlock( PAFD_FCB FCB ) {
- #ifdef DBG
+ #if DBG
PVOID CurrentThread = KeGetCurrentThread();
#endif
ASSERT(FCB->LockCount > 0);
#include "tdiconn.h"
#include "debug.h"
- #ifdef DBG
+ #if DBG
/* See debug.h for debug/trace constants */
//DWORD DebugTraceLevel = DEBUG_ULTRA;
for( i = 0; i < Len; i++ ) {
if( i && !(i & 0xf) ) DbgPrint( "\n" );
- if( !(i & 0xf) ) DbgPrint( "%08x: ", (UINT)(Data + i) );
+ if( !(i & 0xf) ) DbgPrint( "%08x: ", (UINT_PTR)(Data + i) );
DbgPrint( " %02x", Data[i] & 0xff );
}
DbgPrint("\n");
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS Status = STATUS_SUCCESS;
- #ifdef DBG
+ #if DBG
PFILE_OBJECT FileObject = IrpSp->FileObject;
#endif
#include <debug.h>
/* Null-terminated array of ports to probe. This is "semi-risky" (Don Becker). */
-ULONG ProbeAddressList[] = { 0x280, 0x300, 0x320, 0x340, 0x360, 0x380, 0 };
+ULONG_PTR ProbeAddressList[] = { 0x280, 0x300, 0x320, 0x340, 0x360, 0x380, 0 };
static BOOLEAN ProbeAddressForNIC(
- ULONG address)
+ ULONG_PTR address)
/*
* FUNCTION: Probes an address for a NIC
* ARGUMENTS:
* Start at 1KB and test for every 1KB up to 64KB
*/
{
- ULONG Base;
+ ULONG_PTR Base;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
NdisStallExecution(500);
}
- #ifdef DBG
+ #if DBG
if (i == 4)
NDIS_DbgPrint(MIN_TRACE, ("NIC was not reset after 2ms.\n"));
#endif
NdisStallExecution(4);
}
- #ifdef DBG
+ #if DBG
if (Count == 0xFFFF)
NDIS_DbgPrint(MIN_TRACE, ("Remote DMA did not complete.\n"));
#endif
NdisStallExecution(4);
}
- #ifdef DBG
+ #if DBG
if (Count == 0xFFFF)
NDIS_DbgPrint(MIN_TRACE, ("Remote DMA did not complete.\n"));
#endif
NdisStallExecution(4);
}
- #ifdef DBG
+ #if DBG
if (Count == 0xFFFF)
NDIS_DbgPrint(MIN_TRACE, ("Remote DMA did not complete.\n"));
#endif
NdisStallExecution(500);
}
- #ifdef DBG
+ #if DBG
if (i == 4)
NDIS_DbgPrint(MIN_TRACE, ("NIC was not reset after 2ms.\n"));
#endif
RtlZeroMemory(Descriptor, sizeof(RECEIVE_DESCRIPTOR));
Descriptor->RBADR =
- (ULONG)(Adapter->ReceiveBufferPtrPhys + Adapter->CurrentReceiveDescriptorIndex * BUFFER_SIZE);
+ (ULONG_PTR)(Adapter->ReceiveBufferPtrPhys + Adapter->CurrentReceiveDescriptorIndex * BUFFER_SIZE);
Descriptor->BCNT = (-BUFFER_SIZE) | 0xf000;
Descriptor->FLAGS |= RD_OWN;
return NDIS_STATUS_RESOURCES;
}
- if(((ULONG)Adapter->InitializationBlockVirt & 0x00000003) != 0)
+ if(((ULONG_PTR)Adapter->InitializationBlockVirt & 0x00000003) != 0)
{
DPRINT("address 0x%x not dword-aligned\n", Adapter->InitializationBlockVirt);
BREAKPOINT;
return NDIS_STATUS_RESOURCES;
}
- Adapter->InitializationBlockPhys = (PINITIALIZATION_BLOCK)NdisGetPhysicalAddressLow(PhysicalAddress);
+ Adapter->InitializationBlockPhys = (PINITIALIZATION_BLOCK)(ptrdiff_t)NdisGetPhysicalAddressLow(PhysicalAddress);
/* allocate the transport descriptor ring */
Adapter->TransmitDescriptorRingLength = sizeof(TRANSMIT_DESCRIPTOR) * NUMBER_OF_BUFFERS;
return NDIS_STATUS_RESOURCES;
}
- if(((ULONG)Adapter->TransmitDescriptorRingVirt & 0x00000003) != 0)
+ if(((ULONG_PTR)Adapter->TransmitDescriptorRingVirt & 0x00000003) != 0)
{
DPRINT("address 0x%x not dword-aligned\n", Adapter->TransmitDescriptorRingVirt);
BREAKPOINT;
return NDIS_STATUS_RESOURCES;
}
- Adapter->TransmitDescriptorRingPhys = (PTRANSMIT_DESCRIPTOR)NdisGetPhysicalAddressLow(PhysicalAddress);
+ Adapter->TransmitDescriptorRingPhys = (PTRANSMIT_DESCRIPTOR)(ptrdiff_t)NdisGetPhysicalAddressLow(PhysicalAddress);
RtlZeroMemory(Adapter->TransmitDescriptorRingVirt, sizeof(TRANSMIT_DESCRIPTOR) * NUMBER_OF_BUFFERS);
/* allocate the receive descriptor ring */
return NDIS_STATUS_RESOURCES;
}
- if(((ULONG)Adapter->ReceiveDescriptorRingVirt & 0x00000003) != 0)
+ if(((ULONG_PTR)Adapter->ReceiveDescriptorRingVirt & 0x00000003) != 0)
{
DPRINT("address 0x%x not dword-aligned\n", Adapter->ReceiveDescriptorRingVirt);
BREAKPOINT;
return NDIS_STATUS_RESOURCES;
}
- Adapter->ReceiveDescriptorRingPhys = (PRECEIVE_DESCRIPTOR)NdisGetPhysicalAddressLow(PhysicalAddress);
+ Adapter->ReceiveDescriptorRingPhys = (PRECEIVE_DESCRIPTOR)(ptrdiff_t)NdisGetPhysicalAddressLow(PhysicalAddress);
RtlZeroMemory(Adapter->ReceiveDescriptorRingVirt, sizeof(RECEIVE_DESCRIPTOR) * NUMBER_OF_BUFFERS);
/* allocate transmit buffers */
return NDIS_STATUS_RESOURCES;
}
- if(((ULONG)Adapter->TransmitBufferPtrVirt & 0x00000003) != 0)
+ if(((ULONG_PTR)Adapter->TransmitBufferPtrVirt & 0x00000003) != 0)
{
DPRINT("address 0x%x not dword-aligned\n", Adapter->TransmitBufferPtrVirt);
BREAKPOINT;
return NDIS_STATUS_RESOURCES;
}
- Adapter->TransmitBufferPtrPhys = (PCHAR)NdisGetPhysicalAddressLow(PhysicalAddress);
+ Adapter->TransmitBufferPtrPhys = (PCHAR)(ULONG_PTR)NdisGetPhysicalAddressLow(PhysicalAddress);
RtlZeroMemory(Adapter->TransmitBufferPtrVirt, BUFFER_SIZE * NUMBER_OF_BUFFERS);
/* allocate receive buffers */
return NDIS_STATUS_RESOURCES;
}
- if(((ULONG)Adapter->ReceiveBufferPtrVirt & 0x00000003) != 0)
+ if(((ULONG_PTR)Adapter->ReceiveBufferPtrVirt & 0x00000003) != 0)
{
DPRINT("address 0x%x not dword-aligned\n", Adapter->ReceiveBufferPtrVirt);
BREAKPOINT;
return NDIS_STATUS_RESOURCES;
}
- Adapter->ReceiveBufferPtrPhys = (PCHAR)NdisGetPhysicalAddressLow(PhysicalAddress);
+ Adapter->ReceiveBufferPtrPhys = (PCHAR)(ULONG_PTR)NdisGetPhysicalAddressLow(PhysicalAddress);
RtlZeroMemory(Adapter->ReceiveBufferPtrVirt, BUFFER_SIZE * NUMBER_OF_BUFFERS);
/* initialize tx descriptors */
TransmitDescriptor = Adapter->TransmitDescriptorRingVirt;
for(i = 0; i < NUMBER_OF_BUFFERS; i++)
{
- (TransmitDescriptor+i)->TBADR = (ULONG)Adapter->TransmitBufferPtrPhys + i * BUFFER_SIZE;
+ (TransmitDescriptor+i)->TBADR = (ULONG_PTR)Adapter->TransmitBufferPtrPhys + i * BUFFER_SIZE;
(TransmitDescriptor+i)->BCNT = 0xf000 | -BUFFER_SIZE; /* 2's compliment + set top 4 bits */
(TransmitDescriptor+i)->FLAGS = TD1_STP | TD1_ENP;
}
ReceiveDescriptor = Adapter->ReceiveDescriptorRingVirt;
for(i = 0; i < NUMBER_OF_BUFFERS; i++)
{
- (ReceiveDescriptor+i)->RBADR = (ULONG)Adapter->ReceiveBufferPtrPhys + i * BUFFER_SIZE;
+ (ReceiveDescriptor+i)->RBADR = (ULONG_PTR)Adapter->ReceiveBufferPtrPhys + i * BUFFER_SIZE;
(ReceiveDescriptor+i)->BCNT = 0xf000 | -BUFFER_SIZE; /* 2's compliment + set top 4 bits */
(ReceiveDescriptor+i)->FLAGS = RD_OWN;
}
/* set up receive ring */
DPRINT("Receive ring physical address: 0x%x\n", Adapter->ReceiveDescriptorRingPhys);
- Adapter->InitializationBlockVirt->RDRA = (ULONG)Adapter->ReceiveDescriptorRingPhys;
+ Adapter->InitializationBlockVirt->RDRA = (ULONG_PTR)Adapter->ReceiveDescriptorRingPhys;
Adapter->InitializationBlockVirt->RLEN = (LOG_NUMBER_OF_BUFFERS << 4) & 0xf0;
/* set up transmit ring */
DPRINT("Transmit ring physical address: 0x%x\n", Adapter->TransmitDescriptorRingPhys);
- Adapter->InitializationBlockVirt->TDRA = (ULONG)Adapter->TransmitDescriptorRingPhys;
+ Adapter->InitializationBlockVirt->TDRA = (ULONG_PTR)Adapter->TransmitDescriptorRingPhys;
Adapter->InitializationBlockVirt->TLEN = (LOG_NUMBER_OF_BUFFERS << 4) & 0xf0;
}
if(Adapter->InitializationBlockVirt)
{
- PhysicalAddress.u.LowPart = (ULONG)Adapter->InitializationBlockPhys;
+ PhysicalAddress.u.LowPart = (ULONG_PTR)Adapter->InitializationBlockPhys;
NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->InitializationBlockLength,
FALSE, Adapter->InitializationBlockVirt, PhysicalAddress);
}
if(Adapter->TransmitDescriptorRingVirt)
{
- PhysicalAddress.u.LowPart = (ULONG)Adapter->TransmitDescriptorRingPhys;
+ PhysicalAddress.u.LowPart = (ULONG_PTR)Adapter->TransmitDescriptorRingPhys;
NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitDescriptorRingLength,
FALSE, Adapter->TransmitDescriptorRingVirt, PhysicalAddress);
}
if(Adapter->ReceiveDescriptorRingVirt)
{
- PhysicalAddress.u.LowPart = (ULONG)Adapter->ReceiveDescriptorRingPhys;
+ PhysicalAddress.u.LowPart = (ULONG_PTR)Adapter->ReceiveDescriptorRingPhys;
NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveDescriptorRingLength,
FALSE, Adapter->ReceiveDescriptorRingVirt, PhysicalAddress);
}
if(Adapter->TransmitBufferPtrVirt)
{
- PhysicalAddress.u.LowPart = (ULONG)Adapter->TransmitBufferPtrPhys;
+ PhysicalAddress.u.LowPart = (ULONG_PTR)Adapter->TransmitBufferPtrPhys;
NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitBufferLength,
FALSE, Adapter->TransmitBufferPtrVirt, PhysicalAddress);
}
if(Adapter->ReceiveBufferPtrVirt)
{
- PhysicalAddress.u.LowPart = (ULONG)Adapter->ReceiveBufferPtrPhys;
+ PhysicalAddress.u.LowPart = (ULONG_PTR)Adapter->ReceiveBufferPtrPhys;
NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveBufferLength,
FALSE, Adapter->ReceiveBufferPtrVirt, PhysicalAddress);
}
/* set up csr1 and csr2 with init block */
NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR1);
- NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)((ULONG)Adapter->InitializationBlockPhys & 0xffff));
+ NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)((ULONG_PTR)Adapter->InitializationBlockPhys & 0xffff));
NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR2);
- NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)((ULONG)Adapter->InitializationBlockPhys >> 16) & 0xffff);
+ NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)((ULONG_PTR)Adapter->InitializationBlockPhys >> 16) & 0xffff);
DPRINT("programmed with init block\n");
Adapter);
NdisMSetPeriodicTimer(&Adapter->MediaDetectionTimer,
MEDIA_DETECTION_INTERVAL);
+ NdisMRegisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle,
+ Adapter,
+ MiniportShutdown);
}
#if DBG
ASSERT(0);
#endif
- NdisMRegisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle, Adapter, MiniportShutdown);
-
DPRINT("returning 0x%x\n", Status);
*OpenErrorStatus = Status;
return Status;
#ifndef __NDISSYS_H
#define __NDISSYS_H
- typedef unsigned long NDIS_STATS;
-
#include <ntifs.h>
#include <ndis.h>
#include <xfilter.h>
#include <afilter.h>
#include <atm.h>
-
- struct _ADAPTER_BINDING;
-
- typedef struct _NDISI_PACKET_POOL {
- NDIS_SPIN_LOCK SpinLock;
- struct _NDIS_PACKET *FreeList;
- UINT PacketLength;
- UCHAR Buffer[1];
- } NDISI_PACKET_POOL, * PNDISI_PACKET_POOL;
-
- /* WDK Compatibility. Taken from w32api DDK */
- #ifndef __NDIS_H
- typedef struct _X_FILTER FDDI_FILTER, *PFDDI_FILTER;
-
- typedef VOID
- (NTAPI *FDDI_RCV_COMPLETE_HANDLER)(
- IN PFDDI_FILTER Filter);
-
- typedef VOID
- (NTAPI *FDDI_RCV_INDICATE_HANDLER)(
- IN PFDDI_FILTER Filter,
- IN NDIS_HANDLE MacReceiveContext,
- IN PCHAR Address,
- IN UINT AddressLength,
- IN PVOID HeaderBuffer,
- IN UINT HeaderBufferSize,
- IN PVOID LookaheadBuffer,
- IN UINT LookaheadBufferSize,
- IN UINT PacketSize);
-
- typedef enum _NDIS_WORK_ITEM_TYPE {
- NdisWorkItemRequest,
- NdisWorkItemSend,
- NdisWorkItemReturnPackets,
- NdisWorkItemResetRequested,
- NdisWorkItemResetInProgress,
- NdisWorkItemHalt,
- NdisWorkItemSendLoopback,
- NdisWorkItemMiniportCallback,
- NdisMaxWorkItems
- } NDIS_WORK_ITEM_TYPE, *PNDIS_WORK_ITEM_TYPE;
-
- #define NUMBER_OF_WORK_ITEM_TYPES NdisMaxWorkItems
- #define NUMBER_OF_SINGLE_WORK_ITEMS 6
-
- typedef struct _NDIS_MINIPORT_WORK_ITEM {
- SINGLE_LIST_ENTRY Link;
- NDIS_WORK_ITEM_TYPE WorkItemType;
- PVOID WorkItemContext;
- } NDIS_MINIPORT_WORK_ITEM, *PNDIS_MINIPORT_WORK_ITEM;
-
- typedef VOID (NTAPI *W_MINIPORT_CALLBACK)(
- IN NDIS_HANDLE MiniportAdapterContext,
- IN PVOID CallbackContext);
-
- typedef struct _NDIS_BIND_PATHS {
- UINT Number;
- NDIS_STRING Paths[1];
- } NDIS_BIND_PATHS, *PNDIS_BIND_PATHS;
-
- #if ARCNET
- #define FILTERDBS_ARCNET_S \
- PARC_FILTER ArcDB;
- #else /* !ARCNET */
- #define FILTERDBS_ARCNET_S \
- PVOID XXXDB;
- #endif /* !ARCNET */
-
- #define FILTERDBS_S \
- union { \
- PETH_FILTER EthDB; \
- PNULL_FILTER NullDB; \
- }; \
- PTR_FILTER TrDB; \
- PFDDI_FILTER FddiDB; \
- FILTERDBS_ARCNET_S
-
- typedef struct _NDIS_LOG {
- PNDIS_MINIPORT_BLOCK Miniport;
- KSPIN_LOCK LogLock;
- PIRP Irp;
- UINT TotalSize;
- UINT CurrentSize;
- UINT InPtr;
- UINT OutPtr;
- UCHAR LogBuf[1];
- } NDIS_LOG, *PNDIS_LOG;
-
- typedef enum _NDIS_PNP_DEVICE_STATE {
- NdisPnPDeviceAdded,
- NdisPnPDeviceStarted,
- NdisPnPDeviceQueryStopped,
- NdisPnPDeviceStopped,
- NdisPnPDeviceQueryRemoved,
- NdisPnPDeviceRemoved,
- NdisPnPDeviceSurpriseRemoved
- } NDIS_PNP_DEVICE_STATE;
-
- typedef struct _OID_LIST OID_LIST, *POID_LIST;
-
- struct _NDIS_MINIPORT_BLOCK {
- PVOID Signature;
- PNDIS_MINIPORT_BLOCK NextMiniport;
- PNDIS_M_DRIVER_BLOCK DriverHandle;
- NDIS_HANDLE MiniportAdapterContext;
- UNICODE_STRING MiniportName;
- PNDIS_BIND_PATHS BindPaths;
- NDIS_HANDLE OpenQueue;
- REFERENCE ShortRef;
- NDIS_HANDLE DeviceContext;
- UCHAR Padding1;
- UCHAR LockAcquired;
- UCHAR PmodeOpens;
- UCHAR AssignedProcessor;
- KSPIN_LOCK Lock;
- PNDIS_REQUEST MediaRequest;
- PNDIS_MINIPORT_INTERRUPT Interrupt;
- ULONG Flags;
- ULONG PnPFlags;
- LIST_ENTRY PacketList;
- PNDIS_PACKET FirstPendingPacket;
- PNDIS_PACKET ReturnPacketsQueue;
- ULONG RequestBuffer;
- PVOID SetMCastBuffer;
- PNDIS_MINIPORT_BLOCK PrimaryMiniport;
- PVOID WrapperContext;
- PVOID BusDataContext;
- ULONG PnPCapabilities;
- PCM_RESOURCE_LIST Resources;
- NDIS_TIMER WakeUpDpcTimer;
- UNICODE_STRING BaseName;
- UNICODE_STRING SymbolicLinkName;
- ULONG CheckForHangSeconds;
- USHORT CFHangTicks;
- USHORT CFHangCurrentTick;
- NDIS_STATUS ResetStatus;
- NDIS_HANDLE ResetOpen;
- FILTERDBS_S
- FILTER_PACKET_INDICATION_HANDLER PacketIndicateHandler;
- NDIS_M_SEND_COMPLETE_HANDLER SendCompleteHandler;
- NDIS_M_SEND_RESOURCES_HANDLER SendResourcesHandler;
- NDIS_M_RESET_COMPLETE_HANDLER ResetCompleteHandler;
- NDIS_MEDIUM MediaType;
- ULONG BusNumber;
- NDIS_INTERFACE_TYPE BusType;
- NDIS_INTERFACE_TYPE AdapterType;
- PDEVICE_OBJECT DeviceObject;
- PDEVICE_OBJECT PhysicalDeviceObject;
- PDEVICE_OBJECT NextDeviceObject;
- PMAP_REGISTER_ENTRY MapRegisters;
- PNDIS_AF_LIST CallMgrAfList;
- PVOID MiniportThread;
- PVOID SetInfoBuf;
- USHORT SetInfoBufLen;
- USHORT MaxSendPackets;
- NDIS_STATUS FakeStatus;
- PVOID LockHandler;
- PUNICODE_STRING pAdapterInstanceName;
- PNDIS_MINIPORT_TIMER TimerQueue;
- UINT MacOptions;
- PNDIS_REQUEST PendingRequest;
- UINT MaximumLongAddresses;
- UINT MaximumShortAddresses;
- UINT CurrentLookahead;
- UINT MaximumLookahead;
- W_HANDLE_INTERRUPT_HANDLER HandleInterruptHandler;
- W_DISABLE_INTERRUPT_HANDLER DisableInterruptHandler;
- W_ENABLE_INTERRUPT_HANDLER EnableInterruptHandler;
- W_SEND_PACKETS_HANDLER SendPacketsHandler;
- NDIS_M_START_SENDS DeferredSendHandler;
- ETH_RCV_INDICATE_HANDLER EthRxIndicateHandler;
- TR_RCV_INDICATE_HANDLER TrRxIndicateHandler;
- FDDI_RCV_INDICATE_HANDLER FddiRxIndicateHandler;
- ETH_RCV_COMPLETE_HANDLER EthRxCompleteHandler;
- TR_RCV_COMPLETE_HANDLER TrRxCompleteHandler;
- FDDI_RCV_COMPLETE_HANDLER FddiRxCompleteHandler;
- NDIS_M_STATUS_HANDLER StatusHandler;
- NDIS_M_STS_COMPLETE_HANDLER StatusCompleteHandler;
- NDIS_M_TD_COMPLETE_HANDLER TDCompleteHandler;
- NDIS_M_REQ_COMPLETE_HANDLER QueryCompleteHandler;
- NDIS_M_REQ_COMPLETE_HANDLER SetCompleteHandler;
- NDIS_WM_SEND_COMPLETE_HANDLER WanSendCompleteHandler;
- WAN_RCV_HANDLER WanRcvHandler;
- WAN_RCV_COMPLETE_HANDLER WanRcvCompleteHandler;
- #if defined(NDIS_WRAPPER)
- PNDIS_MINIPORT_BLOCK NextGlobalMiniport;
- SINGLE_LIST_ENTRY WorkQueue[NUMBER_OF_WORK_ITEM_TYPES];
- SINGLE_LIST_ENTRY SingleWorkItems[NUMBER_OF_SINGLE_WORK_ITEMS];
- UCHAR SendFlags;
- UCHAR TrResetRing;
- UCHAR ArcnetAddress;
- UCHAR XState;
- union {
- #if ARCNET
- PNDIS_ARC_BUF ArcBuf;
- #endif
- PVOID BusInterface;
- };
- PNDIS_LOG Log;
- ULONG SlotNumber;
- PCM_RESOURCE_LIST AllocatedResources;
- PCM_RESOURCE_LIST AllocatedResourcesTranslated;
- SINGLE_LIST_ENTRY PatternList;
- NDIS_PNP_CAPABILITIES PMCapabilities;
- DEVICE_CAPABILITIES DeviceCaps;
- ULONG WakeUpEnable;
- DEVICE_POWER_STATE CurrentDevicePowerState;
- PIRP pIrpWaitWake;
- SYSTEM_POWER_STATE WaitWakeSystemState;
- LARGE_INTEGER VcIndex;
- KSPIN_LOCK VcCountLock;
- LIST_ENTRY WmiEnabledVcs;
- PNDIS_GUID pNdisGuidMap;
- PNDIS_GUID pCustomGuidMap;
- USHORT VcCount;
- USHORT cNdisGuidMap;
- USHORT cCustomGuidMap;
- USHORT CurrentMapRegister;
- PKEVENT AllocationEvent;
- USHORT BaseMapRegistersNeeded;
- USHORT SGMapRegistersNeeded;
- ULONG MaximumPhysicalMapping;
- NDIS_TIMER MediaDisconnectTimer;
- USHORT MediaDisconnectTimeOut;
- USHORT InstanceNumber;
- NDIS_EVENT OpenReadyEvent;
- NDIS_PNP_DEVICE_STATE PnPDeviceState;
- NDIS_PNP_DEVICE_STATE OldPnPDeviceState;
- PGET_SET_DEVICE_DATA SetBusData;
- PGET_SET_DEVICE_DATA GetBusData;
- KDPC DeferredDpc;
- #if 0
- /* FIXME: */
- NDIS_STATS NdisStats;
- #else
- ULONG NdisStats;
- #endif
- PNDIS_PACKET IndicatedPacket[MAXIMUM_PROCESSORS];
- PKEVENT RemoveReadyEvent;
- PKEVENT AllOpensClosedEvent;
- PKEVENT AllRequestsCompletedEvent;
- ULONG InitTimeMs;
- NDIS_MINIPORT_WORK_ITEM WorkItemBuffer[NUMBER_OF_SINGLE_WORK_ITEMS];
- PDMA_ADAPTER SystemAdapterObject;
- ULONG DriverVerifyFlags;
- POID_LIST OidList;
- USHORT InternalResetCount;
- USHORT MiniportResetCount;
- USHORT MediaSenseConnectCount;
- USHORT MediaSenseDisconnectCount;
- PNDIS_PACKET *xPackets;
- ULONG UserModeOpenReferences;
- union {
- PVOID SavedSendHandler;
- PVOID SavedWanSendHandler;
- };
- PVOID SavedSendPacketsHandler;
- PVOID SavedCancelSendPacketsHandler;
- W_SEND_PACKETS_HANDLER WSendPacketsHandler;
- ULONG MiniportAttributes;
- PDMA_ADAPTER SavedSystemAdapterObject;
- USHORT NumOpens;
- USHORT CFHangXTicks;
- ULONG RequestCount;
- ULONG IndicatedPacketsCount;
- ULONG PhysicalMediumType;
- PNDIS_REQUEST LastRequest;
- LONG DmaAdapterRefCount;
- PVOID FakeMac;
- ULONG LockDbg;
- ULONG LockDbgX;
- PVOID LockThread;
- ULONG InfoFlags;
- KSPIN_LOCK TimerQueueLock;
- PKEVENT ResetCompletedEvent;
- PKEVENT QueuedBindingCompletedEvent;
- PKEVENT DmaResourcesReleasedEvent;
- FILTER_PACKET_INDICATION_HANDLER SavedPacketIndicateHandler;
- ULONG RegisteredInterrupts;
- PNPAGED_LOOKASIDE_LIST SGListLookasideList;
- ULONG ScatterGatherListSize;
- #endif /* _NDIS_ */
- };
-
- #if 1
- /* FIXME: */
- typedef PVOID QUEUED_CLOSE;
- #endif
-
- #if defined(NDIS_WRAPPER)
- #define NDIS_COMMON_OPEN_BLOCK_WRAPPER_S \
- ULONG Flags; \
- ULONG References; \
- KSPIN_LOCK SpinLock; \
- NDIS_HANDLE FilterHandle; \
- ULONG ProtocolOptions; \
- USHORT CurrentLookahead; \
- USHORT ConnectDampTicks; \
- USHORT DisconnectDampTicks; \
- W_SEND_HANDLER WSendHandler; \
- W_TRANSFER_DATA_HANDLER WTransferDataHandler; \
- W_SEND_PACKETS_HANDLER WSendPacketsHandler; \
- W_CANCEL_SEND_PACKETS_HANDLER CancelSendPacketsHandler; \
- ULONG WakeUpEnable; \
- PKEVENT CloseCompleteEvent; \
- QUEUED_CLOSE QC; \
- ULONG AfReferences; \
- PNDIS_OPEN_BLOCK NextGlobalOpen;
- #else
- #define NDIS_COMMON_OPEN_BLOCK_WRAPPER_S
- #endif
-
- #define NDIS_COMMON_OPEN_BLOCK_S \
- PVOID MacHandle; \
- NDIS_HANDLE BindingHandle; \
- PNDIS_MINIPORT_BLOCK MiniportHandle; \
- PNDIS_PROTOCOL_BLOCK ProtocolHandle; \
- NDIS_HANDLE ProtocolBindingContext; \
- PNDIS_OPEN_BLOCK MiniportNextOpen; \
- PNDIS_OPEN_BLOCK ProtocolNextOpen; \
- NDIS_HANDLE MiniportAdapterContext; \
- BOOLEAN Reserved1; \
- BOOLEAN Reserved2; \
- BOOLEAN Reserved3; \
- BOOLEAN Reserved4; \
- PNDIS_STRING BindDeviceName; \
- KSPIN_LOCK Reserved5; \
- PNDIS_STRING RootDeviceName; \
- union { \
- SEND_HANDLER SendHandler; \
- WAN_SEND_HANDLER WanSendHandler; \
- }; \
- TRANSFER_DATA_HANDLER TransferDataHandler; \
- SEND_COMPLETE_HANDLER SendCompleteHandler; \
- TRANSFER_DATA_COMPLETE_HANDLER TransferDataCompleteHandler; \
- RECEIVE_HANDLER ReceiveHandler; \
- RECEIVE_COMPLETE_HANDLER ReceiveCompleteHandler; \
- WAN_RECEIVE_HANDLER WanReceiveHandler; \
- REQUEST_COMPLETE_HANDLER RequestCompleteHandler; \
- RECEIVE_PACKET_HANDLER ReceivePacketHandler; \
- SEND_PACKETS_HANDLER SendPacketsHandler; \
- RESET_HANDLER ResetHandler; \
- REQUEST_HANDLER RequestHandler; \
- RESET_COMPLETE_HANDLER ResetCompleteHandler; \
- STATUS_HANDLER StatusHandler; \
- STATUS_COMPLETE_HANDLER StatusCompleteHandler; \
- NDIS_COMMON_OPEN_BLOCK_WRAPPER_S
-
- typedef struct _NDIS_COMMON_OPEN_BLOCK {
- NDIS_COMMON_OPEN_BLOCK_S
- } NDIS_COMMON_OPEN_BLOCK;
-
- struct _NDIS_OPEN_BLOCK
- {
- #ifdef __cplusplus
- NDIS_COMMON_OPEN_BLOCK NdisCommonOpenBlock;
- #else
- NDIS_COMMON_OPEN_BLOCK_S
- #endif
- #if defined(NDIS_WRAPPER)
- struct _NDIS_OPEN_CO
- {
- struct _NDIS_CO_AF_BLOCK * NextAf;
- W_CO_CREATE_VC_HANDLER MiniportCoCreateVcHandler;
- W_CO_REQUEST_HANDLER MiniportCoRequestHandler;
- CO_CREATE_VC_HANDLER CoCreateVcHandler;
- CO_DELETE_VC_HANDLER CoDeleteVcHandler;
- PVOID CmActivateVcCompleteHandler;
- PVOID CmDeactivateVcCompleteHandler;
- PVOID CoRequestCompleteHandler;
- LIST_ENTRY ActiveVcHead;
- LIST_ENTRY InactiveVcHead;
- LONG PendingAfNotifications;
- PKEVENT AfNotifyCompleteEvent;
- };
- #endif /* _NDIS_ */
- };
-
- #define NDIS30_PROTOCOL_CHARACTERISTICS_S \
- UCHAR MajorNdisVersion; \
- UCHAR MinorNdisVersion; \
- USHORT Filler; \
- union { \
- UINT Reserved; \
- UINT Flags; \
- }; \
- OPEN_ADAPTER_COMPLETE_HANDLER OpenAdapterCompleteHandler; \
- CLOSE_ADAPTER_COMPLETE_HANDLER CloseAdapterCompleteHandler; \
- union { \
- SEND_COMPLETE_HANDLER SendCompleteHandler; \
- WAN_SEND_COMPLETE_HANDLER WanSendCompleteHandler; \
- }; \
- union { \
- TRANSFER_DATA_COMPLETE_HANDLER TransferDataCompleteHandler; \
- WAN_TRANSFER_DATA_COMPLETE_HANDLER WanTransferDataCompleteHandler; \
- }; \
- RESET_COMPLETE_HANDLER ResetCompleteHandler; \
- REQUEST_COMPLETE_HANDLER RequestCompleteHandler; \
- union { \
- RECEIVE_HANDLER ReceiveHandler; \
- WAN_RECEIVE_HANDLER WanReceiveHandler; \
- }; \
- RECEIVE_COMPLETE_HANDLER ReceiveCompleteHandler; \
- STATUS_HANDLER StatusHandler; \
- STATUS_COMPLETE_HANDLER StatusCompleteHandler; \
- NDIS_STRING Name;
-
- typedef struct _NDIS30_PROTOCOL_CHARACTERISTICS {
- NDIS30_PROTOCOL_CHARACTERISTICS_S
- } NDIS30_PROTOCOL_CHARACTERISTICS, *PNDIS30_PROTOCOL_CHARACTERISTICS;
-
- #define NDIS30_MINIPORT_CHARACTERISTICS_S \
- UCHAR MajorNdisVersion; \
- UCHAR MinorNdisVersion; \
- USHORT Filler; \
- UINT Reserved; \
- W_CHECK_FOR_HANG_HANDLER CheckForHangHandler; \
- W_DISABLE_INTERRUPT_HANDLER DisableInterruptHandler; \
- W_ENABLE_INTERRUPT_HANDLER EnableInterruptHandler; \
- W_HALT_HANDLER HaltHandler; \
- W_HANDLE_INTERRUPT_HANDLER HandleInterruptHandler; \
- W_INITIALIZE_HANDLER InitializeHandler; \
- W_ISR_HANDLER ISRHandler; \
- W_QUERY_INFORMATION_HANDLER QueryInformationHandler; \
- W_RECONFIGURE_HANDLER ReconfigureHandler; \
- W_RESET_HANDLER ResetHandler; \
- union { \
- W_SEND_HANDLER SendHandler; \
- WM_SEND_HANDLER WanSendHandler; \
- }u1; \
- W_SET_INFORMATION_HANDLER SetInformationHandler; \
- union { \
- W_TRANSFER_DATA_HANDLER TransferDataHandler; \
- WM_TRANSFER_DATA_HANDLER WanTransferDataHandler; \
- }u2;
-
- typedef struct _NDIS30_MINIPORT_CHARACTERISTICS {
- NDIS30_MINIPORT_CHARACTERISTICS_S
- } NDIS30_MINIPORT_CHARACTERISTICS, *PSNDIS30_MINIPORT_CHARACTERISTICS;
-
- #ifdef __cplusplus
-
- #define NDIS40_MINIPORT_CHARACTERISTICS_S \
- NDIS30_MINIPORT_CHARACTERISTICS Ndis30Chars; \
- W_RETURN_PACKET_HANDLER ReturnPacketHandler; \
- W_SEND_PACKETS_HANDLER SendPacketsHandler; \
- W_ALLOCATE_COMPLETE_HANDLER AllocateCompleteHandler;
-
- #else /* !__cplusplus */
-
- #define NDIS40_MINIPORT_CHARACTERISTICS_S \
- NDIS30_MINIPORT_CHARACTERISTICS_S \
- W_RETURN_PACKET_HANDLER ReturnPacketHandler; \
- W_SEND_PACKETS_HANDLER SendPacketsHandler; \
- W_ALLOCATE_COMPLETE_HANDLER AllocateCompleteHandler;
-
- #endif /* !__cplusplus */
-
- typedef struct _NDIS40_MINIPORT_CHARACTERISTICS {
- NDIS40_MINIPORT_CHARACTERISTICS_S
- } NDIS40_MINIPORT_CHARACTERISTICS, *PNDIS40_MINIPORT_CHARACTERISTICS;
-
- #endif
+ #include <ndistapi.h>
+ #include <ndisguid.h>
+ #include <debug.h>
#include "miniport.h"
#include "protocol.h"
-
- #include <debug.h>
+ #include "buffer.h"
/* Exported functions */
#ifndef EXPORT
ExGetCurrentProcessorCpuUsage(
PULONG CpuUsage);
+/* portability fixes */
+#ifdef _M_AMD64
+#define KfReleaseSpinLock KeReleaseSpinLock
+#define KefAcquireSpinLockAtDpcLevel KeAcquireSpinLockAtDpcLevel
+#define KefReleaseSpinLockFromDpcLevel KeReleaseSpinLockFromDpcLevel
+#endif
+
#endif /* __NDISSYS_H */
/* EOF */
--- /dev/null
- ;NdisCompareAnsiString ?
- ;NdisCompareUnicodeString ?
+; NDIS Kernel Module - ReactOS Operating System
+
+LIBRARY NDIS.SYS
+
+EXPORTS
+ArcFilterDprIndicateReceive
+ArcFilterDprIndicateReceiveComplete
+EthFilterDprIndicateReceive
+EthFilterDprIndicateReceiveComplete
+FddiFilterDprIndicateReceive
+FddiFilterDprIndicateReceiveComplete
+NDIS_BUFFER_TO_SPAN_PAGES
+NdisAcquireReadWriteLock
+NdisAcquireSpinLock
+NdisAdjustBufferLength
+NdisAllocateBuffer
+NdisAllocateBufferPool
+NdisAllocateDmaChannel
+NdisAllocateMemory
++NdisAllocateFromBlockPool
+NdisAllocateMemoryWithTag
+NdisAllocatePacket
+NdisAllocatePacketPool
+NdisAllocatePacketPoolEx
+NdisAllocateSharedMemory
+NdisAllocateSpinLock
+NdisAnsiStringToUnicodeString
+NdisBufferLength
+NdisBufferVirtualAddress
++NdisCancelSendPackets
+NdisCancelTimer
+NdisClAddParty
+NdisClCloseAddressFamily
+NdisClCloseCall
+NdisClDeregisterSap
+NdisClDropParty
++NdisClGetProtocolVcContextFromTapiCallId
+NdisClIncomingCallComplete
+NdisClMakeCall
+NdisClModifyCallQoS
+NdisClOpenAddressFamily
+NdisClRegisterSap
+NdisCloseAdapter
+NdisCloseConfiguration
+NdisCloseFile
+NdisCmActivateVc
+NdisCmAddPartyComplete
+NdisCmCloseAddressFamilyComplete
+NdisCmCloseCallComplete
+NdisCmDeactivateVc
+NdisCmDeregisterSapComplete
+NdisCmDispatchCallConnected
+NdisCmDispatchIncomingCall
+NdisCmDispatchIncomingCallQoSChange
+NdisCmDispatchIncomingCloseCall
+NdisCmDispatchIncomingDropParty
+NdisCmDropPartyComplete
+NdisCmMakeCallComplete
+NdisCmModifyCallQoSComplete
+NdisCmOpenAddressFamilyComplete
+NdisCmRegisterAddressFamily
+NdisCmRegisterSapComplete
++NdisCoAssignInstanceName
+NdisCoCreateVc
+NdisCoDeleteVc
++NdisCoGetTapiCallId
+NdisCoRequest
+NdisCoRequestComplete
+NdisCoSendPackets
- ;NdisInterlockedAddLargeInterger ?
++NdisCompareAnsiString
++NdisCompareUnicodeString
+NdisCompleteBindAdapter
+NdisCompleteCloseAdapter
+NdisCompleteDmaTransfer
+NdisCompleteOpenAdapter
+NdisCompletePnPEvent
+NdisCompleteQueryStatistics
+NdisCompleteUnbindAdapter
+NdisConvertStringToAtmAddress
+NdisCopyBuffer
+NdisCopyFromPacketToPacket
++NdisCopyFromPacketToPacketSafe
++NdisCreateBlockPool
+NdisDeregisterAdapter
+NdisDeregisterAdapterShutdownHandler
+NdisDeregisterMac
+NdisDeregisterProtocol
++NdisDeregisterTdiCallBack
++NdisDestroyBlockPool
+NdisDprAcquireSpinLock
+NdisDprAllocatePacket
+NdisDprAllocatePacketNonInterlocked
+NdisDprFreePacket
+NdisDprFreePacketNonInterlocked
+NdisDprReleaseSpinLock
+NdisEqualString
+NdisFreeBuffer
+NdisFreeBufferPool
+NdisFreeDmaChannel
++NdisFreeToBlockPool
+NdisFreeMemory
+NdisFreePacket
+NdisFreePacketPool
+NdisFreeSharedMemory
+NdisFreeSpinLock
++NdisGeneratePartialCancelId
+NdisGetBufferPhysicalArraySize
+NdisGetCurrentProcessorCounts
+NdisGetCurrentProcessorCpuUsage
+NdisGetCurrentSystemTime
+NdisGetDriverHandle
+NdisGetFirstBufferFromPacket
++NdisGetFirstBufferFromPacketSafe
++NdisGetPacketCancelId
++NdisGetPoolFromPacket
+NdisGetReceivedPacket
++NdisGetRoutineAddress
++NdisGetSharedDataAlignment
+NdisGetSystemUpTime
++NdisGetVersion
+NdisIMAssociateMiniport
+NdisIMCancelInitializeDeviceInstance
+NdisIMCopySendCompletePerPacketInfo
+NdisIMCopySendPerPacketInfo
+NdisIMDeInitializeDeviceInstance
+NdisIMDeregisterLayeredMiniport
+NdisIMGetBindingContext
++NdisIMGetCurrentPacketStack
+NdisIMGetDeviceContext
+NdisIMInitializeDeviceInstance
+NdisIMInitializeDeviceInstanceEx
++NdisIMNotifyPnPEvent
+NdisImmediateReadPciSlotInformation
+NdisImmediateReadPortUchar
+NdisImmediateReadPortUlong
+NdisImmediateReadPortUshort
+NdisImmediateReadSharedMemory
+NdisImmediateWritePciSlotInformation
+NdisImmediateWritePortUchar
+NdisImmediateWritePortUlong
+NdisImmediateWritePortUshort
+NdisImmediateWriteSharedMemory
+NdisIMQueueMiniportCallback
+NdisIMRegisterLayeredMiniport
+NdisIMRevertBack
+NdisIMSwitchToMiniport
+NdisInitAnsiString
+NdisInitializeEvent
+NdisInitializeReadWriteLock
+NdisInitializeString
+NdisInitializeTimer
+NdisInitializeWrapper
+NdisInitUnicodeString
- ;NdisOverrideBusNumber ?
++NdisInterlockedAddLargeInteger
+NdisInterlockedAddUlong
+NdisInterlockedDecrement
+NdisInterlockedIncrement
+NdisInterlockedInsertHeadList
+NdisInterlockedInsertTailList
+NdisInterlockedPopEntrySList
+NdisInterlockedPushEntrySList
+NdisInterlockedRemoveHeadList
+NdisMAllocateMapRegisters
+NdisMAllocateSharedMemory
+NdisMAllocateSharedMemoryAsync
+NdisMapFile
+NdisMapIoSpace
+;NdisMatchPdoWithPacket ?
+NdisMCancelTimer
+NdisMCloseLog
+NdisMCmActivateVc
+NdisMCmCreateVc
+NdisMCmDeactivateVc
+NdisMCmDeleteVc
+NdisMCmRegisterAddressFamily
+NdisMCmRequest
+NdisMCoActivateVcComplete
+NdisMCoDeactivateVcComplete
+NdisMCoIndicateReceivePacket
+NdisMCoIndicateStatus
+NdisMCompleteBufferPhysicalMapping
+NdisMCoReceiveComplete
+NdisMCoRequestComplete
+NdisMCoSendComplete
+NdisMCreateLog
+NdisMDeregisterAdapterShutdownHandler
+NdisMDeregisterDevice
+NdisMDeregisterDmaChannel
+NdisMDeregisterInterrupt
+NdisMDeregisterIoPortRange
+NdisMFlushLog
+NdisMFreeMapRegisters
+NdisMFreeSharedMemory
+NdisMGetDeviceProperty
+NdisMGetDmaAlignment
+NdisMIndicateStatus
+NdisMIndicateStatusComplete
+NdisMInitializeScatterGatherDma
+NdisMInitializeTimer
+NdisMMapIoSpace
+NdisMPciAssignResources
+NdisMPromoteMiniport
+NdisMQueryAdapterInstanceName
+NdisMQueryAdapterResources
+NdisMQueryInformationComplete
+NdisMReadDmaCounter
+NdisMRegisterAdapterShutdownHandler
+NdisMRegisterDevice
+NdisMRegisterDmaChannel
+NdisMRegisterInterrupt
+NdisMRegisterIoPortRange
+NdisMRegisterMiniport
+NdisMRegisterUnloadHandler
+NdisMRemoveMiniport
+NdisMResetComplete
+NdisMSendComplete
+NdisMSendResourcesAvailable
+NdisMSetAttributes
+NdisMSetAttributesEx
+NdisMSetInformationComplete
+NdisMSetMiniportSecondary
+NdisMSetPeriodicTimer
+NdisMSetTimer
+NdisMSleep
+NdisMStartBufferPhysicalMapping
+NdisMSynchronizeWithInterrupt
+NdisMTransferDataComplete
+NdisMUnmapIoSpace
+NdisMWanIndicateReceive
+NdisMWanIndicateReceiveComplete
+NdisMWanSendComplete
+NdisMWriteLogData
+NdisOpenAdapter
+NdisOpenConfiguration
+NdisOpenConfigurationKeyByIndex
+NdisOpenConfigurationKeyByName
+NdisOpenFile
+NdisOpenProtocolConfiguration
- ;NdisQueryBindInstanceName?
++NdisOverrideBusNumber
+NdisPacketPoolUsage
++NdisPacketSize
+NdisPciAssignResources
+NdisQueryAdapterInstanceName
- ;NdisReEnumerateProtocolBindings ?
++NdisQueryBindInstanceName
+NdisQueryBuffer
+NdisQueryBufferOffset
+NdisQueryBufferSafe
+NdisQueryMapRegisterCount
++NdisQueryPendingIOCount
+NdisReadConfiguration
+NdisReadEisaSlotInformation
+NdisReadEisaSlotInformationEx
+NdisReadMcaPosInformation
+NdisReadNetworkAddress
+NdisReadPciSlotInformation
+NdisReadPcmciaAttributeMemory
- ;NdisRegisterTdiCallBack ?
++NdisReEnumerateProtocolBindings
+NdisRegisterAdapter
+NdisRegisterAdapterShutdownHandler
+NdisRegisterProtocol
- ;NdisSetPacketPoolProtocolId ?
- ;NdisSetProtocolFilter ?
++NdisRegisterTdiCallBack
+NdisReleaseAdapterResources
+NdisReleaseReadWriteLock
+NdisReleaseSpinLock
+NdisRequest
+NdisReset
+NdisResetEvent
+NdisReturnPackets
+NdisSend
+NdisSendPackets
+NdisSetEvent
++NdisSetPacketCancelId
++NdisSetPacketPoolProtocolId
++NdisSetPacketStatus
++NdisSetProtocolFilter
+NdisSetTimer
++NdisSetTimerEx
+NdisSetupDmaTransfer
+NdisSystemProcessorCount
+NdisTerminateWrapper
+NdisTransferData
+NdisUnchainBufferAtBack
+NdisUnchainBufferAtFront
+NdisUnicodeStringToAnsiString
+NdisUnmapFile
+NdisUpcaseUnicodeString
+NdisUpdateSharedMemory
+NdisWaitEvent
+NdisWriteConfiguration
+NdisWriteErrorLogEntry
+NdisWritePciSlotInformation
+NdisWritePcmciaAttributeMemory
+TrFilterDprIndicateReceive
+TrFilterDprIndicateReceiveComplete
+NdisScheduleWorkItem
+
+; EOF
NdisAllocateBuffer@20
NdisAllocateBufferPool@12
NdisAllocateDmaChannel@20
+ NdisAllocateFromBlockPool@4
NdisAllocateMemory@20
NdisAllocateMemoryWithTag@12
NdisAllocatePacket@12
NdisAnsiStringToUnicodeString@8
NdisBufferLength@4
NdisBufferVirtualAddress@4
+ NdisCancelSendPackets@8
NdisCancelTimer@8
NdisClAddParty@16
NdisClCloseAddressFamily@4
NdisClCloseCall@16
NdisClDeregisterSap@4
NdisClDropParty@12
+ NdisClGetProtocolVcContextFromTapiCallId@12
NdisClIncomingCallComplete@12
NdisClMakeCall@16
NdisClModifyCallQoS@8
NdisCmOpenAddressFamilyComplete@12
NdisCmRegisterAddressFamily@16
NdisCmRegisterSapComplete@12
+ NdisCoAssignInstanceName@12
NdisCoCreateVc@16
NdisCoDeleteVc@4
+ NdisCoGetTapiCallId@8
NdisCoRequest@20
NdisCoRequestComplete@20
NdisCoSendPackets@12
- ;NdisCompareAnsiString ?
- ;NdisCompareUnicodeString ?
+ NdisCompareAnsiString@12
+ NdisCompareUnicodeString@12
NdisCompleteBindAdapter@12
NdisCompleteCloseAdapter@8
NdisCompleteDmaTransfer@24
NdisConvertStringToAtmAddress@12
NdisCopyBuffer@24
NdisCopyFromPacketToPacket@24
+ NdisCopyFromPacketToPacketSafe@28
+ NdisCreateBlockPool@16
NdisDeregisterAdapter@4
NdisDeregisterAdapterShutdownHandler@4
NdisDeregisterMac@8
NdisDeregisterProtocol@8
+ NdisDeregisterTdiCallBack@0
+ NdisDestroyBlockPool@4
NdisDprAcquireSpinLock@4
NdisDprAllocatePacket@12
NdisDprAllocatePacketNonInterlocked@12
NdisFreeBuffer@4
NdisFreeBufferPool@4
NdisFreeDmaChannel@4
+ NdisFreeToBlockPool@4
NdisFreeMemory@12
NdisFreePacket@4
NdisFreePacketPool@4
NdisFreeSharedMemory@24
NdisFreeSpinLock@4
+ NdisGeneratePartialCancelId@0
NdisGetBufferPhysicalArraySize@8
NdisGetCurrentProcessorCounts@12
NdisGetCurrentProcessorCpuUsage@4
NdisGetCurrentSystemTime@4
NdisGetDriverHandle@8
NdisGetFirstBufferFromPacket@20
+ NdisGetFirstBufferFromPacketSafe@24
+ NdisGetPacketCancelId@4
+ NdisGetPoolFromPacket@4
NdisGetReceivedPacket@8
+ NdisGetRoutineAddress@4
+ NdisGetSharedDataAlignment@0
NdisGetSystemUpTime@4
+ NdisGetVersion@0
NdisIMAssociateMiniport@8
NdisIMCancelInitializeDeviceInstance@8
NdisIMCopySendCompletePerPacketInfo@8
NdisIMDeInitializeDeviceInstance@4
NdisIMDeregisterLayeredMiniport@4
NdisIMGetBindingContext@4
+ NdisIMGetCurrentPacketStack@8
NdisIMGetDeviceContext@4
NdisIMInitializeDeviceInstance@8
NdisIMInitializeDeviceInstanceEx@12
+ NdisIMNotifyPnPEvent@8
NdisImmediateReadPciSlotInformation@20
NdisImmediateReadPortUchar@12
NdisImmediateReadPortUlong@12
NdisInitializeTimer@12
NdisInitializeWrapper@16
NdisInitUnicodeString@8
- ;NdisInterlockedAddLargeInterger ?
+ NdisInterlockedAddLargeInteger@16
NdisInterlockedAddUlong@12
NdisInterlockedDecrement@4
NdisInterlockedIncrement@4
NdisOpenConfigurationKeyByName@16
NdisOpenFile@24
NdisOpenProtocolConfiguration@12
- ;NdisOverrideBusNumber ?
+ NdisOverrideBusNumber@12
NdisPacketPoolUsage@4
+ NdisPacketSize@4
NdisPciAssignResources@20
NdisQueryAdapterInstanceName@8
- ;NdisQueryBindInstanceName?
+ NdisQueryBindInstanceName@8
NdisQueryBuffer@12
NdisQueryBufferOffset@12
NdisQueryBufferSafe@16
NdisQueryMapRegisterCount@8
+ NdisQueryPendingIOCount@8
NdisReadConfiguration@20
NdisReadEisaSlotInformation@16
NdisReadEisaSlotInformationEx@20
NdisReadNetworkAddress@16
NdisReadPciSlotInformation@20
NdisReadPcmciaAttributeMemory@16
- ;NdisReEnumerateProtocolBindings ?
+ NdisReEnumerateProtocolBindings@4
NdisRegisterAdapter@24
NdisRegisterAdapterShutdownHandler@12
NdisRegisterProtocol@16
- ;NdisRegisterTdiCallBack ?
+ NdisRegisterTdiCallBack@8
NdisReleaseAdapterResources@4
NdisReleaseReadWriteLock@8
NdisReleaseSpinLock@4
NdisSend@12
NdisSendPackets@12
NdisSetEvent@4
- ;NdisSetPacketPoolProtocolId ?
- ;NdisSetProtocolFilter ?
+ NdisSetPacketCancelId@8
+ NdisSetPacketPoolProtocolId@8
+ NdisSetPacketStatus@16
+ NdisSetProtocolFilter@32
NdisSetTimer@8
+ NdisSetTimerEx@12
NdisSetupDmaTransfer@24
NdisSystemProcessorCount@0
NdisTerminateWrapper@8
NDIS_DbgPrint(MAX_TRACE, ("Called. Interrupt (0x%X)\n", NdisInterrupt));
if (NdisInterrupt->IsrRequested) {
+ NDIS_DbgPrint(MAX_TRACE, ("Calling MiniportISR\n"));
(*NdisMiniportBlock->DriverHandle->MiniportCharacteristics.ISRHandler)(
&InterruptRecognized,
&QueueMiniportHandleInterrupt,
NdisMiniportBlock->MiniportAdapterContext);
} else if (NdisMiniportBlock->DriverHandle->MiniportCharacteristics.DisableInterruptHandler) {
+ NDIS_DbgPrint(MAX_TRACE, ("Calling MiniportDisableInterrupt\n"));
(*NdisMiniportBlock->DriverHandle->MiniportCharacteristics.DisableInterruptHandler)(
NdisMiniportBlock->MiniportAdapterContext);
QueueMiniportHandleInterrupt = TRUE;
OUT PUCHAR Data)
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- *Data = READ_PORT_UCHAR((PUCHAR)Port); // FIXME: What to do with WrapperConfigurationContext?
+ *Data = READ_PORT_UCHAR(UlongToPtr(Port)); // FIXME: What to do with WrapperConfigurationContext?
}
\f
OUT PULONG Data)
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- *Data = READ_PORT_ULONG((PULONG)Port); // FIXME: What to do with WrapperConfigurationContext?
+ *Data = READ_PORT_ULONG(UlongToPtr(Port)); // FIXME: What to do with WrapperConfigurationContext?
}
\f
OUT PUSHORT Data)
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- *Data = READ_PORT_USHORT((PUSHORT)Port); // FIXME: What to do with WrapperConfigurationContext?
+ *Data = READ_PORT_USHORT(UlongToPtr(Port)); // FIXME: What to do with WrapperConfigurationContext?
}
\f
IN UCHAR Data)
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- WRITE_PORT_UCHAR((PUCHAR)Port, Data); // FIXME: What to do with WrapperConfigurationContext?
+ WRITE_PORT_UCHAR(UlongToPtr(Port), Data); // FIXME: What to do with WrapperConfigurationContext?
}
\f
IN ULONG Data)
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- WRITE_PORT_ULONG((PULONG)Port, Data); // FIXME: What to do with WrapperConfigurationContext?
+ WRITE_PORT_ULONG(UlongToPtr(Port), Data); // FIXME: What to do with WrapperConfigurationContext?
}
\f
IN USHORT Data)
{
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- WRITE_PORT_USHORT((PUSHORT)Port, Data); // FIXME: What to do with WrapperConfigurationContext?
+ WRITE_PORT_USHORT(UlongToPtr(Port), Data); // FIXME: What to do with WrapperConfigurationContext?
}
\f
ASSERT(Adapter);
/* only bus masters may call this routine */
- if(!(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_BUS_MASTER))
+ if(!(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_BUS_MASTER)) {
+ NDIS_DbgPrint(MIN_TRACE, ("Not a bus master\n"));
return NDIS_STATUS_NOT_SUPPORTED;
+ }
DeviceObject = Adapter->NdisMiniportBlock.DeviceObject;
if(DmaSize == NDIS_DMA_64BITS)
Description.Dma64BitAddresses = TRUE;
- else
+ else if(DmaSize == NDIS_DMA_32BITS)
Description.Dma32BitAddresses = TRUE;
AdapterObject = IoGetDmaAdapter(
VOID
EXPORT
NdisMDeregisterDmaChannel(
- IN PNDIS_HANDLE MiniportDmaHandle)
+ IN NDIS_HANDLE MiniportDmaHandle)
{
- PNDIS_MINIPORT_BLOCK NdisMiniportBlock = (PNDIS_MINIPORT_BLOCK)MiniportDmaHandle;
- PDMA_ADAPTER AdapterObject = NdisMiniportBlock->SystemAdapterObject;
+ PNDIS_DMA_BLOCK DmaBlock = MiniportDmaHandle;
+ PDMA_ADAPTER AdapterObject = (PDMA_ADAPTER)DmaBlock->SystemAdapterObject;
+
+ if (AdapterObject == ((PLOGICAL_ADAPTER)DmaBlock->Miniport)->NdisMiniportBlock.SystemAdapterObject)
+ ((PLOGICAL_ADAPTER)DmaBlock->Miniport)->NdisMiniportBlock.SystemAdapterObject = NULL;
AdapterObject->DmaOperations->PutDmaAdapter(AdapterObject);
- NdisMiniportBlock->SystemAdapterObject = NULL;
+ ExFreePool(DmaBlock);
}
\f
ASSERT(Adapter);
/* only bus masters may call this routine */
- ASSERT(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_BUS_MASTER);
if(!(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_BUS_MASTER) ||
- Adapter->NdisMiniportBlock.SystemAdapterObject == NULL)
+ Adapter->NdisMiniportBlock.SystemAdapterObject == NULL) {
+ NDIS_DbgPrint(MIN_TRACE, ("Not bus master or bad adapter object\n"));
return;
+ }
MapRegistersPerBaseRegister = ((Adapter->NdisMiniportBlock.MaximumPhysicalMapping - 2) / PAGE_SIZE) + 2;
NdisMReadDmaCounter(
IN NDIS_HANDLE MiniportDmaHandle)
{
- PNDIS_MINIPORT_BLOCK MiniportBlock = (PNDIS_MINIPORT_BLOCK)MiniportDmaHandle;
- PDMA_ADAPTER AdapterObject = MiniportBlock->SystemAdapterObject;
+ PNDIS_DMA_BLOCK DmaBlock = MiniportDmaHandle;
+ PDMA_ADAPTER AdapterObject = (PDMA_ADAPTER)DmaBlock->SystemAdapterObject;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- if (AdapterObject == NULL)
- return 0;
-
return AdapterObject->DmaOperations->ReadDmaCounter(AdapterObject);
}
NdisMGetDmaAlignment(
IN NDIS_HANDLE MiniportDmaHandle)
{
- PNDIS_MINIPORT_BLOCK MiniportBlock = (PNDIS_MINIPORT_BLOCK)MiniportDmaHandle;
- PDMA_ADAPTER AdapterObject = MiniportBlock->SystemAdapterObject;
+ PNDIS_DMA_BLOCK DmaBlock = MiniportDmaHandle;
+ PDMA_ADAPTER AdapterObject = (PDMA_ADAPTER)DmaBlock->SystemAdapterObject;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- if (AdapterObject == NULL)
- return 0;
-
return AdapterObject->DmaOperations->GetDmaAlignment(AdapterObject);
}
PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
DEVICE_DESCRIPTION DeviceDesc;
ULONG MapRegisters;
+ PNDIS_DMA_BLOCK DmaBlock;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- if (Adapter->NdisMiniportBlock.SystemAdapterObject)
- {
- NDIS_DbgPrint(MIN_TRACE,("Using existing DMA adapter\n"));
- *MiniportDmaHandle = &Adapter->NdisMiniportBlock;
- return NDIS_STATUS_SUCCESS;
- }
-
RtlZeroMemory(&DeviceDesc, sizeof(DEVICE_DESCRIPTION));
DeviceDesc.Version = DEVICE_DESCRIPTION_VERSION;
DeviceDesc.DmaSpeed = DmaDescription->DmaSpeed;
DeviceDesc.MaximumLength = MaximumLength;
- Adapter->NdisMiniportBlock.SystemAdapterObject =
- IoGetDmaAdapter(Adapter->NdisMiniportBlock.PhysicalDeviceObject, &DeviceDesc, &MapRegisters);
- if (!Adapter->NdisMiniportBlock.SystemAdapterObject)
+ DmaBlock = ExAllocatePool(NonPagedPool, sizeof(NDIS_DMA_BLOCK));
+ if (!DmaBlock) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
return NDIS_STATUS_RESOURCES;
+ }
- *MiniportDmaHandle = &Adapter->NdisMiniportBlock;
+ DmaBlock->SystemAdapterObject = (PVOID)IoGetDmaAdapter(Adapter->NdisMiniportBlock.PhysicalDeviceObject, &DeviceDesc, &MapRegisters);
+
+ if (!DmaBlock->SystemAdapterObject) {
+ NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
+ ExFreePool(DmaBlock);
+ return NDIS_STATUS_RESOURCES;
+ }
+
+ Adapter->NdisMiniportBlock.SystemAdapterObject = (PDMA_ADAPTER)DmaBlock->SystemAdapterObject;
+
+ DmaBlock->Miniport = Adapter;
+
+ *MiniportDmaHandle = DmaBlock;
return NDIS_STATUS_SUCCESS;
}
if(AddressSpace)
{
ASSERT(TranslatedAddress.u.HighPart == 0);
- *PortOffset = (PVOID) TranslatedAddress.u.LowPart;
+ *PortOffset = (PVOID)(ULONG_PTR)TranslatedAddress.QuadPart;
NDIS_DbgPrint(MAX_TRACE, ("Returning 0x%x\n", *PortOffset));
return NDIS_STATUS_SUCCESS;
}
*PortOffset = MmMapIoSpace(TranslatedAddress, NumberOfPorts, MmNonCached);
NDIS_DbgPrint(MAX_TRACE, ("Returning 0x%x for port range\n", *PortOffset));
- if(!*PortOffset)
+ if(!*PortOffset) {
+ NDIS_DbgPrint(MIN_TRACE, ("MmMapIoSpace failed\n"));
return NDIS_STATUS_RESOURCES;
+ }
return NDIS_STATUS_SUCCESS;
}
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
- if (!(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_BUS_MASTER))
+ if (!(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_BUS_MASTER)) {
+ NDIS_DbgPrint(MIN_TRACE, ("Not a bus master\n"));
return NDIS_STATUS_NOT_SUPPORTED;
-
- if (Adapter->NdisMiniportBlock.SystemAdapterObject)
- {
- NDIS_DbgPrint(MIN_TRACE,("Using existing DMA adapter\n"));
- return NDIS_STATUS_SUCCESS;
}
RtlZeroMemory(&DeviceDesc, sizeof(DEVICE_DESCRIPTION));
if (!Adapter->NdisMiniportBlock.SystemAdapterObject)
return NDIS_STATUS_RESOURCES;
+ /* FIXME: Right now we just use this as a place holder */
+ Adapter->NdisMiniportBlock.ScatterGatherListSize = 1;
+
return NDIS_STATUS_SUCCESS;
}
EHeader->EType = ETYPE_IPv6;
break;
default:
- #ifdef DBG
+ #if DBG
/* Should not happen */
TI_DbgPrint(MIN_TRACE, ("Unknown LAN protocol.\n"));
if (Adapter->MTU < PacketLength) {
/* This is NOT a pointer. MSDN explicitly says so. */
NDIS_PER_PACKET_INFO_FROM_PACKET(NdisPacket,
- TcpLargeSendPacketInfo) = (PVOID)((ULONG)Adapter->MTU);
+ TcpLargeSendPacketInfo) = (PVOID)((ULONG_PTR)Adapter->MTU);
}
TcpipAcquireSpinLock( &Adapter->Lock, &OldIrql );
Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0;
- #ifdef DBG
+ #if DBG
if (!Irp->Cancel)
TI_DbgPrint(MIN_TRACE, ("Irp->Cancel is FALSE, should be TRUE.\n"));
#endif
TI_DbgPrint(DEBUG_IRP, ("IRP at (0x%X).\n", Irp));
- #ifdef DBG
+ #if DBG
if (!Irp->Cancel)
TI_DbgPrint(MIN_TRACE, ("Irp->Cancel is FALSE, should be TRUE.\n"));
#endif
AddressInfo = (PTDI_ADDRESS_INFO)MmGetSystemAddressForMdl(Irp->MdlAddress);
Address = (PTA_IP_ADDRESS)&AddressInfo->Address;
- switch ((ULONG)IrpSp->FileObject->FsContext2) {
+ switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
case TDI_TRANSPORT_ADDRESS_FILE:
AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
AddressInfo = (PTDI_CONNECTION_INFORMATION)
MmGetSystemAddressForMdl(Irp->MdlAddress);
- switch ((ULONG)IrpSp->FileObject->FsContext2) {
+ switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
case TDI_TRANSPORT_ADDRESS_FILE:
AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
break;
(*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send)));
if( (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send) )
+ {
+ ULONG DataUsed = 0;
Status = (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send)(
Request.Handle.AddressHandle,
DgramInfo->SendDatagramInformation,
DataBuffer,
BufferSize,
- &Irp->IoStatus.Information);
+ &DataUsed);
+ Irp->IoStatus.Information = DataUsed;
+ }
else
Status = STATUS_UNSUCCESSFUL;
}
TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
- switch ((ULONG)IrpSp->FileObject->FsContext2) {
+ switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
case TDI_TRANSPORT_ADDRESS_FILE:
Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
break;
TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
Info = (PTCP_REQUEST_SET_INFORMATION_EX)Irp->AssociatedIrp.SystemBuffer;
- switch ((ULONG)IrpSp->FileObject->FsContext2) {
+ switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
case TDI_TRANSPORT_ADDRESS_FILE:
Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
break;
UCHAR MediaChangeCountDown;
- #ifdef DBG
+ #if DBG
//
// Second timer to keep track of how long the media change IRP has been
// in use. If this value exceeds the timeout (#defined) then we should
#define CDROM_SRB_LIST_SIZE 4
- #ifdef DBG
+ #if DBG
//
// Used to detect the loss of the autorun irp. The driver prints out a message
deviceExtension->MediaChangeNoMedia = TRUE;
cddata->MediaChangeIrp = NULL;
- #ifdef DBG
+ #if DBG
cddata->MediaChangeIrpTimeInUse = 0;
cddata->MediaChangeIrpLost = FALSE;
#endif
// The data buffer must be aligned.
//
- srb->DataBuffer = (PVOID) (((ULONG) (context + 1) + (alignment - 1)) &
+ srb->DataBuffer = (PVOID) (((ULONG_PTR) (context + 1) + (alignment - 1)) &
~(alignment - 1));
cddata->MediaChangeCountDown--;
- #ifdef DBG
+ #if DBG
cddata->MediaChangeIrpTimeInUse = 0;
cddata->MediaChangeIrpLost = FALSE;
#endif
}
} else {
- #ifdef DBG
+ #if DBG
if(cddata->MediaChangeIrpLost == FALSE) {
if(cddata->MediaChangeIrpTimeInUse++ >
MEDIA_CHANGE_TIMEOUT_TIME) {
irpStack = IoGetCurrentIrpStackLocation(irp);
if (irpStack->Parameters.Others.Argument3) {
- ULONG count;
+ ULONG_PTR count;
//
// Decrement the countdown timer and put the IRP back in the list.
PIO_STACK_LOCATION irpStack;
NTSTATUS status;
BOOLEAN retry;
- ULONG retryCount;
+ ULONG_PTR retryCount;
ULONG lastSector;
PIRP originalIrp;
PCDROM_DATA cddata;
/* i/o space */
if (AddressSpace != 0)
- return((PVOID)TranslatedAddress.u.LowPart);
+ return((PVOID)(ULONG_PTR)TranslatedAddress.QuadPart);
MappedAddress = MmMapIoSpace(TranslatedAddress,
NumberOfBytes,
PortConfig->AccessRanges = (PVOID)(PortConfig+1);
/* Align to LONGLONG */
- PortConfig->AccessRanges = (PVOID)((ULONG)(PortConfig->AccessRanges) + 7);
- PortConfig->AccessRanges = (PVOID)((ULONG)(PortConfig->AccessRanges) & ~7);
+ PortConfig->AccessRanges = (PVOID)((ULONG_PTR)(PortConfig->AccessRanges) + 7);
+ PortConfig->AccessRanges = (PVOID)((ULONG_PTR)(PortConfig->AccessRanges) & ~7);
/* Copy the data */
RtlCopyMemory(PortConfig->AccessRanges,
SCSI_PORT_RESET | SCSI_PORT_RESET_REPORTED;
break;
+ case CallDisableInterrupts:
+ DPRINT1("UNIMPLEMENTED SCSI Notification called: CallDisableInterrupts!\n");
+ break;
+
+ case CallEnableInterrupts:
+ DPRINT1("UNIMPLEMENTED SCSI Notification called: CallEnableInterrupts!\n");
+ break;
+
+ case RequestTimerCall:
+ DPRINT1("UNIMPLEMENTED SCSI Notification called: RequestTimerCall!\n");
+ break;
+
+ case BusChangeDetected:
+ DPRINT1("UNIMPLEMENTED SCSI Notification called: BusChangeDetected!\n");
+ break;
+
default:
- DPRINT1 ("Unsupported notification %lu\n", NotificationType);
+ DPRINT1 ("Unsupported notification from WMI: %lu\n", NotificationType);
break;
}
Status = SpiGetInquiryData(DeviceExtension, Irp);
break;
+ case IOCTL_SCSI_MINIPORT:
+ DPRINT1("IOCTL_SCSI_MINIPORT unimplemented!\n");
+ break;
+
+ case IOCTL_SCSI_PASS_THROUGH:
+ DPRINT1("IOCTL_SCSI_PASS_THROUGH unimplemented!\n");
+ break;
+
default:
DPRINT1(" unknown ioctl code: 0x%lX\n",
Stack->Parameters.DeviceIoControl.IoControlCode);
if (Status)
*Status = NO_ERROR;
- return (PVOID)TranslatedAddress.u.LowPart;
+ return (PVOID)(ULONG_PTR)TranslatedAddress.u.LowPart;
}
/* user space */
Status = ZwUnmapViewOfSection(NtCurrentProcess(), MappedAddress);
if (!NT_SUCCESS(Status))
{
- WARN_(VIDEOPRT, "Warning: Mapping for address 0x%x not found!\n", (ULONG)MappedAddress);
+ WARN_(VIDEOPRT, "Warning: Mapping for address 0x%p not found!\n", MappedAddress);
}
}
FullList < AllocatedResources->List + AllocatedResources->Count;
FullList++)
{
+ INFO_(VIDEOPRT, "InterfaceType %u BusNumber List %u Device BusNumber %u Version %u Revision %u\n",
+ FullList->InterfaceType, FullList->BusNumber, DeviceExtension->SystemIoBusNumber, FullList->PartialResourceList.Version, FullList->PartialResourceList.Revision);
+
ASSERT(FullList->InterfaceType == PCIBus &&
FullList->BusNumber == DeviceExtension->SystemIoBusNumber &&
1 == FullList->PartialResourceList.Version &&
+;ScsiPortNotification // vista64
@ stdcall VideoPortAcquireDeviceLock(ptr)
@ stdcall VideoPortAcquireSpinLock(ptr ptr ptr)
@ stdcall VideoPortAcquireSpinLockAtDpcLevel(ptr ptr)
@ stdcall VideoPortAllocateCommonBuffer(ptr ptr long ptr long ptr)
@ stdcall VideoPortAllocateContiguousMemory(ptr long long long)
@ stdcall VideoPortAllocatePool(ptr long long long)
- ;VideoPortAssociateEventsWithDmaHandle
+ @ stdcall VideoPortAssociateEventsWithDmaHandle(ptr ptr ptr ptr)
@ stdcall VideoPortCheckForDeviceExistence(ptr long long long long long long)
+;VideoPortCheckForDeviceExistence there's a second dummy export with the same name on ms videoprt
@ stdcall VideoPortClearEvent(ptr ptr)
@ stdcall VideoPortCompareMemory(ptr ptr long) NTOSKRNL.RtlCompareMemory
- ;VideoPortCompleteDma
+ @ stdcall VideoPortCompleteDma(ptr ptr ptr long)
@ stdcall VideoPortCreateEvent(ptr long ptr ptr)
@ stdcall VideoPortCreateSecondaryDisplay(ptr ptr long)
@ stdcall VideoPortCreateSpinLock(ptr ptr)
@ stdcall VideoPortDDCMonitorHelper(ptr ptr ptr long)
+;VideoPortDbgReportComplete // vista64
+;VideoPortDbgReportCreate // vista64
+;VideoPortDbgReportSecondaryData // vista64
@ cdecl VideoPortDebugPrint(long ptr)
@ stdcall VideoPortDeleteEvent(ptr ptr)
@ stdcall VideoPortDeleteSpinLock(ptr ptr)
@ stdcall VideoPortDisableInterrupt(ptr)
- ;VideoPortDoDma
+ @ stdcall VideoPortDoDma(ptr ptr long)
@ stdcall VideoPortEnableInterrupt(ptr)
@ stdcall VideoPortEnumerateChildren(ptr ptr)
- ;VideoPortFlushRegistry
+ @ stdcall VideoPortFlushRegistry(ptr)
@ stdcall VideoPortFreeCommonBuffer(ptr long ptr long long long)
@ stdcall VideoPortFreeDeviceBase(ptr ptr)
@ stdcall VideoPortFreePool(ptr ptr)
@ stdcall VideoPortGetAccessRanges(ptr long ptr long ptr ptr ptr ptr)
@ stdcall VideoPortGetAgpServices(ptr ptr)
@ stdcall VideoPortGetAssociatedDeviceExtension(ptr)
- ;VideoPortGetAssociatedDeviceID
+ @ stdcall VideoPortGetAssociatedDeviceID(ptr)
@ stdcall VideoPortGetBusData(ptr long long ptr long long)
- ;VideoPortGetBytesUsed
- ;VideoPortGetCommonBuffer
+ @ stdcall VideoPortGetBytesUsed(ptr ptr)
+ @ stdcall VideoPortGetCommonBuffer(ptr long long ptr ptr long)
@ stdcall VideoPortGetCurrentIrql()
@ stdcall VideoPortGetDeviceBase(ptr long long long long)
@ stdcall VideoPortGetDeviceData(ptr long ptr ptr)
@ stdcall VideoPortGetDmaAdapter(ptr ptr)
- ;VideoPortGetDmaContext
- ;VideoPortGetMdl
+ @ stdcall VideoPortGetDmaContext(ptr ptr)
+ @ stdcall VideoPortGetMdl(ptr ptr)
@ stdcall VideoPortGetRegistryParameters(ptr wstr long ptr ptr)
@ stdcall VideoPortGetRomImage(ptr ptr long long)
@ stdcall VideoPortGetVersion(ptr ptr)
@ fastcall VideoPortInterlockedExchange(ptr long) NTOSKRNL.InterlockedExchange
@ fastcall VideoPortInterlockedIncrement(ptr) NTOSKRNL.InterlockedIncrement
@ stdcall VideoPortLockBuffer(ptr ptr long long)
- ;VideoPortLockPages
+;VideoPortIsNoVesa // 2003 and later
+ @ stdcall VideoPortLockPages(ptr ptr ptr ptr long)
@ stdcall VideoPortLogError(ptr ptr long long)
@ stdcall VideoPortMapBankedMemory(ptr long long ptr ptr ptr long long ptr ptr)
- ;VideoPortMapDmaMemory
+ @ stdcall VideoPortMapDmaMemory(ptr ptr double ptr ptr ptr ptr ptr)
@ stdcall VideoPortMapMemory(ptr long long ptr ptr ptr)
@ stdcall VideoPortMoveMemory(ptr ptr long) NTOSKRNL.RtlMoveMemory
+;VideoPortNotification
@ stdcall VideoPortPutDmaAdapter(ptr ptr)
@ stdcall VideoPortQueryPerformanceCounter(ptr ptr)
@ stdcall VideoPortQueryServices(ptr long ptr)
@ stdcall VideoPortQuerySystemTime(ptr) NTOSKRNL.KeQuerySystemTime
@ stdcall VideoPortQueueDpc(ptr ptr ptr)
-@ stdcall VideoPortReadPortUchar(ptr) HAL.READ_PORT_UCHAR
-@ stdcall VideoPortReadPortUshort(ptr) HAL.READ_PORT_USHORT
-@ stdcall VideoPortReadPortUlong(ptr) HAL.READ_PORT_ULONG
@ stdcall VideoPortReadPortBufferUchar(ptr ptr long) HAL.READ_PORT_BUFFER_UCHAR
-@ stdcall VideoPortReadPortBufferUshort(ptr ptr long) HAL.READ_PORT_BUFFER_USHORT
@ stdcall VideoPortReadPortBufferUlong(ptr ptr long) HAL.READ_PORT_BUFFER_ULONG
-@ stdcall VideoPortReadRegisterUchar(ptr) NTOSKRNL.READ_REGISTER_UCHAR
-@ stdcall VideoPortReadRegisterUshort(ptr) NTOSKRNL.READ_REGISTER_USHORT
-@ stdcall VideoPortReadRegisterUlong(ptr) NTOSKRNL.READ_REGISTER_ULONG
+@ stdcall VideoPortReadPortBufferUshort(ptr ptr long) HAL.READ_PORT_BUFFER_USHORT
+@ stdcall VideoPortReadPortUchar(ptr) HAL.READ_PORT_UCHAR
+@ stdcall VideoPortReadPortUlong(ptr) HAL.READ_PORT_ULONG
+@ stdcall VideoPortReadPortUshort(ptr) HAL.READ_PORT_USHORT
@ stdcall VideoPortReadRegisterBufferUchar(ptr ptr long) NTOSKRNL.READ_REGISTER_BUFFER_UCHAR
-@ stdcall VideoPortReadRegisterBufferUshort(ptr ptr long) NTOSKRNL.READ_REGISTER_BUFFER_USHORT
@ stdcall VideoPortReadRegisterBufferUlong(ptr ptr long) NTOSKRNL.READ_REGISTER_BUFFER_ULONG
- ;VideoPortReadStateEvent
+@ stdcall VideoPortReadRegisterBufferUshort(ptr ptr long) NTOSKRNL.READ_REGISTER_BUFFER_USHORT
+@ stdcall VideoPortReadRegisterUchar(ptr) NTOSKRNL.READ_REGISTER_UCHAR
+@ stdcall VideoPortReadRegisterUlong(ptr) NTOSKRNL.READ_REGISTER_ULONG
+@ stdcall VideoPortReadRegisterUshort(ptr) NTOSKRNL.READ_REGISTER_USHORT
+ @ stdcall VideoPortReadStateEvent(ptr ptr)
@ stdcall VideoPortRegisterBugcheckCallback(ptr long ptr long)
@ stdcall VideoPortReleaseBuffer(ptr ptr)
@ stdcall VideoPortReleaseCommonBuffer(ptr ptr long long long ptr long)
@ stdcall VideoPortReleaseSpinLockFromDpcLevel(ptr ptr)
@ stdcall VideoPortScanRom(ptr ptr long ptr)
@ stdcall VideoPortSetBusData(ptr long long ptr long long)
- ;VideoPortSetBytesUsed
- ;VideoPortSetDmaContext
+ @ stdcall VideoPortSetBytesUsed(ptr ptr long)
+ @ stdcall VideoPortSetDmaContext(ptr ptr ptr)
@ stdcall VideoPortSetEvent(ptr ptr)
@ stdcall VideoPortSetRegistryParameters(ptr wstr ptr long)
@ stdcall VideoPortSetTrappedEmulatorPorts(ptr long ptr)
- ;VideoPortSignalDmaComplete
+ @ stdcall VideoPortSignalDmaComplete(ptr ptr)
@ stdcall VideoPortStallExecution(ptr) HAL.KeStallExecutionProcessor
- ;VideoPortStartDma
+ @ stdcall VideoPortStartDma(ptr ptr ptr long ptr ptr ptr long)
@ stdcall VideoPortStartTimer(ptr)
@ stdcall VideoPortStopTimer(ptr)
@ stdcall VideoPortSynchronizeExecution(ptr long ptr ptr)
@ stdcall VideoPortUnlockBuffer(ptr ptr)
- ;VideoPortUnlockPages
- ;VideoPortUnmapDmaMemory
+ @ stdcall VideoPortUnlockPages(ptr ptr)
+ @ stdcall VideoPortUnmapDmaMemory(ptr ptr ptr ptr)
@ stdcall VideoPortUnmapMemory(ptr ptr ptr)
@ stdcall VideoPortVerifyAccessRanges(ptr long ptr)
@ stdcall VideoPortWaitForSingleObject(ptr ptr ptr)
-@ stdcall VideoPortWritePortUchar(ptr long) HAL.WRITE_PORT_UCHAR
-@ stdcall VideoPortWritePortUshort(ptr long) HAL.WRITE_PORT_USHORT
-@ stdcall VideoPortWritePortUlong(ptr long) HAL.WRITE_PORT_ULONG
@ stdcall VideoPortWritePortBufferUchar(ptr ptr long) HAL.WRITE_PORT_BUFFER_UCHAR
-@ stdcall VideoPortWritePortBufferUshort(ptr ptr long) HAL.WRITE_PORT_BUFFER_USHORT
@ stdcall VideoPortWritePortBufferUlong(ptr ptr long) HAL.WRITE_PORT_BUFFER_ULONG
-@ stdcall VideoPortWriteRegisterUchar(ptr long) NTOSKRNL.WRITE_REGISTER_UCHAR
-@ stdcall VideoPortWriteRegisterUshort(ptr long) NTOSKRNL.WRITE_REGISTER_USHORT
-@ stdcall VideoPortWriteRegisterUlong(ptr long) NTOSKRNL.WRITE_REGISTER_ULONG
+@ stdcall VideoPortWritePortBufferUshort(ptr ptr long) HAL.WRITE_PORT_BUFFER_USHORT
+@ stdcall VideoPortWritePortUchar(ptr long) HAL.WRITE_PORT_UCHAR
+@ stdcall VideoPortWritePortUlong(ptr long) HAL.WRITE_PORT_ULONG
+@ stdcall VideoPortWritePortUshort(ptr long) HAL.WRITE_PORT_USHORT
@ stdcall VideoPortWriteRegisterBufferUchar(ptr ptr long) NTOSKRNL.WRITE_REGISTER_BUFFER_UCHAR
-@ stdcall VideoPortWriteRegisterBufferUshort(ptr ptr long) NTOSKRNL.WRITE_REGISTER_BUFFER_USHORT
@ stdcall VideoPortWriteRegisterBufferUlong(ptr ptr long) NTOSKRNL.WRITE_REGISTER_BUFFER_ULONG
-@ stdcall VideoPortZeroMemory(ptr long) NTOSKRNL.RtlZeroMemory
+@ stdcall VideoPortWriteRegisterBufferUshort(ptr ptr long) NTOSKRNL.WRITE_REGISTER_BUFFER_USHORT
+@ stdcall VideoPortWriteRegisterUchar(ptr long) NTOSKRNL.WRITE_REGISTER_UCHAR
+@ stdcall VideoPortWriteRegisterUlong(ptr long) NTOSKRNL.WRITE_REGISTER_ULONG
+@ stdcall VideoPortWriteRegisterUshort(ptr long) NTOSKRNL.WRITE_REGISTER_USHORT
@ stdcall VideoPortZeroDeviceMemory(ptr long) NTOSKRNL.RtlZeroMemory
+@ stdcall VideoPortZeroMemory(ptr long) NTOSKRNL.RtlZeroMemory
@ stdcall VpNotifyEaData(ptr ptr)
<include base="drmk">.</include>
<include base="drmk">..</include>
<include base="drmk">../include</include>
- <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
- <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ <group compilerset="gcc">
+ <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
+ <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ </group>
<importlibrary definition="drmk.spec" />
<library>ntoskrnl</library>
<define name="BUILDING_DRMK" />
- <file>stubs.cpp</file>
+ <file>stubs.c</file>
<file>drmk.rc</file>
</module>
#define _AddressOfReturnAddress() (&(((void **)(__builtin_frame_address(0)))[1]))
/* TODO: __getcallerseflags but how??? */
- /* Maybe the same for x86? */
- #ifdef _x86_64
- #define _alloca(s) __builtin_alloca(s)
- #endif
/*** Atomic operations ***/
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) > 40100
#define _ReadWriteBarrier() __sync_synchronize()
#else
- static void __inline__ __attribute__((always_inline)) _MemoryBarrier(void)
+ __INTRIN_INLINE void _MemoryBarrier(void)
{
__asm__ __volatile__("" : : : "memory");
}
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) > 40100
- static __inline__ __attribute__((always_inline)) char _InterlockedCompareExchange8(volatile char * Destination, const char Exchange, const char Comperand)
-__INTRIN_INLINE char _InterlockedCompareExchange8(volatile char * const Destination, const char Exchange, const char Comperand)
++__INTRIN_INLINE char _InterlockedCompareExchange8(volatile char * Destination, const char Exchange, const char Comperand)
{
return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
}
- static __inline__ __attribute__((always_inline)) short _InterlockedCompareExchange16(volatile short * Destination, const short Exchange, const short Comperand)
-__INTRIN_INLINE short _InterlockedCompareExchange16(volatile short * const Destination, const short Exchange, const short Comperand)
++__INTRIN_INLINE short _InterlockedCompareExchange16(volatile short * Destination, const short Exchange, const short Comperand)
{
return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedCompareExchange(volatile long * Destination, const long Exchange, const long Comperand)
-__INTRIN_INLINE long _InterlockedCompareExchange(volatile long * const Destination, const long Exchange, const long Comperand)
++__INTRIN_INLINE long _InterlockedCompareExchange(volatile long * Destination, const long Exchange, const long Comperand)
{
return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
}
- static __inline__ __attribute__((always_inline)) void * _InterlockedCompareExchangePointer(void * volatile * Destination, void * const Exchange, void * const Comperand)
-__INTRIN_INLINE void * _InterlockedCompareExchangePointer(void * volatile * const Destination, void * const Exchange, void * const Comperand)
++__INTRIN_INLINE void * _InterlockedCompareExchangePointer(void * volatile * Destination, void * const Exchange, void * const Comperand)
{
return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedExchange(volatile long * Target, const long Value)
-__INTRIN_INLINE long _InterlockedExchange(volatile long * const Target, const long Value)
++__INTRIN_INLINE long _InterlockedExchange(volatile long * Target, const long Value)
{
/* NOTE: __sync_lock_test_and_set would be an acquire barrier, so we force a full barrier */
__sync_synchronize();
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) long long _InterlockedExchange64(volatile long long * Target, const long long Value)
-__INTRIN_INLINE long long _InterlockedExchange64(volatile long long * const Target, const long long Value)
++__INTRIN_INLINE long long _InterlockedExchange64(volatile long long * Target, const long long Value)
{
/* NOTE: __sync_lock_test_and_set would be an acquire barrier, so we force a full barrier */
__sync_synchronize();
}
#endif
- static __inline__ __attribute__((always_inline)) void * _InterlockedExchangePointer(void * volatile * Target, void * const Value)
-__INTRIN_INLINE void * _InterlockedExchangePointer(void * volatile * const Target, void * const Value)
++__INTRIN_INLINE void * _InterlockedExchangePointer(void * volatile * Target, void * const Value)
{
/* NOTE: ditto */
__sync_synchronize();
return __sync_lock_test_and_set(Target, Value);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd16(volatile short * Addend, const short Value)
-__INTRIN_INLINE long _InterlockedExchangeAdd16(volatile short * const Addend, const short Value)
++__INTRIN_INLINE long _InterlockedExchangeAdd16(volatile short * Addend, const short Value)
{
return __sync_fetch_and_add(Addend, Value);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd(volatile long * Addend, const long Value)
-__INTRIN_INLINE long _InterlockedExchangeAdd(volatile long * const Addend, const long Value)
++__INTRIN_INLINE long _InterlockedExchangeAdd(volatile long * Addend, const long Value)
{
return __sync_fetch_and_add(Addend, Value);
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) long long _InterlockedExchangeAdd64(volatile long long * Addend, const long long Value)
-__INTRIN_INLINE long long _InterlockedExchangeAdd64(volatile long long * const Addend, const long long Value)
++__INTRIN_INLINE long long _InterlockedExchangeAdd64(volatile long long * Addend, const long long Value)
{
return __sync_fetch_and_add(Addend, Value);
}
#endif
- static __inline__ __attribute__((always_inline)) char _InterlockedAnd8(volatile char * value, const char mask)
-__INTRIN_INLINE char _InterlockedAnd8(volatile char * const value, const char mask)
++__INTRIN_INLINE char _InterlockedAnd8(volatile char * value, const char mask)
{
return __sync_fetch_and_and(value, mask);
}
- static __inline__ __attribute__((always_inline)) short _InterlockedAnd16(volatile short * value, const short mask)
-__INTRIN_INLINE short _InterlockedAnd16(volatile short * const value, const short mask)
++__INTRIN_INLINE short _InterlockedAnd16(volatile short * value, const short mask)
{
return __sync_fetch_and_and(value, mask);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedAnd(volatile long * value, const long mask)
-__INTRIN_INLINE long _InterlockedAnd(volatile long * const value, const long mask)
++__INTRIN_INLINE long _InterlockedAnd(volatile long * value, const long mask)
{
return __sync_fetch_and_and(value, mask);
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) long _InterlockedAnd64(volatile long long * value, const long long mask)
-__INTRIN_INLINE long _InterlockedAnd64(volatile long long * const value, const long long mask)
++__INTRIN_INLINE long _InterlockedAnd64(volatile long long * value, const long long mask)
{
return __sync_fetch_and_and(value, mask);
}
#endif
- static __inline__ __attribute__((always_inline)) char _InterlockedOr8(volatile char * value, const char mask)
-__INTRIN_INLINE char _InterlockedOr8(volatile char * const value, const char mask)
++__INTRIN_INLINE char _InterlockedOr8(volatile char * value, const char mask)
{
return __sync_fetch_and_or(value, mask);
}
- static __inline__ __attribute__((always_inline)) short _InterlockedOr16(volatile short * value, const short mask)
-__INTRIN_INLINE short _InterlockedOr16(volatile short * const value, const short mask)
++__INTRIN_INLINE short _InterlockedOr16(volatile short * value, const short mask)
{
return __sync_fetch_and_or(value, mask);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedOr(volatile long * value, const long mask)
-__INTRIN_INLINE long _InterlockedOr(volatile long * const value, const long mask)
++__INTRIN_INLINE long _InterlockedOr(volatile long * value, const long mask)
{
return __sync_fetch_and_or(value, mask);
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) long _InterlockedOr64(volatile long long * value, const long long mask)
-__INTRIN_INLINE long _InterlockedOr64(volatile long long * const value, const long long mask)
++__INTRIN_INLINE long _InterlockedOr64(volatile long long * value, const long long mask)
{
return __sync_fetch_and_or(value, mask);
}
#endif
- static __inline__ __attribute__((always_inline)) char _InterlockedXor8(volatile char * value, const char mask)
-__INTRIN_INLINE char _InterlockedXor8(volatile char * const value, const char mask)
++__INTRIN_INLINE char _InterlockedXor8(volatile char * value, const char mask)
{
return __sync_fetch_and_xor(value, mask);
}
- static __inline__ __attribute__((always_inline)) short _InterlockedXor16(volatile short * value, const short mask)
-__INTRIN_INLINE short _InterlockedXor16(volatile short * const value, const short mask)
++__INTRIN_INLINE short _InterlockedXor16(volatile short * value, const short mask)
{
return __sync_fetch_and_xor(value, mask);
}
- static __inline__ __attribute__((always_inline)) long _InterlockedXor(volatile long * const value, const long mask)
-__INTRIN_INLINE long _InterlockedXor(volatile long * const value, const long mask)
++__INTRIN_INLINE long _InterlockedXor(volatile long * value, const long mask)
{
return __sync_fetch_and_xor(value, mask);
}
#else
- static __inline__ __attribute__((always_inline)) char _InterlockedCompareExchange8(volatile char * Destination, const char Exchange, const char Comperand)
-__INTRIN_INLINE char _InterlockedCompareExchange8(volatile char * const Destination, const char Exchange, const char Comperand)
++__INTRIN_INLINE char _InterlockedCompareExchange8(volatile char * Destination, const char Exchange, const char Comperand)
{
char retval = Comperand;
__asm__("lock; cmpxchgb %b[Exchange], %[Destination]" : [retval] "+a" (retval) : [Destination] "m" (*Destination), [Exchange] "q" (Exchange) : "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) short _InterlockedCompareExchange16(volatile short * Destination, const short Exchange, const short Comperand)
-__INTRIN_INLINE short _InterlockedCompareExchange16(volatile short * const Destination, const short Exchange, const short Comperand)
++__INTRIN_INLINE short _InterlockedCompareExchange16(volatile short * Destination, const short Exchange, const short Comperand)
{
short retval = Comperand;
__asm__("lock; cmpxchgw %w[Exchange], %[Destination]" : [retval] "+a" (retval) : [Destination] "m" (*Destination), [Exchange] "q" (Exchange): "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedCompareExchange(volatile long * Destination, const long Exchange, const long Comperand)
-__INTRIN_INLINE long _InterlockedCompareExchange(volatile long * const Destination, const long Exchange, const long Comperand)
++__INTRIN_INLINE long _InterlockedCompareExchange(volatile long * Destination, const long Exchange, const long Comperand)
{
long retval = Comperand;
__asm__("lock; cmpxchgl %k[Exchange], %[Destination]" : [retval] "+a" (retval) : [Destination] "m" (*Destination), [Exchange] "q" (Exchange): "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) void * _InterlockedCompareExchangePointer(void * volatile * Destination, void * const Exchange, void * const Comperand)
-__INTRIN_INLINE void * _InterlockedCompareExchangePointer(void * volatile * const Destination, void * const Exchange, void * const Comperand)
++__INTRIN_INLINE void * _InterlockedCompareExchangePointer(void * volatile * Destination, void * const Exchange, void * const Comperand)
{
void * retval = (void *)Comperand;
__asm__("lock; cmpxchgl %k[Exchange], %[Destination]" : [retval] "=a" (retval) : "[retval]" (retval), [Destination] "m" (*Destination), [Exchange] "q" (Exchange) : "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedExchange(volatile long * Target, const long Value)
-__INTRIN_INLINE long _InterlockedExchange(volatile long * const Target, const long Value)
++__INTRIN_INLINE long _InterlockedExchange(volatile long * Target, const long Value)
{
long retval = Value;
__asm__("xchgl %[retval], %[Target]" : [retval] "+r" (retval) : [Target] "m" (*Target) : "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) void * _InterlockedExchangePointer(void * volatile * Target, void * const Value)
-__INTRIN_INLINE void * _InterlockedExchangePointer(void * volatile * const Target, void * const Value)
++__INTRIN_INLINE void * _InterlockedExchangePointer(void * volatile * Target, void * const Value)
{
void * retval = Value;
__asm__("xchgl %[retval], %[Target]" : [retval] "+r" (retval) : [Target] "m" (*Target) : "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd16(volatile short * Addend, const short Value)
-__INTRIN_INLINE long _InterlockedExchangeAdd16(volatile short * const Addend, const short Value)
++__INTRIN_INLINE long _InterlockedExchangeAdd16(volatile short * Addend, const short Value)
{
long retval = Value;
__asm__("lock; xaddw %[retval], %[Addend]" : [retval] "+r" (retval) : [Addend] "m" (*Addend) : "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd(volatile long * Addend, const long Value)
-__INTRIN_INLINE long _InterlockedExchangeAdd(volatile long * const Addend, const long Value)
++__INTRIN_INLINE long _InterlockedExchangeAdd(volatile long * Addend, const long Value)
{
long retval = Value;
__asm__("lock; xaddl %[retval], %[Addend]" : [retval] "+r" (retval) : [Addend] "m" (*Addend) : "memory");
return retval;
}
- static __inline__ __attribute__((always_inline)) char _InterlockedAnd8(volatile char * value, const char mask)
-__INTRIN_INLINE char _InterlockedAnd8(volatile char * const value, const char mask)
++__INTRIN_INLINE char _InterlockedAnd8(volatile char * value, const char mask)
{
char x;
char y;
return y;
}
- static __inline__ __attribute__((always_inline)) short _InterlockedAnd16(volatile short * value, const short mask)
-__INTRIN_INLINE short _InterlockedAnd16(volatile short * const value, const short mask)
++__INTRIN_INLINE short _InterlockedAnd16(volatile short * value, const short mask)
{
short x;
short y;
return y;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedAnd(volatile long * value, const long mask)
-__INTRIN_INLINE long _InterlockedAnd(volatile long * const value, const long mask)
++__INTRIN_INLINE long _InterlockedAnd(volatile long * value, const long mask)
{
long x;
long y;
return y;
}
- static __inline__ __attribute__((always_inline)) char _InterlockedOr8(volatile char * value, const char mask)
-__INTRIN_INLINE char _InterlockedOr8(volatile char * const value, const char mask)
++__INTRIN_INLINE char _InterlockedOr8(volatile char * value, const char mask)
{
char x;
char y;
return y;
}
- static __inline__ __attribute__((always_inline)) short _InterlockedOr16(volatile short * value, const short mask)
-__INTRIN_INLINE short _InterlockedOr16(volatile short * const value, const short mask)
++__INTRIN_INLINE short _InterlockedOr16(volatile short * value, const short mask)
{
short x;
short y;
return y;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedOr(volatile long * value, const long mask)
-__INTRIN_INLINE long _InterlockedOr(volatile long * const value, const long mask)
++__INTRIN_INLINE long _InterlockedOr(volatile long * value, const long mask)
{
long x;
long y;
return y;
}
- static __inline__ __attribute__((always_inline)) char _InterlockedXor8(volatile char * value, const char mask)
-__INTRIN_INLINE char _InterlockedXor8(volatile char * const value, const char mask)
++__INTRIN_INLINE char _InterlockedXor8(volatile char * value, const char mask)
{
char x;
char y;
return y;
}
- static __inline__ __attribute__((always_inline)) short _InterlockedXor16(volatile short * value, const short mask)
-__INTRIN_INLINE short _InterlockedXor16(volatile short * const value, const short mask)
++__INTRIN_INLINE short _InterlockedXor16(volatile short * value, const short mask)
{
short x;
short y;
return y;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedXor(volatile long * value, const long mask)
-__INTRIN_INLINE long _InterlockedXor(volatile long * const value, const long mask)
++__INTRIN_INLINE long _InterlockedXor(volatile long * value, const long mask)
{
long x;
long y;
#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) > 40100 && defined(__x86_64__)
- static __inline__ __attribute__((always_inline)) long long _InterlockedCompareExchange64(volatile long long * Destination, const long long Exchange, const long long Comperand)
-__INTRIN_INLINE long long _InterlockedCompareExchange64(volatile long long * const Destination, const long long Exchange, const long long Comperand)
++__INTRIN_INLINE long long _InterlockedCompareExchange64(volatile long long * Destination, const long long Exchange, const long long Comperand)
{
return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
}
#else
- static __inline__ __attribute__((always_inline)) long long _InterlockedCompareExchange64(volatile long long * Destination, const long long Exchange, const long long Comperand)
-__INTRIN_INLINE long long _InterlockedCompareExchange64(volatile long long * const Destination, const long long Exchange, const long long Comperand)
++__INTRIN_INLINE long long _InterlockedCompareExchange64(volatile long long * Destination, const long long Exchange, const long long Comperand)
{
long long retval = Comperand;
#endif
- static __inline__ __attribute__((always_inline)) long _InterlockedAddLargeStatistic(volatile long long * Addend, const long Value)
-__INTRIN_INLINE long _InterlockedAddLargeStatistic(volatile long long * const Addend, const long Value)
++__INTRIN_INLINE long _InterlockedAddLargeStatistic(volatile long long * Addend, const long Value)
{
__asm__
(
return Value;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedDecrement(volatile long * lpAddend)
-__INTRIN_INLINE long _InterlockedDecrement(volatile long * const lpAddend)
++__INTRIN_INLINE long _InterlockedDecrement(volatile long * lpAddend)
{
return _InterlockedExchangeAdd(lpAddend, -1) - 1;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedIncrement(volatile long * lpAddend)
-__INTRIN_INLINE long _InterlockedIncrement(volatile long * const lpAddend)
++__INTRIN_INLINE long _InterlockedIncrement(volatile long * lpAddend)
{
return _InterlockedExchangeAdd(lpAddend, 1) + 1;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedDecrement16(volatile short * lpAddend)
-__INTRIN_INLINE short _InterlockedDecrement16(volatile short * const lpAddend)
++__INTRIN_INLINE short _InterlockedDecrement16(volatile short * lpAddend)
{
return _InterlockedExchangeAdd16(lpAddend, -1) - 1;
}
- static __inline__ __attribute__((always_inline)) long _InterlockedIncrement16(volatile short * lpAddend)
-__INTRIN_INLINE short _InterlockedIncrement16(volatile short * const lpAddend)
++__INTRIN_INLINE short _InterlockedIncrement16(volatile short * lpAddend)
{
return _InterlockedExchangeAdd16(lpAddend, 1) + 1;
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) long long _InterlockedDecrement64(volatile long long * lpAddend)
-__INTRIN_INLINE long long _InterlockedDecrement64(volatile long long * const lpAddend)
++__INTRIN_INLINE long long _InterlockedDecrement64(volatile long long * lpAddend)
{
return _InterlockedExchangeAdd64(lpAddend, -1) - 1;
}
- static __inline__ __attribute__((always_inline)) long long _InterlockedIncrement64(volatile long long * lpAddend)
-__INTRIN_INLINE long long _InterlockedIncrement64(volatile long long * const lpAddend)
++__INTRIN_INLINE long long _InterlockedIncrement64(volatile long long * lpAddend)
{
return _InterlockedExchangeAdd64(lpAddend, 1) + 1;
}
#endif
- static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandreset(volatile long * a, const long b)
+ __INTRIN_INLINE unsigned char _interlockedbittestandreset(volatile long * a, const long b)
{
unsigned char retval;
__asm__("lock; btrl %[b], %[a]; setb %b[retval]" : [retval] "=q" (retval), [a] "+m" (*a) : [b] "Ir" (b) : "memory");
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandreset64(volatile long long * a, const long long b)
+ __INTRIN_INLINE unsigned char _interlockedbittestandreset64(volatile long long * a, const long long b)
{
unsigned char retval;
__asm__("lock; btrq %[b], %[a]; setb %b[retval]" : [retval] "=r" (retval), [a] "+m" (*a) : [b] "Ir" (b) : "memory");
}
#endif
- static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandset(volatile long * a, const long b)
+ __INTRIN_INLINE unsigned char _interlockedbittestandset(volatile long * a, const long b)
{
unsigned char retval;
__asm__("lock; btsl %[b], %[a]; setc %b[retval]" : [retval] "=q" (retval), [a] "+m" (*a) : [b] "Ir" (b) : "memory");
}
#if defined(_M_AMD64)
- static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandset64(volatile long long * a, const long long b)
+ __INTRIN_INLINE unsigned char _interlockedbittestandset64(volatile long long * a, const long long b)
{
unsigned char retval;
__asm__("lock; btsq %[b], %[a]; setc %b[retval]" : [retval] "=r" (retval), [a] "+m" (*a) : [b] "Ir" (b) : "memory");
/*** String operations ***/
/* NOTE: we don't set a memory clobber in the __stosX functions because Visual C++ doesn't */
- static __inline__ __attribute__((always_inline)) void __stosb(unsigned char * Dest, const unsigned char Data, size_t Count)
+ __INTRIN_INLINE void __stosb(unsigned char * Dest, const unsigned char Data, size_t Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __stosw(unsigned short * Dest, const unsigned short Data, size_t Count)
+ __INTRIN_INLINE void __stosw(unsigned short * Dest, const unsigned short Data, size_t Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __stosd(unsigned long * Dest, const unsigned long Data, size_t Count)
+ __INTRIN_INLINE void __stosd(unsigned long * Dest, const unsigned long Data, size_t Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __movsb(unsigned char * Destination, const unsigned char * Source, size_t Count)
+ __INTRIN_INLINE void __movsb(unsigned char * Destination, const unsigned char * Source, size_t Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __movsw(unsigned short * Destination, const unsigned short * Source, size_t Count)
+ __INTRIN_INLINE void __movsw(unsigned short * Destination, const unsigned short * Source, size_t Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __movsd(unsigned long * Destination, const unsigned long * Source, size_t Count)
+ __INTRIN_INLINE void __movsd(unsigned long * Destination, const unsigned long * Source, size_t Count)
{
__asm__ __volatile__
(
#if defined(_M_AMD64)
/*** GS segment addressing ***/
- static __inline__ __attribute__((always_inline)) void __writegsbyte(const unsigned long Offset, const unsigned char Data)
+ __INTRIN_INLINE void __writegsbyte(const unsigned long Offset, const unsigned char Data)
{
__asm__ __volatile__("movb %b[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writegsword(const unsigned long Offset, const unsigned short Data)
+ __INTRIN_INLINE void __writegsword(const unsigned long Offset, const unsigned short Data)
{
__asm__ __volatile__("movw %w[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writegsdword(const unsigned long Offset, const unsigned long Data)
+ __INTRIN_INLINE void __writegsdword(const unsigned long Offset, const unsigned long Data)
{
__asm__ __volatile__("movl %k[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writegsqword(const unsigned long Offset, const unsigned __int64 Data)
+ __INTRIN_INLINE void __writegsqword(const unsigned long Offset, const unsigned __int64 Data)
{
__asm__ __volatile__("movq %q[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) unsigned char __readgsbyte(const unsigned long Offset)
+ __INTRIN_INLINE unsigned char __readgsbyte(const unsigned long Offset)
{
unsigned char value;
__asm__ __volatile__("movb %%gs:%a[Offset], %b[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned short __readgsword(const unsigned long Offset)
+ __INTRIN_INLINE unsigned short __readgsword(const unsigned long Offset)
{
unsigned short value;
__asm__ __volatile__("movw %%gs:%a[Offset], %w[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned long __readgsdword(const unsigned long Offset)
+ __INTRIN_INLINE unsigned long __readgsdword(const unsigned long Offset)
{
unsigned long value;
__asm__ __volatile__("movl %%gs:%a[Offset], %k[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readgsqword(const unsigned long Offset)
+ __INTRIN_INLINE unsigned __int64 __readgsqword(const unsigned long Offset)
{
unsigned __int64 value;
__asm__ __volatile__("movq %%gs:%a[Offset], %q[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
return value;
}
- static __inline__ __attribute__((always_inline)) void __incgsbyte(const unsigned long Offset)
+ __INTRIN_INLINE void __incgsbyte(const unsigned long Offset)
{
__asm__ __volatile__("incb %%gs:%a[Offset]" : : [Offset] "ir" (Offset) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __incgsword(const unsigned long Offset)
+ __INTRIN_INLINE void __incgsword(const unsigned long Offset)
{
__asm__ __volatile__("incw %%gs:%a[Offset]" : : [Offset] "ir" (Offset) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __incgsdword(const unsigned long Offset)
+ __INTRIN_INLINE void __incgsdword(const unsigned long Offset)
{
__asm__ __volatile__("incl %%gs:%a[Offset]" : : [Offset] "ir" (Offset) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __addgsbyte(const unsigned long Offset, const unsigned char Data)
+ __INTRIN_INLINE void __addgsbyte(const unsigned long Offset, const unsigned char Data)
{
__asm__ __volatile__("addb %b[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __addgsword(const unsigned long Offset, const unsigned short Data)
+ __INTRIN_INLINE void __addgsword(const unsigned long Offset, const unsigned short Data)
{
__asm__ __volatile__("addw %w[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __addgsdword(const unsigned long Offset, const unsigned int Data)
+ __INTRIN_INLINE void __addgsdword(const unsigned long Offset, const unsigned int Data)
{
__asm__ __volatile__("addl %k[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __addgsqword(const unsigned long Offset, const unsigned __int64 Data)
+ __INTRIN_INLINE void __addgsqword(const unsigned long Offset, const unsigned __int64 Data)
{
__asm__ __volatile__("addq %k[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
#else
/*** FS segment addressing ***/
- static __inline__ __attribute__((always_inline)) void __writefsbyte(const unsigned long Offset, const unsigned char Data)
+ __INTRIN_INLINE void __writefsbyte(const unsigned long Offset, const unsigned char Data)
{
__asm__ __volatile__("movb %b[Data], %%fs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writefsword(const unsigned long Offset, const unsigned short Data)
+ __INTRIN_INLINE void __writefsword(const unsigned long Offset, const unsigned short Data)
{
__asm__ __volatile__("movw %w[Data], %%fs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writefsdword(const unsigned long Offset, const unsigned long Data)
+ __INTRIN_INLINE void __writefsdword(const unsigned long Offset, const unsigned long Data)
{
__asm__ __volatile__("movl %k[Data], %%fs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) unsigned char __readfsbyte(const unsigned long Offset)
+ __INTRIN_INLINE unsigned char __readfsbyte(const unsigned long Offset)
{
unsigned char value;
__asm__ __volatile__("movb %%fs:%a[Offset], %b[value]" : [value] "=q" (value) : [Offset] "irm" (Offset) : "memory");
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned short __readfsword(const unsigned long Offset)
+ __INTRIN_INLINE unsigned short __readfsword(const unsigned long Offset)
{
unsigned short value;
- __asm__ __volatile__("movw %%fs:%a[Offset], %w[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
+ __asm__ __volatile__("movw %%fs:%a[Offset], %w[value]" : [value] "=q" (value) : [Offset] "irm" (Offset) : "memory");
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned long __readfsdword(const unsigned long Offset)
+ __INTRIN_INLINE unsigned long __readfsdword(const unsigned long Offset)
{
unsigned long value;
- __asm__ __volatile__("movl %%fs:%a[Offset], %k[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
+ __asm__ __volatile__("movl %%fs:%a[Offset], %k[value]" : [value] "=q" (value) : [Offset] "irm" (Offset) : "memory");
return value;
}
- static __inline__ __attribute__((always_inline)) void __incfsbyte(const unsigned long Offset)
+ __INTRIN_INLINE void __incfsbyte(const unsigned long Offset)
{
__asm__ __volatile__("incb %%fs:%a[Offset]" : : [Offset] "ir" (Offset) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __incfsword(const unsigned long Offset)
+ __INTRIN_INLINE void __incfsword(const unsigned long Offset)
{
__asm__ __volatile__("incw %%fs:%a[Offset]" : : [Offset] "ir" (Offset) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __incfsdword(const unsigned long Offset)
+ __INTRIN_INLINE void __incfsdword(const unsigned long Offset)
{
__asm__ __volatile__("incl %%fs:%a[Offset]" : : [Offset] "ir" (Offset) : "memory");
}
/* NOTE: the bizarre implementation of __addfsxxx mimics the broken Visual C++ behavior */
- static __inline__ __attribute__((always_inline)) void __addfsbyte(const unsigned long Offset, const unsigned char Data)
+ __INTRIN_INLINE void __addfsbyte(const unsigned long Offset, const unsigned char Data)
{
if(!__builtin_constant_p(Offset))
- __asm__ __volatile__("addb %k[Offset], %%fs:%a[Offset]" : : [Offset] "r" (Offset) : "memory");
+ __asm__ __volatile__("addb %b[Offset], %%fs:%a[Offset]" : : [Offset] "r" (Offset) : "memory");
else
__asm__ __volatile__("addb %b[Data], %%fs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __addfsword(const unsigned long Offset, const unsigned short Data)
+ __INTRIN_INLINE void __addfsword(const unsigned long Offset, const unsigned short Data)
{
if(!__builtin_constant_p(Offset))
- __asm__ __volatile__("addw %k[Offset], %%fs:%a[Offset]" : : [Offset] "r" (Offset) : "memory");
+ __asm__ __volatile__("addw %w[Offset], %%fs:%a[Offset]" : : [Offset] "r" (Offset) : "memory");
else
__asm__ __volatile__("addw %w[Data], %%fs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __addfsdword(const unsigned long Offset, const unsigned int Data)
+ __INTRIN_INLINE void __addfsdword(const unsigned long Offset, const unsigned int Data)
{
if(!__builtin_constant_p(Offset))
__asm__ __volatile__("addl %k[Offset], %%fs:%a[Offset]" : : [Offset] "r" (Offset) : "memory");
/*** Bit manipulation ***/
- static __inline__ __attribute__((always_inline)) unsigned char _BitScanForward(unsigned long * const Index, const unsigned long Mask)
+ __INTRIN_INLINE unsigned char _BitScanForward(unsigned long * const Index, const unsigned long Mask)
{
__asm__("bsfl %[Mask], %[Index]" : [Index] "=r" (*Index) : [Mask] "mr" (Mask));
return Mask ? 1 : 0;
}
- static __inline__ __attribute__((always_inline)) unsigned char _BitScanReverse(unsigned long * const Index, const unsigned long Mask)
+ __INTRIN_INLINE unsigned char _BitScanReverse(unsigned long * const Index, const unsigned long Mask)
{
__asm__("bsrl %[Mask], %[Index]" : [Index] "=r" (*Index) : [Mask] "mr" (Mask));
return Mask ? 1 : 0;
}
/* NOTE: again, the bizarre implementation follows Visual C++ */
- static __inline__ __attribute__((always_inline)) unsigned char _bittest(const long * const a, const long b)
+ __INTRIN_INLINE unsigned char _bittest(const long * const a, const long b)
{
unsigned char retval;
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned char _bittestandcomplement(long * const a, const long b)
+ __INTRIN_INLINE unsigned char _bittestandcomplement(long * const a, const long b)
{
unsigned char retval;
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned char _bittestandreset(long * const a, const long b)
+ __INTRIN_INLINE unsigned char _bittestandreset(long * const a, const long b)
{
unsigned char retval;
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned char _bittestandset(long * const a, const long b)
+ __INTRIN_INLINE unsigned char _bittestandset(long * const a, const long b)
{
unsigned char retval;
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned char _rotl8(unsigned char value, unsigned char shift)
+ __INTRIN_INLINE unsigned char _rotl8(unsigned char value, unsigned char shift)
{
unsigned char retval;
__asm__("rolb %b[shift], %b[retval]" : [retval] "=rm" (retval) : "[retval]" (value), [shift] "Nc" (shift));
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned short _rotl16(unsigned short value, unsigned char shift)
+ __INTRIN_INLINE unsigned short _rotl16(unsigned short value, unsigned char shift)
{
unsigned short retval;
__asm__("rolw %b[shift], %w[retval]" : [retval] "=rm" (retval) : "[retval]" (value), [shift] "Nc" (shift));
}
#ifndef __MSVCRT__
- static __inline__ __attribute__((always_inline)) unsigned int _rotl(unsigned int value, int shift)
+ __INTRIN_INLINE unsigned int _rotl(unsigned int value, int shift)
{
unsigned long retval;
__asm__("roll %b[shift], %k[retval]" : [retval] "=rm" (retval) : "[retval]" (value), [shift] "Nc" (shift));
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned int _rotr(unsigned int value, int shift)
+ __INTRIN_INLINE unsigned int _rotr(unsigned int value, int shift)
{
unsigned long retval;
__asm__("rorl %b[shift], %k[retval]" : [retval] "=rm" (retval) : "[retval]" (value), [shift] "Nc" (shift));
}
#endif
- static __inline__ __attribute__((always_inline)) unsigned char _rotr8(unsigned char value, unsigned char shift)
+ __INTRIN_INLINE unsigned char _rotr8(unsigned char value, unsigned char shift)
{
unsigned char retval;
__asm__("rorb %b[shift], %b[retval]" : [retval] "=rm" (retval) : "[retval]" (value), [shift] "Nc" (shift));
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned short _rotr16(unsigned short value, unsigned char shift)
+ __INTRIN_INLINE unsigned short _rotr16(unsigned short value, unsigned char shift)
{
unsigned short retval;
__asm__("rorw %b[shift], %w[retval]" : [retval] "=rm" (retval) : "[retval]" (value), [shift] "Nc" (shift));
just confuses it. Also we declare Bit as an int and then truncate it to
match Visual C++ behavior
*/
- static __inline__ __attribute__((always_inline)) unsigned long long __ll_lshift(const unsigned long long Mask, const int Bit)
+ __INTRIN_INLINE unsigned long long __ll_lshift(const unsigned long long Mask, const int Bit)
{
unsigned long long retval = Mask;
return retval;
}
- static __inline__ __attribute__((always_inline)) long long __ll_rshift(const long long Mask, const int Bit)
+ __INTRIN_INLINE long long __ll_rshift(const long long Mask, const int Bit)
{
unsigned long long retval = Mask;
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned long long __ull_rshift(const unsigned long long Mask, int Bit)
+ __INTRIN_INLINE unsigned long long __ull_rshift(const unsigned long long Mask, int Bit)
{
unsigned long long retval = Mask;
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned short _byteswap_ushort(unsigned short value)
+ __INTRIN_INLINE unsigned short _byteswap_ushort(unsigned short value)
{
unsigned short retval;
__asm__("rorw $8, %w[retval]" : [retval] "=rm" (retval) : "[retval]" (value));
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned long _byteswap_ulong(unsigned long value)
+ __INTRIN_INLINE unsigned long _byteswap_ulong(unsigned long value)
{
unsigned long retval;
__asm__("bswapl %[retval]" : [retval] "=rm" (retval) : "[retval]" (value));
}
#ifdef _M_AMD64
- static __inline__ __attribute__((always_inline)) unsigned __int64 _byteswap_uint64(unsigned __int64 value)
+ __INTRIN_INLINE unsigned __int64 _byteswap_uint64(unsigned __int64 value)
{
unsigned __int64 retval;
__asm__("bswapq %[retval]" : [retval] "=rm" (retval) : "[retval]" (value));
return retval;
}
#else
- static __inline__ __attribute__((always_inline)) unsigned __int64 _byteswap_uint64(unsigned __int64 value)
+ __INTRIN_INLINE unsigned __int64 _byteswap_uint64(unsigned __int64 value)
{
union {
__int64 int64part;
#endif
/*** 64-bit math ***/
- static __inline__ __attribute__((always_inline)) long long __emul(const int a, const int b)
+ __INTRIN_INLINE long long __emul(const int a, const int b)
{
long long retval;
__asm__("imull %[b]" : "=A" (retval) : [a] "a" (a), [b] "rm" (b));
return retval;
}
- static __inline__ __attribute__((always_inline)) unsigned long long __emulu(const unsigned int a, const unsigned int b)
+ __INTRIN_INLINE unsigned long long __emulu(const unsigned int a, const unsigned int b)
{
unsigned long long retval;
__asm__("mull %[b]" : "=A" (retval) : [a] "a" (a), [b] "rm" (b));
return retval;
}
- #ifdef _M_AMD64
-
- static __inline__ __attribute__((always_inline)) __int64 __mulh(__int64 a, __int64 b)
- {
- __int64 retval;
- __asm__("imulq %[b]" : "=d" (retval) : [a] "a" (a), [b] "rm" (b));
- return retval;
- }
-
- static __inline__ __attribute__((always_inline)) unsigned __int64 __umulh(unsigned __int64 a, unsigned __int64 b)
- {
- unsigned __int64 retval;
- __asm__("mulq %[b]" : "=d" (retval) : [a] "a" (a), [b] "rm" (b));
- return retval;
- }
-
- #endif
/*** Port I/O ***/
- static __inline__ __attribute__((always_inline)) unsigned char __inbyte(const unsigned short Port)
+ __INTRIN_INLINE unsigned char __inbyte(const unsigned short Port)
{
unsigned char byte;
__asm__ __volatile__("inb %w[Port], %b[byte]" : [byte] "=a" (byte) : [Port] "Nd" (Port));
return byte;
}
- static __inline__ __attribute__((always_inline)) unsigned short __inword(const unsigned short Port)
+ __INTRIN_INLINE unsigned short __inword(const unsigned short Port)
{
unsigned short word;
__asm__ __volatile__("inw %w[Port], %w[word]" : [word] "=a" (word) : [Port] "Nd" (Port));
return word;
}
- static __inline__ __attribute__((always_inline)) unsigned long __indword(const unsigned short Port)
+ __INTRIN_INLINE unsigned long __indword(const unsigned short Port)
{
unsigned long dword;
__asm__ __volatile__("inl %w[Port], %k[dword]" : [dword] "=a" (dword) : [Port] "Nd" (Port));
return dword;
}
- static __inline__ __attribute__((always_inline)) void __inbytestring(unsigned short Port, unsigned char * Buffer, unsigned long Count)
+ __INTRIN_INLINE void __inbytestring(unsigned short Port, unsigned char * Buffer, unsigned long Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __inwordstring(unsigned short Port, unsigned short * Buffer, unsigned long Count)
+ __INTRIN_INLINE void __inwordstring(unsigned short Port, unsigned short * Buffer, unsigned long Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __indwordstring(unsigned short Port, unsigned long * Buffer, unsigned long Count)
+ __INTRIN_INLINE void __indwordstring(unsigned short Port, unsigned long * Buffer, unsigned long Count)
{
__asm__ __volatile__
(
);
}
- static __inline__ __attribute__((always_inline)) void __outbyte(unsigned short const Port, const unsigned char Data)
+ __INTRIN_INLINE void __outbyte(unsigned short const Port, const unsigned char Data)
{
__asm__ __volatile__("outb %b[Data], %w[Port]" : : [Port] "Nd" (Port), [Data] "a" (Data));
}
- static __inline__ __attribute__((always_inline)) void __outword(unsigned short const Port, const unsigned short Data)
+ __INTRIN_INLINE void __outword(unsigned short const Port, const unsigned short Data)
{
__asm__ __volatile__("outw %w[Data], %w[Port]" : : [Port] "Nd" (Port), [Data] "a" (Data));
}
- static __inline__ __attribute__((always_inline)) void __outdword(unsigned short const Port, const unsigned long Data)
+ __INTRIN_INLINE void __outdword(unsigned short const Port, const unsigned long Data)
{
__asm__ __volatile__("outl %k[Data], %w[Port]" : : [Port] "Nd" (Port), [Data] "a" (Data));
}
- static __inline__ __attribute__((always_inline)) void __outbytestring(unsigned short const Port, const unsigned char * const Buffer, const unsigned long Count)
+ __INTRIN_INLINE void __outbytestring(unsigned short const Port, const unsigned char * const Buffer, const unsigned long Count)
{
__asm__ __volatile__("rep; outsb" : : [Port] "d" (Port), [Buffer] "S" (Buffer), "c" (Count));
}
- static __inline__ __attribute__((always_inline)) void __outwordstring(unsigned short const Port, const unsigned short * const Buffer, const unsigned long Count)
+ __INTRIN_INLINE void __outwordstring(unsigned short const Port, const unsigned short * const Buffer, const unsigned long Count)
{
__asm__ __volatile__("rep; outsw" : : [Port] "d" (Port), [Buffer] "S" (Buffer), "c" (Count));
}
- static __inline__ __attribute__((always_inline)) void __outdwordstring(unsigned short const Port, const unsigned long * const Buffer, const unsigned long Count)
+ __INTRIN_INLINE void __outdwordstring(unsigned short const Port, const unsigned long * const Buffer, const unsigned long Count)
{
__asm__ __volatile__("rep; outsl" : : [Port] "d" (Port), [Buffer] "S" (Buffer), "c" (Count));
}
/*** System information ***/
- static __inline__ __attribute__((always_inline)) void __cpuid(int CPUInfo[], const int InfoType)
+ __INTRIN_INLINE void __cpuid(int CPUInfo[], const int InfoType)
{
__asm__ __volatile__("cpuid" : "=a" (CPUInfo[0]), "=b" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3]) : "a" (InfoType));
}
- static __inline__ __attribute__((always_inline)) unsigned long long __rdtsc(void)
+ __INTRIN_INLINE unsigned long long __rdtsc(void)
{
#ifdef _M_AMD64
unsigned long long low, high;
#endif
}
- static __inline__ __attribute__((always_inline)) void __writeeflags(uintptr_t Value)
+ __INTRIN_INLINE void __writeeflags(uintptr_t Value)
{
__asm__ __volatile__("push %0\n popf" : : "rim"(Value));
}
- static __inline__ __attribute__((always_inline)) uintptr_t __readeflags(void)
+ __INTRIN_INLINE uintptr_t __readeflags(void)
{
uintptr_t retval;
__asm__ __volatile__("pushf\n pop %0" : "=rm"(retval));
}
/*** Interrupts ***/
- static __inline__ __attribute__((always_inline)) void __debugbreak(void)
+ __INTRIN_INLINE void __debugbreak(void)
{
__asm__("int $3");
}
- static __inline__ __attribute__((always_inline)) void __int2c(void)
+ __INTRIN_INLINE void __int2c(void)
{
__asm__("int $0x2c");
}
- static __inline__ __attribute__((always_inline)) void _disable(void)
+ __INTRIN_INLINE void _disable(void)
{
__asm__("cli");
}
- static __inline__ __attribute__((always_inline)) void _enable(void)
+ __INTRIN_INLINE void _enable(void)
{
__asm__("sti");
}
/*** Protected memory management ***/
- static __inline__ __attribute__((always_inline)) void __writecr0(const unsigned __int64 Data)
+ __INTRIN_INLINE void __writecr0(const unsigned __int64 Data)
{
__asm__("mov %[Data], %%cr0" : : [Data] "q" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writecr3(const unsigned __int64 Data)
+ __INTRIN_INLINE void __writecr3(const unsigned __int64 Data)
{
__asm__("mov %[Data], %%cr3" : : [Data] "q" (Data) : "memory");
}
- static __inline__ __attribute__((always_inline)) void __writecr4(const unsigned __int64 Data)
+ __INTRIN_INLINE void __writecr4(const unsigned __int64 Data)
{
__asm__("mov %[Data], %%cr4" : : [Data] "q" (Data) : "memory");
}
#ifdef _M_AMD64
- static __inline__ __attribute__((always_inline)) void __writecr8(const unsigned __int64 Data)
+ __INTRIN_INLINE void __writecr8(const unsigned __int64 Data)
{
__asm__("mov %[Data], %%cr8" : : [Data] "q" (Data) : "memory");
}
- #endif
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readcr0(void)
+ __INTRIN_INLINE unsigned __int64 __readcr0(void)
{
unsigned __int64 value;
__asm__ __volatile__("mov %%cr0, %[value]" : [value] "=q" (value));
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readcr2(void)
+ __INTRIN_INLINE unsigned __int64 __readcr2(void)
{
unsigned __int64 value;
__asm__ __volatile__("mov %%cr2, %[value]" : [value] "=q" (value));
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readcr3(void)
+ __INTRIN_INLINE unsigned __int64 __readcr3(void)
{
unsigned __int64 value;
__asm__ __volatile__("mov %%cr3, %[value]" : [value] "=q" (value));
return value;
}
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readcr4(void)
+ __INTRIN_INLINE unsigned __int64 __readcr4(void)
{
unsigned __int64 value;
__asm__ __volatile__("mov %%cr4, %[value]" : [value] "=q" (value));
return value;
}
- #ifdef _M_AMD64
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readcr8(void)
+ __INTRIN_INLINE unsigned __int64 __readcr8(void)
{
unsigned __int64 value;
__asm__ __volatile__("movq %%cr8, %q[value]" : [value] "=q" (value));
return value;
}
+ #else
+ __INTRIN_INLINE unsigned long __readcr0(void)
+ {
+ unsigned long value;
+ __asm__ __volatile__("mov %%cr0, %[value]" : [value] "=q" (value));
+ return value;
+ }
+
+ __INTRIN_INLINE unsigned long __readcr2(void)
+ {
+ unsigned long value;
+ __asm__ __volatile__("mov %%cr2, %[value]" : [value] "=q" (value));
+ return value;
+ }
+
+ __INTRIN_INLINE unsigned long __readcr3(void)
+ {
+ unsigned long value;
+ __asm__ __volatile__("mov %%cr3, %[value]" : [value] "=q" (value));
+ return value;
+ }
+
+ __INTRIN_INLINE unsigned long __readcr4(void)
+ {
+ unsigned long value;
+ __asm__ __volatile__("mov %%cr4, %[value]" : [value] "=q" (value));
+ return value;
+ }
#endif
#ifdef _M_AMD64
- static __inline__ __attribute__((always_inline)) unsigned __int64 __readdr(unsigned int reg)
+ __INTRIN_INLINE unsigned __int64 __readdr(unsigned int reg)
{
unsigned __int64 value;
switch (reg)
return value;
}
- static __inline__ __attribute__((always_inline)) void __writedr(unsigned reg, unsigned __int64 value)
+ __INTRIN_INLINE void __writedr(unsigned reg, unsigned __int64 value)
+ {
+ switch (reg)
+ {
+ case 0:
+ __asm__("movq %q[value], %%dr0" : : [value] "q" (value) : "memory");
+ break;
+ case 1:
+ __asm__("movq %q[value], %%dr1" : : [value] "q" (value) : "memory");
+ break;
+ case 2:
+ __asm__("movq %q[value], %%dr2" : : [value] "q" (value) : "memory");
+ break;
+ case 3:
+ __asm__("movq %q[value], %%dr3" : : [value] "q" (value) : "memory");
+ break;
+ case 4:
+ __asm__("movq %q[value], %%dr4" : : [value] "q" (value) : "memory");
+ break;
+ case 5:
+ __asm__("movq %q[value], %%dr5" : : [value] "q" (value) : "memory");
+ break;
+ case 6:
+ __asm__("movq %q[value], %%dr6" : : [value] "q" (value) : "memory");
+ break;
+ case 7:
+ __asm__("movq %q[value], %%dr7" : : [value] "q" (value) : "memory");
+ break;
+ }
+ }
+ #else
+ __INTRIN_INLINE unsigned int __readdr(unsigned int reg)
+ {
+ unsigned int value;
+ switch (reg)
+ {
+ case 0:
+ __asm__ __volatile__("movq %%dr0, %q[value]" : [value] "=q" (value));
+ break;
+ case 1:
+ __asm__ __volatile__("movq %%dr1, %q[value]" : [value] "=q" (value));
+ break;
+ case 2:
+ __asm__ __volatile__("movq %%dr2, %q[value]" : [value] "=q" (value));
+ break;
+ case 3:
+ __asm__ __volatile__("movq %%dr3, %q[value]" : [value] "=q" (value));
+ break;
+ case 4:
+ __asm__ __volatile__("movq %%dr4, %q[value]" : [value] "=q" (value));
+ break;
+ case 5:
+ __asm__ __volatile__("movq %%dr5, %q[value]" : [value] "=q" (value));
+ break;
+ case 6:
+ __asm__ __volatile__("movq %%dr6, %q[value]" : [value] "=q" (value));
+ break;
+ case 7:
+ __asm__ __volatile__("movq %%dr7, %q[value]" : [value] "=q" (value));
+ break;
+ }
+ return value;
+ }
+
+ __INTRIN_INLINE void __writedr(unsigned reg, unsigned int value)
{
switch (reg)
{
}
#endif
- static __inline__ __attribute__((always_inline)) void __invlpg(void * const Address)
+ __INTRIN_INLINE void __invlpg(void * const Address)
{
__asm__("invlpg %[Address]" : : [Address] "m" (*((unsigned char *)(Address))));
}
/*** System operations ***/
- static __inline__ __attribute__((always_inline)) unsigned long long __readmsr(const int reg)
+ __INTRIN_INLINE unsigned long long __readmsr(const int reg)
{
#ifdef _M_AMD64
unsigned long low, high;
#endif
}
- static __inline__ __attribute__((always_inline)) void __writemsr(const unsigned long Register, const unsigned long long Value)
+ __INTRIN_INLINE void __writemsr(const unsigned long Register, const unsigned long long Value)
{
#ifdef _M_AMD64
__asm__ __volatile__("wrmsr" : : "a" (Value), "d" (Value >> 32), "c" (Register));
#endif
}
- static __inline__ __attribute__((always_inline)) unsigned long long __readpmc(const int counter)
+ __INTRIN_INLINE unsigned long long __readpmc(const int counter)
{
unsigned long long retval;
__asm__ __volatile__("rdpmc" : "=A" (retval) : "c" (counter));
}
/* NOTE: an immediate value for 'a' will raise an ICE in Visual C++ */
- static __inline__ __attribute__((always_inline)) unsigned long __segmentlimit(const unsigned long a)
+ __INTRIN_INLINE unsigned long __segmentlimit(const unsigned long a)
{
unsigned long retval;
__asm__ __volatile__("lsl %[a], %[retval]" : [retval] "=r" (retval) : [a] "rm" (a));
return retval;
}
- static __inline__ __attribute__((always_inline)) void __wbinvd(void)
+ __INTRIN_INLINE void __wbinvd(void)
{
__asm__ __volatile__("wbinvd");
}
- static __inline__ __attribute__((always_inline)) void __lidt(void *Source)
+ __INTRIN_INLINE void __lidt(void *Source)
{
__asm__ __volatile__("lidt %0" : : "m"(*(short*)Source));
}
- static __inline__ __attribute__((always_inline)) void __sidt(void *Destination)
+ __INTRIN_INLINE void __sidt(void *Destination)
{
__asm__ __volatile__("sidt %0" : : "m"(*(short*)Destination) : "memory");
}
- static __inline__ __attribute__((always_inline)) void _mm_pause(void)
+ __INTRIN_INLINE void _mm_pause(void)
{
__asm__ __volatile__("pause");
}
#include <crtdefs.h>
+ #define __need___va_list
+ #include <stdarg.h>
+
#pragma pack(push,_CRT_PACKING)
#ifdef __cplusplus
#endif
#define _STDIO_DEFINED
-#endif
+#endif // !_STDIO_DEFINED
#define _fgetc_nolock(_stream) (--(_stream)->_cnt >= 0 ? 0xff & *(_stream)->_ptr++ : _filbuf(_stream))
#define _fputc_nolock(_c,_stream) (--(_stream)->_cnt >= 0 ? 0xff & (*(_stream)->_ptr++ = (char)(_c)) : _flsbuf((_c),(_stream)))
_CRTIMP extern char *_sys_errlist[];
_CRTIMP extern int _sys_nerr;
-#if (defined(_X86_) && !defined(__x86_64))
+#if (defined(_X86_) || defined(__x86_64)) // HACK
_CRTIMP int *__cdecl __p___argc(void);
_CRTIMP char ***__cdecl __p___argv(void);
_CRTIMP wchar_t ***__cdecl __p___wargv(void);
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#else
extern "C++" {
- template <typename _CountofType,size_t _SizeOfArray> char (*__countof_helper(UNALIGNED _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+ template <typename _CountofType,size_t _SizeOfArray>
+ char (*__countof_helper(/*UNALIGNED*/ _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
#define _countof(_Array) sizeof(*__countof_helper(_Array))
}
#endif
_CRTIMP __declspec(noreturn) void __cdecl _exit(int _Code);
#if !defined __NO_ISOCEXT /* extern stub in static libmingwex.a */
/* C99 function name */
- void __cdecl __declspec(noreturn) _Exit(int); /* Declare to get noreturn attribute. */
+ __declspec(noreturn) void __cdecl _Exit(int); /* Declare to get noreturn attribute. */
__CRT_INLINE void __cdecl _Exit(int status)
{ _exit(status); }
#endif
#pragma push_macro("abort")
#undef abort
#endif
- void __cdecl __declspec(noreturn) abort(void);
+ __declspec(noreturn) void __cdecl abort(void);
#if __MINGW_GNUC_PREREQ(4,4)
#pragma pop_macro("abort")
#endif
#include <crtdefs.h>
+ #define __need___va_list
+ #include <stdarg.h>
+
#pragma pack(push,_CRT_PACKING)
#ifdef __cplusplus
extern "C" {
#endif
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable:4820)
+ #endif
+
#ifndef WCHAR_MIN
#define WCHAR_MIN 0
#endif
#ifndef _WTIME_DEFINED
#define _WTIME_DEFINED
-
- _CRTIMP wchar_t *__cdecl _wasctime(const struct tm *_Tm);
- _CRTIMP wchar_t *__cdecl _wctime32(const __time32_t *_Time);
- size_t __cdecl wcsftime(wchar_t *_Buf,size_t _SizeInWords,const wchar_t *_Format,const struct tm *_Tm);
+ _CRTIMP _CRT_INSECURE_DEPRECATE(_wasctime_s) wchar_t *__cdecl _wasctime(const struct tm *_Tm);
+ _CRTIMP wchar_t *__cdecl _wctime(const time_t *_Time);
+ _CRTIMP _CRT_INSECURE_DEPRECATE(_wctime32_s) wchar_t *__cdecl _wctime32(const __time32_t *_Time);
+ _CRTIMP size_t __cdecl wcsftime(wchar_t *_Buf,size_t _SizeInWords,const wchar_t *_Format,const struct tm *_Tm);
_CRTIMP size_t __cdecl _wcsftime_l(wchar_t *_Buf,size_t _SizeInWords,const wchar_t *_Format,const struct tm *_Tm,_locale_t _Locale);
_CRTIMP wchar_t *__cdecl _wstrdate(wchar_t *_Buffer);
_CRTIMP wchar_t *__cdecl _wstrtime(wchar_t *_Buffer);
+
+ _CRTIMP errno_t __cdecl _wasctime_s(wchar_t *_Buf,size_t _SizeInWords,const struct tm *_Tm);
+ _CRTIMP errno_t __cdecl _wctime32_s(wchar_t *_Buf,size_t _SizeInWords,const __time32_t *_Time);
+ _CRTIMP errno_t __cdecl _wstrdate_s(wchar_t *_Buf,size_t _SizeInWords);
+ _CRTIMP errno_t __cdecl _wstrtime_s(wchar_t *_Buf,size_t _SizeInWords);
#if _INTEGRAL_MAX_BITS >= 64
- _CRTIMP wchar_t *__cdecl _wctime64(const __time64_t *_Time);
+ _CRTIMP _CRT_INSECURE_DEPRECATE(_wctime64_s) wchar_t *__cdecl _wctime64(const __time64_t *_Time);
+ _CRTIMP errno_t __cdecl _wctime64_s(wchar_t *_Buf,size_t _SizeInWords,const __time64_t *_Time);
#endif
#if !defined (RC_INVOKED) && !defined (_INC_WTIME_INL)
#define _INC_WTIME_INL
#ifdef _USE_32BIT_TIME_T
-__CRT_INLINE wchar_t *__cdecl _wctime(const time_t *_Time) { return _wctime32(_Time); }
+/* Do it like this to be compatible to msvcrt.dll on 32 bit windows XP and before */
+__CRT_INLINE wchar_t *__cdecl _wctime32(const time_t *_Time) { return _wctime(_Time); }
+__CRT_INLINE errno_t _wctime32_s(wchar_t *_Buffer, size_t _SizeInWords,const __time32_t *_Time) { return _wctime32_s(_Buffer, _SizeInWords, _Time); }
#else
__CRT_INLINE wchar_t *__cdecl _wctime(const time_t *_Time) { return _wctime64(_Time); }
+__CRT_INLINE errno_t _wctime_s(wchar_t *_Buffer, size_t _SizeInWords,const time_t *_Time) { return _wctime64_s(_Buffer, _SizeInWords, _Time); }
#endif
#endif
-#endif
+
+#endif /* !_WTIME_DEFINED */
typedef int mbstate_t;
typedef wchar_t _Wint_t;
}
return (_S);
}
+
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
+
#ifdef __cplusplus
}
#endif
ULONG PatternFlags;
} NDIS_PM_PACKET_PATTERN, *PNDIS_PM_PACKET_PATTERN;
+ typedef struct _NDIS_PACKET_STACK {
+ ULONG_PTR IMReserved[2];
+ ULONG_PTR NdisReserved[4];
+ } NDIS_PACKET_STACK, *PNDIS_PACKET_STACK;
/* Request types used by NdisRequest */
typedef enum _NDIS_REQUEST_TYPE {
(*ADAPTER_SHUTDOWN_HANDLER)(
IN PVOID ShutdownContext);
+ typedef NTSTATUS DDKAPI
+ (*TDI_REGISTER_CALLBACK)(
+ IN PUNICODE_STRING DeviceName,
+ OUT HANDLE* TdiHandle);
+
+ typedef NTSTATUS DDKAPI
+ (*TDI_PNP_HANDLER)(
+ IN PUNICODE_STRING UpperComponent,
+ IN PUNICODE_STRING LowerComponent,
+ IN PUNICODE_STRING BindList,
+ IN PVOID ReconfigBuffer,
+ IN UINT ReconfigBufferSize,
+ IN UINT Operation);
typedef struct _OID_LIST OID_LIST, *POID_LIST;
ULONG EncapsulationHeaderSize;
} NDIS_ENCAPSULATION_FORMAT, *PNDIS_ENCAPSULATION_FORMAT;
+ typedef struct _NDIS_TASK_OFFLOAD_HEADER
+ {
+ ULONG Version;
+ ULONG Size;
+ ULONG Reserved;
+ ULONG OffsetFirstTask;
+ NDIS_ENCAPSULATION_FORMAT EncapsulationFormat;
+ } NDIS_TASK_OFFLOAD_HEADER, *PNDIS_TASK_OFFLOAD_HEADER;
+
typedef struct _NDIS_TASK_TCP_IP_CHECKSUM {
struct {
ULONG IpOptionsSupported:1;
#define NdisQueryPacketLength(Packet, \
TotalPacketLength) \
{ \
- if ((TotalPacketLength)) \
- { \
- if (!(Packet)->Private.ValidCounts) { \
- UINT _Offset; \
- UINT _PacketLength; \
- PNDIS_BUFFER _NdisBuffer; \
- UINT _PhysicalBufferCount = 0; \
- UINT _TotalPacketLength = 0; \
- UINT _Count = 0; \
- \
- for (_NdisBuffer = (Packet)->Private.Head; \
- _NdisBuffer != (PNDIS_BUFFER)NULL; \
- _NdisBuffer = _NdisBuffer->Next) \
- { \
- _PhysicalBufferCount += NDIS_BUFFER_TO_SPAN_PAGES(_NdisBuffer); \
- NdisQueryBufferOffset(_NdisBuffer, &_Offset, &_PacketLength); \
- _TotalPacketLength += _PacketLength; \
- _Count++; \
- } \
- (Packet)->Private.PhysicalCount = _PhysicalBufferCount; \
- (Packet)->Private.TotalLength = _TotalPacketLength; \
- (Packet)->Private.Count = _Count; \
- (Packet)->Private.ValidCounts = TRUE; \
- } \
- \
- if (TotalPacketLength) \
- *((PUINT)TotalPacketLength) = (Packet)->Private.TotalLength; \
- } \
+ if (!(Packet)->Private.ValidCounts) \
+ NdisQueryPacket(Packet, NULL, NULL, NULL, TotalPacketLength); \
+ else \
+ *(TotalPacketLength) = (Packet)->Private.TotalLength; \
}
#define NdisZeroMemory(Destination, Length) \
RtlZeroMemory(Destination, Length)
-
+ typedef VOID DDKAPI
+ (*NDIS_BLOCK_INITIALIZER) (
+ IN PUCHAR Block,
+ IN SIZE_T NumberOfBytes
+ );
/* Configuration routines */
#define NTKERNELAPI DECLSPEC_IMPORT\r
#endif\r
\r
+ #ifdef _WIN64\r
+ #define PORT_MAXIMUM_MESSAGE_LENGTH 512\r
+ #else\r
+ #define PORT_MAXIMUM_MESSAGE_LENGTH 256\r
+ #endif\r
+ \r
+ \r
/* Simple types */\r
typedef UCHAR KPROCESSOR_MODE;\r
typedef LONG KPRIORITY;\r
/*\r
* PVOID\r
* InterlockedExchangePointer(\r
- * IN OUT PVOID VOLATILE *Target,\r
+ * IN OUT PVOID volatile *Target,\r
* IN PVOID Value)\r
*/\r
#define InterlockedExchangePointer(Target, Value) \\r
return InterlockedExchangeAdd64(Addend, Value) + Value;\r
}\r
//#endif\r
+#define BitScanForward _BitScanForward\r
+#define BitScanReverse _BitScanReverse\r
+#endif\r
+\r
+#ifdef _M_AMD64\r
+#define InterlockedBitTestAndSet64 _interlockedbittestandset64\r
+#define InterlockedBitTestAndReset64 _interlockedbittestandreset64\r
#endif\r
\r
#endif /* !__INTERLOCKED_DECLARED */\r
#define PSLIST_ENTRY PSINGLE_LIST_ENTRY\r
\r
#if defined(_WIN64)\r
-typedef union _SLIST_HEADER {\r
+typedef union DECLSPEC_ALIGN(16) _SLIST_HEADER {\r
struct {\r
ULONGLONG Alignment;\r
ULONGLONG Region;\r
ULONGLONG Reserved:59;\r
ULONGLONG Region:3;\r
} Header8;\r
+ struct {\r
ULONGLONG Depth:16;\r
ULONGLONG Sequence:48;\r
ULONGLONG HeaderType:1;\r
ULONGLONG Init:1;\r
ULONGLONG Reserved:2;\r
ULONGLONG NextEntry:60;\r
- struct {\r
} Header16;\r
} SLIST_HEADER, *PSLIST_HEADER;\r
#else\r
SYNCHRONIZE | \
31)
+ //
+ // Job Limit Flags
+ //
+ #define JOB_OBJECT_LIMIT_WORKINGSET 0x1
+ #define JOB_OBJECT_LIMIT_PROCESS_TIME 0x2
+ #define JOB_OBJECT_LIMIT_JOB_TIME 0x4
+ #define JOB_OBJECT_LIMIT_ACTIVE_PROCESS 0x8
+ #define JOB_OBJECT_LIMIT_AFFINITY 0x10
+ #define JOB_OBJECT_LIMIT_PRIORITY_CLASS 0x20
+ #define JOB_OBJECT_LIMIT_PRESERVE_JOB_TIME 0x40
+ #define JOB_OBJECT_LIMIT_SCHEDULING_CLASS 0x80
+ #define JOB_OBJECT_LIMIT_PROCESS_MEMORY 0x100
+ #define JOB_OBJECT_LIMIT_JOB_MEMORY 0x200
+ #define JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION 0x400
+ #define JOB_OBJECT_LIMIT_BREAKAWAY_OK 0x800
+ #define JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK 0x1000
+ #define JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE 0x2000
+
+
//
// Cross Thread Flags
//
UCHAR ReadImageFileExecOptions;
UCHAR BeingDebugged;
#if (NTDDI_VERSION >= NTDDI_WS03)
- struct
+ union
{
- UCHAR ImageUsesLargePages:1;
+ UCHAR BitField;
+ struct
+ {
+ UCHAR ImageUsesLargePages:1;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
- UCHAR IsProtectedProcess:1;
- UCHAR IsLegacyProcess:1;
- UCHAR SpareBits:5;
+ UCHAR IsProtectedProcess:1;
+ UCHAR IsLegacyProcess:1;
+ UCHAR IsImageDynamicallyRelocated:1;
+ UCHAR SkipPatchingUser32Forwarders:1;
+ UCHAR SpareBits:3;
#else
- UCHAR SpareBits:7;
+ UCHAR SpareBits:7;
#endif
+ };
};
#else
BOOLEAN SpareBool;
struct _RTL_CRITICAL_SECTION *FastPebLock;
PVOID AltThunkSListPtr;
PVOID IFEOKey;
- ULONG Spare;
+ union
+ {
+ ULONG CrossProcessFlags;
+ struct
+ {
+ ULONG ProcessInJob:1;
+ ULONG ProcessInitializing:1;
+ ULONG ProcessUsingVEH:1;
+ ULONG ProcessUsingVCH:1;
+ ULONG ReservedBits0:28;
+ };
+ };
union
{
PVOID* KernelCallbackTable;
};
ULONG SystemReserved[1];
ULONG SpareUlong;
+ ULONG_PTR SparePebPtr0;
#else
PVOID FastPebLock;
PPEBLOCKROUTINE FastPebLockRoutine;
PVOID* KernelCallbackTable;
PVOID EventLogSection;
PVOID EventLog;
-#endif
PPEB_FREE_BLOCK FreeList;
+#endif
ULONG TlsExpansionCounter;
PVOID TlsBitmap;
ULONG TlsBitmapBits[0x2];
PVOID ReadOnlySharedMemoryBase;
+#if (NTDDI_VERSION >= NTDDI_LONGHORN)
+ PVOID HotpatchInformation;
+#else
PVOID ReadOnlySharedMemoryHeap;
+#endif
PVOID* ReadOnlyStaticServerData;
PVOID AnsiCodePageData;
PVOID OemCodePageData;
ULONG NumberOfProcessors;
ULONG NtGlobalFlag;
LARGE_INTEGER CriticalSectionTimeout;
- ULONG HeapSegmentReserve;
- ULONG HeapSegmentCommit;
- ULONG HeapDeCommitTotalFreeThreshold;
- ULONG HeapDeCommitFreeBlockThreshold;
+ ULONG_PTR HeapSegmentReserve;
+ ULONG_PTR HeapSegmentCommit;
+ ULONG_PTR HeapDeCommitTotalFreeThreshold;
+ ULONG_PTR HeapDeCommitFreeBlockThreshold;
ULONG NumberOfHeaps;
ULONG MaximumNumberOfHeaps;
PVOID* ProcessHeaps;
ULONG ImageSubSystemMajorVersion;
ULONG ImageSubSystemMinorVersion;
ULONG ImageProcessAffinityMask;
+#ifdef _WIN64
+ ULONG GdiHandleBuffer[0x3c];
+#else
ULONG GdiHandleBuffer[0x22];
+#endif
PPOST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
struct _RTL_BITMAP *TlsExpansionBitmap;
ULONG TlsExpansionBitmapBits[0x20];
struct _ASSEMBLY_STORAGE_MAP *ProcessAssemblyStorageMap;
struct _ACTIVATION_CONTEXT_DATA *SystemDefaultActivationContextData;
struct _ASSEMBLY_STORAGE_MAP *SystemAssemblyStorageMap;
- ULONG MinimumStackCommit;
+ ULONG_PTR MinimumStackCommit;
#endif
#if (NTDDI_VERSION >= NTDDI_WS03)
PVOID *FlsCallback;
#endif
PPS_IMPERSONATION_INFORMATION ImpersonationInfo;
LIST_ENTRY IrpList;
- ULONG TopLevelIrp;
+ ULONG_PTR TopLevelIrp;
PDEVICE_OBJECT DeviceToVerify;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
PPSP_RATE_APC RateControlApc;
#if !defined(__ROS_LONG64__)
#ifdef __WINESRC__
-#define __ROS_LONG64__
+//#define __ROS_LONG64__
#endif
#endif
{ return( (void*)(ULONG_PTR)ul ); }
#endif /* !__midl */
#else /* !_WIN64 */
- #if 1// !defined(__ROS_LONG64__)
+ #if !defined(__ROS_LONG64__)
typedef int INT_PTR, *PINT_PTR;
typedef unsigned int UINT_PTR, *PUINT_PTR;
- #else // WTF??? HACK of break
+ #else
typedef long INT_PTR, *PINT_PTR;
typedef unsigned long UINT_PTR, *PUINT_PTR;
#endif
#ifdef __cplusplus
extern "C" {
#endif
+
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable:4201)
+ #endif
+
#define WINMMAPI DECLSPEC_IMPORT
#define _loadds
#define _huge
DWORD dwValue;
} MIXERCONTROLDETAILS_UNSIGNED,*PMIXERCONTROLDETAILS_UNSIGNED,*LPMIXERCONTROLDETAILS_UNSIGNED;
-typedef void(CALLBACK TIMECALLBACK)(UINT,UINT,DWORD,DWORD,DWORD);
+typedef void(CALLBACK TIMECALLBACK)(UINT,UINT,DWORD_PTR,DWORD_PTR,DWORD_PTR);
typedef TIMECALLBACK *LPTIMECALLBACK;
typedef const MMCKINFO *LPCMMCKINFO;
typedef struct tagMCI_GENERIC_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
} MCI_GENERIC_PARMS,*PMCI_GENERIC_PARMS,*LPMCI_GENERIC_PARMS;
typedef struct tagMCI_OPEN_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
} MCI_OPEN_PARMSA,*PMCI_OPEN_PARMSA,*LPMCI_OPEN_PARMSA;
typedef struct tagMCI_OPEN_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
} MCI_OPEN_PARMSW,*PMCI_OPEN_PARMSW,*LPMCI_OPEN_PARMSW;
typedef struct tagMCI_PLAY_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_PLAY_PARMS,*PMCI_PLAY_PARMS,*LPMCI_PLAY_PARMS;
typedef struct tagMCI_SEEK_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwTo;
} MCI_SEEK_PARMS, *PMCI_SEEK_PARMS,*LPMCI_SEEK_PARMS;
typedef struct tagMCI_STATUS_PARMS {
- DWORD dwCallback;
- DWORD dwReturn;
+ DWORD_PTR dwCallback;
+ DWORD_PTR dwReturn;
DWORD dwItem;
DWORD dwTrack;
} MCI_STATUS_PARMS,*PMCI_STATUS_PARMS,*LPMCI_STATUS_PARMS;
typedef struct tagMCI_INFO_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
} MCI_INFO_PARMSA,*LPMCI_INFO_PARMSA;
typedef struct tagMCI_INFO_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPWSTR lpstrReturn;
DWORD dwRetSize;
} MCI_INFO_PARMSW,*LPMCI_INFO_PARMSW;
typedef struct tagMCI_GETDEVCAPS_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwReturn;
DWORD dwItem;
} MCI_GETDEVCAPS_PARMS,*PMCI_GETDEVCAPS_PARMS,*LPMCI_GETDEVCAPS_PARMS;
typedef struct tagMCI_SYSINFO_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwNumber;
} MCI_SYSINFO_PARMSA,*PMCI_SYSINFO_PARMSA,*LPMCI_SYSINFO_PARMSA;
typedef struct tagMCI_SYSINFO_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPWSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwNumber;
} MCI_SYSINFO_PARMSW,*PMCI_SYSINFO_PARMSW,*LPMCI_SYSINFO_PARMSW;
typedef struct tagMCI_SET_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
} MCI_SET_PARMS,*PMCI_SET_PARMS,*LPMCI_SET_PARMS;
typedef struct tagMCI_BREAK_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
int nVirtKey;
HWND hwndBreak;
} MCI_BREAK_PARMS,*PMCI_BREAK_PARMS,*LPMCI_BREAK_PARMS;
typedef struct tagMCI_SAVE_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
} MCI_SAVE_PARMSA,*PMCI_SAVE_PARMSA,*LPMCI_SAVE_PARMSA;
typedef struct tagMCI_SAVE_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
} MCI_SAVE_PARMSW,*PMCI_SAVE_PARMSW,*LPMCI_SAVE_PARMSW;
typedef struct tagMCI_LOAD_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
} MCI_LOAD_PARMSA,*PMCI_LOAD_PARMSA,*LPMCI_LOAD_PARMSA;
typedef struct tagMCI_LOAD_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
} MCI_LOAD_PARMSW,*PMCI_LOAD_PARMSW,*LPMCI_LOAD_PARMSW;
typedef struct tagMCI_RECORD_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_RECORD_PARMS,*LPMCI_RECORD_PARMS;
typedef struct tagMCI_VD_PLAY_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
DWORD dwSpeed;
} MCI_VD_PLAY_PARMS,*PMCI_VD_PLAY_PARMS,*LPMCI_VD_PLAY_PARMS;
typedef struct tagMCI_VD_STEP_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_VD_STEP_PARMS,*PMCI_VD_STEP_PARMS,*LPMCI_VD_STEP_PARMS;
typedef struct tagMCI_VD_ESCAPE_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMSA,*PMCI_VD_ESCAPE_PARMSA,*LPMCI_VD_ESCAPE_PARMSA;
typedef struct tagMCI_VD_ESCAPE_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCWSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMSW,*PMCI_VD_ESCAPE_PARMSW,*LPMCI_VD_ESCAPE_PARMSW;
typedef struct tagMCI_WAVE_OPEN_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
} MCI_WAVE_OPEN_PARMSA,*PMCI_WAVE_OPEN_PARMSA,*LPMCI_WAVE_OPEN_PARMSA;
typedef struct tagMCI_WAVE_OPEN_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
} MCI_WAVE_OPEN_PARMSW,*PMCI_WAVE_OPEN_PARMSW,*LPMCI_WAVE_OPEN_PARMSW;
typedef struct tagMCI_WAVE_DELETE_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_WAVE_DELETE_PARMS, *PMCI_WAVE_DELETE_PARMS,*LPMCI_WAVE_DELETE_PARMS;
typedef struct tagMCI_WAVE_SET_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
UINT wInput;
WORD wReserved5;
} MCI_WAVE_SET_PARMS,*PMCI_WAVE_SET_PARMS,*LPMCI_WAVE_SET_PARMS;
-LRESULT WINAPI CloseDriver(HDRVR,LONG,LONG);
-HDRVR WINAPI OpenDriver(LPCWSTR,LPCWSTR,LONG);
-LRESULT WINAPI SendDriverMessage(HDRVR,UINT,LONG,LONG);
+LRESULT WINAPI CloseDriver(HDRVR,LPARAM,LPARAM);
+HDRVR WINAPI OpenDriver(LPCWSTR,LPCWSTR,LPARAM);
+LRESULT WINAPI SendDriverMessage(HDRVR,UINT,LPARAM,LPARAM);
HMODULE WINAPI DrvGetModuleHandle(HDRVR);
HMODULE WINAPI GetDriverModuleHandle(HDRVR);
LRESULT WINAPI DefDriverProc(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
MMRESULT WINAPI mmioDescend(HMMIO,LPMMCKINFO,const MMCKINFO*,UINT);
MMRESULT WINAPI mmioAscend(HMMIO,LPMMCKINFO,UINT);
MMRESULT WINAPI mmioCreateChunk(HMMIO,LPMMCKINFO,UINT);
-MCIERROR WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD,DWORD_PTR);
-MCIERROR WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD,DWORD_PTR);
+MCIERROR WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
+MCIERROR WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
MCIERROR WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
MCIERROR WINAPI mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND);
MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR);
BOOL WINAPI mciGetErrorStringA(MCIERROR,LPSTR,UINT);
BOOL WINAPI mciGetErrorStringW(MCIERROR,LPWSTR,UINT);
BOOL WINAPI mciSetYieldProc(MCIDEVICEID,YIELDPROC,DWORD);
-HTASK WINAPI mciGetCreatorTask(MCIDEVICEID);
+HANDLE WINAPI mciGetCreatorTask(MCIDEVICEID);
YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID,PDWORD);
typedef struct tagMCI_SEQ_SET_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
DWORD dwTempo;
DWORD dwOffset;
} MCI_SEQ_SET_PARMS,*PMCI_SEQ_SET_PARMS,*LPMCI_SEQ_SET_PARMS;
typedef struct tagMCI_ANIM_OPEN_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
HWND hWndParent;
} MCI_ANIM_OPEN_PARMSA,*PMCI_ANIM_OPEN_PARMSA,*LPMCI_ANIM_OPEN_PARMSA;
typedef struct tagMCI_ANIM_OPEN_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
HWND hWndParent;
} MCI_ANIM_OPEN_PARMSW,*PMCI_ANIM_OPEN_PARMSW,*LPMCI_ANIM_OPEN_PARMSW;
typedef struct tagMCI_ANIM_PLAY_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
DWORD dwSpeed;
} MCI_ANIM_PLAY_PARMS,*PMCI_ANIM_PLAY_PARMS,*LPMCI_ANIM_PLAY_PARMS;
typedef struct tagMCI_ANIM_STEP_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_ANIM_STEP_PARMS,*PMCI_ANIM_STEP_PARMS,*LPMCI_ANIM_STEP_PARMS;
typedef struct tagMCI_ANIM_WINDOW_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCSTR lpstrText;
} MCI_ANIM_WINDOW_PARMSA,*PMCI_ANIM_WINDOW_PARMSA,*LPMCI_ANIM_WINDOW_PARMSA;
typedef struct tagMCI_ANIM_WINDOW_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCWSTR lpstrText;
} MCI_ANIM_WINDOW_PARMSW,*PMCI_ANIM_WINDOW_PARMSW,*LPMCI_ANIM_WINDOW_PARMSW;
typedef struct tagMCI_ANIM_RECT_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
#ifdef MCI_USE_OFFEXT
POINT ptOffset;
POINT ptExtent;
#endif
} MCI_ANIM_RECT_PARMS,*PMCI_ANIM_RECT_PARMS,*LPMCI_ANIM_RECT_PARMS;
typedef struct tagMCI_ANIM_UPDATE_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
RECT rc;
HDC hDC;
} MCI_ANIM_UPDATE_PARMS,*PMCI_ANIM_UPDATE_PARMS,*LPMCI_ANIM_UPDATE_PARMS;
typedef struct tagMCI_OVLY_OPEN_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
HWND hWndParent;
} MCI_OVLY_OPEN_PARMSA,*PMCI_OVLY_OPEN_PARMSA,*LPMCI_OVLY_OPEN_PARMSA;
typedef struct tagMCI_OVLY_OPEN_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
HWND hWndParent;
} MCI_OVLY_OPEN_PARMSW,*PMCI_OVLY_OPEN_PARMSW,*LPMCI_OVLY_OPEN_PARMSW;
typedef struct tagMCI_OVLY_WINDOW_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCSTR lpstrText;
} MCI_OVLY_WINDOW_PARMSA,*PMCI_OVLY_WINDOW_PARMSA,*LPMCI_OVLY_WINDOW_PARMSA;
typedef struct tagMCI_OVLY_WINDOW_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCWSTR lpstrText;
} MCI_OVLY_WINDOW_PARMSW,*PMCI_OVLY_WINDOW_PARMSW,*LPMCI_OVLY_WINDOW_PARMSW;
typedef struct tagMCI_OVLY_RECT_PARMS {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
#ifdef MCI_USE_OFFEXT
POINT ptOffset;
POINT ptExtent;
#endif
} MCI_OVLY_RECT_PARMS,*PMCI_OVLY_RECT_PARMS,*LPMCI_OVLY_RECT_PARMS;
typedef struct tagMCI_OVLY_SAVE_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
RECT rc;
} MCI_OVLY_SAVE_PARMSA,*PMCI_OVLY_SAVE_PARMSA,*LPMCI_OVLY_SAVE_PARMSA;
typedef struct tagMCI_OVLY_SAVE_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
RECT rc;
} MCI_OVLY_SAVE_PARMSW,*PMCI_OVLY_SAVE_PARMSW,*LPMCI_OVLY_SAVE_PARMSW;
typedef struct tagMCI_OVLY_LOAD_PARMSA {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCSTR lpfilename;
RECT rc;
} MCI_OVLY_LOAD_PARMSA,*PMCI_OVLY_LOAD_PARMSA,*LPMCI_OVLY_LOAD_PARMSA;
typedef struct tagMCI_OVLY_LOAD_PARMSW {
- DWORD dwCallback;
+ DWORD_PTR dwCallback;
LPCWSTR lpfilename;
RECT rc;
} MCI_OVLY_LOAD_PARMSW,*PMCI_OVLY_LOAD_PARMSW,*LPMCI_OVLY_LOAD_PARMSW;
#define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDA
#define mciGetErrorString mciGetErrorStringA
#endif
+
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
+
#ifdef __cplusplus
}
#endif
#if !defined(__ROS_LONG64__)
#ifdef __WINESRC__
-#define __ROS_LONG64__
+//#define __ROS_LONG64__
#endif
#endif
extern "C" {
#endif
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable:4255)
+ #endif
+
#ifndef WINVER
#define WINVER 0x0400
/*
SHORT y;
} POINTS,*PPOINTS,*LPPOINTS;
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
+
#ifdef __cplusplus
}
#endif
#if !defined(__ROS_LONG64__)
#ifdef __WINESRC__
-#define __ROS_LONG64__
+//#define __ROS_LONG64__ <- hack of fail!!!
#endif
#endif
#ifdef _X86_
#define UNALIGNED
#else
+#undef UNALIGNED
#define UNALIGNED
#endif
#define NTAPI __stdcall
#include <basetsd.h>
+
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable:4201)
+ #pragma warning(disable:4214)
+ #pragma warning(disable:4820)
+ #endif
+
#define ACE_OBJECT_TYPE_PRESENT 0x00000001
#define ACE_INHERITED_OBJECT_TYPE_PRESENT 0x00000002
#define APPLICATION_ERROR_MASK 0x20000000
#define RTL_CRITSECT_TYPE 0
#define RTL_RESOURCE_TYPE 1
/* Also in winddk.h */
+ #ifndef __GNUC__
#define FIELD_OFFSET(t,f) ((LONG_PTR)&(((t*)0)->f))
+ #else
+ #define FIELD_OFFSET(t,f) __builtin_offsetof(t,f)
+ #endif
#ifndef CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field) \
((type *)(((ULONG_PTR)address) - (ULONG_PTR)(&(((type *)0)->field))))
DWORD Sacl;
DWORD Dacl;
} SECURITY_DESCRIPTOR_RELATIVE, *PISECURITY_DESCRIPTOR_RELATIVE;
+
typedef enum _TOKEN_INFORMATION_CLASS {
- TokenUser=1,TokenGroups,TokenPrivileges,TokenOwner,
- TokenPrimaryGroup,TokenDefaultDacl,TokenSource,TokenType,
- TokenImpersonationLevel,TokenStatistics,TokenRestrictedSids,
- TokenSessionId,TokenGroupsAndPrivileges,TokenSessionReference,
- TokenSandBoxInert,TokenAuditPolicy,TokenOrigin,
+ TokenUser = 1,
+ TokenGroups,
+ TokenPrivileges,
+ TokenOwner,
+ TokenPrimaryGroup,
+ TokenDefaultDacl,
+ TokenSource,
+ TokenType,
+ TokenImpersonationLevel,
+ TokenStatistics,
+ TokenRestrictedSids,
+ TokenSessionId,
+ TokenGroupsAndPrivileges,
+ TokenSessionReference,
+ TokenSandBoxInert,
+ TokenAuditPolicy,
+ TokenOrigin,
+ TokenElevationType,
+ TokenLinkedToken,
+ TokenElevation,
+ TokenHasRestrictions,
+ TokenAccessInformation,
+ TokenVirtualizationAllowed,
+ TokenVirtualizationEnabled,
+ TokenIntegrityLevel,
+ TokenUIAccess,
+ TokenMandatoryPolicy,
+ TokenLogonSid,
+ MaxTokenInfoClass
} TOKEN_INFORMATION_CLASS;
+
#endif
typedef enum _SID_NAME_USE {
SidTypeUser=1,SidTypeGroup,SidTypeDomain,SidTypeAlias,
struct _SINGLE_LIST_ENTRY *Next;
} SINGLE_LIST_ENTRY,*PSINGLE_LIST_ENTRY;
+//
+// Slist Header
+//
#ifndef _SLIST_HEADER_
#define _SLIST_HEADER_
+
#define SLIST_ENTRY SINGLE_LIST_ENTRY
#define _SLIST_ENTRY _SINGLE_LIST_ENTRY
#define PSLIST_ENTRY PSINGLE_LIST_ENTRY
+
+#if defined(_WIN64)
+typedef union DECLSPEC_ALIGN(16) _SLIST_HEADER {
+ struct {
+ ULONGLONG Alignment;
+ ULONGLONG Region;
+ } DUMMYSTRUCTNAME;
+ struct {
+ ULONGLONG Depth:16;
+ ULONGLONG Sequence:9;
+ ULONGLONG NextEntry:39;
+ ULONGLONG HeaderType:1;
+ ULONGLONG Init:1;
+ ULONGLONG Reserved:59;
+ ULONGLONG Region:3;
+ } Header8;
+ struct {
+ ULONGLONG Depth:16;
+ ULONGLONG Sequence:48;
+ ULONGLONG HeaderType:1;
+ ULONGLONG Init:1;
+ ULONGLONG Reserved:2;
+ ULONGLONG NextEntry:60;
+ } Header16;
+} SLIST_HEADER, *PSLIST_HEADER;
+#else
typedef union _SLIST_HEADER {
- ULONGLONG Alignment;
- _ANONYMOUS_STRUCT struct {
- SLIST_ENTRY Next;
- WORD Depth;
- WORD Sequence;
- } DUMMYSTRUCTNAME;
-} SLIST_HEADER,*PSLIST_HEADER;
-#endif /* !_SLIST_HEADER_ */
+ ULONGLONG Alignment;
+ struct {
+ SLIST_ENTRY Next;
+ USHORT Depth;
+ USHORT Sequence;
+ } DUMMYSTRUCTNAME;
+} SLIST_HEADER, *PSLIST_HEADER;
+#endif
+
+#endif /* _SLIST_HEADER_ */
+
NTSYSAPI
VOID
typedef OSVERSIONINFOEXA OSVERSIONINFOEX,*POSVERSIONINFOEX,*LPOSVERSIONINFOEX;
#endif
- #if (WIN32_WINNT >= 0x0500)
+ #if (_WIN32_WINNT >= 0x0500)
ULONGLONG WINAPI VerSetConditionMask(ULONGLONG,DWORD,BYTE);
#endif
FORCEINLINE
PVOID
- RtlSecureZeroMemory(IN PVOID ptr,
- IN SIZE_T cnt)
+ RtlSecureZeroMemory(IN PVOID Buffer,
+ IN SIZE_T Length)
{
- volatile char *vptr = (volatile char *)ptr;
+ volatile char *VolatilePointer;
+
+ /* Get a volatile pointer to prevent any compiler optimizations */
+ VolatilePointer = (volatile char *)Buffer;
- while (cnt)
+ /* Loop the whole buffer */
+ while (Length)
{
- *vptr = 0;
- vptr++;
- cnt--;
+ /* Zero the current byte and move on */
+ *VolatilePointer++ = 0;
+ Length--;
}
- return ptr;
+ /* Return the pointer to ensure the compiler won't optimize this away */
+ return Buffer;
}
typedef struct _OBJECT_TYPE_LIST {
#endif
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
+
#endif /* RC_INVOKED */
#ifdef __cplusplus
#if !defined(__ROS_LONG64__)
#ifdef __WINESRC__
-#define __ROS_LONG64__
+//#define __ROS_LONG64__
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable:4820)
+ #endif
/* Names common to Winsock1.1 and Winsock2 */
#if !defined ( _BSDTYPES_DEFINED )
/* also defined in gmon.h and in cygwin's sys/types */
#warning "fd_set and associated macros have been defined in sys/types. \
This may cause runtime problems with W32 sockets"
#endif /* ndef _SYS_TYPES_FD_SET */
- #if !(defined (__INSIDE_CYGWIN__) || (__INSIDE_MSYS__))
+ #if !(defined (__INSIDE_CYGWIN__) || (defined (__INSIDE_MSYS__) && (__INSIDE_MSYS__)))
#ifndef _TIMEVAL_DEFINED
/* also in sys/time.h */
#define _TIMEVAL_DEFINED
#define WSASetService WSASetServiceA
#endif
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
+
#ifdef __cplusplus
}
#endif
extern "C" {
#endif
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable:4201)
+ #pragma warning(disable:4820)
+ #endif
+
#if !defined(_USER32_)
#define WINUSERAPI DECLSPEC_IMPORT
#else
#define DCX_EXCLUDERGN 64
#define DCX_INTERSECTRGN 128
#define DCX_VALIDATE 0x200000
+#define DCX_USESTYLE 0x00010000
#define DCX_EXCLUDEUPDATE 0x100
#define GMDI_GOINTOPOPUPS 2
#define GMDI_USEDISABLED 1
int iVertSpacing;
int iTitleWrap;
LOGFONTA lfFont;
-} ICONMETRICSA,*LPICONMETRICSA;
+} ICONMETRICSA, *PICONMETRICSA, *LPICONMETRICSA;
typedef struct tagICONMETRICSW {
UINT cbSize;
int iHorzSpacing;
int iVertSpacing;
int iTitleWrap;
LOGFONTW lfFont;
-} ICONMETRICSW,*LPICONMETRICSW;
+} ICONMETRICSW, *PICONMETRICSW, *LPICONMETRICSW;
#ifdef UNICODE
typedef ICONMETRICSW ICONMETRICS,*LPICONMETRICS;
#else /* UNICODE */
#define wsprintf wsprintfW
#define wvsprintf wvsprintfW
-#ifndef NOGDI
+#if defined(_WINGDI_) && !defined(NOGDI)
#define ChangeDisplaySettings ChangeDisplaySettingsW
#define ChangeDisplaySettingsEx ChangeDisplaySettingsExW
#define CreateDesktop CreateDesktopW
#define EnumDisplaySettings EnumDisplaySettingsW
#define EnumDisplaySettingsEx EnumDisplaySettingsExW
#define EnumDisplayDevices EnumDisplayDevicesW
-#endif /* NOGDI */
+#endif /* _WINGDI_ && !NOGDI */
#else /* UNICODE */
#define EDITWORDBREAKPROC EDITWORDBREAKPROCA
#define PROPENUMPROC PROPENUMPROCA
#endif /* UNICODE */
#endif /* RC_INVOKED */
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
+
#ifdef __cplusplus
}
#endif
#ifndef __WIN32K_NTUSER_H
#define __WIN32K_NTUSER_H
- struct _PROCESSINFO;
+ typedef struct _PROCESSINFO *PPROCESSINFO;
struct _W32THREADINFO;
struct _WINDOW;
DWORD SrvEventActivity;
} SERVERINFO, *PSERVERINFO;
- typedef struct _PROCESSINFO
- {
- PVOID UserHandleTable;
- HANDLE hUserHeap;
- ULONG_PTR UserHeapDelta;
- HINSTANCE hModUser;
- PWINDOWCLASS LocalClassList;
- PWINDOWCLASS GlobalClassList;
- PWINDOWCLASS SystemClassList;
-
- UINT RegisteredSysClasses : 1;
-
- } PROCESSINFO, *PPROCESSINFO;
-
#define CTI_INSENDMESSAGE 0x0002
typedef struct _CLIENTTHREADINFO
} CLIENTINFO, *PCLIENTINFO;
/* Make sure it fits exactly into the TEB */
+#ifdef __i386__
C_ASSERT(sizeof(CLIENTINFO) == FIELD_OFFSET(TEB, glDispatchTable) - FIELD_OFFSET(TEB, Win32ClientInfo));
+#endif
#define GetWin32ClientInfo() ((PCLIENTINFO)(NtCurrentTeb()->Win32ClientInfo))
LPARAM lParam,
BOOL Ansi);
-DWORD
+DWORD_PTR
NTAPI
NtUserCallNoParam(
DWORD Routine);
-DWORD
+DWORD_PTR
NTAPI
NtUserCallOneParam(
DWORD Param,
DWORD Routine);
-DWORD
+DWORD_PTR
NTAPI
NtUserCallTwoParam(
DWORD Param1,
THREADSTATE_GETINPUTSTATE
};
-DWORD
+DWORD_PTR
NTAPI
NtUserGetThreadState(
DWORD Routine);
NtUserVkKeyScanEx(
WCHAR wChar,
HKL KeyboardLayout,
- DWORD Unknown2);
+ BOOL bUsehHK);
DWORD
NTAPI
<?xml version="1.0"?>
<!DOCTYPE module SYSTEM "../../tools/rbuild/project.dtd">
-<module name="icu4ros" type="staticlibrary">
+<module name="icu4ros" type="staticlibrary" allowwarnings="true">
<define name="U_STATIC_IMPLEMENTATION" />
<define name="U_HAVE_INTTYPES_H" />
<define name="UCONFIG_NO_FILE_IO">1</define>
<define name="ICU_NO_USER_DATA_OVERRIDE">1</define>
- <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
- <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ <group compilerset="gcc">
+ <compilerflag compiler="cxx">-fno-exceptions</compilerflag>
+ <compilerflag compiler="cxx">-fno-rtti</compilerflag>
+ </group>
<include base="icu4ros">icu/source/common</include>
<include base="icu4ros">icu/source/i18n</include>
<file>stubs.cpp</file>
<directory name="arm">
<file>debug_asm.S</file>
</directory>
- <file>mem.c</file>
- <file>memgen.c</file>
+ <file>mem.c</file>
+ <file>memgen.c</file>
+ </if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>debug_asm.S</file>
+ <file>except_asm.S</file>
+ <file>interlck.S</file>
+ <file>unwind.c</file>
+ <file>stubs.c</file>
+ </directory>
+ <file>mem.c</file>
+ <file>memgen.c</file>
</if>
<directory name="austin">
<file>avl.c</file>
<pch>rtl.h</pch>
-->
<!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38054#c7 -->
- <compilerflag>-fno-unit-at-a-time</compilerflag>
+ <compilerflag compilerset="gcc">-fno-unit-at-a-time</compilerflag>
</module>
/* INCLUDES ******************************************************************/
/* PAGED_CODE equivalent for user-mode RTL */
- #ifdef DBG
+ #if DBG
extern VOID FASTCALL CHECK_PAGED_CODE_RTL(char *file, int line);
#define PAGED_CODE_RTL() CHECK_PAGED_CODE_RTL(__FILE__, __LINE__)
#else
#define ROUND_UP(n, align) \
ROUND_DOWN(((ULONG)n) + (align) - 1, (align))
+#define RVA(m, b) ((PVOID)((ULONG_PTR)(b) + (ULONG_PTR)(m)))
+
VOID
NTAPI
-RtlpGetStackLimits(PULONG_PTR StackBase,
- PULONG_PTR StackLimit);
+RtlpGetStackLimits(PULONG_PTR LowLimit,
+ PULONG_PTR HighLimit);
PEXCEPTION_REGISTRATION_RECORD
NTAPI
reactos/dll/directx/amstream # Autosync
reactos/dll/directx/dinput # Synced to Wine-1_1_4
reactos/dll/directx/dinput8 # Synced to Wine-1_1_4
+ reactos/dll/directx/dmusic # Synced to Wine-1_1_23
reactos/dll/directx/dplay # Synced to Wine-0_9_5
reactos/dll/directx/dplayx # Synced to Wine-0_9_5
reactos/dll/directx/dxdiagn # Synced to Wine-0_9_5
reactos/dll/win32/comdlg32 # Autosync
reactos/dll/win32/compstui # Autosync
reactos/dll/win32/credui # Autosync
- reactos/dll/win32/crypt32 # Synced to Wine-1_0-rc1
+ reactos/dll/win32/crypt32 # Synced to Wine-1_1_21
reactos/dll/win32/cryptdll # Autosync
reactos/dll/win32/cryptnet # Autosync
reactos/dll/win32/cryptui # Autosync
reactos/dll/win32/mciwave # Autosync
reactos/dll/win32/mlang # Autosync
reactos/dll/win32/mpr # Autosync
-reactos/dll/win32/msacm32 # Out of sync
+reactos/dll/win32/msacm32 # Synced to Wine-1_1_21
reactos/dll/win32/msadp32.acm # Autosync
reactos/dll/win32/mscat32 # Autosync
reactos/dll/win32/mscms # Autosync
reactos/dll/win32/msvcrt20 # Autosync
reactos/dll/win32/msvfw32 # Autosync
reactos/dll/win32/msvidc32 # Autosync
- reactos/dll/win32/msxml3 # Synced to Wine-20071230
+ reactos/dll/win32/msxml3 # Synced to Wine-1_1_20
reactos/dll/win32/nddeapi # Autosync
reactos/dll/win32/netapi32 # Autosync
reactos/dll/win32/ntdsapi # Autosync
reactos/dll/win32/ntprint # Autosync
reactos/dll/win32/objsel # Autosync
-reactos/dll/win32/odbc32 # Out of sync. Depends on port of Linux ODBC.
+reactos/dll/win32/odbc32 # Synced to Wine-1.1.21. Depends on port of Linux ODBC.
reactos/dll/win32/odbccp32 # Autosync
reactos/dll/win32/ole32 # Autosync
reactos/dll/win32/oleacc # Autosync
reactos/dll/win32/sensapi # Autosync
reactos/dll/win32/setupapi # Forked at Wine-20050524
reactos/dll/win32/shell32 # Forked at Wine-20071011
- reactos/dll/win32/shdocvw # Synced to Wine-0_9_5
+ reactos/dll/win32/shdocvw # Synced to Wine-1_1_20
reactos/dll/win32/shfolder # Autosync
reactos/dll/win32/shlwapi # Autosync
reactos/dll/win32/slbcsp # Autosync
reactos/base/applications/wordpad # Autosync
reactos/base/services/rpcss # Synced to Wine-20081105
reactos/base/system/expand # Out of sync
- reactos/base/system/msiexec # Wine 1.0-rc1
+ reactos/base/system/msiexec # Synced to Wine-1_1_23
reactos/modules/rosapps/winfile # Autosync
In addition the following libs, dlls and source files are mostly based on code ported
reactos/dll/win32/kernel32/misc/errormsg.c # Out of sync
reactos/dll/win32/kernel32/misc/profile.c # Out of sync
reactos/dll/win32/kernel32/misc/lcformat.c # Out of sync
+ reactos/dll/win32/kernel32/misc/lzexpand.c # Synced to Wine-1_1_23
msvcrt -
reactos/lib/sdk/crt/except/cpp.c # Synced at 20071111
reactos/dll/win32/snmpapi/main.c # Synced at 20090222
User32 -
- reactos/dll/win32/user32/controls/button.c # Synced to Wine-1_1_13
- reactos/dll/win32/user32/controls/combo.c # Synced to Wine-1_1_13
- reactos/dll/win32/user32/controls/edit.c # Synced to Wine-1_1_13
+ reactos/dll/win32/user32/controls/button.c # Synced to Wine-1_1_22
+ reactos/dll/win32/user32/controls/combo.c # Synced to Wine-1_1_22
+ reactos/dll/win32/user32/controls/edit.c # Synced to Wine-1_1_22
reactos/dll/win32/user32/controls/icontitle.c # Synced to Wine-1_1_13
- reactos/dll/win32/user32/controls/listbox.c # Synced to Wine-1_1_13
+ reactos/dll/win32/user32/controls/listbox.c # Synced to Wine-1_1_22
reactos/dll/win32/user32/controls/scrollbar.c # Forked
- reactos/dll/win32/user32/controls/static.c # Synced at 20071024
+ reactos/dll/win32/user32/controls/static.c # Synced to Wine-1_1_22
reactos/dll/win32/user32/misc/dde.c # Synced to wine 1.1.17 (dde_misc.c)
- reactos/dll/win32/user32/misc/ddeclient.c # Synced to wine 1.1.17
- reactos/dll/win32/user32/misc/ddeserver.c # Synced to wine 1.1.17
- reactos/dll/win32/user32/misc/exticon.c # Last sync date unknown
+ reactos/dll/win32/user32/misc/ddeclient.c # Synced to Wine-1_1_23
+ reactos/dll/win32/user32/misc/ddeserver.c # Synced to Wine-1_1_23
+ reactos/dll/win32/user32/misc/exticon.c # Synced to Wine-1_1_22
reactos/dll/win32/user32/misc/resources.c # Forked?
reactos/dll/win32/user32/misc/winhelp.c # Last sync date unknown
- reactos/dll/win32/user32/misc/wsprintf.c # Synced to Wine-1_1_13
+ reactos/dll/win32/user32/misc/wsprintf.c # Synced to Wine-1_1_23
reactos/dll/win32/user32/windows/defwnd.c # Forked
reactos/dll/win32/user32/windows/draw.c # Forked at Wine-20020904 (uitools.c)
/* PRIVATE FUNCTIONS *********************************************************/
+#ifdef _WIN64
+#define InterlockedAndPointer(ptr,val) InterlockedAnd64((PLONGLONG)ptr,(LONGLONG)val)
+#else
+#define InterlockedAndPointer(ptr,val) InterlockedAnd((PLONG)ptr,(LONG)val)
+#endif
+
/*++
* @name ExpInitializePushLocks
*
ASSERT(NewValue.Waiting);
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
}
/* Save the First Block */
- FirstWaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ FirstWaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
WaitBlock = FirstWaitBlock;
ASSERT(!NewValue.Waking);
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) break;
ASSERT(PushLock->Waiting);
/* Remove waking bit from pushlock */
- InterlockedAnd((PLONG)PushLock, ~EX_PUSH_LOCK_WAKING);
+ InterlockedAndPointer(&PushLock->Value, ~EX_PUSH_LOCK_WAKING);
/* Leave the loop */
break;
/* Sanity check */
ASSERT(!WaitBlock->Signaled);
- #ifdef DBG
+ #if DBG
/* We are about to get signaled */
WaitBlock->Signaled = TRUE;
#endif
}
/* Get the wait block */
- WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
/* Loop the blocks */
ASSERT(!NewValue.Waking);
/* Update the value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
ASSERT(NewValue.Locked);
/* Set the new value */
- if (InterlockedCompareExchangePointer(PushLock,
+ if (InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr) != OldValue.Ptr)
{
WaitBlock->ShareCount = 0;
/* Set the current Wait Block pointer */
- WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)
- OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS);
+ WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)(
+ OldValue.Value &~ EX_PUSH_LOCK_PTR_BITS);
/* Point to ours */
NewValue.Value = (OldValue.Value & EX_PUSH_LOCK_MULTIPLE_SHARED) |
/* Write the new value */
TempValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value)
ASSERT(NewValue.Locked);
/* Set the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value)
if (OldValue.Waiting)
{
/* Set the current Wait Block pointer */
- WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)
- OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS);
+ WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)(
+ OldValue.Value &~ EX_PUSH_LOCK_PTR_BITS);
/* Nobody is the last waiter yet */
WaitBlock->Last = NULL;
#endif
/* Write the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Ptr != OldValue.Ptr)
}
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
if (OldValue.MultipleShared)
{
/* Get the wait block */
- WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
/* Loop until we find the last wait block */
ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared);
/* Write the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
/* Write the new value */
WakeValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value) continue;
}
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
if (OldValue.MultipleShared)
{
/* Get the wait block */
- WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
/* Loop until we find the last wait block */
ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared);
/* Write the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
/* Write the new value */
WakeValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value) continue;
/* Write the New Value. Save our original value for waking */
WakeValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
ASSERT(NewValue.Waking && !NewValue.Waiting);
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
NewValue.Waking = TRUE;
/* Write the New Value */
- if (InterlockedCompareExchangePointer(PushLock,
+ if (InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr) == OldValue.Ptr)
{
#define IsOwnedExclusive(r) (r->Flag & ResourceOwnedExclusive)
#define IsBoostAllowed(r) (!(r->Flag & ResourceHasDisabledPriorityBoost))
- #if (!(defined(CONFIG_SMP)) && !(defined(DBG)))
+ #if (!(defined(CONFIG_SMP)) && !(DBG))
FORCEINLINE
VOID
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
/* Set it */
- if (InterlockedCompareExchangePointer(&Resource->ExclusiveWaiters,
+ if (InterlockedCompareExchangePointer((PVOID*)&Resource->ExclusiveWaiters,
Event,
NULL))
{
KeInitializeSemaphore(Semaphore, 0, MAXLONG);
/* Set it */
- if (InterlockedCompareExchangePointer(&Resource->SharedWaiters,
+ if (InterlockedCompareExchangePointer((PVOID*)&Resource->SharedWaiters,
Semaphore,
NULL))
{
#ifdef _M_IX86
/* Return the current thread */
return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
+#elif defined (_M_AMD64)
+ return (PRKTHREAD)__readgsqword(FIELD_OFFSET(KIPCR, Prcb.CurrentThread));
#else
PKPRCB Prcb = KeGetCurrentPrcb();
return Prcb->CurrentThread;
VOID
KiRundownThread(IN PKTHREAD Thread)
{
-#if defined(_M_IX86) || defined(_M_AMD64)
+#if defined(_M_IX86)
/* Check if this is the NPX Thread */
if (KeGetCurrentPrcb()->NpxThread == Thread)
{
/* Value changed... wait until it's locked */
while (*(volatile KSPIN_LOCK *)SpinLock == 1)
{
- #ifdef DBG
+ #if DBG
/* On debug builds, we use a much slower but useful routine */
//Kii386SpinOnSpinLock(SpinLock, 5);
}
else
{
- #ifdef DBG
+ #if DBG
/* On debug builds, we OR in the KTHREAD */
*SpinLock = (KSPIN_LOCK)KeGetCurrentThread() | 1;
#endif
VOID
KxReleaseSpinLock(IN PKSPIN_LOCK SpinLock)
{
- #ifdef DBG
+ #if DBG
/* Make sure that the threads match */
if (((KSPIN_LOCK)KeGetCurrentThread() | 1) != *SpinLock)
{
//
// Define this if you want debugging support
//
- #define _PS_DEBUG_ 0x01
+ #define _PS_DEBUG_ 0x00
//
// These define the Debug Masks Supported
"Pointer Count [%p] @%d: %lx\n", \
x, \
__LINE__, \
- OBJECT_TO_OBJECT_HEADER(x)->PointerCount);
+ OBJECT_TO_OBJECT_HEADER(x)->PointerCount)
#else
- #define PSTRACE(x, ...) DPRINT(__VA_ARGS__);
+ #define PSTRACE(x, ...) DPRINT(__VA_ARGS__)
#define PSREFTRACE(x)
#endif
extern LARGE_INTEGER ShortPsLockDelay;
extern UNICODE_STRING PsNtDllPathName;
extern LIST_ENTRY PsLoadedModuleList;
-extern ULONG PsNtosImageBase;
+extern ULONG_PTR PsNtosImageBase;
//
// Inlined Functions
PVOID Queue;
PFILE_COMPLETION_INFORMATION CompletionInfo = FileInformation;
PIO_COMPLETION_CONTEXT Context;
+ PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
/* Check if we're called from user mode */
}
_SEH2_END;
+ /* Update transfer count */
+ IopUpdateTransferCount(IopOtherTransfer, Length);
+
/* Release the file lock, dereference the file and return */
IopUnlockFileObject(FileObject);
ObDereferenceObject(FileObject);
{
/* Use local event */
Event = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_IO);
+ if (!Event)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
KeInitializeEvent(Event, SynchronizationEvent, FALSE);
LocalEvent = TRUE;
}
/* Set the Data */
Context->Key = CompletionInfo->Key;
Context->Port = Queue;
- if (InterlockedCompareExchangePointer(&FileObject->
+ if (InterlockedCompareExchangePointer((PVOID*)&FileObject->
CompletionContext,
Context,
NULL))
}
}
+ /* Update transfer count for everything but create operation */
+ if (!(Irp->Flags & IRP_CREATE_OPERATION))
+ {
+ if (Irp->Flags & IRP_WRITE_OPERATION)
+ {
+ /* Update write transfer count */
+ IopUpdateTransferCount(IopWriteTransfer,
+ (ULONG)Irp->IoStatus.Information);
+ }
+ else if (Irp->Flags & IRP_READ_OPERATION)
+ {
+ /* Update read transfer count */
+ IopUpdateTransferCount(IopReadTransfer,
+ (ULONG)Irp->IoStatus.Information);
+ }
+ else
+ {
+ /* Update other transfer count */
+ IopUpdateTransferCount(IopOtherTransfer,
+ (ULONG)Irp->IoStatus.Information);
+ }
+ }
+
/* Now that we've signaled the events, de-associate the IRP */
IopUnQueueIrpFromThread(Irp);
if (LastStackPtr->Control & SL_ERROR_RETURNED)
{
/* Get the error code */
- ErrorCode = (NTSTATUS)LastStackPtr->Parameters.Others.Argument4;
+ ErrorCode = PtrToUlong(LastStackPtr->Parameters.Others.Argument4);
}
/* Get the Current Stack and skip it */
/* Update the error for the current stack */
ErrorCode = Irp->IoStatus.Status;
StackPtr->Control |= SL_ERROR_RETURNED;
- LastStackPtr->Parameters.Others.Argument4 = (PVOID)ErrorCode;
+ LastStackPtr->Parameters.Others.Argument4 = UlongToPtr(ErrorCode);
LastStackPtr->Control |= SL_ERROR_RETURNED;
}
}
IoGetRequestorProcessId(IN PIRP Irp)
{
/* Return the requestor process' id */
- return (ULONG)(IoGetRequestorProcess(Irp)->UniqueProcessId);
+ return PtrToUlong(IoGetRequestorProcess(Irp)->UniqueProcessId);
}
/*
IoSetTopLevelIrp(IN PIRP Irp)
{
/* Set the IRP */
- PsGetCurrentThread()->TopLevelIrp = (ULONG)Irp;
+ PsGetCurrentThread()->TopLevelIrp = (ULONG_PTR)Irp;
}
Result = KdpPrintString(Buffer1, Buffer1Length);
break;
- #ifdef DBG
+ #if DBG
case TAG('R', 'o', 's', ' '): /* ROS-INTERNAL */
{
- switch ((ULONG)Buffer1)
+ switch ((ULONG_PTR)Buffer1)
{
case DumpNonPagedPool:
MiDebugDumpNonPagedPool(FALSE);
KdpServiceDispatcher(BREAKPOINT_PRINT,
(PVOID)ExceptionRecord->ExceptionInformation[1],
ExceptionRecord->ExceptionInformation[2]);
+ Context->Eax = STATUS_SUCCESS;
}
else if (ExceptionCommand == BREAKPOINT_LOAD_SYMBOLS)
{
/* GLOBALS *******************************************************************/
- STATIC LONG KdbEntryCount = 0;
- STATIC CHAR KdbStack[KDB_STACK_SIZE];
-
- STATIC ULONG KdbBreakPointCount = 0; /* Number of used breakpoints in the array */
- STATIC KDB_BREAKPOINT KdbBreakPoints[KDB_MAXIMUM_BREAKPOINT_COUNT] = {{0}}; /* Breakpoint array */
- STATIC ULONG KdbSwBreakPointCount = 0; /* Number of enabled software breakpoints */
- STATIC ULONG KdbHwBreakPointCount = 0; /* Number of enabled hardware breakpoints */
- STATIC PKDB_BREAKPOINT KdbSwBreakPoints[KDB_MAXIMUM_SW_BREAKPOINT_COUNT]; /* Enabled software breakpoints, orderless */
- STATIC PKDB_BREAKPOINT KdbHwBreakPoints[KDB_MAXIMUM_HW_BREAKPOINT_COUNT]; /* Enabled hardware breakpoints, orderless */
- STATIC PKDB_BREAKPOINT KdbBreakPointToReenable = NULL; /* Set to a breakpoint struct when single stepping after
+ static LONG KdbEntryCount = 0;
+ static CHAR KdbStack[KDB_STACK_SIZE];
+
+ static ULONG KdbBreakPointCount = 0; /* Number of used breakpoints in the array */
+ static KDB_BREAKPOINT KdbBreakPoints[KDB_MAXIMUM_BREAKPOINT_COUNT] = {{0}}; /* Breakpoint array */
+ static ULONG KdbSwBreakPointCount = 0; /* Number of enabled software breakpoints */
+ static ULONG KdbHwBreakPointCount = 0; /* Number of enabled hardware breakpoints */
+ static PKDB_BREAKPOINT KdbSwBreakPoints[KDB_MAXIMUM_SW_BREAKPOINT_COUNT]; /* Enabled software breakpoints, orderless */
+ static PKDB_BREAKPOINT KdbHwBreakPoints[KDB_MAXIMUM_HW_BREAKPOINT_COUNT]; /* Enabled hardware breakpoints, orderless */
+ static PKDB_BREAKPOINT KdbBreakPointToReenable = NULL; /* Set to a breakpoint struct when single stepping after
a software breakpoint was hit, to reenable it */
LONG KdbLastBreakPointNr = -1; /* Index of the breakpoint which cause KDB to be entered */
ULONG KdbNumSingleSteps = 0; /* How many single steps to do */
BOOLEAN KdbSingleStepOver = FALSE; /* Whether to step over calls/reps. */
ULONG KdbDebugState = 0; /* KDBG Settings (NOECHO, KDSERIAL) */
- STATIC BOOLEAN KdbEnteredOnSingleStep = FALSE; /* Set to true when KDB was entered because of single step */
+ static BOOLEAN KdbEnteredOnSingleStep = FALSE; /* Set to true when KDB was entered because of single step */
PEPROCESS KdbCurrentProcess = NULL; /* The current process context in which KDB runs */
PEPROCESS KdbOriginalProcess = NULL; /* The process in whichs context KDB was intered */
PETHREAD KdbCurrentThread = NULL; /* The current thread context in which KDB runs */
PETHREAD KdbOriginalThread = NULL; /* The thread in whichs context KDB was entered */
PKDB_KTRAP_FRAME KdbCurrentTrapFrame = NULL; /* Pointer to the current trapframe */
- STATIC KDB_KTRAP_FRAME KdbTrapFrame = { { 0 } }; /* The trapframe which was passed to KdbEnterDebuggerException */
- STATIC KDB_KTRAP_FRAME KdbThreadTrapFrame = { { 0 } }; /* The trapframe of the current thread (KdbCurrentThread) */
- STATIC KAPC_STATE KdbApcState;
+ static KDB_KTRAP_FRAME KdbTrapFrame = { { 0 } }; /* The trapframe which was passed to KdbEnterDebuggerException */
+ static KDB_KTRAP_FRAME KdbThreadTrapFrame = { { 0 } }; /* The trapframe of the current thread (KdbCurrentThread) */
+ static KAPC_STATE KdbApcState;
extern BOOLEAN KdbpBugCheckRequested;
/* Array of conditions when to enter KDB */
- STATIC KDB_ENTER_CONDITION KdbEnterConditions[][2] =
+ static KDB_ENTER_CONDITION KdbEnterConditions[][2] =
{
/* First chance Last chance */
{ KdbDoNotEnter, KdbEnterFromKmode }, /* Zero devide */
};
/* Exception descriptions */
- STATIC CONST CHAR *ExceptionNrToString[] =
+ static const CHAR *ExceptionNrToString[] =
{
"Divide Error",
"Debug Trap",
/* FUNCTIONS *****************************************************************/
- STATIC VOID
+ static VOID
KdbpTrapFrameToKdbTrapFrame(PKTRAP_FRAME TrapFrame, PKDB_KTRAP_FRAME KdbTrapFrame)
{
ULONG TrapCr0, TrapCr2, TrapCr3, TrapCr4;
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
}
- STATIC VOID
+ static VOID
KdbpKdbTrapFrameToTrapFrame(PKDB_KTRAP_FRAME KdbTrapFrame, PKTRAP_FRAME TrapFrame)
{
/* Copy the TrapFrame only up to Eflags and zero the rest*/
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
}
- STATIC VOID
+ static VOID
KdbpKdbTrapFrameFromKernelStack(PVOID KernelStack,
PKDB_KTRAP_FRAME KdbTrapFrame)
{
RtlZeroMemory(KdbTrapFrame, sizeof(KDB_KTRAP_FRAME));
StackPtr = (ULONG_PTR *) KernelStack;
+#if _M_X86_
KdbTrapFrame->Tf.Ebp = StackPtr[3];
KdbTrapFrame->Tf.Edi = StackPtr[4];
KdbTrapFrame->Tf.Esi = StackPtr[5];
KdbTrapFrame->Tf.SegDs = KGDT_R0_DATA;
KdbTrapFrame->Tf.SegEs = KGDT_R0_DATA;
KdbTrapFrame->Tf.SegGs = KGDT_R0_DATA;
+#endif
/* FIXME: what about the other registers??? */
}
*
* \returns NTSTATUS
*/
- STATIC NTSTATUS
+ static NTSTATUS
KdbpOverwriteInstruction(
IN PEPROCESS Process,
IN ULONG_PTR Address,
}
/* Get the interrupt descriptor */
- if (!NT_SUCCESS(KdbpSafeReadMemory(IntDesc, (PVOID)(Idtr.Base + (IntVect * 8)), sizeof (IntDesc))))
+ if (!NT_SUCCESS(KdbpSafeReadMemory(IntDesc, (PVOID)(ULONG_PTR)(Idtr.Base + (IntVect * 8)), sizeof (IntDesc))))
{
/*KdbpPrint("Couldn't access memory at 0x%p\n", (ULONG_PTR)Idtr.Base + (IntVect * 8));*/
return FALSE;
*
* \returns Breakpoint number, -1 on error.
*/
- STATIC LONG
+ static LONG
KdbpIsBreakPointOurs(
IN NTSTATUS ExceptionCode,
IN PKTRAP_FRAME TrapFrame)
/* Get a pointer to the thread */
if (!NT_SUCCESS(PsLookupThreadByThreadId(ThreadId, &Thread)))
{
- KdbpPrint("Invalid thread id: 0x%08x\n", (ULONG)ThreadId);
+ KdbpPrint("Invalid thread id: 0x%08x\n", (ULONG_PTR)ThreadId);
return FALSE;
}
Process = Thread->ThreadsProcess;
/* Get a pointer to the process */
if (!NT_SUCCESS(PsLookupProcessByProcessId(ProcessId, &Process)))
{
- KdbpPrint("Invalid process id: 0x%08x\n", (ULONG)ProcessId);
+ KdbpPrint("Invalid process id: 0x%08x\n", (ULONG_PTR)ProcessId);
return FALSE;
}
ObDereferenceObject(Process);
if (Entry == &KdbCurrentProcess->ThreadListHead)
{
- KdbpPrint("No threads in process 0x%08x, cannot attach to process!\n", (ULONG)ProcessId);
+ KdbpPrint("No threads in process 0x%p, cannot attach to process!\n", ProcessId);
return FALSE;
}
/*!\brief Calls the main loop ...
*/
- STATIC VOID
+ static VOID
KdbpCallMainLoop()
{
KdbpCliMainLoop(KdbEnteredOnSingleStep);
*
* Disables interrupts, releases display ownership, ...
*/
- STATIC VOID
+ static VOID
KdbpInternalEnter()
{
PETHREAD Thread;
SavedStackLimit = Thread->Tcb.StackLimit;
SavedKernelStack = Thread->Tcb.KernelStack;
Thread->Tcb.InitialStack = Thread->Tcb.StackBase = (char*)KdbStack + KDB_STACK_SIZE;
- Thread->Tcb.StackLimit = (ULONG)KdbStack;
+ Thread->Tcb.StackLimit = (ULONG_PTR)KdbStack;
Thread->Tcb.KernelStack = (char*)KdbStack + KDB_STACK_SIZE;
/*KdbpPrint("Switching to KDB stack 0x%08x-0x%08x (Current Stack is 0x%08x)\n", Thread->Tcb.StackLimit, Thread->Tcb.StackBase, Esp);*/
KbdEnableMouse();
}
- STATIC ULONG
+ static ULONG
KdbpGetExceptionNumberFromStatus(IN NTSTATUS ExceptionCode)
{
ULONG Ret;
}
else
{
- CONST CHAR *ExceptionString = (ExpNr < RTL_NUMBER_OF(ExceptionNrToString)) ?
+ const CHAR *ExceptionString = (ExpNr < RTL_NUMBER_OF(ExceptionNrToString)) ?
(ExceptionNrToString[ExpNr]) :
("Unknown/User defined exception");
*
* \sa KdbpSymFindModule
*/
- STATIC BOOLEAN
+ static BOOLEAN
KdbpSymFindUserModule(IN PVOID Address OPTIONAL,
IN LPCWSTR Name OPTIONAL,
IN INT Index OPTIONAL,
*
* \sa KdbpSymFindUserModule
*/
- STATIC BOOLEAN
+ static BOOLEAN
KdbpSymFindModule(IN PVOID Address OPTIONAL,
IN LPCWSTR Name OPTIONAL,
IN INT Index OPTIONAL,
*
* \sa KdbpSymAddCachedFile
*/
- STATIC PROSSYM_INFO
+ static PROSSYM_INFO
KdbpSymFindCachedFile(IN PUNICODE_STRING FileName)
{
PIMAGE_SYMBOL_INFO_CACHE Current;
*
* \sa KdbpSymRemoveCachedFile
*/
- STATIC VOID
+ static VOID
KdbpSymAddCachedFile(IN PUNICODE_STRING FileName,
IN PROSSYM_INFO RosSymInfo)
{
*
* \sa KdbpSymAddCachedFile
*/
- STATIC VOID
+ static VOID
KdbpSymRemoveCachedFile(IN PROSSYM_INFO RosSymInfo)
{
PIMAGE_SYMBOL_INFO_CACHE Current;
*
* \sa KdbpSymUnloadModuleSymbols
*/
- STATIC VOID
+ static VOID
KdbpSymLoadModuleSymbols(IN PUNICODE_STRING FileName,
OUT PROSSYM_INFO *RosSymInfo)
{
*
* \sa KdbpSymLoadModuleSymbols
*/
- STATIC VOID
+ static VOID
KdbpSymUnloadModuleSymbols(IN PROSSYM_INFO RosSymInfo)
{
DPRINT("Unloading symbols\n");
KdbpSymAddCachedFile(&LdrEntry->FullDllName, LdrEntry->PatchInformation);
}
- DPRINT("Installed symbols: %wZ@%08x-%08x %p\n",
+ DPRINT("Installed symbols: %wZ@%p-%p %p\n",
&LdrEntry->BaseDllName,
LdrEntry->DllBase,
- LdrEntry->SizeOfImage + (ULONG)LdrEntry->DllBase,
+ (PVOID)(LdrEntry->SizeOfImage + (ULONG_PTR)LdrEntry->DllBase),
LdrEntry->PatchInformation);
}
LoadSymbols = FALSE;
- #ifdef DBG
+ #if DBG
/* Load symbols only if we have 96Mb of RAM or more */
if (MmNumberOfPhysicalPages >= 0x6000)
LoadSymbols = TRUE;
return (USHORT)i;
}
-
VOID
FASTCALL
-KeRosDumpStackFrameArray(IN PULONG Frames,
+KeRosDumpStackFrameArray(IN PULONG_PTR Frames,
IN ULONG FrameCount)
{
- ULONG i, Addr;
+ ULONG i;
+ ULONG_PTR Addr;
BOOLEAN InSystem;
PVOID p;
{
/* Print out the module name */
Addr -= (ULONG_PTR)LdrEntry->DllBase;
- DbgPrint("<%wZ: %x>\n", &LdrEntry->FullDllName, Addr);
+ DbgPrint("<%wZ: %p>", &LdrEntry->FullDllName, (PVOID)Addr);
}
}
else
{
/* Print only the address */
- DbgPrint("<%x>\n", Addr);
+ DbgPrint("<%p>", (PVOID)Addr);
}
/* Go to the next frame */
VOID
NTAPI
-KeRosDumpStackFrames(IN PULONG Frame OPTIONAL,
+KeRosDumpStackFrames(IN PULONG_PTR Frame OPTIONAL,
IN ULONG FrameCount OPTIONAL)
{
- ULONG Frames[32];
+ ULONG_PTR Frames[32];
ULONG RealFrameCount;
/* If the caller didn't ask, assume 32 frames */
}
}
+
VOID
NTAPI
KeRosDumpTriageForBugZillaReport(VOID)
/* Show the technical Data */
sprintf(AnsiName,
- "\r\n\r\n*** STOP: 0x%08lX (0x%p,0x%p,0x%p,0x%p)\r\n\r\n",
- KiBugCheckData[0],
+ "\r\n\r\n*** STOP: 0x%p (0x%p,0x%p,0x%p,0x%p)\r\n\r\n",
+ (PVOID)KiBugCheckData[0],
(PVOID)KiBugCheckData[1],
(PVOID)KiBugCheckData[2],
(PVOID)KiBugCheckData[3],
/* Check if we need to save the context for KD */
#ifdef _WINKD_
- if (!KdPitchDebugger) KdDebuggerDataBlock.SavedContext = (ULONG)&Context;
+ if (!KdPitchDebugger) KdDebuggerDataBlock.SavedContext = (ULONG_PTR)&Context;
#endif
/* Check if a debugger is connected */
#endif
/* Display the BSOD */
- KeLowerIrql(APC_LEVEL); // This is a nastier hack than any ever before
KiDisplayBlueScreen(MessageId,
IsHardError,
HardErrCaption,
HardErrMessage,
AnsiName);
- KeRaiseIrql(HIGH_LEVEL, &OldIrql);
/* Check if the debugger is disabled but we can enable it */
if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
Prcb->VendorString[sizeof(Prcb->VendorString) - sizeof(CHAR)] = ANSI_NULL;
/* Now check the CPU Type */
- if (!strcmp(Prcb->VendorString, CmpIntelID))
+ if (!strcmp((PCHAR)Prcb->VendorString, CmpIntelID))
{
return CPU_INTEL;
}
- else if (!strcmp(Prcb->VendorString, CmpAmdID))
+ else if (!strcmp((PCHAR)Prcb->VendorString, CmpAmdID))
{
return CPU_AMD;
}
- else if (!strcmp(Prcb->VendorString, CmpCyrixID))
+ else if (!strcmp((PCHAR)Prcb->VendorString, CmpCyrixID))
{
DPRINT1("Cyrix CPU support not fully tested!\n");
return CPU_CYRIX;
}
- else if (!strcmp(Prcb->VendorString, CmpTransmetaID))
+ else if (!strcmp((PCHAR)Prcb->VendorString, CmpTransmetaID))
{
DPRINT1("Transmeta CPU support not fully tested!\n");
return CPU_TRANSMETA;
}
- else if (!strcmp(Prcb->VendorString, CmpCentaurID))
+ else if (!strcmp((PCHAR)Prcb->VendorString, CmpCentaurID))
{
DPRINT1("Centaur CPU support not fully tested!\n");
return CPU_CENTAUR;
}
- else if (!strcmp(Prcb->VendorString, CmpRiseID))
+ else if (!strcmp((PCHAR)Prcb->VendorString, CmpRiseID))
{
DPRINT1("Rise CPU support not fully tested!\n");
return CPU_RISE;
KeSaveFloatingPointState(OUT PKFLOATING_SAVE Save)
{
PFNSAVE_FORMAT FpState;
- ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
+ ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
DPRINT1("%s is not really implemented\n", __FUNCTION__);
/* check if we are doing software emulation */
cmp dword ptr [esp+20], 0
je Return
- #ifdef DBG
+ #if DBG
/* Assert Fxsr support */
test byte ptr _KeI386FxsrPresent, 1
jnz AssertOk
cmp byte ptr [eax+KTHREAD_NPX_STATE], NPX_STATE_NOT_LOADED
jnz DontSave
- #ifdef DBG
+ #if DBG
/* We are the NPX Thread with an unloaded NPX State... this isn't normal! */
int 3
#endif
.endfunc
/*++
- * KiSwapContextInternal
+ * KiSwapContextInternal
*
+ * \brief
* The KiSwapContextInternal routine switches context to another thread.
*
+ * BOOLEAN USERCALL KiSwapContextInternal();
+ *
* Params:
* ESI - Pointer to the KTHREAD to which the caller wishes to
* switch to.
* EDI - Pointer to the KTHREAD to which the caller wishes to
* switch from.
*
- * Returns:
- * None.
+ * \returns
+ * APC state.
*
- * Remarks:
+ * \remarks
* Absolutely all registers except ESP can be trampled here for maximum code flexibility.
*
*--*/
AfterTrace:
#ifdef CONFIG_SMP
- #ifdef DBG
+ #if DBG
/* Assert that we're on the right CPU */
mov cl, [esi+KTHREAD_NEXT_PROCESSOR]
cmp cl, [ebx+KPCR_PROCESSOR_NUMBER]
lock xor [eax+KPROCESS_ACTIVE_PROCESSORS], ecx
/* Assert change went ok */
- #ifdef DBG
+ #if DBG
test [ebp+KPROCESS_ACTIVE_PROCESSORS], ecx
jz WrongActiveCpu
test [eax+KPROCESS_ACTIVE_PROCESSORS], ecx
NewCr0:
- #ifdef DBG
+ #if DBG
/* Assert NPX State */
test byte ptr [esi+KTHREAD_NPX_STATE], ~(NPX_STATE_NOT_LOADED)
jnz InvalidNpx
push ATTEMPTED_SWITCH_FROM_DPC
call _KeBugCheckEx@20
- #ifdef DBG
+ #if DBG
InvalidNpx:
int 3
WrongActiveCpu:
#endif
.endfunc
-/*++
- * KiSwapContext
+/**
+ * KiSwapContext
*
+ * \brief
* The KiSwapContext routine switches context to another thread.
*
- * Params:
- * TargetThread - Pointer to the KTHREAD to which the caller wishes to
- * switch to.
+ * BOOLEAN FASTCALL
+ * KiSwapContext(PKTHREAD CurrentThread, PKTHREAD TargetThread);
*
- * Returns:
+ * \param CurrentThread
+ * Pointer to the KTHREAD of the current thread.
+ *
+ * \param TargetThread
+ * Pointer to the KTHREAD to which the caller wishes to switch to.
+ *
+ * \returns
* The WaitStatus of the Target Thread.
*
- * Remarks:
+ * \remarks
* This is a wrapper around KiSwapContextInternal which will save all the
* non-volatile registers so that the Internal function can use all of
* them. It will also save the old current thread and set the new one.
lock xor [eax+KPROCESS_ACTIVE_PROCESSORS], ecx
/* Sanity check */
- #ifdef DBG
+ #if DBG
test dword ptr [edx+KPROCESS_ACTIVE_PROCESSORS], 0
jz WrongCpu1
test dword ptr [eax+KPROCESS_ACTIVE_PROCESSORS], 0
/* FIXME: TODO */
int 3
- #ifdef DBG
+ #if DBG
WrongCpu1:
int 3
WrongCpu2:
/* PUBLIC FUNCTIONS **********************************************************/
+#ifdef _X86_
/*
* @implemented
*/
/* Clear it */
*SpinLock = 0;
}
+#endif
/*
* @implemented
return FALSE;
}
- #ifdef DBG
+ #if DBG
/* On debug builds, we OR in the KTHREAD */
*SpinLock = (ULONG_PTR)KeGetCurrentThread() | 1;
#endif
*/
{
MEMORY_AREA* MemoryArea;
- NTSTATUS Status;
+ NTSTATUS Status = STATUS_SUCCESS;
PEPROCESS Process;
PMMSUPPORT AddressSpace;
PVOID BaseAddress;
ULONG RegionSize;
+ PAGED_CODE();
+
DPRINT("NtFreeVirtualMemory(ProcessHandle %x, *PBaseAddress %x, "
"*PRegionSize %x, FreeType %x)\n",ProcessHandle,*PBaseAddress,
*PRegionSize,FreeType);
return STATUS_INVALID_PARAMETER_4;
}
+ if(ExGetPreviousMode() != KernelMode)
+ {
+ _SEH2_TRY
+ {
+ /* Probe user pointers */
+ ProbeForWriteSize_t(PRegionSize);
+ ProbeForWritePointer(PBaseAddress);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Get exception code */
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+ if (!NT_SUCCESS(Status)) return Status;
+ }
+
BaseAddress = (PVOID)PAGE_ROUND_DOWN((*PBaseAddress));
RegionSize = PAGE_ROUND_UP((ULONG_PTR)(*PBaseAddress) + (*PRegionSize)) -
PAGE_ROUND_DOWN((*PBaseAddress));
MmQueryAnonMem(PMEMORY_AREA MemoryArea,
PVOID Address,
PMEMORY_BASIC_INFORMATION Info,
- PULONG ResultLength)
+ PSIZE_T ResultLength)
{
PMM_REGION Region;
PVOID RegionBase = NULL;
NTSTATUS
NTAPI
MmInitializeHandBuiltProcess(IN PEPROCESS Process,
- IN PULONG DirectoryTableBase)
+ IN PULONG_PTR DirectoryTableBase)
{
/* Share the directory base with the idle process */
DirectoryTableBase[0] = PsGetCurrentProcess()->Pcb.DirectoryTableBase[0];
/* Initialize the Addresss Space */
KeInitializeGuardedMutex(&Process->AddressCreationLock);
Process->Vm.WorkingSetExpansionLinks.Flink = NULL;
+ ASSERT(Process->VadRoot.NumberGenericTableElements == 0);
+ Process->VadRoot.BalancedRoot.u1.Parent = &Process->VadRoot.BalancedRoot;
/* The process now has an address space */
Process->HasAddressSpace = TRUE;
NTSTATUS Status;
ULONG i, j;
PFN_TYPE Pfn[2];
- PULONG PageDirectory;
+ PULONG_PTR PageDirectory;
DPRINT("MmCopyMmInfo(Src %x, Dest %x)\n", MinWs, Process);
#define NDEBUG
#include <debug.h>
- /* Uncomment to enable pool overruns debugging */
+ /* Uncomment to enable pool overruns debugging. Don't forget to increase
+ max pool sizes (MM_[NON]PAGED_POOL_SIZE) in include/internal/mm.h */
//#define DEBUG_NPOOL
//#define DEBUG_PPOOL
* @implemented
*/
PVOID NTAPI
-ExAllocatePool (POOL_TYPE PoolType, ULONG NumberOfBytes)
+ExAllocatePool (POOL_TYPE PoolType, SIZE_T NumberOfBytes)
/*
* FUNCTION: Allocates pool memory of a specified type and returns a pointer
* to the allocated block. This routine is used for general purpose allocation
* @implemented
*/
PVOID NTAPI
-ExAllocatePoolWithTag (POOL_TYPE PoolType, ULONG NumberOfBytes, ULONG Tag)
+ExAllocatePoolWithTag (POOL_TYPE PoolType, SIZE_T NumberOfBytes, ULONG Tag)
{
PVOID Block;
*/
#undef ExAllocatePoolWithQuota
PVOID NTAPI
-ExAllocatePoolWithQuota (POOL_TYPE PoolType, ULONG NumberOfBytes)
+ExAllocatePoolWithQuota (POOL_TYPE PoolType, SIZE_T NumberOfBytes)
{
return(ExAllocatePoolWithQuotaTag(PoolType, NumberOfBytes, TAG_NONE));
}
PVOID
NTAPI
ExAllocatePoolWithQuotaTag (IN POOL_TYPE PoolType,
- IN ULONG NumberOfBytes,
+ IN SIZE_T NumberOfBytes,
IN ULONG Tag)
{
PEPROCESS Process;
(char*)Block < ((char*)MmPagedPoolBase + MmPagedPoolSize))
{
/* Validate tag */
+ #ifndef DEBUG_PPOOL
if (Tag != 0 && Tag != EiGetPagedPoolTag(Block))
KeBugCheckEx(BAD_POOL_CALLER,
0x0a,
(ULONG_PTR)Block,
EiGetPagedPoolTag(Block),
Tag);
-
+ #endif
/* Validate IRQL */
if (KeGetCurrentIrql() > APC_LEVEL)
KeBugCheckEx(BAD_POOL_CALLER,
(char*)Block < ((char*)MiNonPagedPoolStart + MiNonPagedPoolLength))
{
/* Validate tag */
+ #ifndef DEBUG_NPOOL
if (Tag != 0 && Tag != EiGetNonPagedPoolTag(Block))
KeBugCheckEx(BAD_POOL_CALLER,
0x0a,
(ULONG_PTR)Block,
EiGetNonPagedPoolTag(Block),
Tag);
-
+ #endif
/* Validate IRQL */
if (KeGetCurrentIrql() > DISPATCH_LEVEL)
KeBugCheckEx(BAD_POOL_CALLER,
{
PETHREAD Thread = PsGetCurrentThread();
- /* Make sure we have reserved space for our grow */
- if (((PCHAR)Thread->Tcb.StackBase - (PCHAR)Thread->Tcb.StackLimit) >
- (KERNEL_LARGE_STACK_SIZE + PAGE_SIZE))
+ /* Make sure the stack did not overflow */
+ ASSERT(((PCHAR)Thread->Tcb.StackBase - (PCHAR)Thread->Tcb.StackLimit) <=
+ (KERNEL_LARGE_STACK_SIZE + PAGE_SIZE));
+
+ /* Check if we have reserved space for our grow */
+ if ((PCHAR)Thread->Tcb.StackBase - (PCHAR)Thread->Tcb.StackLimit +
+ KERNEL_STACK_SIZE > KERNEL_LARGE_STACK_SIZE)
{
- return STATUS_NO_MEMORY;
+ return STATUS_STACK_OVERFLOW;
}
/*
ImageConfigData = RtlImageDirectoryEntryToData(Peb->ImageBaseAddress,
TRUE,
IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG,
- &ViewSize);
+ (PULONG)&ViewSize);
ProbeForRead(ImageConfigData,
sizeof(IMAGE_LOAD_CONFIG_DIRECTORY),
KeInitializeGuardedMutex(&Process->AddressCreationLock);
Process->Vm.WorkingSetExpansionLinks.Flink = NULL;
+ /* Initialize AVL tree */
+ ASSERT(Process->VadRoot.NumberGenericTableElements == 0);
+ Process->VadRoot.BalancedRoot.u1.Parent = &Process->VadRoot.BalancedRoot;
+
/* Acquire the Lock */
MmLockAddressSpace(ProcessAddressSpace);
typedef unsigned long rulong;
-#define R_IS_POOL_PTR(pool,ptr) (void*)(ptr) >= pool->UserBase && (ULONG_PTR)(ptr) < ((ULONG_PTR)pool->UserBase + pool->UserSize)
+#define R_IS_POOL_PTR(pool,ptr) (((void*)(ULONG_PTR)(ptr) >= pool->UserBase) && ((ULONG_PTR)(ptr) < ((ULONG_PTR)pool->UserBase + pool->UserSize)))
#define R_ASSERT_PTR(pool,ptr) ASSERT( R_IS_POOL_PTR(pool,ptr) )
#define R_ASSERT_SIZE(pool,sz) ASSERT( sz > (sizeof(R_USED)+2*R_RZ) && sz >= sizeof(R_FREE) && sz < pool->UserSize )
ASSERT ( pool->FirstFree == Item );
pool->FirstFree = Item->NextFree;
}
- #ifdef DBG
+ #if DBG
Item->NextFree = Item->PrevFree = (PR_FREE)(ULONG_PTR)0xDEADBEEF;
#endif//DBG
}
#endif//R_FREEMAGIC
block->Status = 0;
RFreeFillStack ( block );
- #ifdef DBG
+ #if DBG
block->PrevFree = block->NextFree = (PR_FREE)(ULONG_PTR)0xDEADBEEF;
#endif//DBG
return block;
//ASSERT_SIZE ( Block->Size );
// now add the block to the used block list
- #ifdef DBG
+ #if DBG
Block->NextUsed = (PR_USED)(ULONG_PTR)0xDEADBEEF;
#endif//R_USED_LIST
Block->UserSize = UserSize;
memset ( Addr - R_RZ, R_RZ_LOVALUE, R_RZ );
memset ( Addr + Block->UserSize, R_RZ_HIVALUE, R_RZ );
- #ifdef DBG
+ #if DBG
memset ( Addr, 0xCD, UserSize );
#endif//DBG
}
if ( R_IS_POOL_PTR(pool,NumberOfBytes) )
{
R_DEBUG("red zone verification requested for block 0x%X\n", NumberOfBytes );
- RUsedRedZoneCheck(pool,RBodyToHdr((void*)NumberOfBytes), (char*)NumberOfBytes, __FILE__, __LINE__ );
+ RUsedRedZoneCheck(pool,RBodyToHdr((void*)(ULONG_PTR)NumberOfBytes), (char*)(ULONG_PTR)NumberOfBytes, __FILE__, __LINE__ );
R_RELEASE_MUTEX(pool);
return NULL;
}
MmQuerySectionView(PMEMORY_AREA MemoryArea,
PVOID Address,
PMEMORY_BASIC_INFORMATION Info,
- PULONG ResultLength)
+ PSIZE_T ResultLength)
{
PMM_REGION Region;
PVOID RegionBaseAddress;
LARGE_INTEGER Offset;
CHAR Buffer;
FILE_STANDARD_INFORMATION FileInfo;
+ ULONG Length;
/*
* Create the section
FileStandardInformation,
sizeof(FILE_STANDARD_INFORMATION),
&FileInfo,
- &Iosb.Information);
+ &Length);
+ Iosb.Information = Length;
if (!NT_SUCCESS(Status))
{
ObDereferenceObject(Section);
PreviousMode = ExGetPreviousMode();
- if(MaximumSize != NULL && PreviousMode != KernelMode)
+ if(PreviousMode != KernelMode)
{
_SEH2_TRY
{
- /* make a copy on the stack */
- SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
- MaximumSize = &SafeMaximumSize;
+ if (MaximumSize != NULL)
+ {
+ /* make a copy on the stack */
+ SafeMaximumSize = ProbeForReadLargeInteger(MaximumSize);
+ MaximumSize = &SafeMaximumSize;
+ }
+ ProbeForWriteHandle(SectionHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = MmUnmapViewOfSegment(AddressSpace, BaseAddress);
}
+ MmUnlockAddressSpace(AddressSpace);
+
/* Notify debugger */
if (ImageBaseAddress) DbgkUnMapViewOfSection(ImageBaseAddress);
- MmUnlockAddressSpace(AddressSpace);
return(STATUS_SUCCESS);
}
NtQuerySection(IN HANDLE SectionHandle,
IN SECTION_INFORMATION_CLASS SectionInformationClass,
OUT PVOID SectionInformation,
- IN ULONG SectionInformationLength,
- OUT PULONG ResultLength OPTIONAL)
+ IN SIZE_T SectionInformationLength,
+ OUT PSIZE_T ResultLength OPTIONAL)
{
PROS_SECTION_OBJECT Section;
KPROCESSOR_MODE PreviousMode;
NTSTATUS Status = STATUS_SUCCESS;
+ PAGED_CODE();
PreviousMode = ExGetPreviousMode();
sizeof(ExSectionInfoClass) / sizeof(ExSectionInfoClass[0]),
SectionInformation,
SectionInformationLength,
+ NULL,
ResultLength,
PreviousMode);
NTSTATUS NTAPI
MmMapViewInSystemSpace (IN PVOID SectionObject,
OUT PVOID * MappedBase,
- IN OUT PULONG ViewSize)
+ IN OUT PSIZE_T ViewSize)
{
PROS_SECTION_OBJECT Section;
PMMSUPPORT AddressSpace;
\r
LIST_ENTRY PsLoadedModuleList;\r
KSPIN_LOCK PsLoadedModuleSpinLock;\r
-ULONG PsNtosImageBase;\r
+ULONG_PTR PsNtosImageBase;\r
KMUTANT MmSystemLoadLock;\r
extern ULONG NtGlobalFlag;\r
\r
Function = (PVOID)((ULONG_PTR)DllBase + ExportTable[Ordinal]);\r
\r
/* We found it! */\r
- ASSERT((Function > (PVOID)ExportDirectory) &&\r
+ ASSERT(!(Function > (PVOID)ExportDirectory) &&\r
(Function < (PVOID)((ULONG_PTR)ExportDirectory + ExportSize)));\r
return Function;\r
}\r
ForwardName->Hint = 0;\r
\r
/* Set the new address */\r
- *(PULONG)&ForwardThunk.u1.AddressOfData = (ULONG)ForwardName;\r
+ ForwardThunk.u1.AddressOfData = (ULONG_PTR)ForwardName;\r
\r
/* Snap the forwarder */\r
Status = MiSnapThunk(LdrEntry->DllBase,\r
LdrEntry = CONTAINING_RECORD(NextEntry,\r
LDR_DATA_TABLE_ENTRY,\r
InLoadOrderLinks);\r
- PsNtosImageBase = (ULONG)LdrEntry->DllBase;\r
+ PsNtosImageBase = (ULONG_PTR)LdrEntry->DllBase;\r
\r
/* Loop the loader block */\r
while (NextEntry != ListHead)\r
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PEPROCESS Process;
NTSTATUS Status = STATUS_SUCCESS;
- ULONG BytesWritten = 0;
+ SIZE_T BytesWritten = 0;
PAGED_CODE();
/* Check if we came from user mode */
SIZE_T NumberOfBytesToProtect = 0;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
NTSTATUS Status = STATUS_SUCCESS;
+ PAGED_CODE();
/* Check for valid protection flags */
Protection = NewAccessProtection & ~(PAGE_GUARD|PAGE_NOCACHE);
WCHAR ModuleFileNameBuffer[MAX_PATH] = {0};
UNICODE_STRING ModuleFileName;
PMEMORY_SECTION_NAME SectionName = NULL;
+ PEPROCESS Process;
union
{
MEMORY_BASIC_INFORMATION BasicInfo;
PreviousMode = ExGetPreviousMode();
- if (PreviousMode != KernelMode && UnsafeResultLength != NULL)
+ if (PreviousMode != KernelMode)
{
_SEH2_TRY
{
- ProbeForWriteSize_t(UnsafeResultLength);
+ ProbeForWrite(VirtualMemoryInformation,
+ Length,
+ sizeof(ULONG_PTR));
+
+ if (UnsafeResultLength) ProbeForWriteSize_t(UnsafeResultLength);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* FIXME: Move this inside MiQueryVirtualMemory */
if (VirtualMemoryInformationClass == MemorySectionName)
{
+ Status = ObReferenceObjectByHandle(ProcessHandle,
+ PROCESS_QUERY_INFORMATION,
+ NULL,
+ PreviousMode,
+ (PVOID*)(&Process),
+ NULL);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NtQueryVirtualMemory() = %x\n",Status);
+ return(Status);
+ }
+
RtlInitEmptyUnicodeString(&ModuleFileName, ModuleFileNameBuffer, sizeof(ModuleFileNameBuffer));
Status = MmGetFileNameForAddress(Address, &ModuleFileName);
}
}
}
+ ObDereferenceObject(Process);
return Status;
}
else
<file>ctxhelp.S</file>
</directory>
</if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file first="true">boot.S</file>
+ <file>context.c</file>
+ <file>cpu.c</file>
+ <file>ctxswitch.S</file>
+ <file>except.c</file>
+ <file>interrupt.c</file>
+ <file>irql.c</file>
+ <file>kiinit.c</file>
+ <file>spinlock.c</file>
+ <file>stubs.c</file>
+ <file>thrdini.c</file>
+ <file>trap.S</file>
+ </directory>
+ </if>
<file>apc.c</file>
<file>balmgr.c</file>
<file>bug.c</file>
<file>cmhardwr.c</file>
</directory>
</if>
+ <if property="ARCH" value="amd64">
+ <directory name="i386">
+ <file>cmhardwr.c</file>
+ </directory>
+ </if>
<if property="ARCH" value="arm">
<directory name="arm">
<file>cmhardwr.c</file>
<file>ioport.S</file>
</directory>
</if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>fastinterlck.c</file>
+ </directory>
+ </if>
<file>atom.c</file>
<file>callback.c</file>
<file>dbgctrl.c</file>
</directory>
</if>
<if property="KDBG" value="1">
- <file>kdb.c</file>
- <file>kdb_cli.c</file>
- <file>kdb_expr.c</file>
+ <ifnot property="ARCH" value="amd64">
+ <file>kdb.c</file>
+ <file>kdb_cli.c</file>
+ <file>kdb_expr.c</file>
+ </ifnot>
<file>kdb_keyboard.c</file>
<file>kdb_serial.c</file>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>kdb.c</file>
+ </directory>
+ </if>
</if>
<if property="DBG_OR_KDBG" value="true">
<file>kdb_symbols.c</file>
</if>
<file>kdbg.c</file>
</directory>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>kd.c</file>
+ </directory>
+ </if>
<file>kdinit.c</file>
<file>kdio.c</file>
<file>kdmain.c</file>
<file>kdlock.c</file>
<file>kdprint.c</file>
<file>kdtrap.c</file>
+ <if property="ARCH" value="i386">
+ <directory name="i386">
+ <file>kd-i386.c</file>
+ </directory>
+ </if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>kd-amd64.c</file>
+ </directory>
+ </if>
</directory>
</if>
<directory name="lpc">
<file>page.c</file>
</directory>
</if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>page.c</file>
+ </directory>
+ </if>
<file>anonmem.c</file>
<file>balance.c</file>
<file>cont.c</file>
<file>psctx.c</file>
</directory>
</if>
+ <if property="ARCH" value="amd64">
+ <directory name="amd64">
+ <file>psctx.c</file>
+ </directory>
+ </if>
<file>debug.c</file>
<file>job.c</file>
<file>kill.c</file>
<linkerscript>ntoskrnl_$(ARCH).lnk</linkerscript>
<!-- See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38054#c7 -->
- <compilerflag>-fno-unit-at-a-time</compilerflag>
+ <compilerflag compilerset="gcc">-fno-unit-at-a-time</compilerflag>
</group>
PPROCESS_BASIC_INFORMATION ProcessBasicInfo =
(PPROCESS_BASIC_INFORMATION)ProcessInformation;
PKERNEL_USER_TIMES ProcessTime = (PKERNEL_USER_TIMES)ProcessInformation;
+ PPROCESS_PRIORITY_CLASS PsPriorityClass = (PPROCESS_PRIORITY_CLASS)ProcessInformation;
ULONG HandleCount;
PPROCESS_SESSION_INFORMATION SessionInfo =
(PPROCESS_SESSION_INFORMATION)ProcessInformation;
PVM_COUNTERS VmCounters = (PVM_COUNTERS)ProcessInformation;
PIO_COUNTERS IoCounters = (PIO_COUNTERS)ProcessInformation;
+ PQUOTA_LIMITS QuotaLimits = (PQUOTA_LIMITS)ProcessInformation;
PROCESS_DEVICEMAP_INFORMATION DeviceMap;
PUNICODE_STRING ImageName;
ULONG Cookie;
PAGED_CODE();
- /* Check validity of Information Class */
- #if 0
- Status = DefaultQueryInfoBufferCheck(ProcessInformationClass,
- PsProcessInfoClass,
- RTL_NUMBER_OF(PsProcessInfoClass),
- ProcessInformation,
- ProcessInformationLength,
- ReturnLength,
- PreviousMode);
- if (!NT_SUCCESS(Status)) return Status;
- #endif
+ /* Check for user-mode caller */
+ if (PreviousMode != KernelMode)
+ {
+ /* Prepare to probe parameters */
+ _SEH2_TRY
+ {
+ ProbeForWrite(ProcessInformation,
+ ProcessInformationLength,
+ sizeof(ULONG));
+ if (ReturnLength) ProbeForWriteUlong(ReturnLength);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Get the error code */
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+ if(!NT_SUCCESS(Status)) return Status;
+ }
if((ProcessInformationClass == ProcessCookie) &&
(ProcessHandle != NtCurrentProcess()))
ProcessBasicInfo->UniqueProcessId = (ULONG_PTR)Process->
UniqueProcessId;
ProcessBasicInfo->InheritedFromUniqueProcessId =
- (ULONG)Process->InheritedFromUniqueProcessId;
+ (ULONG_PTR)Process->InheritedFromUniqueProcessId;
ProcessBasicInfo->BasePriority = Process->Pcb.BasePriority;
}
ObDereferenceObject(Process);
break;
- /* Quote limits: not implemented */
+ /* Process quota limits */
case ProcessQuotaLimits:
Length = sizeof(QUOTA_LIMITS);
NULL);
if (!NT_SUCCESS(Status)) break;
- /* TODO: Implement this case */
- Status = STATUS_NOT_IMPLEMENTED;
+ /* Indicate success */
+ Status = STATUS_SUCCESS;
+
+ _SEH2_TRY
+ {
+ /* Set max/min working set sizes */
+ QuotaLimits->MaximumWorkingSetSize =
+ Process->Vm.MaximumWorkingSetSize << PAGE_SHIFT;
+ QuotaLimits->MinimumWorkingSetSize =
+ Process->Vm.MinimumWorkingSetSize << PAGE_SHIFT;
+
+ /* Set default time limits */
+ QuotaLimits->TimeLimit.LowPart = (ULONG)-1;
+ QuotaLimits->TimeLimit.HighPart = (ULONG)-1;
+
+ /* Is quota block a default one? */
+ if (Process->QuotaBlock == &PspDefaultQuotaBlock)
+ {
+ /* Set default pools and pagefile limits */
+ QuotaLimits->PagedPoolLimit = (SIZE_T)-1;
+ QuotaLimits->NonPagedPoolLimit = (SIZE_T)-1;
+ QuotaLimits->PagefileLimit = (SIZE_T)-1;
+ }
+ else
+ {
+ /* Get limits from non-default quota block */
+ QuotaLimits->PagedPoolLimit =
+ Process->QuotaBlock->QuotaEntry[PagedPool].Limit;
+ QuotaLimits->NonPagedPoolLimit =
+ Process->QuotaBlock->QuotaEntry[NonPagedPool].Limit;
+ QuotaLimits->PagefileLimit =
+ Process->QuotaBlock->QuotaEntry[2].Limit;
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Get exception code */
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
/* Dereference the process */
ObDereferenceObject(Process);
case ProcessLdtInformation:
case ProcessWorkingSetWatch:
case ProcessWx86Information:
+
+ /* Reference the process */
+ Status = ObReferenceObjectByHandle(ProcessHandle,
+ PROCESS_QUERY_INFORMATION,
+ PsProcessType,
+ PreviousMode,
+ (PVOID*)&Process,
+ NULL);
+ if (!NT_SUCCESS(Status)) break;
+
+ DPRINT1("Not implemented: %lx\n", ProcessInformationClass);
+
+ /* Dereference the process */
+ ObDereferenceObject(Process);
Status = STATUS_NOT_IMPLEMENTED;
break;
_SEH2_TRY
{
/* Write back the Session ID */
- SessionInfo->SessionId = Process->Session;
+ SessionInfo->SessionId = PtrToUlong(Process->Session);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* WOW64: Not implemented */
case ProcessWow64Information:
+
+ /* Set the return length */
+ Length = sizeof(ULONG_PTR);
+
+ if (ProcessInformationLength != Length)
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ /* Reference the process */
+ Status = ObReferenceObjectByHandle(ProcessHandle,
+ PROCESS_QUERY_INFORMATION,
+ PsProcessType,
+ PreviousMode,
+ (PVOID*)&Process,
+ NULL);
+ if (!NT_SUCCESS(Status)) break;
+
+ DPRINT1("Not implemented: ProcessWow64Information\n");
+
+ /* Dereference the process */
+ ObDereferenceObject(Process);
Status = STATUS_NOT_IMPLEMENTED;
break;
case ProcessPriorityClass:
/* Set the return length*/
- Length = sizeof(USHORT);
+ Length = sizeof(PROCESS_PRIORITY_CLASS);
if (ProcessInformationLength != Length)
{
_SEH2_TRY
{
/* Return current priority class */
- *(PUSHORT)ProcessInformation = Process->PriorityClass;
+ PsPriorityClass->PriorityClass = Process->PriorityClass;
+ PsPriorityClass->Foreground = FALSE;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
case ProcessAffinityMask:
case ProcessForegroundInformation:
default:
+ DPRINT1("Unsupported or unimplemented: %lx\n", ProcessInformationClass);
Status = STATUS_INVALID_INFO_CLASS;
}
HANDLE PortHandle = NULL;
HANDLE TokenHandle = NULL;
PROCESS_SESSION_INFORMATION SessionInfo = {0};
+ PROCESS_PRIORITY_CLASS PriorityClass = {0};
PVOID ExceptionPort;
PAGED_CODE();
/* Check what kind of information class this is */
switch (ProcessInformationClass)
{
- /* Quotas and priorities: not implemented */
- case ProcessQuotaLimits:
- case ProcessBasePriority:
- case ProcessRaisePriority:
- Status = STATUS_NOT_IMPLEMENTED;
- break;
-
/* Error/Exception Port */
case ProcessExceptionPort:
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(HANDLE))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
/* Security Token */
case ProcessAccessToken:
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(PROCESS_ACCESS_TOKEN))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
/* Hard error processing */
case ProcessDefaultHardErrorMode:
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(ULONG))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Enter SEH for direct buffer read */
_SEH2_TRY
{
/* Session ID */
case ProcessSessionInformation:
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(PROCESS_SESSION_INFORMATION))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Enter SEH for capture */
_SEH2_TRY
{
//PsUnlockProcess(Process);
break;
- /* Priority class: HACK! */
case ProcessPriorityClass:
+
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(PROCESS_PRIORITY_CLASS))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ /* Enter SEH for capture */
+ _SEH2_TRY
+ {
+ /* Capture the caller's buffer */
+ PriorityClass = *(PPROCESS_PRIORITY_CLASS)ProcessInformation;
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Get the exception code */
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+ if (!NT_SUCCESS(Status)) break;
+
+ /* Check for invalid PriorityClass value */
+ if (PriorityClass.PriorityClass > PROCESS_PRIORITY_CLASS_ABOVE_NORMAL)
+ {
+ Status = STATUS_INVALID_PARAMETER;
+ break;
+ }
+
+ /* TODO: Check privileges */
+
+ /* Check if we have a job */
+ if (Process->Job)
+ {
+ DPRINT1("Jobs not yet supported\n");
+ }
+
+ /* Set process priority class */
+ Process->PriorityClass = PriorityClass.PriorityClass;
+
+ /* Set process priority mode (foreground or background) */
+ PsSetProcessPriorityByClass(Process,
+ !PriorityClass.Foreground ? PsProcessPriorityBackground :
+ PsProcessPriorityForeground);
+
+ Status = STATUS_SUCCESS;
+ break;
+
+ case ProcessQuotaLimits:
+
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(QUOTA_LIMITS))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ DPRINT1("Not implemented: ProcessQuotaLimits\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+
+ case ProcessBasePriority:
+
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(KPRIORITY))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ DPRINT1("Not implemented: ProcessBasePriority\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+
+ case ProcessRaisePriority:
+
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(ULONG))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ DPRINT1("Not implemented: ProcessRaisePriority\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+
+ case ProcessWx86Information:
+
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(HANDLE))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ DPRINT1("Not implemented: ProcessWx86Information\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+
+ case ProcessDebugPort:
+
+ /* Check buffer length */
+ if (ProcessInformationLength != sizeof(HANDLE))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
+ DPRINT1("Not implemented: ProcessDebugPort\n");
+ Status = STATUS_NOT_IMPLEMENTED;
break;
/* We currently don't implement any of these */
case ProcessUserModeIOPL:
case ProcessEnableAlignmentFaultFixup:
case ProcessAffinityMask:
+ DPRINT1("Not implemented: %lx\n", ProcessInformationClass);
Status = STATUS_NOT_IMPLEMENTED;
break;
case ProcessIoCounters:
case ProcessTimes:
case ProcessPooledUsageAndLimits:
- case ProcessWx86Information:
case ProcessHandleCount:
case ProcessWow64Information:
- case ProcessDebugPort:
default:
+ DPRINT1("Unsupported or unimplemented: %lx\n", ProcessInformationClass);
Status = STATUS_INVALID_INFO_CLASS;
}
/* Thread priority */
case ThreadPriority:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(KPRIORITY))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadBasePriority:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(LONG))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadAffinityMask:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(ULONG_PTR))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadImpersonationToken:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(HANDLE))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadQuerySetWin32StartAddress:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(ULONG_PTR))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadIdealProcessor:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(ULONG_PTR))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadPriorityBoost:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(ULONG_PTR))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
case ThreadZeroTlsCell:
+ /* Check buffer length */
+ if (ThreadInformationLength != sizeof(ULONG_PTR))
+ {
+ Status = STATUS_INFO_LENGTH_MISMATCH;
+ break;
+ }
+
/* Use SEH for capture */
_SEH2_TRY
{
/* FUNCTIONS *****************************************************************/
+PVOID
+NTAPI
+RtlpLookupModuleBase(
+ PVOID Address)
+{
+ PLDR_DATA_TABLE_ENTRY LdrEntry;
+ BOOLEAN InSystem;
+ PVOID p;
+
+ /* Get the base for this file */
+ if ((ULONG_PTR)Address > (ULONG_PTR)MmHighestUserAddress)
+ {
+ /* We are in kernel */
+ p = KiPcToFileHeader(Address, &LdrEntry, FALSE, &InSystem);
+ }
+ else
+ {
+ /* We are in user land */
+ p = KiRosPcToUserFileHeader(Address, &LdrEntry);
+ }
+
+ return p;
+}
+
VOID
NTAPI
RtlInitializeRangeListPackage(VOID)
return STATUS_SUCCESS;
}
- #ifdef DBG
+ #if DBG
VOID FASTCALL
CHECK_PAGED_CODE_RTL(char *file, int line)
{
return FALSE;
}
-#ifndef _ARM_
+#if !defined(_ARM_) && !defined(_AMD64_)
BOOLEAN
NTAPI
#endif
+#ifdef _AMD64_
+VOID
+NTAPI
+RtlpGetStackLimits(
+ OUT PULONG_PTR LowLimit,
+ OUT PULONG_PTR HighLimit)
+{
+ PKTHREAD CurrentThread = KeGetCurrentThread();
+ *HighLimit = (ULONG_PTR)CurrentThread->InitialStack;
+ *LowLimit = (ULONG_PTR)CurrentThread->StackLimit;
+}
+#endif
+
/* RTL Atom Tables ************************************************************/
NTSTATUS
* 16/11/2004: Created
*/
- /* TODO: Check how the WNDOBJ implementation should behave with a driver on windows. */
+ /* TODO: Check how the WNDOBJ implementation should behave with a driver on windows.
+
+ Simple! Use Prop's!
+ */
#include <w32k.h>
RtlCopyMemory(&WndObjInt->WndObj.coClient, ClipObj, sizeof (CLIPOBJ));
RtlCopyMemory(&WndObjInt->WndObj.rclClient, &Window->Wnd->ClientRect, sizeof (RECT));
- OldClipObj = InterlockedExchangePointer(&WndObjInt->ClientClipObj, ClipObj);
+ OldClipObj = InterlockedExchangePointer((PVOID*)&WndObjInt->ClientClipObj, ClipObj);
if (OldClipObj != NULL)
IntEngDeleteClipRegion(OldClipObj);
void FASTCALL DestroyProcessClasses(PW32PROCESS Process )
{
PWINDOWCLASS Class;
- PPROCESSINFO pi = Process->ProcessInfo;
+ PPROCESSINFO pi = (PPROCESSINFO)Process;
if (pi != NULL)
{
Class->Clone = NULL;
Class->Base = BaseClass;
Class->Next = BaseClass->Clone;
- (void)InterlockedExchangePointer(&BaseClass->Clone,
+ (void)InterlockedExchangePointer((VOID*)&BaseClass->Clone,
Class);
}
}
/* create a new hook table */
- static PHOOKTABLE
+ static
+ PHOOKTABLE
IntAllocHookTable(void)
{
- PHOOKTABLE Table;
- UINT i;
-
- Table = ExAllocatePoolWithTag(PagedPool, sizeof(HOOKTABLE), TAG_HOOK);
- if (NULL != Table)
- {
- for (i = 0; i < NB_HOOKS; i++)
- {
- InitializeListHead(&Table->Hooks[i]);
- Table->Counts[i] = 0;
- }
- }
-
- return Table;
+ PHOOKTABLE Table;
+ UINT i;
+
+ Table = ExAllocatePoolWithTag(PagedPool, sizeof(HOOKTABLE), TAG_HOOK);
+ if (NULL != Table)
+ {
+ for (i = 0; i < NB_HOOKS; i++)
+ {
+ InitializeListHead(&Table->Hooks[i]);
+ Table->Counts[i] = 0;
+ }
+ }
+
+ return Table;
}
- PHOOK FASTCALL IntGetHookObject(HHOOK hHook)
+ PHOOK
+ FASTCALL
+ IntGetHookObject(HHOOK hHook)
{
- PHOOK Hook;
+ PHOOK Hook;
- if (!hHook)
- {
- SetLastWin32Error(ERROR_INVALID_HOOK_HANDLE);
- return NULL;
- }
+ if (!hHook)
+ {
+ SetLastWin32Error(ERROR_INVALID_HOOK_HANDLE);
+ return NULL;
+ }
- Hook = (PHOOK)UserGetObject(gHandleTable, hHook, otHook);
- if (!Hook)
- {
- SetLastWin32Error(ERROR_INVALID_HOOK_HANDLE);
- return NULL;
- }
+ Hook = (PHOOK)UserGetObject(gHandleTable, hHook, otHook);
+ if (!Hook)
+ {
+ SetLastWin32Error(ERROR_INVALID_HOOK_HANDLE);
+ return NULL;
+ }
- ASSERT(USER_BODY_TO_HEADER(Hook)->RefCount >= 0);
+ ASSERT(USER_BODY_TO_HEADER(Hook)->RefCount >= 0);
- USER_BODY_TO_HEADER(Hook)->RefCount++;
+ USER_BODY_TO_HEADER(Hook)->RefCount++;
- return Hook;
+ return Hook;
}
/* create a new hook and add it to the specified table */
- static PHOOK
+ static
+ PHOOK
IntAddHook(PETHREAD Thread, int HookId, BOOLEAN Global, PWINSTATION_OBJECT WinStaObj)
{
- PTHREADINFO W32Thread;
- PHOOK Hook;
- PHOOKTABLE Table = Global ? GlobalHooks : MsqGetHooks(((PTHREADINFO)Thread->Tcb.Win32Thread)->MessageQueue);
- HANDLE Handle;
-
- if (NULL == Table)
- {
- Table = IntAllocHookTable();
- if (NULL == Table)
- {
- return NULL;
- }
- if (Global)
- {
- GlobalHooks = Table;
- }
- else
- {
- MsqSetHooks(((PTHREADINFO)Thread->Tcb.Win32Thread)->MessageQueue, Table);
- }
- }
-
- Hook = UserCreateObject(gHandleTable, &Handle, otHook, sizeof(HOOK));
- if (NULL == Hook)
- {
- return NULL;
- }
-
- Hook->Self = Handle;
- Hook->Thread = Thread;
- Hook->HookId = HookId;
-
- if (Thread)
- {
- W32Thread = ((PTHREADINFO)Thread->Tcb.Win32Thread);
- ASSERT(W32Thread != NULL);
- W32Thread->fsHooks |= HOOKID_TO_FLAG(HookId);
-
- GetWin32ClientInfo()->fsHooks = W32Thread->fsHooks;
-
- if (W32Thread->ThreadInfo != NULL)
- W32Thread->ThreadInfo->fsHooks = W32Thread->fsHooks;
- }
-
- RtlInitUnicodeString(&Hook->ModuleName, NULL);
-
- InsertHeadList(&Table->Hooks[HOOKID_TO_INDEX(HookId)], &Hook->Chain);
-
- return Hook;
+ PTHREADINFO W32Thread;
+ PHOOK Hook;
+ PHOOKTABLE Table = Global ? GlobalHooks : MsqGetHooks(((PTHREADINFO)Thread->Tcb.Win32Thread)->MessageQueue);
+ HANDLE Handle;
+
+ if (NULL == Table)
+ {
+ Table = IntAllocHookTable();
+ if (NULL == Table)
+ {
+ return NULL;
+ }
+ if (Global)
+ {
+ GlobalHooks = Table;
+ }
+ else
+ {
+ MsqSetHooks(((PTHREADINFO)Thread->Tcb.Win32Thread)->MessageQueue, Table);
+ }
+ }
+
+ Hook = UserCreateObject(gHandleTable, &Handle, otHook, sizeof(HOOK));
+ if (NULL == Hook)
+ {
+ return NULL;
+ }
+
+ Hook->Self = Handle;
+ Hook->Thread = Thread;
+ Hook->HookId = HookId;
+
+ if (Thread)
+ {
+ W32Thread = ((PTHREADINFO)Thread->Tcb.Win32Thread);
+ ASSERT(W32Thread != NULL);
+ W32Thread->fsHooks |= HOOKID_TO_FLAG(HookId);
+
+ GetWin32ClientInfo()->fsHooks = W32Thread->fsHooks;
+
+ if (W32Thread->ThreadInfo != NULL)
+ W32Thread->ThreadInfo->fsHooks = W32Thread->fsHooks;
+ }
+
+ RtlInitUnicodeString(&Hook->ModuleName, NULL);
+
+ InsertHeadList(&Table->Hooks[HOOKID_TO_INDEX(HookId)], &Hook->Chain);
+
+ return Hook;
}
/* get the hook table that a given hook belongs to */
- static PHOOKTABLE FASTCALL
+ static
+ PHOOKTABLE
+ FASTCALL
IntGetTable(PHOOK Hook)
{
- if (NULL == Hook->Thread || WH_KEYBOARD_LL == Hook->HookId ||
- WH_MOUSE_LL == Hook->HookId)
- {
- return GlobalHooks;
- }
+ if (NULL == Hook->Thread || WH_KEYBOARD_LL == Hook->HookId ||
+ WH_MOUSE_LL == Hook->HookId)
+ {
+ return GlobalHooks;
+ }
- return MsqGetHooks(((PTHREADINFO)Hook->Thread->Tcb.Win32Thread)->MessageQueue);
+ return MsqGetHooks(((PTHREADINFO)Hook->Thread->Tcb.Win32Thread)->MessageQueue);
}
/* get the first hook in the chain */
- static PHOOK FASTCALL
+ static
+ PHOOK
+ FASTCALL
IntGetFirstHook(PHOOKTABLE Table, int HookId)
{
- PLIST_ENTRY Elem = Table->Hooks[HOOKID_TO_INDEX(HookId)].Flink;
- return Elem == &Table->Hooks[HOOKID_TO_INDEX(HookId)]
- ? NULL : CONTAINING_RECORD(Elem, HOOK, Chain);
+ PLIST_ENTRY Elem = Table->Hooks[HOOKID_TO_INDEX(HookId)].Flink;
+
+ return Elem == &Table->Hooks[HOOKID_TO_INDEX(HookId)]
+ ? NULL : CONTAINING_RECORD(Elem, HOOK, Chain);
}
/* find the first non-deleted hook in the chain */
- static PHOOK FASTCALL
+ static
+ PHOOK
+ FASTCALL
IntGetFirstValidHook(PHOOKTABLE Table, int HookId)
{
- PHOOK Hook;
- PLIST_ENTRY Elem;
-
- Hook = IntGetFirstHook(Table, HookId);
- while (NULL != Hook && NULL == Hook->Proc)
- {
- Elem = Hook->Chain.Flink;
- Hook = (Elem == &Table->Hooks[HOOKID_TO_INDEX(HookId)]
- ? NULL : CONTAINING_RECORD(Elem, HOOK, Chain));
- }
-
- return Hook;
+ PHOOK Hook;
+ PLIST_ENTRY Elem;
+
+ Hook = IntGetFirstHook(Table, HookId);
+
+ while (NULL != Hook && NULL == Hook->Proc)
+ {
+ Elem = Hook->Chain.Flink;
+ Hook = (Elem == &Table->Hooks[HOOKID_TO_INDEX(HookId)]
+ ? NULL : CONTAINING_RECORD(Elem, HOOK, Chain));
+ }
+
+ return Hook;
}
/* find the next hook in the chain, skipping the deleted ones */
FASTCALL
IntGetNextHook(PHOOK Hook)
{
- PHOOKTABLE Table = IntGetTable(Hook);
- int HookId = Hook->HookId;
- PLIST_ENTRY Elem;
-
- Elem = Hook->Chain.Flink;
- while (Elem != &Table->Hooks[HOOKID_TO_INDEX(HookId)])
- {
- Hook = CONTAINING_RECORD(Elem, HOOK, Chain);
- if (NULL != Hook->Proc)
- {
- return Hook;
- }
- }
-
- if (NULL != GlobalHooks && Table != GlobalHooks) /* now search through the global table */
- {
- return IntGetFirstValidHook(GlobalHooks, HookId);
- }
-
- return NULL;
+ PHOOKTABLE Table = IntGetTable(Hook);
+ int HookId = Hook->HookId;
+ PLIST_ENTRY Elem;
+
+ Elem = Hook->Chain.Flink;
+ while (Elem != &Table->Hooks[HOOKID_TO_INDEX(HookId)])
+ {
+ Hook = CONTAINING_RECORD(Elem, HOOK, Chain);
+ if (NULL != Hook->Proc)
+ {
+ return Hook;
+ }
+ }
+
+ if (NULL != GlobalHooks && Table != GlobalHooks) /* now search through the global table */
+ {
+ return IntGetFirstValidHook(GlobalHooks, HookId);
+ }
+
+ return NULL;
}
/* free a hook, removing it from its chain */
- static VOID FASTCALL
+ static
+ VOID
+ FASTCALL
IntFreeHook(PHOOKTABLE Table, PHOOK Hook, PWINSTATION_OBJECT WinStaObj)
{
- RemoveEntryList(&Hook->Chain);
- RtlFreeUnicodeString(&Hook->ModuleName);
+ RemoveEntryList(&Hook->Chain);
+ RtlFreeUnicodeString(&Hook->ModuleName);
- /* Dereference thread if required */
- if (Hook->Flags & HOOK_THREAD_REFERENCED)
- {
- ObDereferenceObject(Hook->Thread);
- }
+ /* Dereference thread if required */
+ if (Hook->Flags & HOOK_THREAD_REFERENCED)
+ {
+ ObDereferenceObject(Hook->Thread);
+ }
- /* Close handle */
- UserDeleteObject(Hook->Self, otHook);
+ /* Close handle */
+ UserDeleteObject(Hook->Self, otHook);
}
/* remove a hook, freeing it if the chain is not in use */
- static VOID
+ static
+ VOID
IntRemoveHook(PHOOK Hook, PWINSTATION_OBJECT WinStaObj, BOOL TableAlreadyLocked)
{
- PTHREADINFO W32Thread;
- PHOOKTABLE Table = IntGetTable(Hook);
-
- ASSERT(NULL != Table);
- if (NULL == Table)
- {
- return;
- }
-
- W32Thread = ((PTHREADINFO)Hook->Thread->Tcb.Win32Thread);
- ASSERT(W32Thread != NULL);
- W32Thread->fsHooks &= ~HOOKID_TO_FLAG(Hook->HookId);
-
- GetWin32ClientInfo()->fsHooks = W32Thread->fsHooks;
-
- if (W32Thread->ThreadInfo != NULL)
- W32Thread->ThreadInfo->fsHooks = W32Thread->fsHooks;
-
- if (0 != Table->Counts[HOOKID_TO_INDEX(Hook->HookId)])
- {
- Hook->Proc = NULL; /* chain is in use, just mark it and return */
- }
- else
- {
- IntFreeHook(Table, Hook, WinStaObj);
- }
+ PTHREADINFO W32Thread;
+ PHOOKTABLE Table = IntGetTable(Hook);
+
+ ASSERT(NULL != Table);
+ if (NULL == Table)
+ {
+ return;
+ }
+
+ W32Thread = ((PTHREADINFO)Hook->Thread->Tcb.Win32Thread);
+ ASSERT(W32Thread != NULL);
+ W32Thread->fsHooks &= ~HOOKID_TO_FLAG(Hook->HookId);
+
+ GetWin32ClientInfo()->fsHooks = W32Thread->fsHooks;
+
+ if (W32Thread->ThreadInfo != NULL)
+ W32Thread->ThreadInfo->fsHooks = W32Thread->fsHooks;
+
+ if (0 != Table->Counts[HOOKID_TO_INDEX(Hook->HookId)])
+ {
+ Hook->Proc = NULL; /* chain is in use, just mark it and return */
+ }
+ else
+ {
+ IntFreeHook(Table, Hook, WinStaObj);
+ }
}
/* release a hook chain, removing deleted hooks if the use count drops to 0 */
- static VOID FASTCALL
+ static
+ VOID
+ FASTCALL
IntReleaseHookChain(PHOOKTABLE Table, int HookId, PWINSTATION_OBJECT WinStaObj)
{
- PLIST_ENTRY Elem;
- PHOOK HookObj;
-
- if (NULL == Table)
- {
- return;
- }
-
- /* use count shouldn't already be 0 */
- ASSERT(0 != Table->Counts[HOOKID_TO_INDEX(HookId)]);
- if (0 == Table->Counts[HOOKID_TO_INDEX(HookId)])
- {
- return;
- }
- if (0 == --Table->Counts[HOOKID_TO_INDEX(HookId)])
- {
- Elem = Table->Hooks[HOOKID_TO_INDEX(HookId)].Flink;
- while (Elem != &Table->Hooks[HOOKID_TO_INDEX(HookId)])
- {
- HookObj = CONTAINING_RECORD(Elem, HOOK, Chain);
- Elem = Elem->Flink;
- if (NULL == HookObj->Proc)
- {
- IntFreeHook(Table, HookObj, WinStaObj);
- }
- }
- }
+ PLIST_ENTRY Elem;
+ PHOOK HookObj;
+
+ if (NULL == Table)
+ {
+ return;
+ }
+
+ /* use count shouldn't already be 0 */
+ ASSERT(0 != Table->Counts[HOOKID_TO_INDEX(HookId)]);
+
+ if (0 == Table->Counts[HOOKID_TO_INDEX(HookId)])
+ {
+ return;
+ }
+
+ if (0 == --Table->Counts[HOOKID_TO_INDEX(HookId)])
+ {
+ Elem = Table->Hooks[HOOKID_TO_INDEX(HookId)].Flink;
+
+ while (Elem != &Table->Hooks[HOOKID_TO_INDEX(HookId)])
+ {
+ HookObj = CONTAINING_RECORD(Elem, HOOK, Chain);
+ Elem = Elem->Flink;
+
+ if (NULL == HookObj->Proc)
+ {
+ IntFreeHook(Table, HookObj, WinStaObj);
+ }
+ }
+ }
}
- static LRESULT FASTCALL
+ static
+ LRESULT
+ FASTCALL
IntCallLowLevelHook(PHOOK Hook, INT Code, WPARAM wParam, LPARAM lParam)
{
- NTSTATUS Status;
- ULONG_PTR uResult;
-
- /* FIXME should get timeout from
- * HKEY_CURRENT_USER\Control Panel\Desktop\LowLevelHooksTimeout */
- Status = co_MsqSendMessage(((PTHREADINFO)Hook->Thread->Tcb.Win32Thread)->MessageQueue,
- (HWND)(UINT_PTR)Code,
- Hook->HookId,
- wParam,
- lParam,
- 5000,
- TRUE,
- MSQ_ISHOOK,
- &uResult);
-
- return NT_SUCCESS(Status) ? uResult : 0;
+ NTSTATUS Status;
+ ULONG_PTR uResult;
+
+ /* FIXME should get timeout from
+ * HKEY_CURRENT_USER\Control Panel\Desktop\LowLevelHooksTimeout */
+ Status = co_MsqSendMessage(((PTHREADINFO)Hook->Thread->Tcb.Win32Thread)->MessageQueue,
- (HWND)Code,
++ (HWND)(UINT_PTR)Code,
+ Hook->HookId,
+ wParam,
+ lParam,
+ 5000,
+ TRUE,
+ MSQ_ISHOOK,
+ &uResult);
+
+ return NT_SUCCESS(Status) ? uResult : 0;
}
/*
FASTCALL
co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
{
- PHOOK Hook, SaveHook;
- PTHREADINFO pti;
- PCLIENTINFO ClientInfo;
- PHOOKTABLE Table;
- LRESULT Result;
- PWINSTATION_OBJECT WinStaObj;
- NTSTATUS Status;
-
- ASSERT(WH_MINHOOK <= HookId && HookId <= WH_MAXHOOK);
-
- pti = PsGetCurrentThreadWin32Thread();
- if (!pti)
- {
- Table = NULL;
- }
- else
- {
- Table = MsqGetHooks(pti->MessageQueue);
- }
-
- if (NULL == Table || ! (Hook = IntGetFirstValidHook(Table, HookId)))
- {
- /* try global table */
- Table = GlobalHooks;
- if (NULL == Table || ! (Hook = IntGetFirstValidHook(Table, HookId)))
- {
- return 0; /* no hook set */
- }
- }
-
- if ((Hook->Thread != PsGetCurrentThread()) && (Hook->Thread != NULL))
- {
- // Post it in message queue.
- return IntCallLowLevelHook(Hook, Code, wParam, lParam);
- }
-
- Table->Counts[HOOKID_TO_INDEX(HookId)]++;
- if (Table != GlobalHooks && GlobalHooks != NULL)
- {
- GlobalHooks->Counts[HOOKID_TO_INDEX(HookId)]++;
- }
-
- ClientInfo = GetWin32ClientInfo();
- SaveHook = ClientInfo->phkCurrent;
- ClientInfo->phkCurrent = Hook; // Load the call.
-
- Result = co_IntCallHookProc( HookId,
- Code,
+ PHOOK Hook, SaveHook;
+ PTHREADINFO pti;
+ PCLIENTINFO ClientInfo;
+ PHOOKTABLE Table;
+ LRESULT Result;
+ PWINSTATION_OBJECT WinStaObj;
+ NTSTATUS Status;
+
+ ASSERT(WH_MINHOOK <= HookId && HookId <= WH_MAXHOOK);
+
+ pti = PsGetCurrentThreadWin32Thread();
+ if (!pti)
+ {
+ Table = NULL;
+ }
+ else
+ {
+ Table = MsqGetHooks(pti->MessageQueue);
+ }
+
+ if (NULL == Table || ! (Hook = IntGetFirstValidHook(Table, HookId)))
+ {
+ /* try global table */
+ Table = GlobalHooks;
+ if (NULL == Table || ! (Hook = IntGetFirstValidHook(Table, HookId)))
+ {
+ return 0; /* no hook set */
+ }
+ }
+
+ if ((Hook->Thread != PsGetCurrentThread()) && (Hook->Thread != NULL))
+ {
+ /* Post it in message queue. */
+ return IntCallLowLevelHook(Hook, Code, wParam, lParam);
+ }
+
+ Table->Counts[HOOKID_TO_INDEX(HookId)]++;
+ if (Table != GlobalHooks && GlobalHooks != NULL)
+ {
+ GlobalHooks->Counts[HOOKID_TO_INDEX(HookId)]++;
+ }
+
+ ClientInfo = GetWin32ClientInfo();
+ SaveHook = ClientInfo->phkCurrent;
+ ClientInfo->phkCurrent = Hook; /* Load the call. */
+
+ Result = co_IntCallHookProc(HookId,
+ Code,
wParam,
lParam,
- Hook->Proc,
- Hook->Ansi,
- &Hook->ModuleName);
-
- ClientInfo->phkCurrent = SaveHook;
-
- Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
- KernelMode,
- 0,
- &WinStaObj);
-
- if (! NT_SUCCESS(Status))
- {
- DPRINT1("Invalid window station????\n");
- }
- else
- {
- IntReleaseHookChain(MsqGetHooks(pti->MessageQueue), HookId, WinStaObj);
- IntReleaseHookChain(GlobalHooks, HookId, WinStaObj);
- ObDereferenceObject(WinStaObj);
- }
-
- return Result;
+ Hook->Proc,
+ Hook->Ansi,
+ &Hook->ModuleName);
+
+ ClientInfo->phkCurrent = SaveHook;
+
+ Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
+ KernelMode,
+ 0,
+ &WinStaObj);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Invalid window station????\n");
+ }
+ else
+ {
+ IntReleaseHookChain(MsqGetHooks(pti->MessageQueue), HookId, WinStaObj);
+ IntReleaseHookChain(GlobalHooks, HookId, WinStaObj);
+ ObDereferenceObject(WinStaObj);
+ }
+
+ return Result;
}
- VOID FASTCALL
+ VOID
+ FASTCALL
HOOK_DestroyThreadHooks(PETHREAD Thread)
{
- int HookId;
- PLIST_ENTRY Elem;
- PHOOK HookObj;
- PWINSTATION_OBJECT WinStaObj;
- NTSTATUS Status;
-
- if (NULL != GlobalHooks)
- {
- Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
- KernelMode,
- 0,
- &WinStaObj);
-
- if (! NT_SUCCESS(Status))
- {
- DPRINT1("Invalid window station????\n");
- return;
- }
-
- for (HookId = WH_MINHOOK; HookId <= WH_MAXHOOK; HookId++)
- {
- /* only low-level keyboard/mouse global hooks can be owned by a thread */
- switch(HookId)
- {
- case WH_KEYBOARD_LL:
- case WH_MOUSE_LL:
- Elem = GlobalHooks->Hooks[HOOKID_TO_INDEX(HookId)].Flink;
- while (Elem != &GlobalHooks->Hooks[HOOKID_TO_INDEX(HookId)])
- {
- HookObj = CONTAINING_RECORD(Elem, HOOK, Chain);
- Elem = Elem->Flink;
- if (HookObj->Thread == Thread)
- {
- IntRemoveHook(HookObj, WinStaObj, TRUE);
- }
- }
- break;
- }
- }
- }
+ int HookId;
+ PLIST_ENTRY Elem;
+ PHOOK HookObj;
+ PWINSTATION_OBJECT WinStaObj;
+ NTSTATUS Status;
+
+ if (NULL != GlobalHooks)
+ {
+ Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
+ KernelMode,
+ 0,
+ &WinStaObj);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Invalid window station????\n");
+ return;
+ }
+
+ for (HookId = WH_MINHOOK; HookId <= WH_MAXHOOK; HookId++)
+ {
+ /* only low-level keyboard/mouse global hooks can be owned by a thread */
+ switch(HookId)
+ {
+ case WH_KEYBOARD_LL:
+ case WH_MOUSE_LL:
+ Elem = GlobalHooks->Hooks[HOOKID_TO_INDEX(HookId)].Flink;
+
+ while (Elem != &GlobalHooks->Hooks[HOOKID_TO_INDEX(HookId)])
+ {
+ HookObj = CONTAINING_RECORD(Elem, HOOK, Chain);
+ Elem = Elem->Flink;
+
+ if (HookObj->Thread == Thread)
+ {
+ IntRemoveHook(HookObj, WinStaObj, TRUE);
+ }
+ }
+ break;
+ }
+ }
+ }
}
- static LRESULT
+ static
+ LRESULT
FASTCALL
co_HOOK_CallHookNext(PHOOK Hook, INT Code, WPARAM wParam, LPARAM lParam)
{
- if ((Hook->Thread != PsGetCurrentThread()) && (Hook->Thread != NULL))
- {
- DPRINT1("CALLING HOOK from another Thread. %d\n",Hook->HookId);
- return IntCallLowLevelHook(Hook, Code, wParam, lParam);
- }
- DPRINT("CALLING HOOK %d\n",Hook->HookId);
- return co_IntCallHookProc(Hook->HookId,
- Code,
- wParam,
- lParam,
- Hook->Proc,
- Hook->Ansi,
- &Hook->ModuleName);
+ if ((Hook->Thread != PsGetCurrentThread()) && (Hook->Thread != NULL))
+ {
+ DPRINT1("CALLING HOOK from another Thread. %d\n", Hook->HookId);
+ return IntCallLowLevelHook(Hook, Code, wParam, lParam);
+ }
+
+ DPRINT("CALLING HOOK %d\n", Hook->HookId);
+
+ return co_IntCallHookProc(Hook->HookId,
+ Code,
+ wParam,
+ lParam,
+ Hook->Proc,
+ Hook->Ansi,
+ &Hook->ModuleName);
}
LRESULT
FASTCALL
- IntCallDebugHook(
- PHOOK Hook,
- int Code,
- WPARAM wParam,
- LPARAM lParam)
+ IntCallDebugHook(PHOOK Hook,
+ int Code,
+ WPARAM wParam,
+ LPARAM lParam)
{
- LRESULT lResult = 0;
- ULONG Size;
- DEBUGHOOKINFO Debug;
- PVOID HooklParam = NULL;
- BOOL BadChk = FALSE;
-
- if (lParam)
- {
- _SEH2_TRY
- {
- ProbeForRead((PVOID)lParam,
- sizeof(DEBUGHOOKINFO),
- 1);
- RtlCopyMemory( &Debug,
- (PVOID)lParam,
- sizeof(DEBUGHOOKINFO));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK WH_DEBUG read from lParam ERROR!\n");
- return lResult;
- }
- }
- else
- return lResult; // Need lParam!
-
- switch (wParam)
- {
- case WH_CBT:
- {
- switch (Debug.code)
- {
- case HCBT_CLICKSKIPPED:
- Size = sizeof(MOUSEHOOKSTRUCTEX);
- break;
- case HCBT_MOVESIZE:
- Size = sizeof(RECT);
- break;
- case HCBT_ACTIVATE:
- Size = sizeof(CBTACTIVATESTRUCT);
- break;
- case HCBT_CREATEWND: // Handle Ansi?
- Size = sizeof(CBT_CREATEWND);
- // What shall we do? Size += sizeof(CREATESTRUCTEX);
- break;
- default:
- Size = sizeof(LPARAM);
- }
- }
- break;
-
- case WH_MOUSE_LL:
- Size = sizeof(MSLLHOOKSTRUCT);
- break;
-
- case WH_KEYBOARD_LL:
- Size = sizeof(KBDLLHOOKSTRUCT);
- break;
-
- case WH_MSGFILTER:
- case WH_SYSMSGFILTER:
- case WH_GETMESSAGE:
- Size = sizeof(MSG);
- break;
-
- case WH_JOURNALPLAYBACK:
- case WH_JOURNALRECORD:
- Size = sizeof(EVENTMSG);
- break;
-
- case WH_FOREGROUNDIDLE:
- case WH_KEYBOARD:
- case WH_SHELL:
- default:
- Size = sizeof(LPARAM);
- }
-
- if (Size > sizeof(LPARAM))
- HooklParam = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_HOOK);
-
- if (HooklParam)
- {
- _SEH2_TRY
- {
- ProbeForRead((PVOID)Debug.lParam,
- Size,
- 1);
- RtlCopyMemory( HooklParam,
- (PVOID)Debug.lParam,
- Size);
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK WH_DEBUG read from Debug.lParam ERROR!\n");
- ExFreePool(HooklParam);
- return lResult;
- }
- }
-
- if (HooklParam) Debug.lParam = (LPARAM)HooklParam;
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Debug);
- if (HooklParam) ExFreePoolWithTag(HooklParam, TAG_HOOK);
- return lResult;
- }
+ LRESULT lResult = 0;
+ ULONG Size;
+ DEBUGHOOKINFO Debug;
+ PVOID HooklParam = NULL;
+ BOOL BadChk = FALSE;
+
+ if (lParam)
+ {
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(DEBUGHOOKINFO),
+ 1);
- /*
- Called from user space via CallNextHook.
- */
- LRESULT
- FASTCALL
- UserCallNextHookEx(
- PHOOK Hook,
- int Code,
- WPARAM wParam,
- LPARAM lParam,
- BOOL Ansi)
- {
- LRESULT lResult = 0;
- BOOL BadChk = FALSE;
-
- // Handle this one first.
- if ((Hook->HookId == WH_MOUSE) ||
- (Hook->HookId == WH_CBT && Code == HCBT_CLICKSKIPPED))
- {
- MOUSEHOOKSTRUCTEX Mouse;
- if (lParam)
- {
+ RtlCopyMemory(&Debug,
+ (PVOID)lParam,
+ sizeof(DEBUGHOOKINFO));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_DEBUG read from lParam ERROR!\n");
+ return lResult;
+ }
+ }
+ else
+ return lResult; /* Need lParam! */
+
+ switch (wParam)
+ {
+ case WH_CBT:
+ {
+ switch (Debug.code)
+ {
+ case HCBT_CLICKSKIPPED:
+ Size = sizeof(MOUSEHOOKSTRUCTEX);
+ break;
+
+ case HCBT_MOVESIZE:
+ Size = sizeof(RECT);
+ break;
+
+ case HCBT_ACTIVATE:
+ Size = sizeof(CBTACTIVATESTRUCT);
+ break;
+
+ case HCBT_CREATEWND: /* Handle Ansi? */
+ Size = sizeof(CBT_CREATEWND);
+ /* What shall we do? Size += sizeof(CREATESTRUCTEX); */
+ break;
+
+ default:
+ Size = sizeof(LPARAM);
+ }
+ }
+ break;
+
+ case WH_MOUSE_LL:
+ Size = sizeof(MSLLHOOKSTRUCT);
+ break;
+
+ case WH_KEYBOARD_LL:
+ Size = sizeof(KBDLLHOOKSTRUCT);
+ break;
+
+ case WH_MSGFILTER:
+ case WH_SYSMSGFILTER:
+ case WH_GETMESSAGE:
+ Size = sizeof(MSG);
+ break;
+
+ case WH_JOURNALPLAYBACK:
+ case WH_JOURNALRECORD:
+ Size = sizeof(EVENTMSG);
+ break;
+
+ case WH_FOREGROUNDIDLE:
+ case WH_KEYBOARD:
+ case WH_SHELL:
+ default:
+ Size = sizeof(LPARAM);
+ }
+
+ if (Size > sizeof(LPARAM))
+ HooklParam = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_HOOK);
+
+ if (HooklParam)
+ {
_SEH2_TRY
{
- ProbeForRead((PVOID)lParam,
- sizeof(MOUSEHOOKSTRUCTEX),
- 1);
- RtlCopyMemory( &Mouse,
- (PVOID)lParam,
- sizeof(MOUSEHOOKSTRUCTEX));
+ ProbeForRead((PVOID)Debug.lParam,
+ Size,
+ 1);
+
+ RtlCopyMemory(HooklParam,
+ (PVOID)Debug.lParam,
+ Size);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- BadChk = TRUE;
+ BadChk = TRUE;
}
_SEH2_END;
+
if (BadChk)
{
- DPRINT1("HOOK WH_MOUSE read from lParam ERROR!\n");
+ DPRINT1("HOOK WH_DEBUG read from Debug.lParam ERROR!\n");
+ ExFreePool(HooklParam);
+ return lResult;
}
- }
- if (!BadChk)
- {
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Mouse);
- }
- return lResult;
- }
-
- switch(Hook->HookId)
- {
- case WH_MOUSE_LL:
- {
- MSLLHOOKSTRUCT Mouse;
- if (lParam)
- {
+ }
+
+ if (HooklParam) Debug.lParam = (LPARAM)HooklParam;
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Debug);
+ if (HooklParam) ExFreePoolWithTag(HooklParam, TAG_HOOK);
+
+ return lResult;
+ }
+
+ /*
+ Called from user space via CallNextHook.
+ */
+ LRESULT
+ FASTCALL
+ UserCallNextHookEx(PHOOK Hook,
+ int Code,
+ WPARAM wParam,
+ LPARAM lParam,
+ BOOL Ansi)
+ {
+ LRESULT lResult = 0;
+ BOOL BadChk = FALSE;
+
+ /* Handle this one first. */
+ if ((Hook->HookId == WH_MOUSE) ||
+ (Hook->HookId == WH_CBT && Code == HCBT_CLICKSKIPPED))
+ {
+ MOUSEHOOKSTRUCTEX Mouse;
+ if (lParam)
+ {
_SEH2_TRY
{
ProbeForRead((PVOID)lParam,
- sizeof(MSLLHOOKSTRUCT),
- 1);
- RtlCopyMemory( &Mouse,
- (PVOID)lParam,
- sizeof(MSLLHOOKSTRUCT));
+ sizeof(MOUSEHOOKSTRUCTEX),
+ 1);
+
+ RtlCopyMemory(&Mouse,
+ (PVOID)lParam,
+ sizeof(MOUSEHOOKSTRUCTEX));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- BadChk = TRUE;
+ BadChk = TRUE;
}
_SEH2_END;
+
if (BadChk)
{
- DPRINT1("HOOK WH_MOUSE_LL read from lParam ERROR!\n");
+ DPRINT1("HOOK WH_MOUSE read from lParam ERROR!\n");
}
- }
- if (!BadChk)
- {
+ }
+
+ if (!BadChk)
+ {
lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Mouse);
- }
- break;
- }
-
- case WH_KEYBOARD_LL:
- {
- KBDLLHOOKSTRUCT Keyboard;
- if (lParam)
- {
- _SEH2_TRY
- {
- ProbeForRead((PVOID)lParam,
- sizeof(KBDLLHOOKSTRUCT),
- 1);
- RtlCopyMemory( &Keyboard,
- (PVOID)lParam,
- sizeof(KBDLLHOOKSTRUCT));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
+ }
+
+ return lResult;
+ }
+
+ switch(Hook->HookId)
+ {
+ case WH_MOUSE_LL:
+ {
+ MSLLHOOKSTRUCT Mouse;
+
+ if (lParam)
{
- DPRINT1("HOOK WH_KEYBORD_LL read from lParam ERROR!\n");
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(MSLLHOOKSTRUCT),
+ 1);
+
+ RtlCopyMemory(&Mouse,
+ (PVOID)lParam,
+ sizeof(MSLLHOOKSTRUCT));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_MOUSE_LL read from lParam ERROR!\n");
+ }
}
- }
- if (!BadChk)
- {
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Keyboard);
- }
- break;
- }
-
- case WH_MSGFILTER:
- case WH_SYSMSGFILTER:
- case WH_GETMESSAGE:
- {
- MSG Msg;
- if (lParam)
- {
- _SEH2_TRY
+
+ if (!BadChk)
{
- ProbeForRead((PVOID)lParam,
- sizeof(MSG),
- 1);
- RtlCopyMemory( &Msg,
- (PVOID)lParam,
- sizeof(MSG));
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Mouse);
}
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ break;
+ }
+
+ case WH_KEYBOARD_LL:
+ {
+ KBDLLHOOKSTRUCT Keyboard;
+
+ if (lParam)
{
- BadChk = TRUE;
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(KBDLLHOOKSTRUCT),
+ 1);
+
+ RtlCopyMemory(&Keyboard,
+ (PVOID)lParam,
+ sizeof(KBDLLHOOKSTRUCT));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_KEYBORD_LL read from lParam ERROR!\n");
+ }
}
- _SEH2_END;
- if (BadChk)
+
+ if (!BadChk)
{
- DPRINT1("HOOK WH_XMESSAGEX read from lParam ERROR!\n");
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Keyboard);
}
- }
- if (!BadChk)
- {
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Msg);
- if (lParam && (Hook->HookId == WH_GETMESSAGE))
+ break;
+ }
+
+ case WH_MSGFILTER:
+ case WH_SYSMSGFILTER:
+ case WH_GETMESSAGE:
+ {
+ MSG Msg;
+
+ if (lParam)
{
- _SEH2_TRY
- {
- ProbeForWrite((PVOID)lParam,
- sizeof(MSG),
- 1);
- RtlCopyMemory((PVOID)lParam,
- &Msg,
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(MSG),
+ 1);
+
+ RtlCopyMemory(&Msg,
+ (PVOID)lParam,
sizeof(MSG));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK WH_GETMESSAGE write to lParam ERROR!\n");
- }
- }
- }
- break;
- }
-
- case WH_CBT:
- DPRINT1("HOOK WH_CBT!\n");
- switch (Code)
- {
- case HCBT_CREATEWND: // Use Ansi.
- DPRINT1("HOOK HCBT_CREATEWND\n");
- // lResult = co_HOOK_CallHookNext(Hook, Code, wParam, lParam);
- break;
-
- case HCBT_MOVESIZE:
- {
- RECTL rt;
- DPRINT1("HOOK HCBT_MOVESIZE\n");
- if (lParam)
- {
- _SEH2_TRY
- {
- ProbeForRead((PVOID)lParam,
- sizeof(RECT),
- 1);
- RtlCopyMemory( &rt,
- (PVOID)lParam,
- sizeof(RECT));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK HCBT_MOVESIZE read from lParam ERROR!\n");
- }
- }
- if (!BadChk)
- {
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&rt);
- }
- break;
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_XMESSAGEX read from lParam ERROR!\n");
+ }
}
- case HCBT_ACTIVATE:
+ if (!BadChk)
{
- CBTACTIVATESTRUCT CbAs;
- DPRINT1("HOOK HCBT_ACTIVATE\n");
- if (lParam)
- {
- _SEH2_TRY
- {
- ProbeForRead((PVOID)lParam,
- sizeof(CBTACTIVATESTRUCT),
- 1);
- RtlCopyMemory( &CbAs,
- (PVOID)lParam,
- sizeof(CBTACTIVATESTRUCT));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK HCBT_ACTIVATE read from lParam ERROR!\n");
- }
- }
- if (!BadChk)
- {
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&CbAs);
- }
- break;
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&Msg);
+
+ if (lParam && (Hook->HookId == WH_GETMESSAGE))
+ {
+ _SEH2_TRY
+ {
+ ProbeForWrite((PVOID)lParam,
+ sizeof(MSG),
+ 1);
+
+ RtlCopyMemory((PVOID)lParam,
+ &Msg,
+ sizeof(MSG));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_GETMESSAGE write to lParam ERROR!\n");
+ }
+ }
}
- /*
- The rest just use default.
- */
- default:
- DPRINT1("HOOK HCBT_ %d\n",Code);
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, lParam);
- break;
- }
- break;
-
- case WH_JOURNALPLAYBACK:
- case WH_JOURNALRECORD:
- {
- EVENTMSG EventMsg;
- if (lParam)
- {
- _SEH2_TRY
+ break;
+ }
+
+ case WH_CBT:
+ DPRINT1("HOOK WH_CBT!\n");
+ switch (Code)
{
- ProbeForRead((PVOID)lParam,
- sizeof(EVENTMSG),
+ case HCBT_CREATEWND: /* Use Ansi. */
+ DPRINT1("HOOK HCBT_CREATEWND\n");
+ /* lResult = co_HOOK_CallHookNext(Hook, Code, wParam, lParam); */
+ break;
+
+ case HCBT_MOVESIZE:
+ {
+ RECTL rt;
+
+ DPRINT1("HOOK HCBT_MOVESIZE\n");
+
+ if (lParam)
+ {
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(RECT),
1);
- RtlCopyMemory( &EventMsg,
- (PVOID)lParam,
- sizeof(EVENTMSG));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK WH_JOURNAL read from lParam ERROR!\n");
+
+ RtlCopyMemory(&rt,
+ (PVOID)lParam,
+ sizeof(RECT));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK HCBT_MOVESIZE read from lParam ERROR!\n");
+ }
+ }
+
+ if (!BadChk)
+ {
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&rt);
+ }
+ break;
+ }
+
+ case HCBT_ACTIVATE:
+ {
+ CBTACTIVATESTRUCT CbAs;
+
+ DPRINT1("HOOK HCBT_ACTIVATE\n");
+ if (lParam)
+ {
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(CBTACTIVATESTRUCT),
+ 1);
+
+ RtlCopyMemory(&CbAs,
+ (PVOID)lParam,
+ sizeof(CBTACTIVATESTRUCT));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK HCBT_ACTIVATE read from lParam ERROR!\n");
+ }
+ }
+
+ if (!BadChk)
+ {
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)&CbAs);
+ }
+ break;
+ }
+
+ /* The rest just use default. */
+ default:
+ DPRINT1("HOOK HCBT_ %d\n",Code);
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, lParam);
+ break;
}
- }
- if (!BadChk)
- {
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)(lParam ? &EventMsg : NULL));
+ break;
+
+ case WH_JOURNALPLAYBACK:
+ case WH_JOURNALRECORD:
+ {
+ EVENTMSG EventMsg;
+
if (lParam)
{
- _SEH2_TRY
- {
- ProbeForWrite((PVOID)lParam,
- sizeof(EVENTMSG),
- 1);
- RtlCopyMemory((PVOID)lParam,
- &EventMsg,
+ _SEH2_TRY
+ {
+ ProbeForRead((PVOID)lParam,
+ sizeof(EVENTMSG),
+ 1);
+
+ RtlCopyMemory(&EventMsg,
+ (PVOID)lParam,
sizeof(EVENTMSG));
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- BadChk = TRUE;
- }
- _SEH2_END;
- if (BadChk)
- {
- DPRINT1("HOOK WH_JOURNAL write to lParam ERROR!\n");
- }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_JOURNAL read from lParam ERROR!\n");
+ }
}
- }
- break;
- }
- case WH_DEBUG:
- lResult = IntCallDebugHook(Hook, Code, wParam, lParam);
- break;
- /*
- Default the rest like, WH_FOREGROUNDIDLE, WH_KEYBOARD and WH_SHELL.
- */
- case WH_FOREGROUNDIDLE:
- case WH_KEYBOARD:
- case WH_SHELL:
- lResult = co_HOOK_CallHookNext(Hook, Code, wParam, lParam);
- break;
-
- default:
- DPRINT1("Unsupported HOOK Id -> %d\n",Hook->HookId);
- break;
- }
- return lResult;
+ if (!BadChk)
+ {
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, (LPARAM)(lParam ? &EventMsg : NULL));
+
+ if (lParam)
+ {
+ _SEH2_TRY
+ {
+ ProbeForWrite((PVOID)lParam,
+ sizeof(EVENTMSG),
+ 1);
+
+ RtlCopyMemory((PVOID)lParam,
+ &EventMsg,
+ sizeof(EVENTMSG));
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ BadChk = TRUE;
+ }
+ _SEH2_END;
+
+ if (BadChk)
+ {
+ DPRINT1("HOOK WH_JOURNAL write to lParam ERROR!\n");
+ }
+ }
+ }
+ break;
+ }
+
+ case WH_DEBUG:
+ lResult = IntCallDebugHook(Hook, Code, wParam, lParam);
+ break;
+
+ /*
+ * Default the rest like, WH_FOREGROUNDIDLE, WH_KEYBOARD and WH_SHELL.
+ */
+ case WH_FOREGROUNDIDLE:
+ case WH_KEYBOARD:
+ case WH_SHELL:
+ lResult = co_HOOK_CallHookNext(Hook, Code, wParam, lParam);
+ break;
+
+ default:
+ DPRINT1("Unsupported HOOK Id -> %d\n",Hook->HookId);
+ break;
+ }
+
+ return lResult;
}
LRESULT
APIENTRY
- NtUserCallNextHookEx(
- int Code,
- WPARAM wParam,
- LPARAM lParam,
- BOOL Ansi)
+ NtUserCallNextHookEx(int Code,
+ WPARAM wParam,
+ LPARAM lParam,
+ BOOL Ansi)
{
- PHOOK HookObj, NextObj;
- PCLIENTINFO ClientInfo;
- PWINSTATION_OBJECT WinStaObj;
- NTSTATUS Status;
- DECLARE_RETURN(LRESULT);
+ PHOOK HookObj, NextObj;
+ PCLIENTINFO ClientInfo;
+ PWINSTATION_OBJECT WinStaObj;
+ NTSTATUS Status;
+ DECLARE_RETURN(LRESULT);
- DPRINT("Enter NtUserCallNextHookEx\n");
- UserEnterExclusive();
+ DPRINT("Enter NtUserCallNextHookEx\n");
+ UserEnterExclusive();
- Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
- KernelMode,
- 0,
- &WinStaObj);
- if (!NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- RETURN( 0);
- }
+ Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
+ KernelMode,
+ 0,
+ &WinStaObj);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ RETURN( 0);
+ }
- ObDereferenceObject(WinStaObj);
+ ObDereferenceObject(WinStaObj);
- ClientInfo = GetWin32ClientInfo();
+ ClientInfo = GetWin32ClientInfo();
- if (!ClientInfo) RETURN( 0);
+ if (!ClientInfo) RETURN( 0);
- HookObj = ClientInfo->phkCurrent;
+ HookObj = ClientInfo->phkCurrent;
- if (!HookObj) RETURN( 0);
+ if (!HookObj) RETURN( 0);
- UserReferenceObject(HookObj);
+ UserReferenceObject(HookObj);
- Ansi = HookObj->Ansi;
+ Ansi = HookObj->Ansi;
- if (NULL != HookObj->Thread && (HookObj->Thread != PsGetCurrentThread()))
- {
- DPRINT1("Thread mismatch\n");
- UserDereferenceObject(HookObj);
- SetLastWin32Error(ERROR_INVALID_HANDLE);
- RETURN( 0);
- }
+ if (NULL != HookObj->Thread && (HookObj->Thread != PsGetCurrentThread()))
+ {
+ DPRINT1("Thread mismatch\n");
+ UserDereferenceObject(HookObj);
+ SetLastWin32Error(ERROR_INVALID_HANDLE);
+ RETURN( 0);
+ }
- NextObj = IntGetNextHook(HookObj);
- ClientInfo->phkCurrent = NextObj; // Preset next hook from list.
- UserCallNextHookEx( HookObj, Code, wParam, lParam, Ansi);
- UserDereferenceObject(HookObj);
+ NextObj = IntGetNextHook(HookObj);
+ ClientInfo->phkCurrent = NextObj; /* Preset next hook from list. */
+ UserCallNextHookEx( HookObj, Code, wParam, lParam, Ansi);
+ UserDereferenceObject(HookObj);
- RETURN( (LRESULT)NextObj);
+ RETURN( (LRESULT)NextObj);
CLEANUP:
- DPRINT("Leave NtUserCallNextHookEx, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
+ DPRINT("Leave NtUserCallNextHookEx, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
HHOOK
APIENTRY
- NtUserSetWindowsHookAW(
- int idHook,
- HOOKPROC lpfn,
- BOOL Ansi)
+ NtUserSetWindowsHookAW(int idHook,
+ HOOKPROC lpfn,
+ BOOL Ansi)
{
- UNICODE_STRING USModuleName;
- RtlInitUnicodeString(&USModuleName, NULL);
- return NtUserSetWindowsHookEx(NULL, &USModuleName, 0, idHook, lpfn, Ansi);
+ UNICODE_STRING USModuleName;
+
+ RtlInitUnicodeString(&USModuleName, NULL);
+
+ return NtUserSetWindowsHookEx(NULL, &USModuleName, 0, idHook, lpfn, Ansi);
}
HHOOK
APIENTRY
- NtUserSetWindowsHookEx(
- HINSTANCE Mod,
- PUNICODE_STRING UnsafeModuleName,
- DWORD ThreadId,
- int HookId,
- HOOKPROC HookProc,
- BOOL Ansi)
+ NtUserSetWindowsHookEx(HINSTANCE Mod,
+ PUNICODE_STRING UnsafeModuleName,
+ DWORD ThreadId,
+ int HookId,
+ HOOKPROC HookProc,
+ BOOL Ansi)
{
- PWINSTATION_OBJECT WinStaObj;
- PCLIENTINFO ClientInfo;
- BOOLEAN Global;
- PETHREAD Thread;
- PHOOK Hook;
- UNICODE_STRING ModuleName;
- NTSTATUS Status;
- HHOOK Handle;
- BOOLEAN ThreadReferenced = FALSE;
- DECLARE_RETURN(HHOOK);
-
- DPRINT("Enter NtUserSetWindowsHookEx\n");
- UserEnterExclusive();
-
- if (HookId < WH_MINHOOK || WH_MAXHOOK < HookId )
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( NULL);
- }
-
- if (!HookProc)
- {
- SetLastWin32Error(ERROR_INVALID_FILTER_PROC);
- RETURN( NULL);
- }
-
- ClientInfo = GetWin32ClientInfo();
-
- if (ThreadId) /* thread-local hook */
- {
- if (HookId == WH_JOURNALRECORD ||
+ PWINSTATION_OBJECT WinStaObj;
+ PCLIENTINFO ClientInfo;
+ BOOLEAN Global;
+ PETHREAD Thread;
+ PHOOK Hook;
+ UNICODE_STRING ModuleName;
+ NTSTATUS Status;
+ HHOOK Handle;
+ BOOLEAN ThreadReferenced = FALSE;
+ DECLARE_RETURN(HHOOK);
+
+ DPRINT("Enter NtUserSetWindowsHookEx\n");
+ UserEnterExclusive();
+
+ if (HookId < WH_MINHOOK || WH_MAXHOOK < HookId )
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ RETURN( NULL);
+ }
+
+ if (!HookProc)
+ {
+ SetLastWin32Error(ERROR_INVALID_FILTER_PROC);
+ RETURN( NULL);
+ }
+
+ ClientInfo = GetWin32ClientInfo();
+
+ if (ThreadId) /* thread-local hook */
+ {
+ if (HookId == WH_JOURNALRECORD ||
HookId == WH_JOURNALPLAYBACK ||
HookId == WH_KEYBOARD_LL ||
HookId == WH_MOUSE_LL ||
HookId == WH_SYSMSGFILTER)
- {
- /* these can only be global */
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( NULL);
- }
- Mod = NULL;
- Global = FALSE;
- if (! NT_SUCCESS(PsLookupThreadByThreadId((HANDLE)(DWORD_PTR)ThreadId, &Thread)))
- {
- DPRINT1("Invalid thread id 0x%x\n", ThreadId);
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( NULL);
- }
- /* Thread was referenced */
- ThreadReferenced = TRUE;
- if (Thread->ThreadsProcess != PsGetCurrentProcess())
- {
- ObDereferenceObject(Thread);
- DPRINT1("Can't specify thread belonging to another process\n");
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( NULL);
- }
- }
- else /* system-global hook */
- {
- if (HookId == WH_KEYBOARD_LL || HookId == WH_MOUSE_LL)
- {
- Mod = NULL;
- Thread = PsGetCurrentThread();
- Status = ObReferenceObjectByPointer(Thread,
- THREAD_ALL_ACCESS,
- PsThreadType,
- KernelMode);
-
- if (! NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- RETURN( (HANDLE) NULL);
- }
-
- /* Thread was referenced */
- ThreadReferenced = TRUE;
- }
- else if (NULL == Mod)
- {
- SetLastWin32Error(ERROR_HOOK_NEEDS_HMOD);
- RETURN( NULL);
- }
- else
- {
- Thread = NULL;
- }
- Global = TRUE;
- }
-
- if ( ( Global && (HookId != WH_KEYBOARD_LL && HookId != WH_MOUSE_LL) ) ||
+ {
+ /* these can only be global */
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ RETURN( NULL);
+ }
+
+ Mod = NULL;
+ Global = FALSE;
+
+ if (!NT_SUCCESS(PsLookupThreadByThreadId((HANDLE) ThreadId, &Thread)))
+ {
+ DPRINT1("Invalid thread id 0x%x\n", ThreadId);
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ RETURN( NULL);
+ }
+
+ /* Thread was referenced */
+ ThreadReferenced = TRUE;
+ if (Thread->ThreadsProcess != PsGetCurrentProcess())
+ {
+ ObDereferenceObject(Thread);
+ DPRINT1("Can't specify thread belonging to another process\n");
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ RETURN( NULL);
+ }
+ }
+ else /* system-global hook */
+ {
+ if (HookId == WH_KEYBOARD_LL || HookId == WH_MOUSE_LL)
+ {
+ Mod = NULL;
+ Thread = PsGetCurrentThread();
+
+ Status = ObReferenceObjectByPointer(Thread,
+ THREAD_ALL_ACCESS,
+ PsThreadType,
+ KernelMode);
+
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ RETURN( (HANDLE) NULL);
+ }
+
+ /* Thread was referenced */
+ ThreadReferenced = TRUE;
+ }
+ else if (NULL == Mod)
+ {
+ SetLastWin32Error(ERROR_HOOK_NEEDS_HMOD);
+ RETURN( NULL);
+ }
+ else
+ {
+ Thread = NULL;
+ }
+ Global = TRUE;
+ }
+
+ if ((Global && (HookId != WH_KEYBOARD_LL && HookId != WH_MOUSE_LL)) ||
WH_DEBUG == HookId ||
WH_JOURNALPLAYBACK == HookId ||
WH_JOURNALRECORD == HookId)
- {
+ {
#if 0 /* Removed to get winEmbed working again */
- UNIMPLEMENTED
+ UNIMPLEMENTED
#else
- DPRINT1("Not implemented: HookId %d Global %s\n", HookId, Global ? "TRUE" : "FALSE");
+ DPRINT1("Not implemented: HookId %d Global %s\n", HookId, Global ? "TRUE" : "FALSE");
#endif
- /* Dereference thread if needed */
- if (ThreadReferenced) ObDereferenceObject(Thread);
- SetLastWin32Error(ERROR_NOT_SUPPORTED);
- RETURN( NULL);
- }
-
- Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
- KernelMode,
- 0,
- &WinStaObj);
-
- if (! NT_SUCCESS(Status))
- {
- /* Dereference thread if needed */
- if (ThreadReferenced) ObDereferenceObject(Thread);
- SetLastNtError(Status);
- RETURN( (HANDLE) NULL);
- }
-
- Hook = IntAddHook(Thread, HookId, Global, WinStaObj);
- if (NULL == Hook)
- {
- /* Dereference thread if needed */
- if (ThreadReferenced) ObDereferenceObject(Thread);
- ObDereferenceObject(WinStaObj);
- RETURN( NULL);
- }
-
- /* Let IntFreeHook now that this thread needs a dereference */
- if (ThreadReferenced)
- {
- Hook->Flags |= HOOK_THREAD_REFERENCED;
- }
-
- if (NULL != Mod)
- {
- Status = MmCopyFromCaller(&ModuleName, UnsafeModuleName, sizeof(UNICODE_STRING));
- if (! NT_SUCCESS(Status))
- {
- UserDereferenceObject(Hook);
- IntRemoveHook(Hook, WinStaObj, FALSE);
- ObDereferenceObject(WinStaObj);
- SetLastNtError(Status);
- RETURN( NULL);
- }
- Hook->ModuleName.Buffer = ExAllocatePoolWithTag(PagedPool,
- ModuleName.MaximumLength,
- TAG_HOOK);
- if (NULL == Hook->ModuleName.Buffer)
- {
- UserDereferenceObject(Hook);
- IntRemoveHook(Hook, WinStaObj, FALSE);
- ObDereferenceObject(WinStaObj);
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
- RETURN( NULL);
- }
- Hook->ModuleName.MaximumLength = ModuleName.MaximumLength;
- Status = MmCopyFromCaller(Hook->ModuleName.Buffer,
- ModuleName.Buffer,
- ModuleName.MaximumLength);
- if (! NT_SUCCESS(Status))
- {
- ExFreePoolWithTag(Hook->ModuleName.Buffer, TAG_HOOK);
- UserDereferenceObject(Hook);
- IntRemoveHook(Hook, WinStaObj, FALSE);
- ObDereferenceObject(WinStaObj);
- SetLastNtError(Status);
- RETURN( NULL);
- }
- Hook->ModuleName.Length = ModuleName.Length;
- /* make proc relative to the module base */
- Hook->Proc = (void *)((char *)HookProc - (char *)Mod);
- }
- else
- Hook->Proc = HookProc;
-
- Hook->Ansi = Ansi;
- Handle = Hook->Self;
-
- // Clear the client threads next hook.
- ClientInfo->phkCurrent = 0;
-
- UserDereferenceObject(Hook);
-
- ObDereferenceObject(WinStaObj);
-
- RETURN( Handle);
+ /* Dereference thread if needed */
+ if (ThreadReferenced) ObDereferenceObject(Thread);
+ SetLastWin32Error(ERROR_NOT_SUPPORTED);
+ RETURN( NULL);
+ }
+
+ Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
+ KernelMode,
+ 0,
+ &WinStaObj);
+
+ if (!NT_SUCCESS(Status))
+ {
+ /* Dereference thread if needed */
+ if (ThreadReferenced) ObDereferenceObject(Thread);
+ SetLastNtError(Status);
+ RETURN( (HANDLE) NULL);
+ }
+
+ Hook = IntAddHook(Thread, HookId, Global, WinStaObj);
+ if (NULL == Hook)
+ {
+ /* Dereference thread if needed */
+ if (ThreadReferenced) ObDereferenceObject(Thread);
+ ObDereferenceObject(WinStaObj);
+ RETURN( NULL);
+ }
+
+ /* Let IntFreeHook now that this thread needs a dereference */
+ if (ThreadReferenced)
+ {
+ Hook->Flags |= HOOK_THREAD_REFERENCED;
+ }
+
+ if (NULL != Mod)
+ {
+ Status = MmCopyFromCaller(&ModuleName, UnsafeModuleName, sizeof(UNICODE_STRING));
+ if (!NT_SUCCESS(Status))
+ {
+ UserDereferenceObject(Hook);
+ IntRemoveHook(Hook, WinStaObj, FALSE);
+ ObDereferenceObject(WinStaObj);
+ SetLastNtError(Status);
+ RETURN( NULL);
+ }
+
+ Hook->ModuleName.Buffer = ExAllocatePoolWithTag(PagedPool,
+ ModuleName.MaximumLength,
+ TAG_HOOK);
+ if (NULL == Hook->ModuleName.Buffer)
+ {
+ UserDereferenceObject(Hook);
+ IntRemoveHook(Hook, WinStaObj, FALSE);
+ ObDereferenceObject(WinStaObj);
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ RETURN( NULL);
+ }
+
+ Hook->ModuleName.MaximumLength = ModuleName.MaximumLength;
+ Status = MmCopyFromCaller(Hook->ModuleName.Buffer,
+ ModuleName.Buffer,
+ ModuleName.MaximumLength);
+ if (!NT_SUCCESS(Status))
+ {
+ ExFreePoolWithTag(Hook->ModuleName.Buffer, TAG_HOOK);
+ UserDereferenceObject(Hook);
+ IntRemoveHook(Hook, WinStaObj, FALSE);
+ ObDereferenceObject(WinStaObj);
+ SetLastNtError(Status);
+ RETURN( NULL);
+ }
+
+ Hook->ModuleName.Length = ModuleName.Length;
+ /* make proc relative to the module base */
+ Hook->Proc = (void *)((char *)HookProc - (char *)Mod);
+ }
+ else
+ Hook->Proc = HookProc;
+
+ Hook->Ansi = Ansi;
+ Handle = Hook->Self;
+
+ /* Clear the client threads next hook. */
+ ClientInfo->phkCurrent = 0;
+
+ UserDereferenceObject(Hook);
+
+ ObDereferenceObject(WinStaObj);
+
+ RETURN( Handle);
CLEANUP:
- DPRINT("Leave NtUserSetWindowsHookEx, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
+ DPRINT("Leave NtUserSetWindowsHookEx, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
BOOL
APIENTRY
- NtUserUnhookWindowsHookEx(
- HHOOK Hook)
+ NtUserUnhookWindowsHookEx(HHOOK Hook)
{
- PWINSTATION_OBJECT WinStaObj;
- PHOOK HookObj;
- NTSTATUS Status;
- DECLARE_RETURN(BOOL);
-
- DPRINT("Enter NtUserUnhookWindowsHookEx\n");
- UserEnterExclusive();
-
- Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
- KernelMode,
- 0,
- &WinStaObj);
-
- if (! NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- RETURN( FALSE);
- }
-
- // Status = UserReferenceObjectByHandle(gHandleTable, Hook,
- // otHookProc, (PVOID *) &HookObj);
- if (!(HookObj = IntGetHookObject(Hook)))
- {
- DPRINT1("Invalid handle passed to NtUserUnhookWindowsHookEx\n");
- ObDereferenceObject(WinStaObj);
- // SetLastNtError(Status);
- RETURN( FALSE);
- }
- ASSERT(Hook == HookObj->Self);
-
- IntRemoveHook(HookObj, WinStaObj, FALSE);
-
- UserDereferenceObject(HookObj);
- ObDereferenceObject(WinStaObj);
-
- RETURN( TRUE);
+ PWINSTATION_OBJECT WinStaObj;
+ PHOOK HookObj;
+ NTSTATUS Status;
+ DECLARE_RETURN(BOOL);
+
+ DPRINT("Enter NtUserUnhookWindowsHookEx\n");
+ UserEnterExclusive();
+
+ Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
+ KernelMode,
+ 0,
+ &WinStaObj);
+
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ RETURN( FALSE);
+ }
+
+ /* Status = UserReferenceObjectByHandle(gHandleTable, Hook,
+ otHookProc, (PVOID *) &HookObj); */
+ if (!(HookObj = IntGetHookObject(Hook)))
+ {
+ DPRINT1("Invalid handle passed to NtUserUnhookWindowsHookEx\n");
+ ObDereferenceObject(WinStaObj);
+ /* SetLastNtError(Status); */
+ RETURN( FALSE);
+ }
+
+ ASSERT(Hook == HookObj->Self);
+
+ IntRemoveHook(HookObj, WinStaObj, FALSE);
+
+ UserDereferenceObject(HookObj);
+ ObDereferenceObject(WinStaObj);
+
+ RETURN( TRUE);
CLEANUP:
- DPRINT("Leave NtUserUnhookWindowsHookEx, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
+ DPRINT("Leave NtUserUnhookWindowsHookEx, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
-
+
/* EOF */
/*
* @unimplemented
*/
-DWORD APIENTRY
+DWORD_PTR APIENTRY
NtUserGetThreadState(
DWORD Routine)
{
- DECLARE_RETURN(DWORD);
+ DWORD_PTR ret = 0;
DPRINT("Enter NtUserGetThreadState\n");
if (Routine != THREADSTATE_GETTHREADINFO)
{
case THREADSTATE_GETTHREADINFO:
GetW32ThreadInfo();
- RETURN(0);
-
+ break;
case THREADSTATE_FOCUSWINDOW:
- RETURN( (DWORD)IntGetThreadFocusWindow());
+ ret = (DWORD_PTR)IntGetThreadFocusWindow();
+ break;
case THREADSTATE_CAPTUREWINDOW:
/* FIXME should use UserEnterShared */
- RETURN( (DWORD)IntGetCapture());
+ ret = (DWORD_PTR)IntGetCapture();
+ break;
case THREADSTATE_PROGMANWINDOW:
- RETURN( (DWORD)GetW32ThreadInfo()->pDeskInfo->hProgmanWindow);
+ ret = (DWORD_PTR)GetW32ThreadInfo()->pDeskInfo->hProgmanWindow;
+ break;
case THREADSTATE_TASKMANWINDOW:
- RETURN( (DWORD)GetW32ThreadInfo()->pDeskInfo->hTaskManWindow);
+ ret = (DWORD_PTR)GetW32ThreadInfo()->pDeskInfo->hTaskManWindow;
+ break;
case THREADSTATE_ACTIVEWINDOW:
- RETURN ( (DWORD)UserGetActiveWindow());
+ ret = (DWORD_PTR)UserGetActiveWindow();
+ break;
case THREADSTATE_INSENDMESSAGE:
{
- DWORD Ret = ISMEX_NOSEND;
PUSER_MESSAGE_QUEUE MessageQueue =
((PTHREADINFO)PsGetCurrentThreadWin32Thread())->MessageQueue;
DPRINT1("THREADSTATE_INSENDMESSAGE\n");
+ ret = ISMEX_NOSEND;
if (!IsListEmpty(&MessageQueue->SentMessagesListHead))
{
- Ret = ISMEX_SEND;
+ ret = ISMEX_SEND;
}
else if (!IsListEmpty(&MessageQueue->NotifyMessagesListHead))
{
/* FIXME Need to set message flag when in callback mode with notify */
- Ret = ISMEX_NOTIFY;
+ ret = ISMEX_NOTIFY;
}
/* FIXME Need to set message flag if replied to or ReplyMessage */
- RETURN( Ret);
+ break;
}
case THREADSTATE_GETMESSAGETIME:
/* FIXME Needs more work! */
- RETURN( ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->timeLast);
+ ret = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->timeLast;
+ break;
case THREADSTATE_GETINPUTSTATE:
- RETURN( HIWORD(IntGetQueueStatus(FALSE)) & (QS_KEY | QS_MOUSEBUTTON));
+ ret = HIWORD(IntGetQueueStatus(FALSE)) & (QS_KEY | QS_MOUSEBUTTON);
+ break;
}
- RETURN( 0);
-CLEANUP:
- DPRINT("Leave NtUserGetThreadState, ret=%i\n",_ret_);
+ DPRINT("Leave NtUserGetThreadState, ret=%i\n", ret);
UserLeave();
- END_CLEANUP;
+
+ return ret;
}
if(idThread)
{
- Status = PsLookupThreadByThreadId((HANDLE)idThread, &Thread);
+ Status = PsLookupThreadByThreadId((HANDLE)(DWORD_PTR)idThread, &Thread);
if(!NT_SUCCESS(Status))
{
SetLastWin32Error(ERROR_ACCESS_DENIED);
PPROCESSINFO
GetW32ProcessInfo(VOID)
{
- PPROCESSINFO pi;
- PW32PROCESS W32Process = PsGetCurrentProcessWin32Process();
-
- if (W32Process == NULL)
- {
- /* FIXME - temporary hack for system threads... */
- return NULL;
- }
-
- if (W32Process->ProcessInfo == NULL)
- {
- pi = UserHeapAlloc(sizeof(PROCESSINFO));
- if (pi != NULL)
- {
- RtlZeroMemory(pi,
- sizeof(PROCESSINFO));
-
- /* initialize it */
- pi->UserHandleTable = gHandleTable;
- pi->hUserHeap = W32Process->HeapMappings.KernelMapping;
- pi->UserHeapDelta = (ULONG_PTR)W32Process->HeapMappings.KernelMapping -
- (ULONG_PTR)W32Process->HeapMappings.UserMapping;
-
- if (InterlockedCompareExchangePointer((PVOID*)&W32Process->ProcessInfo,
- pi,
- NULL) != NULL)
- {
- UserHeapFree(pi);
- }
- }
- else
- {
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
- }
- }
-
- return W32Process->ProcessInfo;
+ return (PPROCESSINFO)PsGetCurrentProcessWin32Process();
}
PW32THREADINFO
&& !(Wnd->ExStyle & WS_EX_TOOLWINDOW);
}
else
- HasIcon = (BOOL) hIcon;
+ HasIcon = (hIcon != 0);
IconWidth = UserGetSystemMetrics(SM_CXSIZE) + Padding;
ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
if (str != NULL)
- {
- SafeStr = ProbeForReadUnicodeString(str);
- if (SafeStr.Length != 0)
- {
- ProbeForRead(SafeStr.Buffer,
- SafeStr.Length,
- sizeof(WCHAR));
- }
- Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
+ {
+ SafeStr = ProbeForReadUnicodeString(str);
+ if (SafeStr.Length != 0)
+ {
+ ProbeForRead( SafeStr.Buffer,
+ SafeStr.Length,
+ sizeof(WCHAR));
+ }
+ Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
}
- else
- Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
+ else
+ Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
{ HostFalse, "", "", "" }, // MessageHeader
};
+ static std::string mscPath;
+ static std::string mslinkPath;
+
string
MingwBackend::GetFullPath ( const FileLocation& file ) const
{
MingwBackend::GenerateGlobalVariables () const
{
fputs ( "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)rules.mak\n", fMakefile );
+ fprintf ( fMakefile, "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)linkers$(SEP)%s.mak\n", ProjectNode.GetLinkerSet ().c_str () );
+ fprintf ( fMakefile, "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)compilers$(SEP)%s.mak\n", ProjectNode.GetCompilerSet ().c_str () );
+
+ if ( mscPath.length() )
+ fprintf ( fMakefile, "export RBUILD_CL_PATH=%s\n", mscPath.c_str () );
+
+ if ( mslinkPath.length() )
+ fprintf ( fMakefile, "export RBUILD_LINK_PATH=%s\n", mslinkPath.c_str () );
if ( configuration.Dependencies == FullDependencies )
{
GenerateGlobalProperties ( "=", ProjectNode.non_if_data );
- fprintf ( fMakefile, "PROJECT_CFLAGS += -Wall\n" );
- fprintf ( fMakefile, "PROJECT_CXXFLAGS += -Wall\n" );
- fprintf ( fMakefile, "ifneq ($(OARCH),)\n" );
- fprintf ( fMakefile, "PROJECT_CFLAGS += -march=$(OARCH)\n" );
- fprintf ( fMakefile, "PROJECT_CXXFLAGS += -march=$(OARCH)\n" );
- fprintf ( fMakefile, "endif\n" );
- fprintf ( fMakefile, "ifneq ($(TUNE),)\n" );
- fprintf ( fMakefile, "PROJECT_CFLAGS += -mtune=$(TUNE)\n" );
- fprintf ( fMakefile, "PROJECT_CXXFLAGS += -mtune=$(TUNE)\n" );
- fprintf ( fMakefile, "endif\n" );
-
- fprintf ( fMakefile, "PROJECT_CFLAGS += -g%s\n", Environment::GetArch() == "amd64" ? "dwarf-2" : "stabs+" );
- fprintf ( fMakefile, "PROJECT_CXXFLAGS += -g%s\n", Environment::GetArch() == "amd64" ? "dwarf-2" : "stabs+" );
- fprintf ( fMakefile, "PROJECT_ASFLAGS += -g%s\n", Environment::GetArch() == "amd64" ? "dwarf-2" : "stabs+" );
-
- MingwModuleHandler::GenerateParameters ( "PROJECT", "+=", ProjectNode.non_if_data );
- MingwModuleHandler::GenerateParameters ( "PROJECT_HOST", "+=", ProjectNode.host_non_if_data );
-
- if ( usePipe )
+ if ( ProjectNode.configuration.Compiler == GnuGcc )
{
- fprintf ( fMakefile, "PROJECT_CFLAGS += -pipe\n" );
- fprintf ( fMakefile, "PROJECT_CXXFLAGS += -pipe\n" );
- fprintf ( fMakefile, "PROJECT_ASFLAGS += -pipe\n" );
+ fprintf ( fMakefile, "PROJECT_CFLAGS += -Wall\n" );
+ fprintf ( fMakefile, "PROJECT_CXXFLAGS += -Wall\n" );
+ fprintf ( fMakefile, "ifneq ($(OARCH),)\n" );
+ fprintf ( fMakefile, "PROJECT_CFLAGS += -march=$(OARCH)\n" );
+ fprintf ( fMakefile, "PROJECT_CXXFLAGS += -march=$(OARCH)\n" );
+ fprintf ( fMakefile, "endif\n" );
+ fprintf ( fMakefile, "ifneq ($(TUNE),)\n" );
+ fprintf ( fMakefile, "PROJECT_CFLAGS += -mtune=$(TUNE)\n" );
+ fprintf ( fMakefile, "PROJECT_CXXFLAGS += -mtune=$(TUNE)\n" );
+ fprintf ( fMakefile, "endif\n" );
+
+ fprintf ( fMakefile, "PROJECT_CFLAGS += -g%s\n", Environment::GetArch() == "amd64" ? "dwarf-2" : "stabs+" );
+ fprintf ( fMakefile, "PROJECT_CXXFLAGS += -g%s\n", Environment::GetArch() == "amd64" ? "dwarf-2" : "stabs+" );
+ fprintf ( fMakefile, "PROJECT_ASFLAGS += -g%s\n", Environment::GetArch() == "amd64" ? "dwarf-2" : "stabs+" );
+
+ if ( usePipe )
+ {
+ fprintf ( fMakefile, "PROJECT_CFLAGS += -pipe\n" );
+ fprintf ( fMakefile, "PROJECT_CXXFLAGS += -pipe\n" );
+ fprintf ( fMakefile, "PROJECT_ASFLAGS += -pipe\n" );
+ }
+
+ // Would be nice to have our own C++ runtime
+ fputs ( "BUILTIN_CXXINCLUDES+= $(TARGET_CPPFLAGS)\n", fMakefile );
}
// Because RosBE gcc is built to suck
fputs ( "BUILTIN_HOST_CPPINCLUDES+= $(HOST_CFLAGS)\n", fMakefile );
fputs ( "BUILTIN_HOST_CXXINCLUDES+= $(HOST_CPPFLAGS)\n", fMakefile );
- // Would be nice to have our own C++ runtime
- fputs ( "BUILTIN_CXXINCLUDES+= $(TARGET_CPPFLAGS)\n", fMakefile );
+ MingwModuleHandler::GenerateParameters ( "PROJECT", "+=", ProjectNode.non_if_data );
+ MingwModuleHandler::GenerateParameters ( "PROJECT_HOST", "+=", ProjectNode.host_non_if_data );
// TODO: linker flags
fprintf ( fMakefile, "PROJECT_LFLAGS := '$(shell ${TARGET_CC} -print-libgcc-file-name)' %s\n", GenerateProjectLFLAGS ().c_str () );
- fprintf ( fMakefile, "PROJECT_LPPFLAGS := '$(shell ${TARGET_CPP} -print-file-name=libstdc++.a)' '$(shell ${TARGET_CPP} -print-file-name=libgcc.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingw32.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingwex.a)' '$(shell ${TARGET_CPP} -print-file-name=libcoldname.a)'\n" );
+ fprintf ( fMakefile, "PROJECT_LPPFLAGS := '$(shell ${TARGET_CPP} -print-file-name=libstdc++.a)' '$(shell ${TARGET_CPP} -print-file-name=libgcc.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingw32.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingwex.a)'\n" );
/* hack to get libgcc_eh.a, should check mingw version or something */
if (Environment::GetArch() == "amd64")
{
printf ( "Detecting compiler..." );
bool detectedCompiler = false;
- const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
- if ( ROS_PREFIXValue.length () > 0 )
+ bool supportedCompiler = false;
+ string compilerVersion;
+
+ if ( ProjectNode.configuration.Compiler == GnuGcc )
{
- compilerPrefix = ROS_PREFIXValue;
- compilerCommand = compilerPrefix + "-gcc";
- detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
- }
+ const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
+ if ( ROS_PREFIXValue.length () > 0 )
+ {
+ compilerPrefix = ROS_PREFIXValue;
+ compilerCommand = compilerPrefix + "-gcc";
+ detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
+ }
#if defined(WIN32)
- if ( !detectedCompiler )
- {
- compilerPrefix = "";
- compilerCommand = "gcc";
- detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
- }
+ if ( !detectedCompiler )
+ {
+ compilerPrefix = "";
+ compilerCommand = "gcc";
+ detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
+ }
#endif
- if ( !detectedCompiler )
+ if ( !detectedCompiler )
+ {
+ compilerPrefix = "mingw32";
+ compilerCommand = compilerPrefix + "-gcc";
+ detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
+ }
+
+ if ( detectedCompiler )
+ compilerVersion = GetCompilerVersion ( compilerCommand );
+
+ supportedCompiler = IsSupportedCompilerVersion ( compilerVersion );
+ }
+ else if ( ProjectNode.configuration.Compiler == MicrosoftC )
{
- compilerPrefix = "mingw32";
- compilerCommand = compilerPrefix + "-gcc";
- detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
+ compilerCommand = "cl";
+ detectedCompiler = DetectMicrosoftCompiler ( compilerVersion, mscPath );
+ supportedCompiler = true; // TODO
}
if ( detectedCompiler )
{
- string compilerVersion = GetCompilerVersion ( compilerCommand );
- if ( IsSupportedCompilerVersion ( compilerVersion ) )
+ if ( supportedCompiler )
printf ( "detected (%s %s)\n", compilerCommand.c_str (), compilerVersion.c_str() );
else
{
printf ( "Detecting binutils..." );
bool detectedBinutils = false;
- const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
+ bool supportedBinutils = false;
+ string binutilsVersion;
- if ( ROS_PREFIXValue.length () > 0 )
+ if ( ProjectNode.configuration.Linker == GnuLd )
{
- binutilsPrefix = ROS_PREFIXValue;
- binutilsCommand = binutilsPrefix + "-ld";
- manualBinutilsSetting = true;
- detectedBinutils = true;
- }
+ const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
+
+ if ( ROS_PREFIXValue.length () > 0 )
+ {
+ binutilsPrefix = ROS_PREFIXValue;
+ binutilsCommand = binutilsPrefix + "-ld";
+ manualBinutilsSetting = true;
+ detectedBinutils = true;
+ }
#if defined(WIN32)
- if ( !detectedBinutils )
- {
- binutilsPrefix = "";
- binutilsCommand = "ld";
- detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
- }
+ if ( !detectedBinutils )
+ {
+ binutilsPrefix = "";
+ binutilsCommand = "ld";
+ detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
+ }
#endif
- if ( !detectedBinutils )
+ if ( !detectedBinutils )
+ {
+ binutilsPrefix = "mingw32";
+ binutilsCommand = binutilsPrefix + "-ld";
+ detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
+ }
+ if ( detectedBinutils )
+ {
+ binutilsVersion = GetBinutilsVersionDate ( binutilsCommand );
+ supportedBinutils = IsSupportedBinutilsVersion ( binutilsVersion );
+ }
+ }
+ else if ( ProjectNode.configuration.Linker == MicrosoftLink )
{
- binutilsPrefix = "mingw32";
- binutilsCommand = binutilsPrefix + "-ld";
- detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
+ compilerCommand = "link";
+ detectedBinutils = DetectMicrosoftLinker ( binutilsVersion, mslinkPath );
+ supportedBinutils = true; // TODO
}
+
if ( detectedBinutils )
{
- string binutilsVersion = GetBinutilsVersionDate ( binutilsCommand );
- if ( IsSupportedBinutilsVersion ( binutilsVersion ) )
- printf ( "detected (%s %s)\n", binutilsCommand.c_str (), GetBinutilsVersion( binutilsCommand ).c_str() );
+ if ( supportedBinutils )
+ printf ( "detected (%s %s)\n", binutilsCommand.c_str (), binutilsVersion.c_str() );
else
{
printf ( "detected (%s), but with unsupported version (%s)\n",
void
MingwBackend::DetectPipeSupport ()
{
- printf ( "Detecting compiler -pipe support..." );
-
- string pipe_detection = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pipe_detection.c";
- string pipe_detectionObjectFilename = ReplaceExtension ( pipe_detection,
- ".o" );
- string command = ssprintf (
- "%s -pipe -c %s -o %s 1>%s 2>%s",
- FixSeparatorForSystemCommand(compilerCommand).c_str (),
- pipe_detection.c_str (),
- pipe_detectionObjectFilename.c_str (),
- NUL,
- NUL );
- int exitcode = system ( command.c_str () );
- FILE* f = fopen ( pipe_detectionObjectFilename.c_str (), "rb" );
- if ( f )
+ if ( ProjectNode.configuration.Compiler == GnuGcc )
{
- usePipe = (exitcode == 0);
- fclose ( f );
- unlink ( pipe_detectionObjectFilename.c_str () );
+ printf ( "Detecting compiler -pipe support..." );
+
+ string pipe_detection = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pipe_detection.c";
+ string pipe_detectionObjectFilename = ReplaceExtension ( pipe_detection,
+ ".o" );
+ string command = ssprintf (
+ "%s -pipe -c %s -o %s 1>%s 2>%s",
+ FixSeparatorForSystemCommand(compilerCommand).c_str (),
+ pipe_detection.c_str (),
+ pipe_detectionObjectFilename.c_str (),
+ NUL,
+ NUL );
+ int exitcode = system ( command.c_str () );
+ FILE* f = fopen ( pipe_detectionObjectFilename.c_str (), "rb" );
+ if ( f )
+ {
+ usePipe = (exitcode == 0);
+ fclose ( f );
+ unlink ( pipe_detectionObjectFilename.c_str () );
+ }
+ else
+ usePipe = false;
+
+ if ( usePipe )
+ printf ( "detected\n" );
+ else
+ printf ( "not detected\n" );
}
else
usePipe = false;
-
- if ( usePipe )
- printf ( "detected\n" );
- else
- printf ( "not detected\n" );
}
void
{
printf ( "Detecting compiler pre-compiled header support..." );
- if ( configuration.PrecompiledHeadersEnabled )
+ if ( configuration.PrecompiledHeadersEnabled && ProjectNode.configuration.Compiler == GnuGcc )
{
string path = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pch_detection.h";
string cmd = ssprintf (
projects / reactos.git / commitdiff