Ros-diffs August 2005

ros-diffs@reactos.org

23 participants
669 discussions

[sedwards] 17138: enable the ntdll and kernel32 wine tests and watch them fail
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

enable the ntdll and kernel32 wine tests and watch them fail Modified: trunk/reactos/regtests/winetests/directory.xml _____ Modified: trunk/reactos/regtests/winetests/directory.xml --- trunk/reactos/regtests/winetests/directory.xml 2005-08-07 03:14:17 UTC (rev 17137) +++ trunk/reactos/regtests/winetests/directory.xml 2005-08-07 03:15:15 UTC (rev 17138) @@ -8,9 +8,15 @@ <directory name="gdi32"> <xi:include href="gdi32/gdi32_test.xml" /> </directory> +<directory name="kernel32"> + <xi:include href="kernel32/kernel32_test.xml" /> +</directory> <directory name="msvcrt"> <xi:include href="msvcrt/msvcrt_test.xml" /> </directory> +<directory name="ntdll"> + <xi:include href="ntdll/ntdll_test.xml" /> +</directory> <directory name="psapi"> <xi:include href="psapi/psapi_test.xml" /> </directory>

1 0

[sedwards] 17137: added kernel32 wine tests
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

added kernel32 wine tests Added: trunk/reactos/regtests/winetests/kernel32/ Added: trunk/reactos/regtests/winetests/kernel32/alloc.c Added: trunk/reactos/regtests/winetests/kernel32/atom.c Added: trunk/reactos/regtests/winetests/kernel32/change.c Added: trunk/reactos/regtests/winetests/kernel32/codepage.c Added: trunk/reactos/regtests/winetests/kernel32/comm.c Added: trunk/reactos/regtests/winetests/kernel32/console.c Added: trunk/reactos/regtests/winetests/kernel32/directory.c Added: trunk/reactos/regtests/winetests/kernel32/drive.c Added: trunk/reactos/regtests/winetests/kernel32/environ.c Added: trunk/reactos/regtests/winetests/kernel32/file.c Added: trunk/reactos/regtests/winetests/kernel32/format_msg.c Added: trunk/reactos/regtests/winetests/kernel32/heap.c Added: trunk/reactos/regtests/winetests/kernel32/kernel32_test.xml Added: trunk/reactos/regtests/winetests/kernel32/locale.c Added: trunk/reactos/regtests/winetests/kernel32/mailslot.c Added: trunk/reactos/regtests/winetests/kernel32/module.c Added: trunk/reactos/regtests/winetests/kernel32/path.c Added: trunk/reactos/regtests/winetests/kernel32/pipe.c Added: trunk/reactos/regtests/winetests/kernel32/process.c Added: trunk/reactos/regtests/winetests/kernel32/profile.c Added: trunk/reactos/regtests/winetests/kernel32/sync.c Added: trunk/reactos/regtests/winetests/kernel32/testlist.c Added: trunk/reactos/regtests/winetests/kernel32/thread.c Added: trunk/reactos/regtests/winetests/kernel32/time.c Added: trunk/reactos/regtests/winetests/kernel32/timer.c Added: trunk/reactos/regtests/winetests/kernel32/virtual.c _____ Added: trunk/reactos/regtests/winetests/kernel32/alloc.c --- trunk/reactos/regtests/winetests/kernel32/alloc.c 2005-08-07 03:00:44 UTC (rev 17136) +++ trunk/reactos/regtests/winetests/kernel32/alloc.c 2005-08-07 03:14:17 UTC (rev 17137) @@ -0,0 +1,406 @@ +/* + * Unit test suite for memory allocation functions. + * + * Copyright 2002 Geoffrey Hausheer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <stdarg.h> + +#include "wine/test.h" +#include "windef.h" +#include "winbase.h" +#include "winerror.h" + + + /* The following functions don't have tests, because either I don't know how + to test them, or they are WinNT only, or require multiple threads. + Since the last two issues shouldn't really stop the tests from being + written, assume for now that it is all due to the first case + HeapCompact + HeapLock + HeapQueryInformation + HeapSetInformation + HeapUnlock + HeapValidate + HeapWalk +*/ +/* In addition, these features aren't being tested + HEAP_NO_SERIALIZE + HEAP_GENERATE_EXCEPTIONS + STATUS_ACCESS_VIOLATION (error code from HeapAlloc) +*/ + +static void test_Heap(void) +{ + SYSTEM_INFO sysInfo; + ULONG memchunk; + HANDLE heap; + LPVOID mem1,mem1a,mem3; + UCHAR *mem2,*mem2a; + UINT error,i; + DWORD dwSize; + +/* Retrieve the page size for this system */ + sysInfo.dwPageSize=0; + GetSystemInfo(&sysInfo); + ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page size\n"); + +/* Create a Heap with a minimum and maximum size */ +/* Note that Windows and Wine seem to behave a bit differently with respect + to memory allocation. In Windows, you can't access all the memory + specified in the heap (due to overhead), so choosing a reasonable maximum + size for the heap was done mostly by trial-and-error on Win2k. It may need + more tweaking for otherWindows variants. +*/ + memchunk=10*sysInfo.dwPageSize; + heap=HeapCreate(0,2*memchunk,5*memchunk); + +/* Check that HeapCreate allocated the right amount of ram */ + todo_wine { + /* Today HeapCreate seems to return a memory block larger than specified. + MSDN says the maximum heap size should be dwMaximumSize rounded up to the + nearest page boundary + */ + mem1=HeapAlloc(heap,0,5*memchunk+1); + ok(mem1==NULL,"HeapCreate allocated more Ram than it should have\n"); + HeapFree(heap,0,mem1); + } + +/* Check that a normal alloc works */ + mem1=HeapAlloc(heap,0,memchunk); + ok(mem1!=NULL,"HeapAlloc failed\n"); + if(mem1) { + ok(HeapSize(heap,0,mem1)>=memchunk, "HeapAlloc should return a big enough memory block\n"); + } + +/* Check that a 'zeroing' alloc works */ + mem2=HeapAlloc(heap,HEAP_ZERO_MEMORY,memchunk); + ok(mem2!=NULL,"HeapAlloc failed\n"); + if(mem2) { + ok(HeapSize(heap,0,mem2)>=memchunk,"HeapAlloc should return a big enough memory block\n"); + error=0; + for(i=0;i<memchunk;i++) { + if(mem2[i]!=0) { + error=1; + } + } + ok(!error,"HeapAlloc should have zeroed out it's allocated memory\n"); + } + +/* Check that HeapAlloc returns NULL when requested way too much memory */ + mem3=HeapAlloc(heap,0,5*memchunk); + ok(mem3==NULL,"HeapAlloc should return NULL\n"); + if(mem3) { + ok(HeapFree(heap,0,mem3),"HeapFree didn't pass successfully\n"); + } + +/* Check that HeapRealloc works */ + mem2a=HeapReAlloc(heap,HEAP_ZERO_MEMORY,mem2,memchunk+5*sysInfo.dwPageSi ze); + ok(mem2a!=NULL,"HeapReAlloc failed\n"); + if(mem2a) { + ok(HeapSize(heap,0,mem2a)>=memchunk+5*sysInfo.dwPageSize,"HeapReAlloc failed\n"); + error=0; + for(i=0;i<5*sysInfo.dwPageSize;i++) { + if(mem2a[memchunk+i]!=0) { + error=1; + } + } + ok(!error,"HeapReAlloc should have zeroed out it's allocated memory\n"); + } + +/* Check that HeapRealloc honours HEAP_REALLOC_IN_PLACE_ONLY */ + error=0; + mem1a=HeapReAlloc(heap,HEAP_REALLOC_IN_PLACE_ONLY,mem1,memchunk+sysInfo. dwPageSize); + if(mem1a!=NULL) { + if(mem1a!=mem1) { + error=1; + } + } + ok(mem1a==NULL || error==0,"HeapReAlloc didn't honour HEAP_REALLOC_IN_PLACE_ONLY\n"); + +/* Check that HeapFree works correctly */ + if(mem1a) { + ok(HeapFree(heap,0,mem1a),"HeapFree failed\n"); + } else { + ok(HeapFree(heap,0,mem1),"HeapFree failed\n"); + } + if(mem2a) { + ok(HeapFree(heap,0,mem2a),"HeapFree failed\n"); + } else { + ok(HeapFree(heap,0,mem2),"HeapFree failed\n"); + } + + /* 0-length buffer */ + mem1 = HeapAlloc(heap, 0, 0); + ok(mem1 != NULL, "Reserved memory\n"); + + dwSize = HeapSize(heap, 0, mem1); + /* should work with 0-length buffer */ + ok((dwSize >= 0) && (dwSize < 0xFFFFFFFF), + "The size of the 0-length buffer\n"); + ok(HeapFree(heap, 0, mem1), "Freed the 0-length buffer\n"); + +/* Check that HeapDestry works */ + ok(HeapDestroy(heap),"HeapDestroy failed\n"); +} + +/* The following functions don't have tests, because either I don't know how + to test them, or they are WinNT only, or require multiple threads. + Since the last two issues shouldn't really stop the tests from being + written, assume for now that it is all due to the first case + GlobalFlags + GlobalMemoryStatus + GlobalMemoryStatusEx +*/ +/* In addition, these features aren't being tested + GMEM_DISCADABLE + GMEM_NOCOMPACT +*/ +static void test_Global(void) +{ + ULONG memchunk; + HGLOBAL mem1,mem2,mem2a,mem2b; + UCHAR *mem2ptr; + UINT error,i; + memchunk=100000; + + SetLastError(NO_ERROR); +/* Check that a normal alloc works */ + mem1=GlobalAlloc(0,memchunk); + ok(mem1!=NULL,"GlobalAlloc failed\n"); + if(mem1) { + ok(GlobalSize(mem1)>=memchunk, "GlobalAlloc should return a big enough memory block\n"); + } + +/* Check that a 'zeroing' alloc works */ + mem2=GlobalAlloc(GMEM_ZEROINIT,memchunk); + ok(mem2!=NULL,"GlobalAlloc failed: error=%ld\n",GetLastError()); + if(mem2) { + ok(GlobalSize(mem2)>=memchunk,"GlobalAlloc should return a big enough memory block\n"); + mem2ptr=GlobalLock(mem2); + ok(mem2ptr==mem2,"GlobalLock should have returned the same memory as was allocated\n"); + if(mem2ptr) { + error=0; + for(i=0;i<memchunk;i++) { + if(mem2ptr[i]!=0) { + error=1; + } + } + ok(!error,"GlobalAlloc should have zeroed out it's allocated memory\n"); + } + } +/* Check that GlobalReAlloc works */ +/* Check that we can change GMEM_FIXED to GMEM_MOVEABLE */ + mem2a=GlobalReAlloc(mem2,0,GMEM_MODIFY | GMEM_MOVEABLE); + if(mem2a!=NULL) { + mem2=mem2a; + mem2ptr=GlobalLock(mem2a); + ok(mem2ptr!=NULL && !GlobalUnlock(mem2a)&&GetLastError()==NO_ERROR, + "Converting from FIXED to MOVEABLE didn't REALLY work\n"); + } + +/* Check that ReAllocing memory works as expected */ + mem2a=GlobalReAlloc(mem2,2*memchunk,GMEM_MOVEABLE | GMEM_ZEROINIT); + ok(mem2a!=NULL,"GlobalReAlloc failed\n"); + if(mem2a) { + ok(GlobalSize(mem2a)>=2*memchunk,"GlobalReAlloc failed\n"); + mem2ptr=GlobalLock(mem2a); + ok(mem2ptr!=NULL,"GlobalLock Failed\n"); + if(mem2ptr) { + error=0; + for(i=0;i<memchunk;i++) { + if(mem2ptr[memchunk+i]!=0) { + error=1; + } + } + ok(!error,"GlobalReAlloc should have zeroed out it's allocated memory\n"); + +/* Check that GlobalHandle works */ + mem2b=GlobalHandle(mem2ptr); + ok(mem2b==mem2a,"GlobalHandle didn't return the correct memory handle\n"); + +/* Check that we can't discard locked memory */ + mem2b=GlobalDiscard(mem2a); + if(mem2b==NULL) { + ok(!GlobalUnlock(mem2a) && GetLastError()==NO_ERROR,"GlobalUnlock Failed\n"); + } + } + } + if(mem1) { + ok(GlobalFree(mem1)==NULL,"GlobalFree failed\n"); + } + if(mem2a) { + ok(GlobalFree(mem2a)==NULL,"GlobalFree failed\n"); + } else { + ok(GlobalFree(mem2)==NULL,"GlobalFree failed\n"); + } +} + + +/* The following functions don't have tests, because either I don't know how + to test them, or they are WinNT only, or require multiple threads. + Since the last two issues shouldn't really stop the tests from being + written, assume for now that it is all due to the first case + LocalDiscard + LocalFlags +*/ +/* In addition, these features aren't being tested + LMEM_DISCADABLE + LMEM_NOCOMPACT +*/ +static void test_Local(void) +{ + ULONG memchunk; + HLOCAL mem1,mem2,mem2a,mem2b; + UCHAR *mem2ptr; + UINT error,i; + memchunk=100000; + +/* Check that a normal alloc works */ + mem1=LocalAlloc(0,memchunk); + ok(mem1!=NULL,"LocalAlloc failed: error=%ld\n",GetLastError()); + if(mem1) { + ok(LocalSize(mem1)>=memchunk, "LocalAlloc should return a big enough memory block\n"); + } + +/* Check that a 'zeroing' and lock alloc works */ + mem2=LocalAlloc(LMEM_ZEROINIT|LMEM_MOVEABLE,memchunk); + ok(mem2!=NULL,"LocalAlloc failed: error=%ld\n",GetLastError()); + if(mem2) { + ok(LocalSize(mem2)>=memchunk,"LocalAlloc should return a big enough memory block\n"); + mem2ptr=LocalLock(mem2); + ok(mem2ptr!=NULL,"LocalLock: error=%ld\n",GetLastError()); + if(mem2ptr) { + error=0; + for(i=0;i<memchunk;i++) { + if(mem2ptr[i]!=0) { + error=1; + } + } + ok(!error,"LocalAlloc should have zeroed out it's allocated memory\n"); + SetLastError(0); + error=LocalUnlock(mem2); + ok(error==0 && GetLastError()==NO_ERROR, + "LocalUnlock Failed: rc=%d err=%ld\n",error,GetLastError()); + } + } + mem2a=LocalFree(mem2); + ok(mem2a==NULL, "LocalFree failed: %p\n",mem2a); + +/* Reallocate mem2 as moveable memory */ + mem2=LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,memchunk); + ok(mem2!=NULL, "LocalAlloc failed to create moveable memory, error=%ld\n",GetLastError()); + +/* Check that ReAllocing memory works as expected */ + mem2a=LocalReAlloc(mem2,2*memchunk,LMEM_MOVEABLE | LMEM_ZEROINIT); + ok(mem2a!=NULL,"LocalReAlloc failed, error=%ld\n",GetLastError()); + if(mem2a) { + ok(LocalSize(mem2a)>=2*memchunk,"LocalReAlloc failed\n"); + mem2ptr=LocalLock(mem2a); + ok(mem2ptr!=NULL,"LocalLock Failed\n"); + if(mem2ptr) { + error=0; + for(i=0;i<memchunk;i++) { + if(mem2ptr[memchunk+i]!=0) { + error=1; + } + } + ok(!error,"LocalReAlloc should have zeroed out it's allocated memory\n"); +/* Check that LocalHandle works */ + mem2b=LocalHandle(mem2ptr); + ok(mem2b==mem2a,"LocalHandle didn't return the correct memory handle\n"); +/* Check that we can't discard locked memory */ + mem2b=LocalDiscard(mem2a); + ok(mem2b==NULL,"Discarded memory we shouldn't have\n"); + SetLastError(NO_ERROR); + ok(!LocalUnlock(mem2a) && GetLastError()==NO_ERROR, "LocalUnlock Failed\n"); + } + } + if(mem1) { + ok(LocalFree(mem1)==NULL,"LocalFree failed\n"); + } + if(mem2a) { + ok(LocalFree(mem2a)==NULL,"LocalFree failed\n"); + } else { + ok(LocalFree(mem2)==NULL,"LocalFree failed\n"); + } +} + +/* The Virtual* routines are not tested as thoroughly, + since I don't really understand how to use them correctly :) + The following routines are not tested at all + VirtualAllocEx + VirtualFreeEx + VirtualLock + VirtualProtect + VirtualProtectEx + VirtualQuery + VirtualQueryEx + VirtualUnlock + And the only features (flags) being tested are + MEM_COMMIT + MEM_RELEASE + PAGE_READWRITE + Testing the rest requires using exceptions, which I really don't + understand well +*/ +static void test_Virtual(void) +{ + SYSTEM_INFO sysInfo; + ULONG memchunk; + UCHAR *mem1; + UINT error,i; + +/* Retrieve the page size for this system */ + sysInfo.dwPageSize=0; + GetSystemInfo(&sysInfo); + ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page size\n"); + +/* Choose a reasonable allocation size */ + memchunk=10*sysInfo.dwPageSize; + +/* Check that a normal alloc works */ + mem1=VirtualAlloc(NULL,memchunk,MEM_COMMIT,PAGE_READWRITE); + ok(mem1!=NULL,"VirtualAlloc failed\n"); + if(mem1) { +/* check that memory is initialized to 0 */ + error=0; + for(i=0;i<memchunk;i++) { + if(mem1[i]!=0) { + error=1; + } + } + ok(!error,"VirtualAlloc did not initialize memory to '0's\n"); +/* Check that we can read/write to memory */ + error=0; + for(i=0;i<memchunk;i+=100) { + mem1[i]='a'; + if(mem1[i]!='a') { + error=1; + } + } + ok(!error,"Virtual memory was not writable\n"); + } + ok(VirtualFree(mem1,0,MEM_RELEASE),"VirtualFree failed\n"); +} +START_TEST(alloc) +{ + test_Heap(); + test_Global(); + test_Local(); + test_Virtual(); +} Property changes on: trunk/reactos/regtests/winetests/kernel32/alloc.c ___________________________________________________________________ Name: svn:executable + * _____ Added: trunk/reactos/regtests/winetests/kernel32/atom.c --- trunk/reactos/regtests/winetests/kernel32/atom.c 2005-08-07 03:00:44 UTC (rev 17136) +++ trunk/reactos/regtests/winetests/kernel32/atom.c 2005-08-07 03:14:17 UTC (rev 17137) @@ -0,0 +1,346 @@ +/* + * Unit tests for atom functions + * + * Copyright (c) 2002 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <stdarg.h> +#include <stdio.h> + +#include "wine/test.h" +#include "windef.h" +#include "winbase.h" +#include "winerror.h" + +static const WCHAR foobarW[] = {'f','o','o','b','a','r',0}; +static const WCHAR FOOBARW[] = {'F','O','O','B','A','R',0}; +static const WCHAR _foobarW[] = {'_','f','o','o','b','a','r',0}; + +static BOOL unicode_OS; + +static void test_add_atom(void) +{ + ATOM atom, w_atom; + int i; + + SetLastError( 0xdeadbeef ); + atom = GlobalAddAtomA( "foobar" ); + ok( atom >= 0xc000, "bad atom id %x\n", atom ); + ok( GetLastError() == 0xdeadbeef, "GlobalAddAtomA set last error\n" ); + + /* Verify that it can be found (or not) appropriately */ + ok( GlobalFindAtomA( "foobar" ) == atom, "could not find atom foobar\n" ); + ok( GlobalFindAtomA( "FOOBAR" ) == atom, "could not find atom FOOBAR\n" ); + ok( !GlobalFindAtomA( "_foobar" ), "found _foobar\n" ); + + /* Add the same atom, specifying string as unicode; should + * find the first one, not add a new one */ + SetLastError( 0xdeadbeef ); + w_atom = GlobalAddAtomW( foobarW ); + if (w_atom && GetLastError() != ERROR_CALL_NOT_IMPLEMENTED) + unicode_OS = TRUE; + else + trace("WARNING: Unicode atom APIs are not supported on this platform\n"); + + if (unicode_OS) + { + ok( w_atom == atom, "Unicode atom does not match ASCII\n" ); + ok( GetLastError() == 0xdeadbeef, "GlobalAddAtomW set last error\n" ); + } + + /* Verify that it can be found (or not) appropriately via unicode name */ + if (unicode_OS) + { + ok( GlobalFindAtomW( foobarW ) == atom, "could not find atom foobar\n" ); + ok( GlobalFindAtomW( FOOBARW ) == atom, "could not find atom FOOBAR\n" ); + ok( !GlobalFindAtomW( _foobarW ), "found _foobar\n" ); + } + + /* Test integer atoms + * (0x0001 .. 0xbfff) should be valid; + * (0xc000 .. 0xffff) should be invalid */ + + SetLastError( 0xdeadbeef ); + ok( GlobalAddAtomA(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to add atom 0\n" ); + if (unicode_OS) + { + SetLastError( 0xdeadbeef ); + ok( GlobalAddAtomW(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to add atom 0\n" ); + } + + SetLastError( 0xdeadbeef ); + for (i = 1; i <= 0xbfff; i++) + { + SetLastError( 0xdeadbeef ); + ok( GlobalAddAtomA((LPCSTR)i) == i && GetLastError() == 0xdeadbeef, + "failed to add atom %x\n", i ); + if (unicode_OS) + { + SetLastError( 0xdeadbeef ); + ok( GlobalAddAtomW((LPCWSTR)i) == i && GetLastError() == 0xdeadbeef, + "failed to add atom %x\n", i ); + } + } + + for (i = 0xc000; i <= 0xffff; i++) + { + ok( !GlobalAddAtomA((LPCSTR)i), "succeeded adding %x\n", i ); + if (unicode_OS) + ok( !GlobalAddAtomW((LPCWSTR)i), "succeeded adding %x\n", i ); + } +} + +static void test_get_atom_name(void) +{ + char buf[10]; + WCHAR bufW[10]; + int i; + UINT len; + static const WCHAR resultW[] = {'f','o','o','b','a','r',0,'.','.','.'}; + + ATOM atom = GlobalAddAtomA( "foobar" ); + + /* Get the name of the atom we added above */ + memset( buf, '.', sizeof(buf) ); + len = GlobalGetAtomNameA( atom, buf, 10 ); + ok( len == strlen("foobar"), "bad length %d\n", len ); + ok( !memcmp( buf, "foobar\0...", 10 ), "bad buffer contents\n" ); + + /* Repeat, unicode-style */ + if (unicode_OS) + { + for (i = 0; i < 10; i++) bufW[i] = '.'; + SetLastError( 0xdeadbeef ); + len = GlobalGetAtomNameW( atom, bufW, 10 ); + ok( len && GetLastError() == 0xdeadbeef, "GlobalGetAtomNameW failed\n" ); + ok( len == lstrlenW(foobarW), "bad length %d\n", len ); + ok( !memcmp( bufW, resultW, 10*sizeof(WCHAR) ), "bad buffer contents\n" ); + } + + /* Check error code returns */ + memset(buf, '.', 10); + ok( !GlobalGetAtomNameA( atom, buf, 0 ), "succeeded\n" ); + ok( !memcmp( buf, "..........", 10 ), "should not touch buffer\n" ); + + if (unicode_OS) + { + static const WCHAR sampleW[10] = {'.','.','.','.','.','.','.','.','.','.'}; + + for (i = 0; i < 10; i++) bufW[i] = '.'; + ok( !GlobalGetAtomNameW( atom, bufW, 0 ), "succeeded\n" ); + ok( !memcmp( bufW, sampleW, 10 * sizeof(WCHAR) ), "should not touch buffer\n" ); + } + + /* Test integer atoms */ + for (i = 0; i <= 0xbfff; i++) + { + memset( buf, 'a', 10 ); + len = GlobalGetAtomNameA( (ATOM)i, buf, 10 ); + if (i) + { + char res[20]; + ok( (len > 1) && (len < 7), "bad length %d\n", len ); + sprintf( res, "#%d", i ); + memset( res + strlen(res) + 1, 'a', 10 ); + ok( !memcmp( res, buf, 10 ), "bad buffer contents %s\n", buf ); + } + else + ok( !len, "bad length %d\n", len ); + } +} + +static void test_error_handling(void) +{ + char buffer[260]; + WCHAR bufferW[260]; + int i; + + memset( buffer, 'a', 256 ); + buffer[256] = 0; + ok( !GlobalAddAtomA(buffer), "add succeeded\n" ); + ok( !GlobalFindAtomA(buffer), "find succeeded\n" ); + + if (unicode_OS) + { + for (i = 0; i < 256; i++) bufferW[i] = 'b'; + bufferW[256] = 0; + ok( !GlobalAddAtomW(bufferW), "add succeeded\n" ); + ok( !GlobalFindAtomW(bufferW), "find succeeded\n" ); + } +} + +static void test_local_add_atom(void) +{ + ATOM atom, w_atom; + int i; + + SetLastError( 0xdeadbeef ); + atom = AddAtomA( "foobar" ); + ok( atom >= 0xc000, "bad atom id %x\n", atom ); + ok( GetLastError() == 0xdeadbeef, "AddAtomA set last error\n" ); + + /* Verify that it can be found (or not) appropriately */ + ok( FindAtomA( "foobar" ) == atom, "could not find atom foobar\n" ); + ok( FindAtomA( "FOOBAR" ) == atom, "could not find atom FOOBAR\n" ); + ok( !FindAtomA( "_foobar" ), "found _foobar\n" ); + + /* Add the same atom, specifying string as unicode; should + * find the first one, not add a new one */ + SetLastError( 0xdeadbeef ); + w_atom = AddAtomW( foobarW ); + if (w_atom && GetLastError() != ERROR_CALL_NOT_IMPLEMENTED) + unicode_OS = TRUE; + else + trace("WARNING: Unicode atom APIs are not supported on this platform\n"); + + if (unicode_OS) + { + ok( w_atom == atom, "Unicode atom does not match ASCII\n" ); + ok( GetLastError() == 0xdeadbeef, "AddAtomW set last error\n" ); + } + + /* Verify that it can be found (or not) appropriately via unicode name */ + if (unicode_OS) + { + ok( FindAtomW( foobarW ) == atom, "could not find atom foobar\n" ); + ok( FindAtomW( FOOBARW ) == atom, "could not find atom FOOBAR\n" ); + ok( !FindAtomW( _foobarW ), "found _foobar\n" ); + } + + /* Test integer atoms + * (0x0001 .. 0xbfff) should be valid; + * (0xc000 .. 0xffff) should be invalid */ + + SetLastError( 0xdeadbeef ); + ok( AddAtomA(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to add atom 0\n" ); + if (unicode_OS) + { + SetLastError( 0xdeadbeef ); + ok( AddAtomW(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to add atom 0\n" ); + } + + SetLastError( 0xdeadbeef ); + for (i = 1; i <= 0xbfff; i++) + { + SetLastError( 0xdeadbeef ); + ok( AddAtomA((LPCSTR)i) == i && GetLastError() == 0xdeadbeef, + "failed to add atom %x\n", i ); + if (unicode_OS) + { + SetLastError( 0xdeadbeef ); + ok( AddAtomW((LPCWSTR)i) == i && GetLastError() == 0xdeadbeef, + "failed to add atom %x\n", i ); + } + } + + for (i = 0xc000; i <= 0xffff; i++) + { + ok( !AddAtomA((LPCSTR)i), "succeeded adding %x\n", i ); + if (unicode_OS) + ok( !AddAtomW((LPCWSTR)i), "succeeded adding %x\n", i ); + } +} + +static void test_local_get_atom_name(void) +{ + char buf[10]; + WCHAR bufW[10]; + int i; + UINT len; + static const WCHAR resultW[] = {'f','o','o','b','a','r',0,'.','.','.'}; + + ATOM atom = AddAtomA( "foobar" ); + + /* Get the name of the atom we added above */ + memset( buf, '.', sizeof(buf) ); + len = GetAtomNameA( atom, buf, 10 ); + ok( len == strlen("foobar"), "bad length %d\n", len ); + ok( !memcmp( buf, "foobar\0...", 10 ), "bad buffer contents\n" ); + + /* Repeat, unicode-style */ + if (unicode_OS) + { + for (i = 0; i < 10; i++) bufW[i] = '.'; + SetLastError( 0xdeadbeef ); + len = GetAtomNameW( atom, bufW, 10 ); + ok( len && GetLastError() == 0xdeadbeef, "GetAtomNameW failed\n" ); + ok( len == lstrlenW(foobarW), "bad length %d\n", len ); + ok( !memcmp( bufW, resultW, 10*sizeof(WCHAR) ), "bad buffer contents\n" ); + } + + /* Check error code returns */ + memset(buf, '.', 10); + ok( !GetAtomNameA( atom, buf, 0 ), "succeeded\n" ); + ok( !memcmp( buf, "..........", 10 ), "should not touch buffer\n" ); + + if (unicode_OS) + { + static const WCHAR sampleW[10] = {'.','.','.','.','.','.','.','.','.','.'}; + + for (i = 0; i < 10; i++) bufW[i] = '.'; + ok( !GetAtomNameW( atom, bufW, 0 ), "succeeded\n" ); + ok( !memcmp( bufW, sampleW, 10 * sizeof(WCHAR) ), "should not touch buffer\n" ); + } + + /* Test integer atoms */ + for (i = 0; i <= 0xbfff; i++) + { + memset( buf, 'a', 10 ); + len = GetAtomNameA( (ATOM)i, buf, 10 ); + if (i) + { + char res[20]; + ok( (len > 1) && (len < 7), "bad length %d\n", len ); + sprintf( res, "#%d", i ); + memset( res + strlen(res) + 1, 'a', 10 ); + ok( !memcmp( res, buf, 10 ), "bad buffer contents %s\n", buf ); + } + else + ok( !len, "bad length %d\n", len ); + } +} + +static void test_local_error_handling(void) +{ + char buffer[260]; + WCHAR bufferW[260]; + int i; + + memset( buffer, 'a', 256 ); + buffer[256] = 0; + ok( !AddAtomA(buffer), "add succeeded\n" ); + ok( !FindAtomA(buffer), "find succeeded\n" ); + + if (unicode_OS) + { + for (i = 0; i < 256; i++) bufferW[i] = 'b'; + bufferW[256] = 0; + ok( !AddAtomW(bufferW), "add succeeded\n" ); + ok( !FindAtomW(bufferW), "find succeeded\n" ); + } +} + + +START_TEST(atom) +{ + test_add_atom(); + test_get_atom_name(); + test_error_handling(); + test_local_add_atom(); + test_local_get_atom_name(); + test_local_error_handling(); +} Property changes on: trunk/reactos/regtests/winetests/kernel32/atom.c ___________________________________________________________________ Name: svn:executable + * _____ Added: trunk/reactos/regtests/winetests/kernel32/change.c --- trunk/reactos/regtests/winetests/kernel32/change.c 2005-08-07 03:00:44 UTC (rev 17136) +++ trunk/reactos/regtests/winetests/kernel32/change.c 2005-08-07 03:14:17 UTC (rev 17137) @@ -0,0 +1,242 @@ +/* + * Tests for file change notification functions + * + * Copyright (c) 2004 Hans Leidekker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* TODO: - security attribute changes + * - compound filter and multiple notifications + * - subtree notifications + * - non-documented flags FILE_NOTIFY_CHANGE_LAST_ACCESS and + * FILE_NOTIFY_CHANGE_CREATION + */ + +#include <stdarg.h> +#include <stdio.h> + +#include "wine/test.h" +#include <windef.h> +#include <winbase.h> + +static DWORD CALLBACK NotificationThread(LPVOID arg) +{ + HANDLE change = (HANDLE) arg; + BOOL ret = FALSE; + DWORD status; + + status = WaitForSingleObject(change, 100); + + if (status == WAIT_OBJECT_0 ) { + ret = FindNextChangeNotification(change); + } + + ret = FindCloseChangeNotification(change); + ok( ret, "FindCloseChangeNotification error: %ld\n", + GetLastError()); + + ExitThread((DWORD)ret); +} + +static HANDLE StartNotificationThread(LPCSTR path, BOOL subtree, DWORD flags) +{ + HANDLE change, thread; + DWORD threadId; + + change = FindFirstChangeNotificationA(path, subtree, flags); + ok(change != INVALID_HANDLE_VALUE, "FindFirstChangeNotification error: %ld\n", GetLastError()); + + thread = CreateThread(NULL, 0, NotificationThread, (LPVOID)change, + 0, &threadId); + ok(thread != INVALID_HANDLE_VALUE, "CreateThread error: %ld\n", GetLastError()); + + return thread; +} + +static DWORD FinishNotificationThread(HANDLE thread) +{ + DWORD status, exitcode; + + status = WaitForSingleObject(thread, 5000); + ok(status == WAIT_OBJECT_0, "WaitForSingleObject status %ld error %ld\n", status, GetLastError()); + + ok(GetExitCodeThread(thread, &exitcode), "Could not retrieve thread exit code\n"); + + return exitcode; +} + +static void test_FindFirstChangeNotification(void) +{ + HANDLE change, file, thread; + DWORD attributes, count; + BOOL ret; + + char workdir[MAX_PATH], dirname1[MAX_PATH], dirname2[MAX_PATH]; + char filename1[MAX_PATH], filename2[MAX_PATH]; + static const char prefix[] = "FCN"; + char buffer[2048]; + + /* pathetic checks */ + + change = FindFirstChangeNotificationA("not-a-file", FALSE, FILE_NOTIFY_CHANGE_FILE_NAME); + ok(change == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND, + "FindFirstChangeNotification error: %ld\n", GetLastError()); + + if (0) /* This documents win2k behavior. It crashes on win98. */ + { + change = FindFirstChangeNotificationA(NULL, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME); + ok(change == NULL && GetLastError() == ERROR_PATH_NOT_FOUND, + "FindFirstChangeNotification error: %ld\n", GetLastError()); + } + + ret = FindNextChangeNotification(NULL); + ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindNextChangeNotification error: %ld\n", + GetLastError()); + + ret = FindCloseChangeNotification(NULL); + ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindCloseChangeNotification error: %ld\n", + GetLastError()); + + ret = GetTempPathA(MAX_PATH, workdir); + ok(ret, "GetTempPathA error: %ld\n", GetLastError()); + + lstrcatA(workdir, "testFileChangeNotification"); + + ret = CreateDirectoryA(workdir, NULL); + ok(ret, "CreateDirectoryA error: %ld\n", GetLastError()); + + ret = GetTempFileNameA(workdir, prefix, 0, filename1); + ok(ret, "GetTempFileNameA error: %ld\n", GetLastError()); + + file = CreateFileA(filename1, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, 0); + ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n", GetLastError()); + ret = CloseHandle(file); + ok( ret, "CloseHandle error: %ld\n", GetLastError()); + + /* Try to register notification for a file. win98 and win2k behave differently here */ + change = FindFirstChangeNotificationA(filename1, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME); + ok(change == INVALID_HANDLE_VALUE && (GetLastError() == ERROR_DIRECTORY || + GetLastError() == ERROR_FILE_NOT_FOUND), + "FindFirstChangeNotification error: %ld\n", GetLastError()); + + lstrcpyA(dirname1, filename1); + lstrcatA(dirname1, "dir"); + + ret = CreateDirectoryA(dirname1, NULL); + ok(ret, "CreateDirectoryA error: %ld\n", GetLastError()); + + /* What if we remove the directory we registered notification for? */ + thread = StartNotificationThread(dirname1, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME); + ret = RemoveDirectoryA(dirname1); + ok(ret, "RemoveDirectoryA error: %ld\n", GetLastError()); + + /* win98 and win2k behave differently here */ + ret = FinishNotificationThread(thread); + ok(ret || !ret, "You'll never read this\n"); + + /* functional checks */ + + /* Create a directory */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME); + ret = CreateDirectoryA(dirname1, NULL); + ok(ret, "CreateDirectoryA error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + lstrcpyA(dirname2, dirname1); + lstrcatA(dirname2, "new"); + + /* Rename a directory */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME); + ret = MoveFileA(dirname1, dirname2); + ok(ret, "MoveFileA error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + /* Delete a directory */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME); + ret = RemoveDirectoryA(dirname2); + ok(ret, "RemoveDirectoryA error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + lstrcpyA(filename2, filename1); + lstrcatA(filename2, "new"); + + /* Rename a file */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME); + ret = MoveFileA(filename1, filename2); + ok(ret, "MoveFileA error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + /* Delete a file */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME); + ret = DeleteFileA(filename2); + ok(ret, "DeleteFileA error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + /* Create a file */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME); + file = CreateFileA(filename2, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, 0); + ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n", GetLastError()); + ret = CloseHandle(file); + ok( ret, "CloseHandle error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + attributes = GetFileAttributesA(filename2); + ok(attributes != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA error: %ld\n", GetLastError()); + attributes &= FILE_ATTRIBUTE_READONLY; + + /* Change file attributes */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_ATTRIBUTES); + ret = SetFileAttributesA(filename2, attributes); + ok(ret, "SetFileAttributesA error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + /* Change last write time by writing to a file */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE); + file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, 0); + ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n", GetLastError()); + ret = WriteFile(file, buffer, sizeof(buffer), &count, NULL); + ok(ret && count == sizeof(buffer), "WriteFile error: %ld\n", GetLastError()); + ret = CloseHandle(file); + ok( ret, "CloseHandle error: %ld\n", GetLastError()); + ok(FinishNotificationThread(thread), "Missed notification\n"); + + /* Change file size by truncating a file */ + thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_SIZE); + file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, 0); + ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n", GetLastError()); + ret = WriteFile(file, buffer, sizeof(buffer) / 2, &count, NULL); + ok(ret && count == sizeof(buffer) / 2, "WriteFileA error: %ld\n", GetLastError()); [truncated at 1000 lines; 12413 more skipped]

1 0

[sedwards] 17136: make the ros test name dllname_rostest.exe, suggested by Usurp
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

make the ros test name dllname_rostest.exe, suggested by Usurp Modified: trunk/reactos/lib/kernel32/tests/kernel32.xml _____ Modified: trunk/reactos/lib/kernel32/tests/kernel32.xml --- trunk/reactos/lib/kernel32/tests/kernel32.xml 2005-08-07 02:54:10 UTC (rev 17135) +++ trunk/reactos/lib/kernel32/tests/kernel32.xml 2005-08-07 03:00:44 UTC (rev 17136) @@ -1,4 +1,4 @@ -<module name="kernel32_tests" type="test"> +<module name="kernel32_rostest" type="test"> <include base="rtshared">.</include> <include base="kernel32">.</include> <define name="_DISABLE_TIDENTS" />

1 0

[sedwards] 17135: Named reactos regression tests dllname_tests.exe and wine test name dllname_test.exe to prevent conflicts
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

Named reactos regression tests dllname_tests.exe and wine test name dllname_test.exe to prevent conflicts Modified: trunk/reactos/lib/kernel32/tests/kernel32.xml _____ Modified: trunk/reactos/lib/kernel32/tests/kernel32.xml --- trunk/reactos/lib/kernel32/tests/kernel32.xml 2005-08-07 02:22:29 UTC (rev 17134) +++ trunk/reactos/lib/kernel32/tests/kernel32.xml 2005-08-07 02:54:10 UTC (rev 17135) @@ -1,4 +1,4 @@ -<module name="kernel32_test" type="test"> +<module name="kernel32_tests" type="test"> <include base="rtshared">.</include> <include base="kernel32">.</include> <define name="_DISABLE_TIDENTS" />

1 0

[sedwards] 17134: add some missing values from Wine
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

add some missing values from Wine Modified: trunk/reactos/w32api/include/winerror.h _____ Modified: trunk/reactos/w32api/include/winerror.h --- trunk/reactos/w32api/include/winerror.h 2005-08-07 02:16:34 UTC (rev 17133) +++ trunk/reactos/w32api/include/winerror.h 2005-08-07 02:22:29 UTC (rev 17134) @@ -4,8 +4,15 @@ #pragma GCC system_header #endif +#ifdef RC_INVOKED +#define _HRESULT_TYPEDEF_(x) (x) +#else +#define _HRESULT_TYPEDEF_(x) ((HRESULT)x) +#endif + #define ERROR_SUCCESS 0L #define NO_ERROR 0L +#define ERROR_AUDITING_DISABLED 0xC0090001L #define ERROR_INVALID_FUNCTION 1L #define ERROR_FILE_NOT_FOUND 2L #define ERROR_PATH_NOT_FOUND 3L @@ -2131,40 +2138,55 @@ #define TYPE_E_CANTLOADLIBRARY ((HRESULT)0x80029C4AL) #define TYPE_E_INCONSISTENTPROPFUNCS ((HRESULT)0x80029C83L) #define TYPE_E_CIRCULARTYPE ((HRESULT)0x80029C84L) -#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L) -#define STG_E_FILENOTFOUND ((HRESULT)0x80030002L) -#define STG_E_PATHNOTFOUND ((HRESULT)0x80030003L) -#define STG_E_TOOMANYOPENFILES ((HRESULT)0x80030004L) -#define STG_E_ACCESSDENIED ((HRESULT)0x80030005L) -#define STG_E_INVALIDHANDLE ((HRESULT)0x80030006L) -#define STG_E_INSUFFICIENTMEMORY ((HRESULT)0x80030008L) -#define STG_E_INVALIDPOINTER ((HRESULT)0x80030009L) -#define STG_E_NOMOREFILES ((HRESULT)0x80030012L) -#define STG_E_DISKISWRITEPROTECTED ((HRESULT)0x80030013L) -#define STG_E_SEEKERROR ((HRESULT)0x80030019L) -#define STG_E_WRITEFAULT ((HRESULT)0x8003001DL) -#define STG_E_READFAULT ((HRESULT)0x8003001EL) -#define STG_E_SHAREVIOLATION ((HRESULT)0x80030020L) -#define STG_E_LOCKVIOLATION ((HRESULT)0x80030021L) -#define STG_E_FILEALREADYEXISTS ((HRESULT)0x80030050L) -#define STG_E_INVALIDPARAMETER ((HRESULT)0x80030057L) -#define STG_E_MEDIUMFULL ((HRESULT)0x80030070L) -#define STG_E_ABNORMALAPIEXIT ((HRESULT)0x800300FAL) -#define STG_E_INVALIDHEADER ((HRESULT)0x800300FBL) -#define STG_E_INVALIDNAME ((HRESULT)0x800300FCL) -#define STG_E_UNKNOWN ((HRESULT)0x800300FDL) -#define STG_E_UNIMPLEMENTEDFUNCTION ((HRESULT)0x800300FEL) -#define STG_E_INVALIDFLAG ((HRESULT)0x800300FFL) -#define STG_E_INUSE ((HRESULT)0x80030100L) -#define STG_E_NOTCURRENT ((HRESULT)0x80030101L) -#define STG_E_REVERTED ((HRESULT)0x80030102L) -#define STG_E_CANTSAVE ((HRESULT)0x80030103L) -#define STG_E_OLDFORMAT ((HRESULT)0x80030104L) -#define STG_E_OLDDLL ((HRESULT)0x80030105L) -#define STG_E_SHAREREQUIRED ((HRESULT)0x80030106L) -#define STG_E_NOTFILEBASEDSTORAGE ((HRESULT)0x80030107L) -#define STG_E_EXTANTMARSHALLINGS ((HRESULT)0x80030108L) -#define STG_S_CONVERTED ((HRESULT)0x00030200L) +#define STG_S_CONVERTED _HRESULT_TYPEDEF_(0x00030200L) +#define STG_S_BLOCK _HRESULT_TYPEDEF_(0x00030201L) +#define STG_S_RETRYNOW _HRESULT_TYPEDEF_(0x00030202L) +#define STG_S_MONITORING _HRESULT_TYPEDEF_(0x00030203L) +#define STG_S_MULTIPLEOPENS _HRESULT_TYPEDEF_(0x00030204L) +#define STG_S_CONSOLIDATIONFAILED _HRESULT_TYPEDEF_(0x00030205L) +#define STG_S_CANNOTCONSOLIDATE _HRESULT_TYPEDEF_(0x00030206L) + +#define STG_E_INVALIDFUNCTION _HRESULT_TYPEDEF_(0x80030001L) +#define STG_E_FILENOTFOUND _HRESULT_TYPEDEF_(0x80030002L) +#define STG_E_PATHNOTFOUND _HRESULT_TYPEDEF_(0x80030003L) +#define STG_E_TOOMANYOPENFILES _HRESULT_TYPEDEF_(0x80030004L) +#define STG_E_ACCESSDENIED _HRESULT_TYPEDEF_(0x80030005L) +#define STG_E_INVALIDHANDLE _HRESULT_TYPEDEF_(0x80030006L) +#define STG_E_INSUFFICIENTMEMORY _HRESULT_TYPEDEF_(0x80030008L) +#define STG_E_INVALIDPOINTER _HRESULT_TYPEDEF_(0x80030009L) +#define STG_E_NOMOREFILES _HRESULT_TYPEDEF_(0x80030012L) +#define STG_E_DISKISWRITEPROTECTED _HRESULT_TYPEDEF_(0x80030013L) +#define STG_E_SEEKERROR _HRESULT_TYPEDEF_(0x80030019L) +#define STG_E_WRITEFAULT _HRESULT_TYPEDEF_(0x8003001DL) +#define STG_E_READFAULT _HRESULT_TYPEDEF_(0x8003001EL) +#define STG_E_SHAREVIOLATION _HRESULT_TYPEDEF_(0x80030020L) +#define STG_E_LOCKVIOLATION _HRESULT_TYPEDEF_(0x80030021L) +#define STG_E_FILEALREADYEXISTS _HRESULT_TYPEDEF_(0x80030050L) +#define STG_E_INVALIDPARAMETER _HRESULT_TYPEDEF_(0x80030057L) +#define STG_E_MEDIUMFULL _HRESULT_TYPEDEF_(0x80030070L) +#define STG_E_ABNORMALAPIEXIT _HRESULT_TYPEDEF_(0x800300FAL) +#define STG_E_INVALIDHEADER _HRESULT_TYPEDEF_(0x800300FBL) +#define STG_E_INVALIDNAME _HRESULT_TYPEDEF_(0x800300FCL) +#define STG_E_UNKNOWN _HRESULT_TYPEDEF_(0x800300FDL) +#define STG_E_UNIMPLEMENTEDFUNCTION _HRESULT_TYPEDEF_(0x800300FEL) +#define STG_E_INVALIDFLAG _HRESULT_TYPEDEF_(0x800300FFL) +#define STG_E_INUSE _HRESULT_TYPEDEF_(0x80030100L) +#define STG_E_NOTCURRENT _HRESULT_TYPEDEF_(0x80030101L) +#define STG_E_REVERTED _HRESULT_TYPEDEF_(0x80030102L) +#define STG_E_CANTSAVE _HRESULT_TYPEDEF_(0x80030103L) +#define STG_E_OLDFORMAT _HRESULT_TYPEDEF_(0x80030104L) +#define STG_E_OLDDLL _HRESULT_TYPEDEF_(0x80030105L) +#define STG_E_SHAREREQUIRED _HRESULT_TYPEDEF_(0x80030106L) +#define STG_E_NOTFILEBASEDSTORAGE _HRESULT_TYPEDEF_(0x80030107L) +#define STG_E_EXTANTMARSHALLINGS _HRESULT_TYPEDEF_(0x80030108L) + +#define STG_E_STATUS_COPY_PROTECTION_FAILURE _HRESULT_TYPEDEF_(0x80030305L) +#define STG_E_CSS_AUTHENTICATION_FAILURE _HRESULT_TYPEDEF_(0x80030306L) +#define STG_E_CSS_KEY_NOT_PRESENT _HRESULT_TYPEDEF_(0x80030307L) +#define STG_E_CSS_KEY_NOT_ESTABLISHED _HRESULT_TYPEDEF_(0x80030308L) +#define STG_E_CSS_SCRAMBLED_SECTOR _HRESULT_TYPEDEF_(0x80030309L) +#define STG_E_CSS_REGION_MISMATCH _HRESULT_TYPEDEF_(0x8003030AL) +#define STG_E_RESETS_EXHAUSTED _HRESULT_TYPEDEF_(0x8003030BL) #define RPC_E_CALL_REJECTED ((HRESULT)0x80010001L) #define RPC_E_CALL_CANCELED ((HRESULT)0x80010002L) #define RPC_E_CANTPOST_INSENDCALL ((HRESULT)0x80010003L) @@ -2239,4 +2261,208 @@ #define NTE_SYS_ERR ((HRESULT)0x80090021L) /* #define NTE_TOKEN_KEYSET_STORAGE ??? */ +#define SEC_E_INSUFFICIENT_MEMORY _HRESULT_TYPEDEF_(0x80090300L) +#define SEC_E_INVALID_HANDLE _HRESULT_TYPEDEF_(0x80090301L) +#define SEC_E_UNSUPPORTED_FUNCTION _HRESULT_TYPEDEF_(0x80090302L) +#define SEC_E_TARGET_UNKNOWN _HRESULT_TYPEDEF_(0x80090303L) +#define SEC_E_INTERNAL_ERROR _HRESULT_TYPEDEF_(0x80090304L) +#define SEC_E_SECPKG_NOT_FOUND _HRESULT_TYPEDEF_(0x80090305L) +#define SEC_E_NOT_OWNER _HRESULT_TYPEDEF_(0x80090306L) +#define SEC_E_CANNOT_INSTALL _HRESULT_TYPEDEF_(0x80090307L) +#define SEC_E_INVALID_TOKEN _HRESULT_TYPEDEF_(0x80090308L) +#define SEC_E_CANNOT_PACK _HRESULT_TYPEDEF_(0x80090309L) +#define SEC_E_QOP_NOT_SUPPORTED _HRESULT_TYPEDEF_(0x8009030AL) +#define SEC_E_NO_IMPERSONATION _HRESULT_TYPEDEF_(0x8009030BL) +#define SEC_E_LOGON_DENIED _HRESULT_TYPEDEF_(0x8009030CL) +#define SEC_E_UNKNOWN_CREDENTIALS _HRESULT_TYPEDEF_(0x8009030DL) +#define SEC_E_NO_CREDENTIALS _HRESULT_TYPEDEF_(0x8009030EL) +#define SEC_E_MESSAGE_ALTERED _HRESULT_TYPEDEF_(0x8009030FL) +#define SEC_E_OUT_OF_SEQUENCE _HRESULT_TYPEDEF_(0x80090310L) +#define SEC_E_NO_AUTHENTICATING_AUTHORITY _HRESULT_TYPEDEF_(0x80090311L) +#define SEC_E_BAD_PKGID _HRESULT_TYPEDEF_(0x80090316L) +#define SEC_E_CONTEXT_EXPIRED _HRESULT_TYPEDEF_(0x80090317L) +#define SEC_E_INCOMPLETE_MESSAGE _HRESULT_TYPEDEF_(0x80090318L) +#define SEC_E_INCOMPLETE_CREDENTIALS _HRESULT_TYPEDEF_(0x80090320L) +#define SEC_E_BUFFER_TOO_SMALL _HRESULT_TYPEDEF_(0x80090321L) +#define SEC_E_WRONG_PRINCIPAL _HRESULT_TYPEDEF_(0x80090322L) +#define SEC_E_TIME_SKEW _HRESULT_TYPEDEF_(0x80090324L) +#define SEC_E_UNTRUSTED_ROOT _HRESULT_TYPEDEF_(0x80090325L) +#define SEC_E_ILLEGAL_MESSAGE _HRESULT_TYPEDEF_(0x80090326L) +#define SEC_E_CERT_UNKNOWN _HRESULT_TYPEDEF_(0x80090327L) +#define SEC_E_CERT_EXPIRED _HRESULT_TYPEDEF_(0x80090328L) +#define SEC_E_ENCRYPT_FAILURE _HRESULT_TYPEDEF_(0x80090329L) +#define SEC_E_DECRYPT_FAILURE _HRESULT_TYPEDEF_(0x80090330L) +#define SEC_E_ALGORITHM_MISMATCH _HRESULT_TYPEDEF_(0x80090331L) +#define SEC_E_SECURITY_QOS_FAILED _HRESULT_TYPEDEF_(0x80090332L) +#define SEC_E_UNFINISHED_CONTEXT_DELETED _HRESULT_TYPEDEF_(0x80090333L) +#define SEC_E_NO_TGT_REPLY _HRESULT_TYPEDEF_(0x80090334L) +#define SEC_E_NO_IP_ADDRESSES _HRESULT_TYPEDEF_(0x80090335L) +#define SEC_E_WRONG_CREDENTIAL_HANDLE _HRESULT_TYPEDEF_(0x80090336L) +#define SEC_E_CRYPTO_SYSTEM_INVALID _HRESULT_TYPEDEF_(0x80090337L) +#define SEC_E_MAX_REFERRALS_EXCEEDED _HRESULT_TYPEDEF_(0x80090338L) +#define SEC_E_MUST_BE_KDC _HRESULT_TYPEDEF_(0x80090339L) +#define SEC_E_STRONG_CRYPTO_NOT_SUPPORTED _HRESULT_TYPEDEF_(0x8009033AL) +#define SEC_E_TOO_MANY_PRINCIPALS _HRESULT_TYPEDEF_(0x8009033BL) +#define SEC_E_NO_PA_DATA _HRESULT_TYPEDEF_(0x8009033CL) +#define SEC_E_PKINIT_NAME_MISMATCH _HRESULT_TYPEDEF_(0x8009033DL) +#define SEC_E_SMARTCARD_LOGON_REQUIRED _HRESULT_TYPEDEF_(0x8009033EL) +#define SEC_E_SHUTDOWN_IN_PROGRESS _HRESULT_TYPEDEF_(0x8009033FL) +#define SEC_E_KDC_INVALID_REQUEST _HRESULT_TYPEDEF_(0x80090340L) +#define SEC_E_KDC_UNABLE_TO_REFER _HRESULT_TYPEDEF_(0x80090341L) +#define SEC_E_KDC_UNKNOWN_ETYPE _HRESULT_TYPEDEF_(0x80090342L) +#define SEC_E_UNSUPPORTED_PREAUTH _HRESULT_TYPEDEF_(0x80090343L) +#define SEC_E_DELEGATION_REQUIRED _HRESULT_TYPEDEF_(0x80090345L) +#define SEC_E_BAD_BINDINGS _HRESULT_TYPEDEF_(0x80090346L) +#define SEC_E_MULTIPLE_ACCOUNTS _HRESULT_TYPEDEF_(0x80090347L) +#define SEC_E_NO_KERB_KEY _HRESULT_TYPEDEF_(0x80090348L) +#define SEC_E_CERT_WRONG_USAGE _HRESULT_TYPEDEF_(0x80090349L) +#define SEC_E_DOWNGRADE_DETECTED _HRESULT_TYPEDEF_(0x80090350L) +#define SEC_E_SMARTCARD_CERT_REVOKED _HRESULT_TYPEDEF_(0x80090351L) +#define SEC_E_ISSUING_CA_UNTRUSTED _HRESULT_TYPEDEF_(0x80090352L) +#define SEC_E_REVOCATION_OFFLINE_C _HRESULT_TYPEDEF_(0x80090353L) +#define SEC_E_PKINIT_CLIENT_FAILURE _HRESULT_TYPEDEF_(0x80090354L) +#define SEC_E_SMARTCARD_CERT_EXPIRED _HRESULT_TYPEDEF_(0x80090355L) +#define SEC_E_NO_S4U_PROT_SUPPORT _HRESULT_TYPEDEF_(0x80090356L) +#define SEC_E_CROSSREALM_DELEGATION_FAILURE _HRESULT_TYPEDEF_(0x80090357L) +#define SEC_E_REVOCATION_OFFLINE_KDC _HRESULT_TYPEDEF_(0x80090358L) +#define SEC_E_ISSUING_CA_UNTRUSTED_KDC _HRESULT_TYPEDEF_(0x80090359L) +#define SEC_E_KDC_CERT_EXPIRED _HRESULT_TYPEDEF_(0x8009035AL) +#define SEC_E_KDC_CERT_REVOKED _HRESULT_TYPEDEF_(0x8009035BL) + +#define CRYPT_E_MSG_ERROR _HRESULT_TYPEDEF_(0x80091001L) +#define CRYPT_E_UNKNOWN_ALGO _HRESULT_TYPEDEF_(0x80091002L) +#define CRYPT_E_OID_FORMAT _HRESULT_TYPEDEF_(0x80091003L) +#define CRYPT_E_INVALID_MSG_TYPE _HRESULT_TYPEDEF_(0x80091004L) +#define CRYPT_E_UNEXPECTED_ENCODING _HRESULT_TYPEDEF_(0x80091005L) +#define CRYPT_E_AUTH_ATTR_MISSING _HRESULT_TYPEDEF_(0x80091006L) +#define CRYPT_E_HASH_VALUE _HRESULT_TYPEDEF_(0x80091007L) +#define CRYPT_E_INVALID_INDEX _HRESULT_TYPEDEF_(0x80091008L) +#define CRYPT_E_ALREADY_DECRYPTED _HRESULT_TYPEDEF_(0x80091009L) +#define CRYPT_E_NOT_DECRYPTED _HRESULT_TYPEDEF_(0x8009100AL) +#define CRYPT_E_RECIPIENT_NOT_FOUND _HRESULT_TYPEDEF_(0x8009100BL) +#define CRYPT_E_CONTROL_TYPE _HRESULT_TYPEDEF_(0x8009100CL) +#define CRYPT_E_ISSUER_SERIALNUMBER _HRESULT_TYPEDEF_(0x8009100DL) +#define CRYPT_E_SIGNER_NOT_FOUND _HRESULT_TYPEDEF_(0x8009100EL) +#define CRYPT_E_ATTRIBUTES_MISSING _HRESULT_TYPEDEF_(0x8009100FL) +#define CRYPT_E_STREAM_MSG_NOT_READY _HRESULT_TYPEDEF_(0x80091010L) +#define CRYPT_E_STREAM_INSUFFICIENT_DATA _HRESULT_TYPEDEF_(0x80091011L) +#define CRYPT_I_NEW_PROTECTION_REQUIRED _HRESULT_TYPEDEF_(0x80091012L) + +#define CRYPT_E_BAD_LEN _HRESULT_TYPEDEF_(0x80092001L) +#define CRYPT_E_BAD_ENCODE _HRESULT_TYPEDEF_(0x80092002L) +#define CRYPT_E_FILE_ERROR _HRESULT_TYPEDEF_(0x80092003L) +#define CRYPT_E_NOT_FOUND _HRESULT_TYPEDEF_(0x80092004L) +#define CRYPT_E_EXISTS _HRESULT_TYPEDEF_(0x80092005L) +#define CRYPT_E_NO_PROVIDER _HRESULT_TYPEDEF_(0x80092006L) +#define CRYPT_E_SELF_SIGNED _HRESULT_TYPEDEF_(0x80092007L) +#define CRYPT_E_DELETED_PREV _HRESULT_TYPEDEF_(0x80092008L) +#define CRYPT_E_NO_MATCH _HRESULT_TYPEDEF_(0x80092009L) +#define CRYPT_E_UNEXPECTED_MSG_TYPE _HRESULT_TYPEDEF_(0x8009200AL) +#define CRYPT_E_NO_KEY_PROPERTY _HRESULT_TYPEDEF_(0x8009200BL) +#define CRYPT_E_NO_DECRYPT_CERT _HRESULT_TYPEDEF_(0x8009200CL) +#define CRYPT_E_BAD_MSG _HRESULT_TYPEDEF_(0x8009200DL) +#define CRYPT_E_NO_SIGNER _HRESULT_TYPEDEF_(0x8009200EL) +#define CRYPT_E_PENDING_CLOSE _HRESULT_TYPEDEF_(0x8009200FL) +#define CRYPT_E_REVOKED _HRESULT_TYPEDEF_(0x80092010L) +#define CRYPT_E_NO_REVOCATION_DLL _HRESULT_TYPEDEF_(0x80092011L) +#define CRYPT_E_NO_REVOCATION_CHECK _HRESULT_TYPEDEF_(0x80092012L) +#define CRYPT_E_REVOCATION_OFFLINE _HRESULT_TYPEDEF_(0x80092013L) +#define CRYPT_E_NOT_IN_REVOCATION_DATABASE _HRESULT_TYPEDEF_(0x80092014L) +#define CRYPT_E_INVALID_NUMERIC_STRING _HRESULT_TYPEDEF_(0x80092020L) +#define CRYPT_E_INVALID_PRINTABLE_STRING _HRESULT_TYPEDEF_(0x80092021L) +#define CRYPT_E_INVALID_IA5_STRING _HRESULT_TYPEDEF_(0x80092022L) +#define CRYPT_E_INVALID_X500_STRING _HRESULT_TYPEDEF_(0x80092023L) +#define CRYPT_E_NOT_CHAR_STRING _HRESULT_TYPEDEF_(0x80092024L) +#define CRYPT_E_FILERESIZED _HRESULT_TYPEDEF_(0x80092025L) +#define CRYPT_E_SECURITY_SETTINGS _HRESULT_TYPEDEF_(0x80092026L) +#define CRYPT_E_NO_VERIFY_USAGE_DLL _HRESULT_TYPEDEF_(0x80092027L) +#define CRYPT_E_NO_VERIFY_USAGE_CHECK _HRESULT_TYPEDEF_(0x80092028L) +#define CRYPT_E_VERIFY_USAGE_OFFLINE _HRESULT_TYPEDEF_(0x80092029L) +#define CRYPT_E_NOT_IN_CTL _HRESULT_TYPEDEF_(0x8009202AL) +#define CRYPT_E_NO_TRUSTED_SIGNER _HRESULT_TYPEDEF_(0x8009202BL) +#define CRYPT_E_MISSING_PUBKEY_PARA _HRESULT_TYPEDEF_(0x8009202CL) +#define CRYPT_E_OSS_ERROR _HRESULT_TYPEDEF_(0x80093000L) +#define OSS_MORE_BUF _HRESULT_TYPEDEF_(0x80093001L) +#define OSS_NEGATIVE_UINTEGER _HRESULT_TYPEDEF_(0x80093002L) +#define OSS_PDU_RANGE _HRESULT_TYPEDEF_(0x80093003L) +#define OSS_MORE_INPUT _HRESULT_TYPEDEF_(0x80093004L) +#define OSS_DATA_ERROR _HRESULT_TYPEDEF_(0x80093005L) +#define OSS_BAD_ARG _HRESULT_TYPEDEF_(0x80093006L) +#define OSS_BAD_VERSION _HRESULT_TYPEDEF_(0x80093007L) +#define OSS_OUT_MEMORY _HRESULT_TYPEDEF_(0x80093008L) +#define OSS_PDU_MISMATCH _HRESULT_TYPEDEF_(0x80093009L) +#define OSS_LIMITED _HRESULT_TYPEDEF_(0x8009300AL) +#define OSS_BAD_PTR _HRESULT_TYPEDEF_(0x8009300BL) +#define OSS_BAD_TIME _HRESULT_TYPEDEF_(0x8009300CL) +#define OSS_INDEFINITE_NOT_SUPPORTED _HRESULT_TYPEDEF_(0x8009300DL) +#define OSS_MEM_ERROR _HRESULT_TYPEDEF_(0x8009300EL) +#define OSS_BAD_TABLE _HRESULT_TYPEDEF_(0x8009300FL) +#define OSS_TOO_LONG _HRESULT_TYPEDEF_(0x80093010L) +#define OSS_CONSTRAINT_VIOLATED _HRESULT_TYPEDEF_(0x80093011L) +#define OSS_FATAL_ERROR _HRESULT_TYPEDEF_(0x80093012L) +#define OSS_ACCESS_SERIALIZATION_ERROR _HRESULT_TYPEDEF_(0x80093013L) +#define OSS_NULL_TBL _HRESULT_TYPEDEF_(0x80093014L) +#define OSS_NULL_FCN _HRESULT_TYPEDEF_(0x80093015L) +#define OSS_BAD_ENCRULES _HRESULT_TYPEDEF_(0x80093016L) +#define OSS_UNAVAIL_ENCRULES _HRESULT_TYPEDEF_(0x80093017L) +#define OSS_CANT_OPEN_TRACE_WINDOW _HRESULT_TYPEDEF_(0x80093018L) +#define OSS_UNIMPLEMENTED _HRESULT_TYPEDEF_(0x80093019L) +#define OSS_OID_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x8009301AL) +#define OSS_CANT_OPEN_TRACE_FILE _HRESULT_TYPEDEF_(0x8009301BL) +#define OSS_TRACE_FILE_ALREADY_OPEN _HRESULT_TYPEDEF_(0x8009301CL) +#define OSS_TABLE_MISMATCH _HRESULT_TYPEDEF_(0x8009301DL) +#define OSS_TYPE_NOT_SUPPORTED _HRESULT_TYPEDEF_(0x8009301EL) +#define OSS_REAL_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x8009301FL) +#define OSS_REAL_CODE_NOT_LINKED _HRESULT_TYPEDEF_(0x80093020L) +#define OSS_OUT_OF_RANGE _HRESULT_TYPEDEF_(0x80093021L) +#define OSS_COPIER_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x80093022L) +#define OSS_CONSTRAINT_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x80093023L) +#define OSS_COMPARATOR_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x80093024L) +#define OSS_COMPARATOR_CODE_NOT_LINKED _HRESULT_TYPEDEF_(0x80093025L) +#define OSS_MEM_MGR_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x80093026L) +#define OSS_PDV_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x80093027L) +#define OSS_PDV_CODE_NOT_LINKED _HRESULT_TYPEDEF_(0x80093028L) +#define OSS_API_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x80093029L) +#define OSS_BERDER_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x8009302AL) +#define OSS_PER_DLL_NOT_LINKED _HRESULT_TYPEDEF_(0x8009302BL) +#define OSS_OPEN_TYPE_ERROR _HRESULT_TYPEDEF_(0x8009302CL) +#define OSS_MUTEX_NOT_CREATED _HRESULT_TYPEDEF_(0x8009302DL) +#define OSS_CANT_CLOSE_TRACE_FILE _HRESULT_TYPEDEF_(0x8009302EL) +#define CRYPT_E_ASN1_ERROR _HRESULT_TYPEDEF_(0x80093100L) +#define CRYPT_E_ASN1_INTERNAL _HRESULT_TYPEDEF_(0x80093101L) +#define CRYPT_E_ASN1_EOD _HRESULT_TYPEDEF_(0x80093102L) +#define CRYPT_E_ASN1_CORRUPT _HRESULT_TYPEDEF_(0x80093103L) +#define CRYPT_E_ASN1_LARGE _HRESULT_TYPEDEF_(0x80093104L) +#define CRYPT_E_ASN1_CONSTRAINT _HRESULT_TYPEDEF_(0x80093105L) +#define CRYPT_E_ASN1_MEMORY _HRESULT_TYPEDEF_(0x80093106L) +#define CRYPT_E_ASN1_OVERFLOW _HRESULT_TYPEDEF_(0x80093107L) +#define CRYPT_E_ASN1_BADPDU _HRESULT_TYPEDEF_(0x80093108L) +#define CRYPT_E_ASN1_BADARGS _HRESULT_TYPEDEF_(0x80093109L) +#define CRYPT_E_ASN1_BADREAL _HRESULT_TYPEDEF_(0x8009310AL) +#define CRYPT_E_ASN1_BADTAG _HRESULT_TYPEDEF_(0x8009310BL) +#define CRYPT_E_ASN1_CHOICE _HRESULT_TYPEDEF_(0x8009310CL) +#define CRYPT_E_ASN1_RULE _HRESULT_TYPEDEF_(0x8009310DL) +#define CRYPT_E_ASN1_UTF8 _HRESULT_TYPEDEF_(0x8009310EL) +#define CRYPT_E_ASN1_PDU_TYPE _HRESULT_TYPEDEF_(0x80093133L) +#define CRYPT_E_ASN1_NYI _HRESULT_TYPEDEF_(0x80093134L) +#define CRYPT_E_ASN1_EXTENDED _HRESULT_TYPEDEF_(0x80093201L) +#define CRYPT_E_ASN1_NOEOD _HRESULT_TYPEDEF_(0x80093202L) + +#define TRUST_E_CERT_SIGNATURE _HRESULT_TYPEDEF_(0x80096004L) +#define TRUST_E_PROVIDER_UNKNOWN _HRESULT_TYPEDEF_(0x800B0001L) +#define TRUST_E_ACTION_UNKNOWN _HRESULT_TYPEDEF_(0x800B0002L) +#define TRUST_E_SUBJECT_FORM_UNKNOWN _HRESULT_TYPEDEF_(0x800B0003L) +#define TRUST_E_SUBJECT_NOT_TRUSTED _HRESULT_TYPEDEF_(0x800B0004L) + +/* Smart card management error codes */ +#define SCARD_E_NO_SMARTCARD _HRESULT_TYPEDEF_(0x8010000CL) +#define SCARD_E_NO_SUCH_CERTIFICATE _HRESULT_TYPEDEF_(0x8010002CL) +#define SCARD_E_COMM_DATA_LOST _HRESULT_TYPEDEF_(0x8010002FL) + +#define SCARD_W_WRONG_CHV _HRESULT_TYPEDEF_(0x8010006BL) +#define SCARD_W_CHV_BLOCKED _HRESULT_TYPEDEF_(0x8010006CL) +#define SCARD_W_CARD_NOT_AUTHENTICATED _HRESULT_TYPEDEF_(0x8010006FL) + + + #endif

1 0

[sedwards] 17133: ntdll pending some winerror.h fixes
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

ntdll pending some winerror.h fixes Added: trunk/reactos/regtests/winetests/ntdll/ Added: trunk/reactos/regtests/winetests/ntdll/atom.c Added: trunk/reactos/regtests/winetests/ntdll/env.c Added: trunk/reactos/regtests/winetests/ntdll/error.c Added: trunk/reactos/regtests/winetests/ntdll/generated.c Added: trunk/reactos/regtests/winetests/ntdll/info.c Added: trunk/reactos/regtests/winetests/ntdll/large_int.c Added: trunk/reactos/regtests/winetests/ntdll/ntdll_test.h Added: trunk/reactos/regtests/winetests/ntdll/ntdll_test.xml Added: trunk/reactos/regtests/winetests/ntdll/path.c Added: trunk/reactos/regtests/winetests/ntdll/reg.c Added: trunk/reactos/regtests/winetests/ntdll/rtl.c Added: trunk/reactos/regtests/winetests/ntdll/rtlbitmap.c Added: trunk/reactos/regtests/winetests/ntdll/rtlstr.c Added: trunk/reactos/regtests/winetests/ntdll/string.c Added: trunk/reactos/regtests/winetests/ntdll/testlist.c Added: trunk/reactos/regtests/winetests/ntdll/time.c _____ Added: trunk/reactos/regtests/winetests/ntdll/atom.c --- trunk/reactos/regtests/winetests/ntdll/atom.c 2005-08-07 01:23:40 UTC (rev 17132) +++ trunk/reactos/regtests/winetests/ntdll/atom.c 2005-08-07 02:16:34 UTC (rev 17133) @@ -0,0 +1,402 @@ +/* Unit test suite for Ntdll atom API functions + * + * Copyright 2003 Gyorgy 'Nog' Jeney + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * NOTES + * We use function pointers here as there is no import library for NTDLL on + * windows. + */ + +#define _WIN32_WINNT 0x0501 + +#include <stdio.h> +#include <stdarg.h> +#include "windows.h" +#include "ntstatus.h" +#include "wine/test.h" +#include "wine/unicode.h" +#include "winternl.h" + +/* Function pointers for ntdll calls */ +static HMODULE hntdll = 0; +static NTSTATUS (WINAPI *pRtlCreateAtomTable)(ULONG,PRTL_ATOM_TABLE); +static NTSTATUS (WINAPI *pRtlDestroyAtomTable)(RTL_ATOM_TABLE); +static NTSTATUS (WINAPI *pRtlEmptyAtomTable)(RTL_ATOM_TABLE,BOOLEAN); +static NTSTATUS (WINAPI *pRtlAddAtomToAtomTable)(RTL_ATOM_TABLE,PCWSTR,PRTL_ATOM); +static NTSTATUS (WINAPI *pRtlDeleteAtomFromAtomTable)(RTL_ATOM_TABLE,RTL_ATOM); +static NTSTATUS (WINAPI *pRtlLookupAtomInAtomTable)(RTL_ATOM_TABLE,PCWSTR,PRTL_ATOM); +static NTSTATUS (WINAPI *pRtlPinAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM); +static NTSTATUS (WINAPI *pRtlQueryAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM,PULONG,PULONG,PWSTR,P ULONG); + +static const WCHAR EmptyAtom[] = {0}; +static const WCHAR testAtom1[] = {'H','e','l','l','o',' ','W','o','r','l','d',0}; +static const WCHAR testAtom2[] = {'H','e','l','l','o',' ','W','o','r','l','d','2',0}; +static const WCHAR testAtom3[] = {'H','e','l','l','o',' ','W','o','r','l','d','3',0}; + +static const WCHAR testAtom1Cap[] = {'H','E','L','L','O',' ','W','O','R','L','D',0}; +static const WCHAR testAtom1Low[] = {'h','e','l','l','o',' ','w','o','r','l','d',0}; + +static const WCHAR testAtomInt[] = {'#','1','3','2',0}; +static const WCHAR testAtomIntInv[] = {'#','2','3','4','z',0}; +static const WCHAR testAtomOTT[] = {'#','1','2','3',0}; + +static void InitFunctionPtr(void) +{ + hntdll = LoadLibraryA("ntdll.dll"); + ok(hntdll != 0, "Unable to load ntdll.dll\n"); + + if (hntdll) + { + pRtlCreateAtomTable = (void *)GetProcAddress(hntdll, "RtlCreateAtomTable"); + pRtlDestroyAtomTable = (void *)GetProcAddress(hntdll, "RtlDestroyAtomTable"); + pRtlEmptyAtomTable = (void *)GetProcAddress(hntdll, "RtlEmptyAtomTable"); + pRtlAddAtomToAtomTable = (void *)GetProcAddress(hntdll, "RtlAddAtomToAtomTable"); + pRtlDeleteAtomFromAtomTable = (void *)GetProcAddress(hntdll, "RtlDeleteAtomFromAtomTable"); + pRtlLookupAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlLookupAtomInAtomTable"); + pRtlPinAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlPinAtomInAtomTable"); + pRtlQueryAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlQueryAtomInAtomTable"); + } +} + +static DWORD RtlAtomTestThread(LPVOID Table) +{ + RTL_ATOM_TABLE AtomTable = *(PRTL_ATOM_TABLE)Table; + RTL_ATOM Atom; + NTSTATUS res; + ULONG RefCount = 0, PinCount = 0, Len = 0; + WCHAR Name[64]; + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &Atom); + ok(!res, "Unable to find atom from another thread, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &Atom); + ok(!res, "Unable to lookup pinned atom in table, retval: %lx\n", res); + + res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, Name, &Len); + ok(res == STATUS_BUFFER_TOO_SMALL, "We got wrong retval: %lx\n", res); + + Len = 64; + res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, Name, &Len); + ok(!res, "Failed with longenough buffer, retval: %lx\n", res); + ok(RefCount == 1, "Refcount was not 1 but %lx\n", RefCount); + ok(PinCount == 1, "Pincount was not 1 but %lx\n", PinCount); + ok(!strcmpW(Name, testAtom2), "We found wrong atom!!\n"); + ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len); + + Len = 64; + res = pRtlQueryAtomInAtomTable(AtomTable, Atom, NULL, NULL, Name, &Len); + ok(!res, "RtlQueryAtomInAtomTable with optional args invalid failed, retval: %lx\n", res); + ok(!strcmpW(Name, testAtom2), "Found Wrong atom!\n"); + ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len); + + res = pRtlPinAtomInAtomTable(AtomTable, Atom); + ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res); + + return 0; +} + +static void test_NtAtom(void) +{ + RTL_ATOM_TABLE AtomTable = NULL; + NTSTATUS res; + RTL_ATOM Atom1, Atom2, Atom3, testEAtom, testAtom; + HANDLE testThread; + ULONG RefCount = 0, PinCount = 0, Len = 0; + WCHAR Name[64]; + + /* If we pass a non-null string to create atom table, then it thinks that we + * have passed it an already allocated atom table */ + res = pRtlCreateAtomTable(0, &AtomTable); + ok(!res, "RtlCreateAtomTable should succeed with an atom table size of 0\n"); + + if (!res) + { + res = pRtlDestroyAtomTable(AtomTable); + ok(!res, "We could create the atom table, but we couldn't destroy it! retval: %lx\n", res); + } + + AtomTable = NULL; + res = pRtlCreateAtomTable(37, &AtomTable); + ok(!res, "We're unable to create an atom table with a valid table size retval: %lx\n", res); + if (!res) + { + res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1); + ok(!res, "We were unable to add a simple atom to the atom table, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1Cap, &testAtom); + ok(!res, "We were unable to find capital version of the atom, retval: %lx\n", res); + ok(Atom1 == testAtom, "Found wrong atom in table when querying capital atom\n"); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1Low, &testAtom); + ok(!res, "Unable to find lowercase version of the atom, retval: %lx\n", res); + ok(testAtom == Atom1, "Found wrong atom when querying lowercase atom\n"); + + res = pRtlAddAtomToAtomTable(AtomTable, EmptyAtom, &testEAtom); + ok(res == STATUS_OBJECT_NAME_INVALID, "Got wrong retval, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(!res, "Failed to find totally legitimate atom, retval: %lx\n", res); + ok(testAtom == Atom1, "Found wrong atom!\n"); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtom2, &Atom2); + ok(!res, "Unable to add other legitimate atom to table, retval: %lx\n", res); + + res = pRtlPinAtomInAtomTable(AtomTable, Atom2); + ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res); + + testThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RtlAtomTestThread, &AtomTable, 0, NULL); + WaitForSingleObject(testThread, INFINITE); + + Len = 64; + res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, &RefCount, &PinCount, Name, &Len); + ok(!res, "Unable to query atom in atom table, retval: %lx\n", res); + ok(RefCount == 1, "RefCount is not 1 but %lx\n", RefCount); + ok(PinCount == 1, "PinCount is not 1 but %lx\n", PinCount); + ok(!strcmpW(Name, testAtom2), "We found wrong atom\n"); + ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len); + + res = pRtlEmptyAtomTable(AtomTable, FALSE); + ok(!res, "Unable to empty atom table, retval %lx\n", res); + + Len = 64; + res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, &RefCount, &PinCount, Name, &Len); + ok(!res, "It seems RtlEmptyAtomTable deleted our pinned atom eaven though we asked it not to, retval: %lx\n", res); + ok(RefCount == 1, "RefCount is not 1 but %lx\n", RefCount); + ok(PinCount == 1, "PinCount is not 1 but %lx\n", PinCount); + ok(!strcmpW(Name, testAtom2), "We found wrong atom\n"); + ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &testAtom); + ok(!res, "We can't find our pinned atom!! retval: %lx\n", res); + ok(testAtom == Atom2, "We found wrong atom!!!\n"); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "We found the atom in our table eaven though we asked RtlEmptyAtomTable to remove it, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtom3, &Atom3); + ok(!res, "Unable to add atom to table, retval: %lx\n", res); + + res = pRtlEmptyAtomTable(AtomTable, TRUE); + ok(!res, "Unable to empty atom table, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &testAtom); + ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "The pinned atom should be removed, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom3, &testAtom); + ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Non pinned atom should also be removed, retval: %lx\n", res); + + res = pRtlDestroyAtomTable(AtomTable); + ok(!res, "Can't destroy atom table, retval: %lx\n", res); + } + + AtomTable = NULL; + res = pRtlCreateAtomTable(37, &AtomTable); + ok(!res, "Unable to create atom table, retval: %lx\n", res); + + if (!res) + { + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Didn't get expected retval with querying an empty atom table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1); + ok(!res, "Unable to add atom to atom table, retval %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(!res, "Can't find previously added atom in table, retval: %lx\n", res); + ok(testAtom == Atom1, "Found wrong atom! retval: %lx\n", res); + + res = pRtlDeleteAtomFromAtomTable(AtomTable, Atom1); + ok(!res, "Unable to delete atom from table, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Able to find previously deleted atom in table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1); + ok(!res, "Unable to add atom to atom table, retval: %lx\n", res); + + Len = 0; + res = pRtlQueryAtomInAtomTable(AtomTable, Atom1, NULL, NULL, Name, &Len); + ok(res == STATUS_BUFFER_TOO_SMALL, "Got wrong retval, retval: %lx\n", res); + ok((strlenW(testAtom1) * sizeof(WCHAR)) == Len, "Got wrong length %lx\n", Len); + + res = pRtlPinAtomInAtomTable(AtomTable, Atom1); + ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(!res, "Unable to find atom in atom table, retval: %lx\n", res); + ok(testAtom == Atom1, "Wrong atom found\n"); + + res = pRtlDeleteAtomFromAtomTable(AtomTable, Atom1); + ok(res == STATUS_WAS_LOCKED, "Unable to delete atom from table, retval: %lx\n", res); + + res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom); + ok(!res, "Able to find deleted atom in table\n"); + + res = pRtlDestroyAtomTable(AtomTable); + ok(!res, "Unable to destroy atom table\n"); + } +} + +/* Test Adding integer atoms to atom table */ +static void test_NtIntAtom(void) +{ + NTSTATUS res; + RTL_ATOM_TABLE AtomTable; + RTL_ATOM testAtom; + ULONG RefCount = 0, PinCount = 0; + int i; + WCHAR Name[64]; + ULONG Len; + + AtomTable = NULL; + res = pRtlCreateAtomTable(37, &AtomTable); + ok(!res, "Unable to create atom table, %lx\n", res); + + if (!res) + { + /* According to the kernel32 functions, integer atoms are only allowd from + * 0x0001 to 0xbfff and not 0xc000 to 0xffff, which is correct */ + res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)0, &testAtom); + ok(res == STATUS_INVALID_PARAMETER, "Didn't get expected result from adding 0 int atom, retval: %lx\n", res); + for (i = 1; i <= 0xbfff; i++) + { + res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)i, &testAtom); + ok(!res, "Unable to add valid integer atom %i, retval: %lx\n", i, res); + } + + for (i = 1; i <= 0xbfff; i++) + { + res = pRtlLookupAtomInAtomTable(AtomTable, (PWSTR)i, &testAtom); + ok(!res, "Unable to find int atom %i, retval: %lx\n", i, res); + if (!res) + { + res = pRtlPinAtomInAtomTable(AtomTable, testAtom); + ok(!res, "Unable to pin int atom %i, retval: %lx\n", i, res); + } + } + + for (i = 0xc000; i <= 0xffff; i++) + { + res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)i, &testAtom); + ok(res, "Able to illeageal integer atom %i, retval: %lx\n", i, res); + } + + res = pRtlDestroyAtomTable(AtomTable); + ok(!res, "Unable to destroy atom table, retval: %lx\n", res); + } + + AtomTable = NULL; + res = pRtlCreateAtomTable(37, &AtomTable); + ok(!res, "Unable to create atom table, %lx\n", res); + if (!res) + { + res = pRtlLookupAtomInAtomTable(AtomTable, (PWSTR)123, &testAtom); + ok(!res, "Unable to query atom in atom table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtomInt, &testAtom); + ok(!res, "Unable to add int atom to table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtomIntInv, &testAtom); + ok(!res, "Unable to add int atom to table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)123, &testAtom); + ok(!res, "Unable to add int atom to table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)123, &testAtom); + ok(!res, "Unable to re-add int atom to table, retval: %lx\n", res); + + Len = 64; + res = pRtlQueryAtomInAtomTable(AtomTable, testAtom, &RefCount, &PinCount, Name, &Len); + ok(!res, "Unable to query atom in atom table, retval: %lx\n", res); + ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount); + ok(RefCount == 1, "Expected refcount 1 but got %lx\n", RefCount); + ok(!strcmpW(testAtomOTT, Name), "Got wrong atom name\n"); + ok((strlenW(testAtomOTT) * sizeof(WCHAR)) == Len, "Got wrong len %ld\n", Len); + + res = pRtlPinAtomInAtomTable(AtomTable, testAtom); + ok(!res, "Unable to pin int atom, retval: %lx\n", res); + + res = pRtlPinAtomInAtomTable(AtomTable, testAtom); + ok(!res, "Unable to pin int atom, retval: %lx\n", res); + + res = pRtlQueryAtomInAtomTable(AtomTable, testAtom, &RefCount, &PinCount, NULL, NULL); + ok(!res, "Unable to query atom in atom table, retval: %lx\n", res); + ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount); + ok(RefCount == 1, "Expected refcount 1 but got %lx\n", RefCount); + + res = pRtlDestroyAtomTable(AtomTable); + ok(!res, "Unable to destroy atom table, retval: %lx\n", res); + } +} + +/* Tests to see how the pincount and refcount actually works */ +static void test_NtRefPinAtom(void) +{ + RTL_ATOM_TABLE AtomTable; + RTL_ATOM Atom; + ULONG PinCount = 0, RefCount = 0; + NTSTATUS res; + + AtomTable = NULL; + res = pRtlCreateAtomTable(37, &AtomTable); + ok(!res, "Unable to create atom table, %lx\n", res); + + if (!res) + { + res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom); + ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom); + ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res); + + res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom); + ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res); + + res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, NULL, NULL); + ok(!res, "Unable to query atom in atom table, retval: %lx\n", res); + ok(PinCount == 0, "Expected pincount 0 but got %lx\n", PinCount); + ok(RefCount == 3, "Expected refcount 3 but got %lx\n", RefCount); + + res = pRtlPinAtomInAtomTable(AtomTable, Atom); + ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res); + + res = pRtlPinAtomInAtomTable(AtomTable, Atom); + ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res); + + res = pRtlPinAtomInAtomTable(AtomTable, Atom); + ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res); + + res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, NULL, NULL); + ok(!res, "Unable to query atom in atom table, retval: %lx\n", res); + ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount); + ok(RefCount == 3, "Expected refcount 3 but got %lx\n", RefCount); + + res = pRtlDestroyAtomTable(AtomTable); + ok(!res, "Unable to destroy atom table, retval: %lx\n", res); + } +} + +START_TEST(atom) +{ + InitFunctionPtr(); + if (pRtlCreateAtomTable) + { + test_NtAtom(); + test_NtIntAtom(); + test_NtRefPinAtom(); + } +} Property changes on: trunk/reactos/regtests/winetests/ntdll/atom.c ___________________________________________________________________ Name: svn:executable + * _____ Added: trunk/reactos/regtests/winetests/ntdll/env.c --- trunk/reactos/regtests/winetests/ntdll/env.c 2005-08-07 01:23:40 UTC (rev 17132) +++ trunk/reactos/regtests/winetests/ntdll/env.c 2005-08-07 02:16:34 UTC (rev 17133) @@ -0,0 +1,298 @@ +/* + * Unit test suite for ntdll path functions + * + * Copyright 2003 Eric Pouech + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include <stdio.h> + +#include "ntdll_test.h" +#include "wine/unicode.h" + +static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)( LPWSTR dst, DWORD dstlen, LPDWORD reslen, + LPCSTR src, DWORD srclen ); +static NTSTATUS (WINAPI *pRtlCreateEnvironment)(BOOLEAN, PWSTR*); +static NTSTATUS (WINAPI *pRtlDestroyEnvironment)(PWSTR); +static NTSTATUS (WINAPI *pRtlQueryEnvironmentVariable_U)(PWSTR, PUNICODE_STRING, PUNICODE_STRING); +static void (WINAPI *pRtlSetCurrentEnvironment)(PWSTR, PWSTR*); +static NTSTATUS (WINAPI *pRtlSetEnvironmentVariable)(PWSTR*, PUNICODE_STRING, PUNICODE_STRING); +static NTSTATUS (WINAPI *pRtlExpandEnvironmentStrings_U)(LPWSTR, PUNICODE_STRING, PUNICODE_STRING, PULONG); + +static WCHAR small_env[] = {'f','o','o','=','t','o','t','o',0, + 'f','o','=','t','i','t','i',0, + 'f','o','o','o','=','t','u','t','u',0, + 's','r','=','a','n','=','o','u','o',0, + 'g','=','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a', + 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a', 'a','a','a','a','a','a','a',0, + '=','o','O','H','=','I','I','I',0, + 'n','u','l','=',0, + 0}; + +static void testQuery(void) +{ + struct test + { + const char *var; + int len; + NTSTATUS status; + const char *val; + }; + + static const struct test tests[] = + { + {"foo", 256, STATUS_SUCCESS, "toto"}, + {"FoO", 256, STATUS_SUCCESS, "toto"}, + {"foo=", 256, STATUS_VARIABLE_NOT_FOUND, NULL}, + {"foo ", 256, STATUS_VARIABLE_NOT_FOUND, NULL}, + {"foo", 1, STATUS_BUFFER_TOO_SMALL, "toto"}, + {"foo", 3, STATUS_BUFFER_TOO_SMALL, "toto"}, + {"foo", 4, STATUS_SUCCESS, "toto"}, + {"fooo", 256, STATUS_SUCCESS, "tutu"}, + {"f", 256, STATUS_VARIABLE_NOT_FOUND, NULL}, + {"g", 256, STATUS_SUCCESS, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaa"}, + {"sr=an", 256, STATUS_VARIABLE_NOT_FOUND, NULL}, + {"sr", 256, STATUS_SUCCESS, "an=ouo"}, + {"=oOH", 256, STATUS_SUCCESS, "III"}, + {"", 256, STATUS_VARIABLE_NOT_FOUND, NULL}, + {"nul", 256, STATUS_SUCCESS, ""}, + {NULL, 0, 0, NULL} + }; + + WCHAR bn[257]; + WCHAR bv[257]; + UNICODE_STRING name; + UNICODE_STRING value; + const struct test* test; + NTSTATUS nts; + + for (test = tests; test->var; test++) + { + name.Length = strlen(test->var) * 2; + name.MaximumLength = name.Length + 2; + name.Buffer = bn; + value.Length = 0; + value.MaximumLength = test->len * 2; + value.Buffer = bv; + bv[test->len] = '@'; + + pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->var, strlen(test->var)+1 ); + nts = pRtlQueryEnvironmentVariable_U(small_env, &name, &value); + ok( nts == test->status, "[%d]: Wrong status for '%s', expecting %lx got %lx\n", + test - tests, test->var, test->status, nts ); + if (nts == test->status) switch (nts) + { + case STATUS_SUCCESS: + pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->val, strlen(test->val)+1 ); + ok( value.Length == strlen(test->val) * sizeof(WCHAR), "Wrong length %d/%d for %s\n", + value.Length, strlen(test->val) * sizeof(WCHAR), test->var ); + ok((value.Length == strlen(test->val) * sizeof(WCHAR) && strncmpW(bv, bn, test->len) == 0) || + strcmpW(bv, bn) == 0, + "Wrong result for %s/%d\n", test->var, test->len); + ok(bv[test->len] == '@', "Writing too far away in the buffer for %s/%d\n", test->var, test->len); + break; + case STATUS_BUFFER_TOO_SMALL: + ok( value.Length == strlen(test->val) * sizeof(WCHAR), + "Wrong returned length %d/%d (too small buffer) for %s\n", + value.Length, strlen(test->val) * sizeof(WCHAR), test->var ); + break; + } + } +} + +static void testSetHelper(LPWSTR* env, const char* var, const char* val, NTSTATUS ret) +{ + WCHAR bvar[256], bval1[256], bval2[256]; + UNICODE_STRING uvar; + UNICODE_STRING uval; + NTSTATUS nts; + + uvar.Length = strlen(var) * sizeof(WCHAR); + uvar.MaximumLength = uvar.Length + sizeof(WCHAR); + uvar.Buffer = bvar; + pRtlMultiByteToUnicodeN( bvar, sizeof(bvar), NULL, var, strlen(var)+1 ); + if (val) + { + uval.Length = strlen(val) * sizeof(WCHAR); + uval.MaximumLength = uval.Length + sizeof(WCHAR); + uval.Buffer = bval1; + pRtlMultiByteToUnicodeN( bval1, sizeof(bval1), NULL, val, strlen(val)+1 ); + } + nts = pRtlSetEnvironmentVariable(env, &uvar, val ? &uval : NULL); + ok(nts == ret, "Setting var %s=%s (%lx/%lx)\n", var, val, nts, ret); + if (nts == STATUS_SUCCESS) + { + uval.Length = 0; + uval.MaximumLength = sizeof(bval2); + uval.Buffer = bval2; + nts = pRtlQueryEnvironmentVariable_U(*env, &uvar, &uval); + switch (nts) + { + case STATUS_SUCCESS: + ok(strcmpW(bval1, bval2) == 0, "Cannot get value written to environment\n"); + break; + case STATUS_VARIABLE_NOT_FOUND: + ok(val == NULL, "Couldn't find variable, but didn't delete it. val = %s\n", val); + break; + default: + ok(0, "Wrong ret %lu for %s\n", nts, var); + break; + } + } +} + +static void testSet(void) +{ + LPWSTR env; + char tmp[16]; + int i; + + ok(pRtlCreateEnvironment(FALSE, &env) == STATUS_SUCCESS, "Creating environment\n"); + memmove(env, small_env, sizeof(small_env)); + + testSetHelper(&env, "cat", "dog", STATUS_SUCCESS); + testSetHelper(&env, "cat", "horse", STATUS_SUCCESS); + testSetHelper(&env, "cat", "zz", STATUS_SUCCESS); + testSetHelper(&env, "cat", NULL, STATUS_SUCCESS); + testSetHelper(&env, "cat", NULL, STATUS_VARIABLE_NOT_FOUND); + testSetHelper(&env, "foo", "meouw", STATUS_SUCCESS); + testSetHelper(&env, "me=too", "also", STATUS_INVALID_PARAMETER); + testSetHelper(&env, "me", "too=also", STATUS_SUCCESS); + testSetHelper(&env, "=too", "also", STATUS_SUCCESS); + testSetHelper(&env, "=", "also", STATUS_SUCCESS); + + for (i = 0; i < 128; i++) + { + sprintf(tmp, "zork%03d", i); + testSetHelper(&env, tmp, "is alive", STATUS_SUCCESS); + } + + for (i = 0; i < 128; i++) + { + sprintf(tmp, "zork%03d", i); + testSetHelper(&env, tmp, NULL, STATUS_SUCCESS); + } + testSetHelper(&env, "fOo", NULL, STATUS_SUCCESS); + + ok(pRtlDestroyEnvironment(env) == STATUS_SUCCESS, "Destroying environment\n"); +} + +static void testExpand(void) +{ + static const struct test + { + const char *src; + const char *dst; + } tests[] = + { + {"hello%foo%world", "hellototoworld"}, + {"hello%=oOH%world", "helloIIIworld"}, + {"hello%foo", "hello%foo"}, + {"hello%bar%world", "hello%bar%world"}, + /* + * {"hello%foo%world%=oOH%eeck", "hellototoworldIIIeeck"}, + * Interestingly enough, with a 8 WCHAR buffers, we get on 2k: + * helloIII + * so it seems like strings overflowing the buffer are written + * (troncated) but the write cursor is not advanced :-/ + */ + {NULL, NULL} + }; + + const struct test* test; + NTSTATUS nts; + UNICODE_STRING us_src, us_dst; + WCHAR src[256], dst[256], rst[256]; + ULONG ul; + + for (test = tests; test->src; test++) + { + pRtlMultiByteToUnicodeN(src, sizeof(src), NULL, test->src, strlen(test->src)+1); + pRtlMultiByteToUnicodeN(rst, sizeof(rst), NULL, test->dst, strlen(test->dst)+1); + + us_src.Length = strlen(test->src) * sizeof(WCHAR); + us_src.MaximumLength = us_src.Length + 2; + us_src.Buffer = src; + + us_dst.Length = 0; + us_dst.MaximumLength = 0; + us_dst.Buffer = NULL; + + nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul); + ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR), + "Wrong returned length for %s: %lu <> %u\n", + test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR)); + + us_dst.Length = 0; + us_dst.MaximumLength = sizeof(dst); + us_dst.Buffer = dst; + + nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul); + ok(nts == STATUS_SUCCESS, "Call failed (%lu)\n", nts); + ok(ul == us_dst.Length + sizeof(WCHAR), + "Wrong returned length for %s: %lu <> %u\n", + test->src, ul, us_dst.Length + sizeof(WCHAR)); + ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR), + "Wrong returned length for %s: %lu <> %u\n", + test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR)); + ok(strcmpW(dst, rst) == 0, "Wrong result for %s: expecting %s\n", + test->src, test->dst); + + us_dst.Length = 0; + us_dst.MaximumLength = 8 * sizeof(WCHAR); + us_dst.Buffer = dst; + dst[8] = '-'; + nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul); + ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%lu)\n", nts); + ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR), + "Wrong returned length for %s (with buffer too small): %lu <> %u\n", + test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR)); + ok(strncmpW(dst, rst, 8) == 0, + "Wrong result for %s (with buffer too small): expecting %s\n", + test->src, test->dst); + ok(dst[8] == '-', "Writing too far in buffer (got %c/%d)\n", dst[8], dst[8]); + } + +} + +START_TEST(env) +{ + HMODULE mod = GetModuleHandleA("ntdll.dll"); + + pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN"); + pRtlCreateEnvironment = (void*)GetProcAddress(mod, "RtlCreateEnvironment"); + pRtlDestroyEnvironment = (void*)GetProcAddress(mod, "RtlDestroyEnvironment"); + pRtlQueryEnvironmentVariable_U = (void*)GetProcAddress(mod, "RtlQueryEnvironmentVariable_U"); + pRtlSetCurrentEnvironment = (void*)GetProcAddress(mod, "RtlSetCurrentEnvironment"); + pRtlSetEnvironmentVariable = (void*)GetProcAddress(mod, "RtlSetEnvironmentVariable"); + pRtlExpandEnvironmentStrings_U = (void*)GetProcAddress(mod, "RtlExpandEnvironmentStrings_U"); + + if (pRtlQueryEnvironmentVariable_U) + testQuery(); + if (pRtlSetEnvironmentVariable) + testSet(); + if (pRtlExpandEnvironmentStrings_U) + testExpand(); +} Property changes on: trunk/reactos/regtests/winetests/ntdll/env.c ___________________________________________________________________ Name: svn:executable + * _____ Added: trunk/reactos/regtests/winetests/ntdll/error.c --- trunk/reactos/regtests/winetests/ntdll/error.c 2005-08-07 01:23:40 UTC (rev 17132) +++ trunk/reactos/regtests/winetests/ntdll/error.c 2005-08-07 02:16:34 UTC (rev 17133) @@ -0,0 +1,950 @@ +/* + * Unit tests for RtlNtStatusToDosError function + * + * Copyright (c) 2002 Andriy Palamarchuk + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define _WIN32_WINNT 0x0501 + +#include <stdarg.h> +#include <stdio.h> + +#include "ntstatus.h" +#define WIN32_NO_STATUS + +#include "wine/test.h" + +#include "windows.h" + +#include "windef.h" +#include "winbase.h" +#include "rpcnterr.h" +#include "winreg.h" +#include "winternl.h" + +/* FIXME!!! this test checks only mappings, defined by MSDN: + * http://support.microsoft.com/default.aspx?scid=KB;EN-US;q113996& + * It is necessary to add other mappings and to test them up to Windows XP. + * + * Some Windows platforms don't know about all the mappings, and in such + * cases they return somewhat strange results (Win98) or a generic error + * like ERROR_MR_MID_NOT_FOUND (NT4). Our tests have to know about these to + * not fail, but we would very much prefer Wine not to return such garbage. + * To you can pass the 'strict' option to this test to force it to only check + * results against the first listed value. This test should pass in strict + * mode on the latest Windows platform (currently XP) and in Wine. + * (of course older Windows platforms will fail to pass the strict mode) + */ + +static ULONG (WINAPI *statustodoserror)(NTSTATUS Status); +static int strict; + +static int prepare_test(void) +{ + HMODULE ntdll; + int argc; + char** argv; + + ntdll = LoadLibraryA("ntdll.dll"); + statustodoserror = (void*)GetProcAddress(ntdll, "RtlNtStatusToDosError"); + if (!statustodoserror) + return 0; + + argc = winetest_get_mainargs(&argv); + strict=(argc >= 3 && strcmp(argv[2],"strict")==0); + return 1; +} + +static void cmp_call(NTSTATUS win_nt, ULONG win32, const char* message) +{ + ULONG err; + + err = statustodoserror(win_nt); + ok(err == win32, + "%s (%lx): got %ld, expected %ld\n", + message, win_nt, err, win32); +} + +static void cmp_call2(NTSTATUS win_nt, ULONG win32, const char* message) +{ + ULONG err; + + err = statustodoserror(win_nt); + ok(err == win32 || + (!strict && err == ERROR_MR_MID_NOT_FOUND), + "%s (%lx): got %ld, expected %ld (or MID_NOT_FOUND)\n", + message, win_nt, err, win32); +} + +static void cmp_call3(NTSTATUS win_nt, ULONG win32_1, ULONG win32_2, const char* message) +{ + ULONG err; + + err = statustodoserror(win_nt); + ok(err == win32_1 || (!strict && err == win32_2), + "%s (%lx): got %ld, expected %ld or %ld\n", + message, win_nt, err, win32_1, win32_2); +} + +static void cmp_call4(NTSTATUS win_nt, ULONG win32_1, ULONG win32_2, const char* message) +{ + ULONG err; + + err = statustodoserror(win_nt); + ok(err == win32_1 || + (!strict && (err == win32_2 || err == ERROR_MR_MID_NOT_FOUND)), + "%s (%lx): got %ld, expected %ld or %ld\n", + message, win_nt, err, win32_1, win32_2); +} + +#define cmp(status, error) \ + cmp_call(status, error, #status) +#define cmp2(status, error) \ + cmp_call2(status, error, #status) +#define cmp3(status, error1, error2) \ + cmp_call3(status, error1, error2, #status) +#define cmp4(status, error1, error2) \ + cmp_call4(status, error1, error2, #status) + +static void run_error_tests(void) +{ + cmp(STATUS_DATATYPE_MISALIGNMENT, ERROR_NOACCESS); + cmp(STATUS_ACCESS_VIOLATION, ERROR_NOACCESS); + cmp2(STATUS_DATATYPE_MISALIGNMENT_ERROR, ERROR_NOACCESS); + cmp(STATUS_CTL_FILE_NOT_SUPPORTED, ERROR_NOT_SUPPORTED); + cmp(STATUS_PORT_ALREADY_SET, ERROR_INVALID_PARAMETER); + cmp(STATUS_SECTION_NOT_IMAGE, ERROR_INVALID_PARAMETER); + cmp(STATUS_BAD_WORKING_SET_LIMIT, ERROR_INVALID_PARAMETER); + cmp(STATUS_WORKING_SET_LIMIT_RANGE, ERROR_INVALID_PARAMETER); + cmp(STATUS_INCOMPATIBLE_FILE_MAP, ERROR_INVALID_PARAMETER); + cmp(STATUS_PORT_DISCONNECTED, ERROR_INVALID_HANDLE); + cmp(STATUS_NOT_LOCKED, ERROR_NOT_LOCKED); + cmp(STATUS_NOT_MAPPED_VIEW, ERROR_INVALID_ADDRESS); + cmp(STATUS_UNABLE_TO_FREE_VM, ERROR_INVALID_PARAMETER); + cmp(STATUS_UNABLE_TO_DELETE_SECTION, ERROR_INVALID_PARAMETER); + cmp(STATUS_MORE_PROCESSING_REQUIRED, ERROR_MORE_DATA); + cmp(STATUS_INVALID_CID, ERROR_INVALID_PARAMETER); + cmp(STATUS_STACK_OVERFLOW, ERROR_STACK_OVERFLOW); + cmp(STATUS_BAD_INITIAL_STACK, ERROR_STACK_OVERFLOW); + cmp(STATUS_INVALID_VOLUME_LABEL, ERROR_LABEL_TOO_LONG); + cmp(STATUS_SECTION_NOT_EXTENDED, ERROR_OUTOFMEMORY); + cmp(STATUS_NOT_MAPPED_DATA, ERROR_INVALID_ADDRESS); + cmp2(STATUS_NO_LDT, ERROR_INVALID_THREAD_ID); + cmp(STATUS_INFO_LENGTH_MISMATCH, ERROR_BAD_LENGTH); + cmp(STATUS_INVALID_INFO_CLASS, ERROR_INVALID_PARAMETER); + cmp(STATUS_SUSPEND_COUNT_EXCEEDED, ERROR_SIGNAL_REFUSED); + cmp(STATUS_NOTIFY_ENUM_DIR, ERROR_NOTIFY_ENUM_DIR); + cmp(STATUS_REGISTRY_RECOVERED, ERROR_REGISTRY_RECOVERED); + cmp(STATUS_REGISTRY_IO_FAILED, ERROR_REGISTRY_IO_FAILED); + cmp(STATUS_NOT_REGISTRY_FILE, ERROR_NOT_REGISTRY_FILE); + cmp(STATUS_KEY_DELETED, ERROR_KEY_DELETED); + cmp(STATUS_NO_LOG_SPACE, ERROR_NO_LOG_SPACE); + cmp(STATUS_KEY_HAS_CHILDREN, ERROR_KEY_HAS_CHILDREN); + cmp(STATUS_CHILD_MUST_BE_VOLATILE, ERROR_CHILD_MUST_BE_VOLATILE); + cmp(STATUS_REGISTRY_CORRUPT, ERROR_BADDB); + cmp(STATUS_DLL_NOT_FOUND, ERROR_MOD_NOT_FOUND); + cmp(STATUS_DLL_INIT_FAILED, ERROR_DLL_INIT_FAILED); + cmp2(STATUS_INVALID_IMPORT_OF_NON_DLL, ERROR_INVALID_IMPORT_OF_NON_DLL); + cmp(STATUS_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL); + cmp(STATUS_DRIVER_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL); + cmp2(STATUS_DRIVER_UNABLE_TO_LOAD, ERROR_BAD_DRIVER); + cmp(STATUS_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND); + cmp(STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND); + cmp(STATUS_PENDING, ERROR_IO_PENDING); + cmp(STATUS_MORE_ENTRIES, ERROR_MORE_DATA); + cmp(STATUS_INTEGER_OVERFLOW, ERROR_ARITHMETIC_OVERFLOW); + cmp(STATUS_BUFFER_OVERFLOW, ERROR_MORE_DATA); + cmp(STATUS_NO_MORE_FILES, ERROR_NO_MORE_FILES); + cmp(STATUS_NO_INHERITANCE, ERROR_NO_INHERITANCE); + cmp(STATUS_NO_MORE_EAS, ERROR_NO_MORE_ITEMS); + cmp(STATUS_NO_MORE_ENTRIES, ERROR_NO_MORE_ITEMS); + cmp(STATUS_GUIDS_EXHAUSTED, ERROR_NO_MORE_ITEMS); + cmp(STATUS_AGENTS_EXHAUSTED, ERROR_NO_MORE_ITEMS); + cmp(STATUS_UNSUCCESSFUL, ERROR_GEN_FAILURE); + cmp(STATUS_TOO_MANY_LINKS, ERROR_TOO_MANY_LINKS); + cmp(STATUS_NOT_IMPLEMENTED, ERROR_INVALID_FUNCTION); + cmp(STATUS_ILLEGAL_FUNCTION, ERROR_INVALID_FUNCTION); + cmp(STATUS_IN_PAGE_ERROR, ERROR_SWAPERROR); + cmp(STATUS_PAGEFILE_QUOTA, ERROR_PAGEFILE_QUOTA); + cmp(STATUS_COMMITMENT_LIMIT, ERROR_COMMITMENT_LIMIT); + cmp(STATUS_SECTION_TOO_BIG, ERROR_NOT_ENOUGH_MEMORY); + cmp(RPC_NT_SS_IN_NULL_CONTEXT, ERROR_INVALID_HANDLE); + cmp(RPC_NT_INVALID_BINDING, ERROR_INVALID_HANDLE); + cmp(STATUS_INVALID_HANDLE, ERROR_INVALID_HANDLE); + cmp(STATUS_OBJECT_TYPE_MISMATCH, ERROR_INVALID_HANDLE); + cmp(STATUS_FILE_CLOSED, ERROR_INVALID_HANDLE); + cmp(STATUS_INVALID_PORT_HANDLE, ERROR_INVALID_HANDLE); + cmp(STATUS_HANDLE_NOT_CLOSABLE, ERROR_INVALID_HANDLE); + cmp(STATUS_NOT_COMMITTED, ERROR_INVALID_ADDRESS); + cmp(STATUS_PARTIAL_COPY, ERROR_PARTIAL_COPY); + cmp(STATUS_LPC_REPLY_LOST, ERROR_INTERNAL_ERROR); + cmp(STATUS_INVALID_PARAMETER, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_1, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_2, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_3, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_4, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_5, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_6, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_7, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_8, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_9, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_10, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_11, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_12, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PARAMETER_MIX, ERROR_INVALID_PARAMETER); + cmp(STATUS_INVALID_PAGE_PROTECTION, ERROR_INVALID_PARAMETER); + cmp(STATUS_SECTION_PROTECTION, ERROR_INVALID_PARAMETER); + cmp(STATUS_RESOURCE_DATA_NOT_FOUND, ERROR_RESOURCE_DATA_NOT_FOUND); + cmp(STATUS_RESOURCE_TYPE_NOT_FOUND, ERROR_RESOURCE_TYPE_NOT_FOUND); + cmp(STATUS_RESOURCE_NAME_NOT_FOUND, ERROR_RESOURCE_NAME_NOT_FOUND); + cmp(STATUS_RESOURCE_LANG_NOT_FOUND, ERROR_RESOURCE_LANG_NOT_FOUND); + cmp(STATUS_NO_SUCH_DEVICE, ERROR_FILE_NOT_FOUND); + cmp(STATUS_NO_SUCH_FILE, ERROR_FILE_NOT_FOUND); + cmp(STATUS_INVALID_DEVICE_REQUEST, ERROR_INVALID_FUNCTION); + cmp2(STATUS_VOLUME_NOT_UPGRADED, ERROR_INVALID_FUNCTION); + cmp(STATUS_END_OF_FILE, ERROR_HANDLE_EOF); + cmp(STATUS_FILE_FORCED_CLOSED, ERROR_HANDLE_EOF); + cmp(STATUS_WRONG_VOLUME, ERROR_WRONG_DISK); + cmp(STATUS_NO_MEDIA, ERROR_NO_MEDIA_IN_DRIVE); + cmp(STATUS_NO_MEDIA_IN_DEVICE, ERROR_NOT_READY); + cmp(STATUS_VOLUME_DISMOUNTED, ERROR_NOT_READY); + cmp(STATUS_NONEXISTENT_SECTOR, ERROR_SECTOR_NOT_FOUND); + cmp(STATUS_WORKING_SET_QUOTA, ERROR_WORKING_SET_QUOTA); + cmp(STATUS_NO_MEMORY, ERROR_NOT_ENOUGH_MEMORY); + cmp(STATUS_CONFLICTING_ADDRESSES, ERROR_INVALID_ADDRESS); + cmp(STATUS_INVALID_SYSTEM_SERVICE, ERROR_INVALID_FUNCTION); + cmp(STATUS_THREAD_IS_TERMINATING, ERROR_ACCESS_DENIED); + cmp(STATUS_PROCESS_IS_TERMINATING, ERROR_ACCESS_DENIED); + cmp(STATUS_INVALID_LOCK_SEQUENCE, ERROR_ACCESS_DENIED); + cmp(STATUS_INVALID_VIEW_SIZE, ERROR_ACCESS_DENIED); + cmp(STATUS_ALREADY_COMMITTED, ERROR_ACCESS_DENIED); + cmp(STATUS_ACCESS_DENIED, ERROR_ACCESS_DENIED); + cmp(STATUS_FILE_IS_A_DIRECTORY, ERROR_ACCESS_DENIED); + cmp(STATUS_CANNOT_DELETE, ERROR_ACCESS_DENIED); + cmp(STATUS_INVALID_COMPUTER_NAME, ERROR_INVALID_COMPUTERNAME); + cmp(STATUS_FILE_DELETED, ERROR_ACCESS_DENIED); + cmp2(STATUS_FILE_RENAMED, ERROR_ACCESS_DENIED); + cmp(STATUS_DELETE_PENDING, ERROR_ACCESS_DENIED); + cmp(STATUS_PORT_CONNECTION_REFUSED, ERROR_ACCESS_DENIED); + cmp(STATUS_NO_SUCH_PRIVILEGE, ERROR_NO_SUCH_PRIVILEGE); + cmp(STATUS_PRIVILEGE_NOT_HELD, ERROR_PRIVILEGE_NOT_HELD); + cmp(STATUS_CANNOT_IMPERSONATE, ERROR_CANNOT_IMPERSONATE); + cmp(STATUS_LOGON_FAILURE, ERROR_LOGON_FAILURE); + cmp2(STATUS_MUTUAL_AUTHENTICATION_FAILED, ERROR_MUTUAL_AUTH_FAILED); + cmp2(STATUS_TIME_DIFFERENCE_AT_DC, ERROR_TIME_SKEW); + cmp2(STATUS_PKINIT_FAILURE, ERROR_PKINIT_FAILURE); + cmp2(STATUS_SMARTCARD_SUBSYSTEM_FAILURE, ERROR_SMARTCARD_SUBSYSTEM_FAILURE); + cmp2(STATUS_DOWNGRADE_DETECTED, ERROR_DOWNGRADE_DETECTED); + cmp2(STATUS_SMARTCARD_CERT_REVOKED, SEC_E_SMARTCARD_CERT_REVOKED); + cmp2(STATUS_ISSUING_CA_UNTRUSTED, SEC_E_ISSUING_CA_UNTRUSTED); + cmp2(STATUS_REVOCATION_OFFLINE_C, SEC_E_REVOCATION_OFFLINE_C); + cmp2(STATUS_PKINIT_CLIENT_FAILURE, SEC_E_PKINIT_CLIENT_FAILURE); + cmp2(STATUS_SMARTCARD_CERT_EXPIRED, SEC_E_SMARTCARD_CERT_EXPIRED); + cmp2(STATUS_NO_KERB_KEY, SEC_E_NO_KERB_KEY); + cmp2(STATUS_CURRENT_DOMAIN_NOT_ALLOWED, ERROR_CURRENT_DOMAIN_NOT_ALLOWED); + cmp2(STATUS_SMARTCARD_WRONG_PIN, SCARD_W_WRONG_CHV); + cmp2(STATUS_SMARTCARD_CARD_BLOCKED, SCARD_W_CHV_BLOCKED); + cmp2(STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED,SCARD_W_CARD_NOT_AUTHENTICA TED); + cmp2(STATUS_SMARTCARD_NO_CARD, SCARD_E_NO_SMARTCARD); + cmp2(STATUS_SMARTCARD_NO_KEY_CONTAINER, NTE_NO_KEY); + cmp2(STATUS_SMARTCARD_NO_CERTIFICATE, SCARD_E_NO_SUCH_CERTIFICATE); + cmp2(STATUS_SMARTCARD_NO_KEYSET, NTE_BAD_KEYSET); + cmp2(STATUS_SMARTCARD_IO_ERROR, SCARD_E_COMM_DATA_LOST); + cmp(STATUS_ACCOUNT_RESTRICTION, ERROR_ACCOUNT_RESTRICTION); + cmp(STATUS_INVALID_LOGON_HOURS, ERROR_INVALID_LOGON_HOURS); + cmp(STATUS_INVALID_WORKSTATION, ERROR_INVALID_WORKSTATION); + cmp(STATUS_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER); + cmp(STATUS_UNABLE_TO_DECOMMIT_VM, ERROR_INVALID_ADDRESS); + cmp(STATUS_DISK_CORRUPT_ERROR, ERROR_DISK_CORRUPT); + cmp(STATUS_FT_MISSING_MEMBER, ERROR_IO_DEVICE); + cmp(STATUS_FT_ORPHANING, ERROR_IO_DEVICE); + cmp(STATUS_VARIABLE_NOT_FOUND, ERROR_ENVVAR_NOT_FOUND); + cmp(STATUS_OBJECT_NAME_INVALID, ERROR_INVALID_NAME); + cmp(STATUS_OBJECT_NAME_NOT_FOUND, ERROR_FILE_NOT_FOUND); [truncated at 1000 lines; 9790 more skipped]

1 0

[ros-diffs] [sedwards] 17132: updated winternl.h, PSDK fixes, etc...
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

updated winternl.h, PSDK fixes, etc... Modified: trunk/reactos/boot/freeldr/freeldr/include/rtl.h Modified: trunk/reactos/lib/crt/except/unwind.c Modified: trunk/reactos/w32api/include/winbase.h Modified: trunk/reactos/w32api/include/winnt.h Modified: trunk/reactos/w32api/include/winternl.h _____ Modified: trunk/reactos/boot/freeldr/freeldr/include/rtl.h --- trunk/reactos/boot/freeldr/freeldr/include/rtl.h 2005-08-07 00:26:13 UTC (rev 17131) +++ trunk/reactos/boot/freeldr/freeldr/include/rtl.h 2005-08-07 01:23:40 UTC (rev 17132) @@ -33,9 +33,6 @@ void * memset(void *src, int val, size_t count); #define RtlCompareMemory(Source1, Source2, Length) memcmp(Source1, Source2, Length) -#define RtlCopyMemory(Destination, Source, Length) memcpy(Destination, Source, Length) -#define RtlFillMemory(Destination, Length, Fill) memset(Destination, Fill, Length) -#define RtlZeroMemory(Destination, Length) memset(Destination, 0, Length) //////////////////////////////////////////////////////////////////////// /////////////// // _____ Modified: trunk/reactos/lib/crt/except/unwind.c --- trunk/reactos/lib/crt/except/unwind.c 2005-08-07 00:26:13 UTC (rev 17131) +++ trunk/reactos/lib/crt/except/unwind.c 2005-08-07 01:23:40 UTC (rev 17132) @@ -1,5 +1,4 @@ #include "precomp.h" -#include <excpt.h> #include <winternl.h> /* _____ Modified: trunk/reactos/w32api/include/winbase.h --- trunk/reactos/w32api/include/winbase.h 2005-08-07 00:26:13 UTC (rev 17131) +++ trunk/reactos/w32api/include/winbase.h 2005-08-07 01:23:40 UTC (rev 17132) @@ -518,10 +518,13 @@ #define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000 #ifndef RC_INVOKED +#ifndef _FILETIME_ +#define _FILETIME_ typedef struct _FILETIME { DWORD dwLowDateTime; DWORD dwHighDateTime; } FILETIME,*PFILETIME,*LPFILETIME; +#endif typedef struct _BY_HANDLE_FILE_INFORMATION { DWORD dwFileAttributes; FILETIME ftCreationTime; @@ -1104,10 +1107,6 @@ BOOL WINAPI CopyFileW(LPCWSTR,LPCWSTR,BOOL); BOOL WINAPI CopyFileExA(LPCSTR,LPCSTR,LPPROGRESS_ROUTINE,LPVOID,LPBOOL,DWORD); BOOL WINAPI CopyFileExW(LPCWSTR,LPCWSTR,LPPROGRESS_ROUTINE,LPVOID,LPBOOL,DWORD); -#define RtlMoveMemory memmove -#define RtlCopyMemory memcpy -#define RtlFillMemory(d,l,f) memset((d), (f), (l)) -#define RtlZeroMemory(d,l) RtlFillMemory((d),(l),0) #define MoveMemory RtlMoveMemory #define CopyMemory RtlCopyMemory #define FillMemory RtlFillMemory _____ Modified: trunk/reactos/w32api/include/winnt.h --- trunk/reactos/w32api/include/winnt.h 2005-08-07 00:26:13 UTC (rev 17131) +++ trunk/reactos/w32api/include/winnt.h 2005-08-07 01:23:40 UTC (rev 17132) @@ -262,14 +262,6 @@ #define FILE_VALID_MAILSLOT_OPTION_FLAGS 0x00000032 #define FILE_VALID_SET_FLAGS 0x00000036 -#define FILE_SUPERSEDE 0x00000000 -#define FILE_OPEN 0x00000001 -#define FILE_CREATE 0x00000002 -#define FILE_OPEN_IF 0x00000003 -#define FILE_OVERWRITE 0x00000004 -#define FILE_OVERWRITE_IF 0x00000005 -#define FILE_MAXIMUM_DISPOSITION 0x00000005 - #define FILE_DIRECTORY_FILE 0x00000001 #define FILE_WRITE_THROUGH 0x00000002 #define FILE_SEQUENTIAL_ONLY 0x00000004 @@ -3495,6 +3487,11 @@ SIZE_T Length ); +#define RtlMoveMemory memmove +#define RtlCopyMemory memcpy +#define RtlFillMemory(d,l,f) memset((d), (f), (l)) +#define RtlZeroMemory(d,l) RtlFillMemory((d),(l),0) + #if defined(__GNUC__) static __inline__ PVOID GetCurrentFiber(void) _____ Modified: trunk/reactos/w32api/include/winternl.h --- trunk/reactos/w32api/include/winternl.h 2005-08-07 00:26:13 UTC (rev 17131) +++ trunk/reactos/w32api/include/winternl.h 2005-08-07 01:23:40 UTC (rev 17132) @@ -18,11 +18,10 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#ifndef __WINE_WINTERNAL_H -#define __WINE_WINTERNAL_H +#ifndef __WINE_WINTERNL_H +#define __WINE_WINTERNL_H #include <windef.h> -#include <wine/winnt.h> #ifdef __cplusplus extern "C" { @@ -33,7 +32,7 @@ * Fundamental types and data structures */ -typedef LONG NTSTATUS, *PNTSTATUS; +typedef LONG NTSTATUS; typedef CONST char *PCSZ; @@ -62,6 +61,50 @@ typedef const UNICODE_STRING *PCUNICODE_STRING; +#ifndef _FILETIME_ +#define _FILETIME_ +/* 64 bit number of 100 nanoseconds intervals since January 1, 1601 */ +typedef struct _FILETIME +{ +#ifdef WORDS_BIGENDIAN + DWORD dwHighDateTime; + DWORD dwLowDateTime; +#else + DWORD dwLowDateTime; + DWORD dwHighDateTime; +#endif +} FILETIME, *PFILETIME, *LPFILETIME; +#endif /* _FILETIME_ */ + +/* + * RTL_SYSTEM_TIME and RTL_TIME_ZONE_INFORMATION are the same as + * the SYSTEMTIME and TIME_ZONE_INFORMATION structures defined + * in winbase.h, however we need to define them seperately so + * winternl.h doesn't depend on winbase.h. They are used by + * RtlQueryTimeZoneInformation and RtlSetTimeZoneInformation. + * The names are guessed; if anybody knows the real names, let me know. + */ +typedef struct _RTL_SYSTEM_TIME { + WORD wYear; + WORD wMonth; + WORD wDayOfWeek; + WORD wDay; + WORD wHour; + WORD wMinute; + WORD wSecond; + WORD wMilliseconds; +} RTL_SYSTEM_TIME, *PRTL_SYSTEM_TIME; + +typedef struct _RTL_TIME_ZONE_INFORMATION { + LONG Bias; + WCHAR StandardName[32]; + RTL_SYSTEM_TIME StandardDate; + LONG StandardBias; + WCHAR DaylightName[32]; + RTL_SYSTEM_TIME DaylightDate; + LONG DaylightBias; +} RTL_TIME_ZONE_INFORMATION, *PRTL_TIME_ZONE_INFORMATION; + typedef struct _CLIENT_ID { HANDLE UniqueProcess; @@ -84,14 +127,14 @@ typedef struct tagRTL_BITMAP { ULONG SizeOfBitMap; /* Number of bits in the bitmap */ - LPBYTE BitMapBuffer; /* Bitmap data, assumed sized to a DWORD boundary */ + PULONG Buffer; /* Bitmap data, assumed sized to a DWORD boundary */ } RTL_BITMAP, *PRTL_BITMAP; typedef const RTL_BITMAP *PCRTL_BITMAP; typedef struct tagRTL_BITMAP_RUN { - ULONG StartOfRun; /* Bit position at which run starts - FIXME: Name? */ - ULONG SizeOfRun; /* Size of the run in bits - FIXME: Name? */ + ULONG StartingIndex; /* Bit position at which run starts */ + ULONG NumberOfBits; /* Size of the run in bits */ } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN; typedef const RTL_BITMAP_RUN *PCRTL_BITMAP_RUN; @@ -102,13 +145,12 @@ ULONG Size; ULONG Flags; ULONG DebugFlags; - HANDLE hConsole; - ULONG ProcessGroup; + HANDLE ConsoleHandle; + ULONG ConsoleFlags; HANDLE hStdInput; HANDLE hStdOutput; HANDLE hStdError; - UNICODE_STRING CurrentDirectoryName; - HANDLE CurrentDirectoryHandle; + CURDIR CurrentDirectory; UNICODE_STRING DllPath; UNICODE_STRING ImagePathName; UNICODE_STRING CommandLine; @@ -142,37 +184,79 @@ LIST_ENTRY InInitializationOrderModuleList; } PEB_LDR_DATA, *PPEB_LDR_DATA; +typedef struct _GDI_TEB_BATCH +{ + ULONG Offset; + HANDLE HDC; + ULONG Buffer[0x136]; +} GDI_TEB_BATCH; + /*********************************************************************** * PEB data structure */ typedef struct _PEB { - BYTE Reserved1[2]; /* 00 */ - BYTE BeingDebugged; /* 02 */ - BYTE Reserved2[5]; /* 03 */ - HMODULE ImageBaseAddress; /* 08 */ - PPEB_LDR_DATA LdrData; /* 0c */ - RTL_USER_PROCESS_PARAMETERS *ProcessParameters; /* 10 */ - PVOID __pad_14; /* 14 */ - HANDLE ProcessHeap; /* 18 */ - BYTE __pad_1c[36]; /* 1c */ - PRTL_BITMAP TlsBitmap; /* 40 */ - ULONG TlsBitmapBits[2]; /* 44 */ - BYTE __pad_4c[104]; /* 4c */ - ULONG ImageSubSystem; /* b4 */ - BYTE __pad_b8[48]; /* b8 */ - PVOID Reserved3[59]; /* e8 */ - ULONG SessionId; /* 1d4 */ + BOOLEAN InheritedAddressSpace; /* 00 */ + BOOLEAN ReadImageFileExecOptions; /* 01 */ + BOOLEAN BeingDebugged; /* 02 */ + BOOLEAN SpareBool; /* 03 */ + HANDLE Mutant; /* 04 */ + HMODULE ImageBaseAddress; /* 08 */ + PPEB_LDR_DATA LdrData; /* 0c */ + RTL_USER_PROCESS_PARAMETERS *ProcessParameters; /* 10 */ + PVOID SubSystemData; /* 14 */ + HANDLE ProcessHeap; /* 18 */ + PRTL_CRITICAL_SECTION FastPebLock; /* 1c */ + PVOID /*PPEBLOCKROUTINE*/ FastPebLockRoutine; /* 20 */ + PVOID /*PPEBLOCKROUTINE*/ FastPebUnlockRoutine; /* 24 */ + ULONG EnvironmentUpdateCount; /* 28 */ + PVOID KernelCallbackTable; /* 2c */ + PVOID EventLogSection; /* 30 */ + PVOID EventLog; /* 34 */ + PVOID /*PPEB_FREE_BLOCK*/ FreeList; /* 38 */ + ULONG TlsExpansionCounter; /* 3c */ + PRTL_BITMAP TlsBitmap; /* 40 */ + ULONG TlsBitmapBits[2]; /* 44 */ + PVOID ReadOnlySharedMemoryBase; /* 4c */ + PVOID ReadOnlySharedMemoryHeap; /* 50 */ + PVOID *ReadOnlyStaticServerData; /* 54 */ + PVOID AnsiCodePageData; /* 58 */ + PVOID OemCodePageData; /* 5c */ + PVOID UnicodeCaseTableData; /* 60 */ + ULONG NumberOfProcessors; /* 64 */ + ULONG NtGlobalFlag; /* 68 */ + BYTE Spare2[4]; /* 6c */ + LARGE_INTEGER CriticalSectionTimeout; /* 70 */ + ULONG HeapSegmentReserve; /* 78 */ + ULONG HeapSegmentCommit; /* 7c */ + ULONG HeapDeCommitTotalFreeThreshold; /* 80 */ + ULONG HeapDeCommitFreeBlockThreshold; /* 84 */ + ULONG NumberOfHeaps; /* 88 */ + ULONG MaximumNumberOfHeaps; /* 8c */ + PVOID *ProcessHeaps; /* 90 */ + PVOID GdiSharedHandleTable; /* 94 */ + PVOID ProcessStarterHelper; /* 98 */ + PVOID GdiDCAttributeList; /* 9c */ + PVOID LoaderLock; /* a0 */ + ULONG OSMajorVersion; /* a4 */ + ULONG OSMinorVersion; /* a8 */ + ULONG OSBuildNumber; /* ac */ + ULONG OSPlatformId; /* b0 */ + ULONG ImageSubSystem; /* b4 */ + ULONG ImageSubSystemMajorVersion; /* b8 */ + ULONG ImageSubSystemMinorVersion; /* bc */ + ULONG ImageProcessAffinityMask; /* c0 */ + ULONG GdiHandleBuffer[34]; /* c4 */ + ULONG PostProcessInitRoutine; /* 14c */ + PRTL_BITMAP TlsExpansionBitmap; /* 150 */ + ULONG TlsExpansionBitmapBits[32]; /* 154 */ + ULONG SessionId; /* 1d4 */ } PEB, *PPEB; /*********************************************************************** * TEB data structure */ -#if defined(_NTSYSTEM_) || defined(_KERNEL32_) /* hack, should go away */ -# define WINE_NO_TEB -#endif - #ifndef WINE_NO_TEB /* don't define TEB if included from thread.h */ # ifndef WINE_TEB_DEFINED # define WINE_TEB_DEFINED @@ -185,19 +269,56 @@ PVOID ThreadLocalStoragePointer; /* 02c */ PPEB Peb; /* 030 */ ULONG LastErrorValue; /* 034 */ - BYTE __pad038[140]; /* 038 */ + ULONG CountOfOwnedCriticalSections;/* 038 */ + PVOID CsrClientThread; /* 03c */ + PVOID Win32ThreadInfo; /* 040 */ + ULONG Win32ClientInfo[31]; /* 044 used for user32 private data in Wine */ + PVOID WOW32Reserved; /* 0c0 */ ULONG CurrentLocale; /* 0c4 */ - BYTE __pad0c8[1752]; /* 0c8 */ - PVOID Reserved2[278]; /* 7a0 */ + ULONG FpSoftwareStatusRegister; /* 0c8 */ + PVOID SystemReserved1[54]; /* 0cc used for kernel32 private data in Wine */ + PVOID Spare1; /* 1a4 */ + LONG ExceptionCode; /* 1a8 */ + BYTE SpareBytes1[40]; /* 1ac */ + PVOID SystemReserved2[10]; /* 1d4 used for ntdll private data in Wine */ + GDI_TEB_BATCH GdiTebBatch; /* 1fc */ + ULONG gdiRgn; /* 6dc */ + ULONG gdiPen; /* 6e0 */ + ULONG gdiBrush; /* 6e4 */ + CLIENT_ID RealClientId; /* 6e8 */ + HANDLE GdiCachedProcessHandle; /* 6f0 */ + ULONG GdiClientPID; /* 6f4 */ + ULONG GdiClientTID; /* 6f8 */ + PVOID GdiThreadLocaleInfo; /* 6fc */ + PVOID UserReserved[5]; /* 700 */ + PVOID glDispachTable[280]; /* 714 */ + ULONG glReserved1[26]; /* b74 */ + PVOID glReserved2; /* bdc */ + PVOID glSectionInfo; /* be0 */ + PVOID glSection; /* be4 */ + PVOID glTable; /* be8 */ + PVOID glCurrentRC; /* bec */ + PVOID glContext; /* bf0 */ + ULONG LastStatusValue; /* bf4 */ UNICODE_STRING StaticUnicodeString; /* bf8 used by advapi32 */ WCHAR StaticUnicodeBuffer[261]; /* c00 used by advapi32 */ PVOID DeallocationStack; /* e0c */ PVOID TlsSlots[64]; /* e10 */ LIST_ENTRY TlsLinks; /* f10 */ - PVOID Reserved4[26]; /* f18 */ - PVOID ReservedForOle; /* f80 Windows 2000 only */ - PVOID Reserved5[4]; /* f84 */ - PVOID TlsExpansionSlots; /* f94 */ + PVOID Vdm; /* f18 */ + PVOID ReservedForNtRpc; /* f1c */ + PVOID DbgSsReserved[2]; /* f20 */ + ULONG HardErrorDisabled; /* f28 */ + PVOID Instrumentation[16]; /* f2c */ + PVOID WinSockData; /* f6c */ + ULONG GdiBatchCount; /* f70 */ + ULONG Spare2; /* f74 */ + ULONG Spare3; /* f78 */ + ULONG Spare4; /* f7c */ + PVOID ReservedForOle; /* f80 */ + ULONG WaitingOnLoaderLock; /* f84 */ + PVOID Reserved5[3]; /* f88 */ + PVOID *TlsExpansionSlots; /* f94 */ } TEB, *PTEB; # endif /* WINE_TEB_DEFINED */ #endif /* WINE_NO_TEB */ @@ -246,7 +367,54 @@ FileMaximumInformation } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS; -#include <pshpack8.h> +typedef struct _FILE_DIRECTORY_INFORMATION { + ULONG NextEntryOffset; + ULONG FileIndex; + LARGE_INTEGER CreationTime; + LARGE_INTEGER LastAccessTime; + LARGE_INTEGER LastWriteTime; + LARGE_INTEGER ChangeTime; + LARGE_INTEGER EndOfFile; + LARGE_INTEGER AllocationSize; + ULONG FileAttributes; + ULONG FileNameLength; + WCHAR FileName[ANYSIZE_ARRAY]; +} FILE_DIRECTORY_INFORMATION, *PFILE_DIRECTORY_INFORMATION; + +typedef struct _FILE_FULL_DIRECTORY_INFORMATION { + ULONG NextEntryOffset; + ULONG FileIndex; + LARGE_INTEGER CreationTime; + LARGE_INTEGER LastAccessTime; + LARGE_INTEGER LastWriteTime; + LARGE_INTEGER ChangeTime; + LARGE_INTEGER EndOfFile; + LARGE_INTEGER AllocationSize; + ULONG FileAttributes; + ULONG FileNameLength; + ULONG EaSize; + WCHAR FileName[ANYSIZE_ARRAY]; +} FILE_FULL_DIRECTORY_INFORMATION, *PFILE_FULL_DIRECTORY_INFORMATION, + FILE_FULL_DIR_INFORMATION, *PFILE_FULL_DIR_INFORMATION; + +typedef struct _FILE_BOTH_DIRECTORY_INFORMATION { + ULONG NextEntryOffset; + ULONG FileIndex; + LARGE_INTEGER CreationTime; + LARGE_INTEGER LastAccessTime; + LARGE_INTEGER LastWriteTime; + LARGE_INTEGER ChangeTime; + LARGE_INTEGER EndOfFile; + LARGE_INTEGER AllocationSize; + ULONG FileAttributes; + ULONG FileNameLength; + ULONG EaSize; + CHAR ShortNameLength; + WCHAR ShortName[12]; + WCHAR FileName[ANYSIZE_ARRAY]; +} FILE_BOTH_DIRECTORY_INFORMATION, *PFILE_BOTH_DIRECTORY_INFORMATION, + FILE_BOTH_DIR_INFORMATION, *PFILE_BOTH_DIR_INFORMATION; + typedef struct _FILE_BASIC_INFORMATION { LARGE_INTEGER CreationTime; LARGE_INTEGER LastAccessTime; @@ -254,7 +422,6 @@ LARGE_INTEGER ChangeTime; ULONG FileAttributes; } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION; -#include <poppack.h> typedef struct _FILE_STANDARD_INFORMATION { LARGE_INTEGER AllocationSize; @@ -264,6 +431,41 @@ BOOLEAN Directory; } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION; +typedef struct _FILE_INTERNAL_INFORMATION { + LARGE_INTEGER IndexNumber; +} FILE_INTERNAL_INFORMATION, *PFILE_INTERNAL_INFORMATION; + +typedef struct _FILE_EA_INFORMATION { + ULONG EaSize; +} FILE_EA_INFORMATION, *PFILE_EA_INFORMATION; + +typedef struct _FILE_ACCESS_INFORMATION { + ACCESS_MASK AccessFlags; +} FILE_ACCESS_INFORMATION, *PFILE_ACCESS_INFORMATION; + +typedef struct _FILE_NAME_INFORMATION { + ULONG FileNameLength; + WCHAR FileName[1]; +} FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION; + +typedef struct _FILE_RENAME_INFORMATION { + BOOLEAN Replace; + HANDLE RootDir; + ULONG FileNameLength; + WCHAR FileName[1]; +} FILE_RENAME_INFORMATION, *PFILE_RENAME_INFORMATION; + +typedef struct _FILE_NAMES_INFORMATION { + ULONG NextEntryOffset; + ULONG FileIndex; + ULONG FileNameLength; + WCHAR FileName[1]; +} FILE_NAMES_INFORMATION, *PFILE_NAMES_INFORMATION; + +typedef struct _FILE_DISPOSITION_INFORMATION { + BOOLEAN DoDeleteFile; +} FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION; + typedef struct _FILE_POSITION_INFORMATION { LARGE_INTEGER CurrentByteOffset; } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION; @@ -272,6 +474,14 @@ ULONG AlignmentRequirement; } FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION; +typedef struct _FILE_ALLOCATION_INFORMATION { + LARGE_INTEGER AllocationSize; +} FILE_ALLOCATION_INFORMATION, *PFILE_ALLOCATION_INFORMATION; + +typedef struct _FILE_END_OF_FILE_INFORMATION { + LARGE_INTEGER EndOfFile; +} FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION; + typedef struct _FILE_NETWORK_OPEN_INFORMATION { LARGE_INTEGER CreationTime; LARGE_INTEGER LastAccessTime; @@ -290,6 +500,10 @@ CHAR EaName[1]; } FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION; +typedef struct _FILE_MODE_INFORMATION { + ULONG Mode; +} FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION; + typedef struct _FILE_STREAM_INFORMATION { ULONG NextEntryOffset; @@ -299,12 +513,37 @@ WCHAR StreamName[1]; } FILE_STREAM_INFORMATION, *PFILE_STREAM_INFORMATION; -struct _FILE_ATTRIBUTE_TAG_INFORMATION +typedef struct _FILE_ATTRIBUTE_TAG_INFORMATION { ULONG FileAttributes; ULONG ReparseTag; } FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION; +typedef struct _FILE_MAILSLOT_QUERY_INFORMATION { + ULONG MaximumMessageSize; + ULONG MailslotQuota; + ULONG NextMessageSize; + ULONG MessagesAvailable; + LARGE_INTEGER ReadTimeout; +} FILE_MAILSLOT_QUERY_INFORMATION, *PFILE_MAILSLOT_QUERY_INFORMATION; + +typedef struct _FILE_MAILSLOT_SET_INFORMATION { + LARGE_INTEGER ReadTimeout; +} FILE_MAILSLOT_SET_INFORMATION, *PFILE_MAILSLOT_SET_INFORMATION; + +typedef struct _FILE_ALL_INFORMATION +{ + FILE_BASIC_INFORMATION BasicInformation; + FILE_STANDARD_INFORMATION StandardInformation; + FILE_INTERNAL_INFORMATION InternalInformation; + FILE_EA_INFORMATION EaInformation; + FILE_ACCESS_INFORMATION AccessInformation; + FILE_POSITION_INFORMATION PositionInformation; + FILE_MODE_INFORMATION ModeInformation; + FILE_ALIGNMENT_INFORMATION AlignmentInformation; + FILE_NAME_INFORMATION NameInformation; +} FILE_ALL_INFORMATION, *PFILE_ALL_INFORMATION; + typedef enum _FSINFOCLASS { FileFsVolumeInformation = 1, FileFsLabelInformation, @@ -367,17 +606,23 @@ ProcessSessionInformation = 24, ProcessForegroundInformation = 25, ProcessWow64Information = 26, + ProcessImageFileName = 27, + ProcessLUIDDeviceMapsEnabled = 28, + ProcessBreakOnTermination = 29, + ProcessDebugObjectHandle = 30, + ProcessDebugFlags = 31, + ProcessHandleTracing = 32, MaxProcessInfoClass -} PROCESSINFOCLASS; +} PROCESSINFOCLASS, PROCESS_INFORMATION_CLASS; typedef enum _SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2 } SECTION_INHERIT; -typedef enum SYSTEM_INFORMATION_CLASS { +typedef enum _SYSTEM_INFORMATION_CLASS { SystemBasicInformation = 0, - Unknown1, + SystemCpuInformation = 1, SystemPerformanceInformation = 2, SystemTimeOfDayInformation = 3, /* was SystemTimeInformation */ Unknown4, @@ -387,22 +632,49 @@ SystemProcessorPerformanceInformation = 8, Unknown9, Unknown10, - SystemDriverInformation, + SystemModuleInformation = 11, Unknown12, Unknown13, Unknown14, Unknown15, - SystemHandleList, + SystemHandleInformation = 16, Unknown17, - Unknown18, + SystemPageFileInformation = 18, Unknown19, Unknown20, - SystemCacheInformation, + SystemCacheInformation = 21, Unknown22, SystemInterruptInformation = 23, + SystemDpcBehaviourInformation = 24, + SystemFullMemoryInformation = 25, + SystemNotImplemented6 = 25, + SystemLoadImage = 26, + SystemUnloadImage = 27, + SystemTimeAdjustmentInformation = 28, + SystemTimeAdjustment = 28, + SystemSummaryMemoryInformation = 29, + SystemNotImplemented7 = 29, + SystemNextEventIdInformation = 30, + SystemNotImplemented8 = 30, + SystemEventIdsInformation = 31, + SystemCrashDumpInformation = 32, SystemExceptionInformation = 33, + SystemCrashDumpStateInformation = 34, + SystemKernelDebuggerInformation = 35, + SystemContextSwitchInformation = 36, SystemRegistryQuotaInformation = 37, - SystemLookasideInformation = 45 + SystemCurrentTimeZoneInformation = 44, + SystemTimeZoneInformation = 44, + SystemLookasideInformation = 45, + SystemSetTimeSlipEvent = 46, + SystemCreateSession = 47, + SystemDeleteSession = 48, + SystemInvalidInfoClass4 = 49, + SystemRangeStartInformation = 50, + SystemVerifierInformation = 51, + SystemAddVerifier = 52, + SystemSessionProcessesInformation = 53, + SystemInformationClassMax } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS; typedef enum _TIMER_TYPE { @@ -441,16 +713,47 @@ LONG BasePriority; } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION; +typedef struct _KERNEL_USER_TIMES { + LARGE_INTEGER CreateTime; + LARGE_INTEGER ExitTime; + LARGE_INTEGER KernelTime; + LARGE_INTEGER UserTime; +} KERNEL_USER_TIMES, *PKERNEL_USER_TIMES; typedef enum _WINSTATIONINFOCLASS { WinStationInformation = 8 } WINSTATIONINFOCLASS; -typedef enum -{ - MemoryBasicInformation = 0 +typedef enum _MEMORY_INFORMATION_CLASS { + MemoryBasicInformation, + MemoryWorkingSetList, + MemorySectionName, + MemoryBasicVlmInformation } MEMORY_INFORMATION_CLASS; +typedef enum _MUTANT_INFORMATION_CLASS +{ + MutantBasicInformation +} MUTANT_INFORMATION_CLASS, *PMUTANT_INFORMATION_CLASS; + +typedef struct _MUTANT_BASIC_INFORMATION { + LONG CurrentCount; + BOOLEAN OwnedByCaller; + BOOLEAN AbandonedState; +} MUTANT_BASIC_INFORMATION, *PMUTANT_BASIC_INFORMATION; + +typedef enum _TIMER_INFORMATION_CLASS +{ + TimerBasicInformation = 0 +} TIMER_INFORMATION_CLASS; + +typedef struct _TIMER_BASIC_INFORMATION +{ + LARGE_INTEGER RemainingTime; + BOOLEAN TimerState; +} TIMER_BASIC_INFORMATION, *PTIMER_BASIC_INFORMATION; + + /* return type of RtlDetermineDosPathNameType_U (FIXME: not the correct names) */ typedef enum { @@ -504,8 +807,7 @@ */ /* This is used by NtQuerySystemInformation */ -/* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */ -typedef struct { +typedef struct _SYSTEM_THREAD_INFORMATION{ FILETIME ftKernelTime; FILETIME ftUserTime; FILETIME ftCreateTime; @@ -518,22 +820,9 @@ DWORD dwContextSwitches; DWORD dwThreadState; DWORD dwWaitReason; -} THREADINFO, *PTHREADINFO; + DWORD dwUnknown; +} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION; -/* FIXME: Isn't THREAD_INFO and THREADINFO the same structure? */ -typedef struct _THREAD_INFO{ - DWORD Unknown1[6]; - DWORD ThreadID; - DWORD Unknown2[3]; - DWORD Status; - DWORD WaitReason; - DWORD Unknown3[4]; -} THREAD_INFO, PTHREAD_INFO; - -/********************************************************************** * - * Types and data structures - */ - typedef struct _IO_STATUS_BLOCK { union { NTSTATUS Status; @@ -640,34 +929,6 @@ #endif } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION; -typedef struct _PROCESS_INFO { - DWORD Offset; /* 00 offset to next PROCESS_INFO ok*/ - DWORD ThreadCount; /* 04 number of ThreadInfo member ok */ - DWORD Unknown1[6]; - FILETIME CreationTime; /* 20 */ - DWORD Unknown2[5]; - PWCHAR ProcessName; /* 3c ok */ - DWORD BasePriority; - DWORD ProcessID; /* 44 ok*/ - DWORD ParentProcessID; - DWORD HandleCount; - DWORD Unknown3[2]; /* 50 */ - ULONG PeakVirtualSize; - ULONG VirtualSize; - ULONG PageFaultCount; - ULONG PeakWorkingSetSize; - ULONG WorkingSetSize; - ULONG QuotaPeakPagedPoolUsage; - ULONG QuotaPagedPoolUsage; - ULONG QuotaPeakNonPagedPoolUsage; - ULONG QuotaNonPagedPoolUsage; - ULONG PagefileUsage; - ULONG PeakPagefileUsage; - DWORD PrivateBytes; - DWORD Unknown6[4]; - THREAD_INFO ati[ANYSIZE_ARRAY]; /* 94 size=0x40*/ -} PROCESS_INFO, PPROCESS_INFO; - typedef struct _RTL_HEAP_DEFINITION { ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */ @@ -690,6 +951,7 @@ } RTL_RWLOCK, *LPRTL_RWLOCK; /* System Information Class 0x00 */ + typedef struct _SYSTEM_BASIC_INFORMATION { #ifdef __WINESRC__ DWORD dwUnknown1; @@ -712,16 +974,117 @@ #endif } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION; +/* System Information Class 0x01 */ + +typedef struct _SYSTEM_CPU_INFORMATION { + WORD Architecture; + WORD Level; + WORD Revision; /* combination of CPU model and stepping */ + WORD Reserved; /* always zero */ + DWORD FeatureSet; /* see bit flags below */ +} SYSTEM_CPU_INFORMATION, *PSYSTEM_CPU_INFORMATION; + +/* definitions of bits in the Feature set for the x86 processors */ +#define CPU_FEATURE_VME 0x00000005 /* Virtual 86 Mode Extensions */ +#define CPU_FEATURE_TSC 0x00000002 /* Time Stamp Counter available */ +#define CPU_FEATURE_CMOV 0x00000008 /* Conditional Move instruction*/ +#define CPU_FEATURE_PGE 0x00000014 /* Page table Entry Global bit */ +#define CPU_FEATURE_PSE 0x00000024 /* Page Size Extension */ +#define CPU_FEATURE_MTRR 0x00000040 /* Memory Type Range Registers */ +#define CPU_FEATURE_CX8 0x00000080 /* Compare and eXchange 8 byte instr. */ +#define CPU_FEATURE_MMX 0x00000100 /* Multi Media eXtensions */ +#define CPU_FEATURE_X86 0x00000200 /* seems to be alway ON, on the '86 */ +#define CPU_FEATURE_PAT 0x00000400 /* Page Attribute Table */ +#define CPU_FEATURE_FXSR 0x00000800 /* FXSAVE and FXSTORE instructions */ +#define CPU_FEATURE_SEP 0x00001000 /* SYSENTER and SYSEXIT instructions */ +#define CPU_FEATURE_SSE 0x00002000 /* SSE extenstions (ext. MMX) */ +#define CPU_FEATURE_3DNOW 0x00008000 /* 3DNOW instructions available + (FIXME: needs to be confirmed) */ +#define CPU_FEATURE_SSE2 0x00010000 /* SSE2 extensions (XMMI64) */ +#define CPU_FEATURE_DS 0x00020000 /* Debug Store */ +#define CPU_FEATURE_HTT 0x00040000 /* Hyper Threading Technology */ + +/* System Information Class 0x02 */ + +typedef struct _SYSTEM_PERFORMANCE_INFORMATION { + BYTE Reserved1[312]; +} SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION; + +/* System Information Class 0x03 */ + +typedef struct _SYSTEM_TIMEOFDAY_INFORMATION { +#ifdef __WINESRC__ + LARGE_INTEGER liKeBootTime; + LARGE_INTEGER liKeSystemTime; + LARGE_INTEGER liExpTimeZoneBias; + ULONG uCurrentTimeZoneId; + DWORD dwUnknown1[5]; +#else + BYTE Reserved1[48]; +#endif +} SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION; /* was SYSTEM_TIME_INFORMATION */ + +/* System Information Class 0x08 */ + +typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION { +#ifdef __WINESRC__ + LARGE_INTEGER liIdleTime; + LARGE_INTEGER liKernelTime; + LARGE_INTEGER liUserTime; + DWORD dwSpare[5]; +#else + LARGE_INTEGER IdleTime; + LARGE_INTEGER KernelTime; + LARGE_INTEGER UserTime; + LARGE_INTEGER Reserved1[2]; + ULONG Reserved2; +#endif +} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; + +/* System Information Class 0x0b */ + +typedef struct _SYSTEM_DRIVER_INFORMATION { + PVOID pvAddress; + DWORD dwUnknown1; + DWORD dwUnknown2; + DWORD dwEntryIndex; + DWORD dwUnknown3; + char szName[MAX_PATH + 1]; +} SYSTEM_DRIVER_INFORMATION, *PSYSTEM_DRIVER_INFORMATION; + +/* System Information Class 0x10 */ + +typedef struct _SYSTEM_HANDLE_ENTRY { + ULONG OwnerPid; + BYTE ObjectType; + BYTE HandleFlags; + USHORT HandleValue; + PVOID ObjectPointer; + ULONG AccessMask; +} SYSTEM_HANDLE_ENTRY, *PSYSTEM_HANDLE_ENTRY; + +typedef struct _SYSTEM_HANDLE_INFORMATION { + ULONG Count; + SYSTEM_HANDLE_ENTRY Handle[1]; +} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION; + /* System Information Class 0x15 */ -typedef struct { + +typedef struct _SYSTEM_CACHE_INFORMATION { ULONG CurrentSize; ULONG PeakSize; ULONG PageFaultCount; ULONG MinimumWorkingSet; ULONG MaximumWorkingSet; ULONG unused[4]; -} SYSTEM_CACHE_INFORMATION; +} SYSTEM_CACHE_INFORMATION, *PSYSTEM_CACHE_INFORMATION; +/* System Information Class 0x17 */ + +typedef struct _SYSTEM_INTERRUPT_INFORMATION { + BYTE Reserved1[24]; +} SYSTEM_INTERRUPT_INFORMATION, *PSYSTEM_INTERRUPT_INFORMATION; + typedef struct _SYSTEM_CONFIGURATION_INFO { union { ULONG OemId; @@ -741,16 +1104,6 @@ WORD ProcessorRevision; } SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO; -/* System Information Class 0x0b */ -typedef struct { - PVOID pvAddress; - DWORD dwUnknown1; - DWORD dwUnknown2; - DWORD dwEntryIndex; - DWORD dwUnknown3; - char szName[MAX_PATH + 1]; -} SYSTEM_DRIVER_INFORMATION; - typedef struct _SYSTEM_EXCEPTION_INFORMATION { BYTE Reserved1[16]; } SYSTEM_EXCEPTION_INFORMATION, *PSYSTEM_EXCEPTION_INFORMATION; @@ -759,68 +1112,45 @@ BYTE Reserved1[32]; } SYSTEM_LOOKASIDE_INFORMATION, *PSYSTEM_LOOKASIDE_INFORMATION; -typedef struct _SYSTEM_INTERRUPT_INFORMATION { - BYTE Reserved1[24]; -} SYSTEM_INTERRUPT_INFORMATION, *PSYSTEM_INTERRUPT_INFORMATION; +typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION { + BOOLEAN DebuggerEnabled; + BOOLEAN DebuggerNotPresent; +} SYSTEM_KERNEL_DEBUGGER_INFORMATION, *PSYSTEM_KERNEL_DEBUGGER_INFORMATION; -/* System Information Class 0x10 */ -typedef struct { - USHORT dwPID; - USHORT dwCreatorBackTraceIndex; - BYTE bObjectType; - BYTE bHandleAttributes; - USHORT usHandleOffset; - DWORD dwKeObject; - ULONG ulGrantedAccess; -} HANDLEINFO, *PHANDLEINFO; /* FIXME: SYSTEM_HANDLE_INFORMATION? */ +/* System Information Class 0x05 */ -typedef struct _SYSTEM_PERFORMANCE_INFORMATION { - BYTE Reserved1[312]; -} SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION; +typedef struct _VM_COUNTERS_ { + SIZE_T PeakVirtualSize; + SIZE_T VirtualSize; + ULONG PageFaultCount; + SIZE_T PeakWorkingSetSize; + SIZE_T WorkingSetSize; + SIZE_T QuotaPeakPagedPoolUsage; + SIZE_T QuotaPagedPoolUsage; + SIZE_T QuotaPeakNonPagedPoolUsage; + SIZE_T QuotaNonPagedPoolUsage; + SIZE_T PagefileUsage; + SIZE_T PeakPagefileUsage; +} VM_COUNTERS, *PVM_COUNTERS; -/* System Information Class 0x02 */ -typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION { -#ifdef __WINESRC__ - LARGE_INTEGER liIdleTime; - DWORD dwSpare[10]; -#else - LARGE_INTEGER IdleTime; - LARGE_INTEGER KernelTime; - LARGE_INTEGER UserTime; - LARGE_INTEGER Reserved1[2]; - ULONG Reserved2; -#endif -} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; - -/* System Information Class 0x05 */ typedef struct _SYSTEM_PROCESS_INFORMATION { #ifdef __WINESRC__ DWORD dwOffset; DWORD dwThreadCount; DWORD dwUnknown1[6]; FILETIME ftCreationTime; - DWORD dwUnknown2[5]; - WCHAR *pszProcessName; + FILETIME ftUserTime; + FILETIME ftKernelTime; + UNICODE_STRING ProcessName; DWORD dwBasePriority; DWORD dwProcessID; DWORD dwParentProcessID; DWORD dwHandleCount; DWORD dwUnknown3; DWORD dwUnknown4; - DWORD dwVirtualBytesPeak; - DWORD dwVirtualBytes; - DWORD dwPageFaults; - DWORD dwWorkingSetPeak; - DWORD dwWorkingSet; - DWORD dwUnknown5; - DWORD dwPagedPool; - DWORD dwUnknown6; - DWORD dwNonPagedPool; - DWORD dwPageFileBytesPeak; - DWORD dwPrivateBytes; - DWORD dwPageFileBytes; - DWORD dwUnknown7[4]; - THREADINFO ti[1]; + VM_COUNTERS vmCounters; + IO_COUNTERS ioCounters; + SYSTEM_THREAD_INFORMATION ti[1]; #else ULONG NextEntryOffset; BYTE Reserved1[52]; @@ -847,19 +1177,6 @@ BOOLEAN TimeAdjustmentDisabled; } SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT; -/* System Information Class 0x03 */ -typedef struct _SYSTEM_TIMEOFDAY_INFORMATION { -#ifdef __WINESRC__ - LARGE_INTEGER liKeBootTime; - LARGE_INTEGER liKeSystemTime; - LARGE_INTEGER liExpTimeZoneBias; - ULONG uCurrentTimeZoneId; - DWORD dwReserved; -#else - BYTE Reserved1[48]; -#endif -} SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION; /* was SYSTEM_TIME_INFORMATION */ - typedef struct _TIME_FIELDS { CSHORT Year; CSHORT Month; @@ -877,20 +1194,6 @@ BYTE Reserved3[1140]; } WINSTATIONINFORMATIONW, *PWINSTATIONINFORMATIONW; -typedef struct _VM_COUNTERS_ { - ULONG PeakVirtualSize; - ULONG VirtualSize; [truncated at 1000 lines; 1024 more skipped]

1 0

[sedwards] 17131: DCX_USESTYLE is a wineism. Dont use it in a header
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

DCX_USESTYLE is a wineism. Dont use it in a header Modified: trunk/reactos/w32api/include/winuser.h _____ Modified: trunk/reactos/w32api/include/winuser.h --- trunk/reactos/w32api/include/winuser.h 2005-08-07 00:25:26 UTC (rev 17130) +++ trunk/reactos/w32api/include/winuser.h 2005-08-07 00:26:13 UTC (rev 17131) @@ -1736,7 +1736,6 @@ #define DCX_EXCLUDERGN 64 #define DCX_INTERSECTRGN 128 #define DCX_VALIDATE 0x200000 -#define DCX_USESTYLE 0x00010000 #define GMDI_GOINTOPOPUPS 2 #define GMDI_USEDISABLED 1 #define FKF_AVAILABLE 2

1 0

[sedwards] 17130: added local define for DCX_USESTYLE
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

added local define for DCX_USESTYLE Modified: trunk/reactos/regtests/winetests/user32/dce.c _____ Modified: trunk/reactos/regtests/winetests/user32/dce.c --- trunk/reactos/regtests/winetests/user32/dce.c 2005-08-07 00:21:24 UTC (rev 17129) +++ trunk/reactos/regtests/winetests/user32/dce.c 2005-08-07 00:25:26 UTC (rev 17130) @@ -33,6 +33,8 @@ #include "wine/test.h" +#define DCX_USESTYLE 0x00010000 + static HWND hwnd_cache, hwnd_owndc, hwnd_classdc, hwnd_classdc2; /* test behavior of DC attributes with various GetDC/ReleaseDC combinations */

1 0

[sedwards] 17129: added DCX_USESTYLE
by sedwards＠svn.reactos.com 07 Aug '05

07 Aug '05

added DCX_USESTYLE Modified: trunk/reactos/w32api/include/winuser.h _____ Modified: trunk/reactos/w32api/include/winuser.h --- trunk/reactos/w32api/include/winuser.h 2005-08-07 00:06:29 UTC (rev 17128) +++ trunk/reactos/w32api/include/winuser.h 2005-08-07 00:21:24 UTC (rev 17129) @@ -1736,6 +1736,7 @@ #define DCX_EXCLUDERGN 64 #define DCX_INTERSECTRGN 128 #define DCX_VALIDATE 0x200000 +#define DCX_USESTYLE 0x00010000 #define GMDI_GOINTOPOPUPS 2 #define GMDI_USEDISABLED 1 #define FKF_AVAILABLE 2

1 0

← Newer
1
...
44
45
46
47
48
49
50
...
67
Older →

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs August 2005