4 * This file contains the Rtl* API functions. These should be implementable.
6 * Copyright 1996-1998 Marcus Meissner
7 * Copyright 1999 Alex Korobka
8 * Copyright 2003 Thomas Mertes
9 * Crc32 code Copyright 1986 Gary S. Brown (Public domain)
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wine/port.h"
33 #ifdef HAVE_NETINET_IN_H
34 #include <netinet/in.h>
37 #define NONAMELESSUNION
38 #define NONAMELESSSTRUCT
39 #define WIN32_NO_STATUS
43 #include "wine/debug.h"
44 #include "wine/exception.h"
45 #include "wine/unicode.h"
46 #include "ntdll_misc.h"
49 #include "ddk/ntddk.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
53 /* CRC polynomial 0xedb88320 */
54 static const DWORD CRC_table
[256] =
56 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
57 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
58 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
59 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
60 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
61 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
62 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
63 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
64 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
65 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
66 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
67 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
68 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
69 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
70 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
71 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
72 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
73 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
74 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
75 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
76 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
77 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
78 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
79 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
80 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
81 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
82 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
83 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
84 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
85 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
86 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
87 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
88 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
89 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
90 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
91 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
92 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
93 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
94 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
95 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
96 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
97 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
98 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
105 /***********************************************************************
106 * RtlInitializeResource (NTDLL.@)
108 * xxxResource() functions implement multiple-reader-single-writer lock.
109 * The code is based on information published in WDJ January 1999 issue.
111 void WINAPI
RtlInitializeResource(LPRTL_RWLOCK rwl
)
115 rwl
->iNumberActive
= 0;
116 rwl
->uExclusiveWaiters
= 0;
117 rwl
->uSharedWaiters
= 0;
118 rwl
->hOwningThreadId
= 0;
119 rwl
->dwTimeoutBoost
= 0; /* no info on this one, default value is 0 */
120 RtlInitializeCriticalSection( &rwl
->rtlCS
);
121 rwl
->rtlCS
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": RTL_RWLOCK.rtlCS");
122 NtCreateSemaphore( &rwl
->hExclusiveReleaseSemaphore
, SEMAPHORE_ALL_ACCESS
, NULL
, 0, 65535 );
123 NtCreateSemaphore( &rwl
->hSharedReleaseSemaphore
, SEMAPHORE_ALL_ACCESS
, NULL
, 0, 65535 );
128 /***********************************************************************
129 * RtlDeleteResource (NTDLL.@)
131 void WINAPI
RtlDeleteResource(LPRTL_RWLOCK rwl
)
135 RtlEnterCriticalSection( &rwl
->rtlCS
);
136 if( rwl
->iNumberActive
|| rwl
->uExclusiveWaiters
|| rwl
->uSharedWaiters
)
137 ERR("Deleting active MRSW lock (%p), expect failure\n", rwl
);
138 rwl
->hOwningThreadId
= 0;
139 rwl
->uExclusiveWaiters
= rwl
->uSharedWaiters
= 0;
140 rwl
->iNumberActive
= 0;
141 NtClose( rwl
->hExclusiveReleaseSemaphore
);
142 NtClose( rwl
->hSharedReleaseSemaphore
);
143 RtlLeaveCriticalSection( &rwl
->rtlCS
);
144 rwl
->rtlCS
.DebugInfo
->Spare
[0] = 0;
145 RtlDeleteCriticalSection( &rwl
->rtlCS
);
150 /***********************************************************************
151 * RtlAcquireResourceExclusive (NTDLL.@)
153 BYTE WINAPI
RtlAcquireResourceExclusive(LPRTL_RWLOCK rwl
, BYTE fWait
)
159 RtlEnterCriticalSection( &rwl
->rtlCS
);
160 if( rwl
->iNumberActive
== 0 ) /* lock is free */
162 rwl
->iNumberActive
= -1;
165 else if( rwl
->iNumberActive
< 0 ) /* exclusive lock in progress */
167 if( rwl
->hOwningThreadId
== ULongToHandle(GetCurrentThreadId()) )
170 rwl
->iNumberActive
--;
178 rwl
->uExclusiveWaiters
++;
180 RtlLeaveCriticalSection( &rwl
->rtlCS
);
181 status
= NtWaitForSingleObject( rwl
->hExclusiveReleaseSemaphore
, FALSE
, NULL
);
184 goto start
; /* restart the acquisition to avoid deadlocks */
187 else /* one or more shared locks are in progress */
192 rwl
->hOwningThreadId
= ULongToHandle(GetCurrentThreadId());
194 RtlLeaveCriticalSection( &rwl
->rtlCS
);
198 /***********************************************************************
199 * RtlAcquireResourceShared (NTDLL.@)
201 BYTE WINAPI
RtlAcquireResourceShared(LPRTL_RWLOCK rwl
, BYTE fWait
)
203 NTSTATUS status
= STATUS_UNSUCCESSFUL
;
208 RtlEnterCriticalSection( &rwl
->rtlCS
);
209 if( rwl
->iNumberActive
< 0 )
211 if( rwl
->hOwningThreadId
== ULongToHandle(GetCurrentThreadId()) )
213 rwl
->iNumberActive
--;
220 rwl
->uSharedWaiters
++;
221 RtlLeaveCriticalSection( &rwl
->rtlCS
);
222 status
= NtWaitForSingleObject( rwl
->hSharedReleaseSemaphore
, FALSE
, NULL
);
230 if( status
!= STATUS_WAIT_0
) /* otherwise RtlReleaseResource() has already done it */
231 rwl
->iNumberActive
++;
235 RtlLeaveCriticalSection( &rwl
->rtlCS
);
240 /***********************************************************************
241 * RtlReleaseResource (NTDLL.@)
243 void WINAPI
RtlReleaseResource(LPRTL_RWLOCK rwl
)
245 RtlEnterCriticalSection( &rwl
->rtlCS
);
247 if( rwl
->iNumberActive
> 0 ) /* have one or more readers */
249 if( --rwl
->iNumberActive
== 0 )
251 if( rwl
->uExclusiveWaiters
)
254 rwl
->uExclusiveWaiters
--;
255 NtReleaseSemaphore( rwl
->hExclusiveReleaseSemaphore
, 1, NULL
);
260 if( rwl
->iNumberActive
< 0 ) /* have a writer, possibly recursive */
262 if( ++rwl
->iNumberActive
== 0 )
264 rwl
->hOwningThreadId
= 0;
265 if( rwl
->uExclusiveWaiters
)
268 if( rwl
->uSharedWaiters
)
270 UINT n
= rwl
->uSharedWaiters
;
271 rwl
->iNumberActive
= rwl
->uSharedWaiters
; /* prevent new writers from joining until
272 * all queued readers have done their thing */
273 rwl
->uSharedWaiters
= 0;
274 NtReleaseSemaphore( rwl
->hSharedReleaseSemaphore
, n
, NULL
);
278 RtlLeaveCriticalSection( &rwl
->rtlCS
);
282 /***********************************************************************
283 * RtlDumpResource (NTDLL.@)
285 void WINAPI
RtlDumpResource(LPRTL_RWLOCK rwl
)
289 MESSAGE("RtlDumpResource(%p):\n\tactive count = %i\n\twaiting readers = %i\n\twaiting writers = %i\n",
290 rwl
, rwl
->iNumberActive
, rwl
->uSharedWaiters
, rwl
->uExclusiveWaiters
);
291 if( rwl
->iNumberActive
)
292 MESSAGE("\towner thread = %p\n", rwl
->hOwningThreadId
);
300 /******************************************************************************
303 NTSTATUS WINAPIV
DbgPrint(LPCSTR fmt
, ...)
308 __ms_va_start(args
, fmt
);
309 NTDLL__vsnprintf(buf
, sizeof(buf
), fmt
, args
);
312 MESSAGE("DbgPrint says: %s",buf
);
313 /* hmm, raise exception? */
314 return STATUS_SUCCESS
;
318 /******************************************************************************
319 * DbgPrintEx [NTDLL.@]
321 NTSTATUS WINAPIV
DbgPrintEx(ULONG iComponentId
, ULONG Level
, LPCSTR fmt
, ...)
326 __ms_va_start(args
, fmt
);
327 ret
= vDbgPrintEx(iComponentId
, Level
, fmt
, args
);
332 /******************************************************************************
333 * vDbgPrintEx [NTDLL.@]
335 NTSTATUS WINAPI
vDbgPrintEx( ULONG id
, ULONG level
, LPCSTR fmt
, __ms_va_list args
)
337 return vDbgPrintExWithPrefix( "", id
, level
, fmt
, args
);
340 /******************************************************************************
341 * vDbgPrintExWithPrefix [NTDLL.@]
343 NTSTATUS WINAPI
vDbgPrintExWithPrefix( LPCSTR prefix
, ULONG id
, ULONG level
, LPCSTR fmt
, __ms_va_list args
)
347 NTDLL__vsnprintf(buf
, sizeof(buf
), fmt
, args
);
349 switch (level
& DPFLTR_MASK
)
351 case DPFLTR_ERROR_LEVEL
: ERR("%s%x: %s", prefix
, id
, buf
); break;
352 case DPFLTR_WARNING_LEVEL
: WARN("%s%x: %s", prefix
, id
, buf
); break;
353 case DPFLTR_TRACE_LEVEL
:
354 case DPFLTR_INFO_LEVEL
:
355 default: TRACE("%s%x: %s", prefix
, id
, buf
); break;
357 return STATUS_SUCCESS
;
360 /******************************************************************************
361 * RtlAcquirePebLock [NTDLL.@]
363 VOID WINAPI
RtlAcquirePebLock(void)
365 RtlEnterCriticalSection( NtCurrentTeb()->Peb
->FastPebLock
);
368 /******************************************************************************
369 * RtlReleasePebLock [NTDLL.@]
371 VOID WINAPI
RtlReleasePebLock(void)
373 RtlLeaveCriticalSection( NtCurrentTeb()->Peb
->FastPebLock
);
376 /******************************************************************************
377 * RtlNewSecurityObject [NTDLL.@]
380 RtlNewSecurityObject( PSECURITY_DESCRIPTOR ParentDescriptor
,
381 PSECURITY_DESCRIPTOR CreatorDescriptor
,
382 PSECURITY_DESCRIPTOR
*NewDescriptor
,
383 BOOLEAN IsDirectoryObject
,
385 PGENERIC_MAPPING GenericMapping
)
387 FIXME("(%p %p %p %d %p %p) stub!\n", ParentDescriptor
, CreatorDescriptor
,
388 NewDescriptor
, IsDirectoryObject
, Token
, GenericMapping
);
389 return STATUS_NOT_IMPLEMENTED
;
392 /******************************************************************************
393 * RtlDeleteSecurityObject [NTDLL.@]
396 RtlDeleteSecurityObject( PSECURITY_DESCRIPTOR
*ObjectDescriptor
)
398 FIXME("(%p) stub!\n", ObjectDescriptor
);
399 return STATUS_NOT_IMPLEMENTED
;
402 /******************************************************************************
403 * RtlInitializeGenericTable [NTDLL.@]
405 PVOID WINAPI
RtlInitializeGenericTable(PVOID pTable
, PVOID arg2
, PVOID arg3
, PVOID arg4
, PVOID arg5
)
407 FIXME("(%p,%p,%p,%p,%p) stub!\n", pTable
, arg2
, arg3
, arg4
, arg5
);
411 /******************************************************************************
412 * RtlEnumerateGenericTableWithoutSplaying [NTDLL.@]
414 PVOID
RtlEnumerateGenericTableWithoutSplaying(PVOID pTable
, PVOID
*RestartKey
)
416 static int warn_once
;
419 FIXME("(%p,%p) stub!\n", pTable
, RestartKey
);
423 /******************************************************************************
424 * RtlNumberGenericTableElements [NTDLL.@]
426 ULONG
RtlNumberGenericTableElements(PVOID pTable
)
428 FIXME("(%p) stub!\n", pTable
);
432 /******************************************************************************
433 * RtlMoveMemory [NTDLL.@]
435 * Move a block of memory that may overlap.
438 * Destination [O] End destination for block
439 * Source [O] Where to start copying from
440 * Length [I] Number of bytes to copy
446 VOID WINAPI
RtlMoveMemory( void *Destination
, const void *Source
, SIZE_T Length
)
448 memmove(Destination
, Source
, Length
);
451 /******************************************************************************
452 * RtlFillMemory [NTDLL.@]
454 * Set a block of memory with a value.
457 * Destination [O] Block to fill
458 * Length [I] Number of bytes to fill
459 * Fill [I] Value to set
465 VOID WINAPI
RtlFillMemory( VOID
*Destination
, SIZE_T Length
, BYTE Fill
)
467 memset(Destination
, Fill
, Length
);
470 /******************************************************************************
471 * RtlZeroMemory [NTDLL.@]
473 * Set a block of memory with 0's.
476 * Destination [O] Block to fill
477 * Length [I] Number of bytes to fill
483 VOID WINAPI
RtlZeroMemory( VOID
*Destination
, SIZE_T Length
)
485 memset(Destination
, 0, Length
);
488 /******************************************************************************
489 * RtlCompareMemory [NTDLL.@]
491 * Compare one block of memory with another
494 * Source1 [I] Source block
495 * Source2 [I] Block to compare to Source1
496 * Length [I] Number of bytes to compare
499 * The length of the first byte at which Source1 and Source2 differ, or Length
500 * if they are the same.
502 SIZE_T WINAPI
RtlCompareMemory( const VOID
*Source1
, const VOID
*Source2
, SIZE_T Length
)
505 for(i
=0; (i
<Length
) && (((const BYTE
*)Source1
)[i
]==((const BYTE
*)Source2
)[i
]); i
++);
509 /******************************************************************************
510 * RtlCompareMemoryUlong [NTDLL.@]
512 * Compare a block of memory with a value, a ULONG at a time
515 * Source1 [I] Source block. This must be ULONG aligned
516 * Length [I] Number of bytes to compare. This should be a multiple of 4
517 * dwVal [I] Value to compare to
520 * The byte position of the first byte at which Source1 is not dwVal.
522 SIZE_T WINAPI
RtlCompareMemoryUlong(const ULONG
*Source1
, SIZE_T Length
, ULONG dwVal
)
525 for(i
= 0; i
< Length
/sizeof(ULONG
) && Source1
[i
] == dwVal
; i
++);
526 return i
* sizeof(ULONG
);
529 /******************************************************************************
530 * RtlCopyMemory [NTDLL.@]
533 void WINAPI
RtlCopyMemory(void *dest
, const void *src
, SIZE_T len
)
535 memcpy(dest
, src
, len
);
538 /******************************************************************************
539 * RtlAssert [NTDLL.@]
541 * Fail a debug assertion.
544 * Nothing. This call does not return control to its caller.
547 * Not implemented in non-debug versions.
549 void WINAPI
RtlAssert(void *assertion
, void *filename
, ULONG linenumber
, char *message
)
551 FIXME("(%s, %s, %u, %s): stub\n", debugstr_a((char*)assertion
), debugstr_a((char*)filename
),
552 linenumber
, debugstr_a(message
));
555 /*************************************************************************
556 * RtlFillMemoryUlong [NTDLL.@]
558 * Fill memory with a 32 bit (dword) value.
561 * lpDest [I] Bitmap pointer
562 * ulCount [I] Number of dwords to write
563 * ulValue [I] Value to fill with
568 VOID WINAPI
RtlFillMemoryUlong(ULONG
* lpDest
, ULONG ulCount
, ULONG ulValue
)
570 TRACE("(%p,%d,%d)\n", lpDest
, ulCount
, ulValue
);
572 ulCount
/= sizeof(ULONG
);
577 /*********************************************************************
578 * RtlComputeCrc32 [NTDLL.@]
580 * Calculate the CRC32 checksum of a block of bytes
583 * dwInitial [I] Initial CRC value
584 * pData [I] Data block
585 * iLen [I] Length of the byte block
588 * The cumulative CRC32 of dwInitial and iLen bytes of the pData block.
590 DWORD WINAPI
RtlComputeCrc32(DWORD dwInitial
, const BYTE
*pData
, INT iLen
)
592 DWORD crc
= ~dwInitial
;
594 TRACE("(%d,%p,%d)\n", dwInitial
, pData
, iLen
);
598 crc
= CRC_table
[(crc
^ *pData
) & 0xff] ^ (crc
>> 8);
606 /*************************************************************************
607 * RtlUlonglongByteSwap [NTDLL.@]
609 * Swap the bytes of an unsigned long long value.
612 * i [I] Value to swap bytes of
615 * The value with its bytes swapped.
617 ULONGLONG __cdecl
RtlUlonglongByteSwap(ULONGLONG i
)
619 return ((ULONGLONG
)RtlUlongByteSwap(i
) << 32) | RtlUlongByteSwap(i
>>32);
622 /*************************************************************************
623 * RtlUlongByteSwap [NTDLL.@]
625 * Swap the bytes of an unsigned int value.
628 * ix86 version takes argument in %ecx. Other systems use the inline version.
631 __ASM_GLOBAL_FUNC(NTDLL_RtlUlongByteSwap
,
637 /*************************************************************************
638 * RtlUshortByteSwap [NTDLL.@]
640 * Swap the bytes of an unsigned short value.
643 * i386 version takes argument in %cx. Other systems use the inline version.
646 __ASM_GLOBAL_FUNC(NTDLL_RtlUshortByteSwap
,
653 /*************************************************************************
654 * RtlUniform [NTDLL.@]
656 * Generates an uniform random number
659 * seed [O] The seed of the Random function
662 * It returns a random number uniformly distributed over [0..MAXLONG-1].
665 * Generates an uniform random number using D.H. Lehmer's 1948 algorithm.
666 * In our case the algorithm is:
668 *| result = (*seed * 0x7fffffed + 0x7fffffc3) % MAXLONG;
673 * The native documentation states that the random number is
674 * uniformly distributed over [0..MAXLONG]. In reality the native
675 * function and our function return a random number uniformly
676 * distributed over [0..MAXLONG-1].
678 ULONG WINAPI
RtlUniform (PULONG seed
)
683 * Instead of the algorithm stated above, we use the algorithm
684 * below, which is totally equivalent (see the tests), but does
685 * not use a division and therefore is faster.
687 result
= *seed
* 0xffffffed + 0x7fffffc3;
688 if (result
== 0xffffffff || result
== 0x7ffffffe) {
689 result
= (result
+ 2) & MAXLONG
;
690 } else if (result
== 0x7fffffff) {
692 } else if ((result
& 0x80000000) == 0) {
693 result
= result
+ (~result
& 1);
695 result
= (result
+ (result
& 1)) & MAXLONG
;
702 /*************************************************************************
703 * RtlRandom [NTDLL.@]
705 * Generates a random number
708 * seed [O] The seed of the Random function
711 * It returns a random number distributed over [0..MAXLONG-1].
713 ULONG WINAPI
RtlRandom (PULONG seed
)
715 static ULONG saved_value
[128] =
716 { /* 0 */ 0x4c8bc0aa, 0x4c022957, 0x2232827a, 0x2f1e7626, 0x7f8bdafb, 0x5c37d02a, 0x0ab48f72, 0x2f0c4ffa,
717 /* 8 */ 0x290e1954, 0x6b635f23, 0x5d3885c0, 0x74b49ff8, 0x5155fa54, 0x6214ad3f, 0x111e9c29, 0x242a3a09,
718 /* 16 */ 0x75932ae1, 0x40ac432e, 0x54f7ba7a, 0x585ccbd5, 0x6df5c727, 0x0374dad1, 0x7112b3f1, 0x735fc311,
719 /* 24 */ 0x404331a9, 0x74d97781, 0x64495118, 0x323e04be, 0x5974b425, 0x4862e393, 0x62389c1d, 0x28a68b82,
720 /* 32 */ 0x0f95da37, 0x7a50bbc6, 0x09b0091c, 0x22cdb7b4, 0x4faaed26, 0x66417ccd, 0x189e4bfa, 0x1ce4e8dd,
721 /* 40 */ 0x5274c742, 0x3bdcf4dc, 0x2d94e907, 0x32eac016, 0x26d33ca3, 0x60415a8a, 0x31f57880, 0x68c8aa52,
722 /* 48 */ 0x23eb16da, 0x6204f4a1, 0x373927c1, 0x0d24eb7c, 0x06dd7379, 0x2b3be507, 0x0f9c55b1, 0x2c7925eb,
723 /* 56 */ 0x36d67c9a, 0x42f831d9, 0x5e3961cb, 0x65d637a8, 0x24bb3820, 0x4d08e33d, 0x2188754f, 0x147e409e,
724 /* 64 */ 0x6a9620a0, 0x62e26657, 0x7bd8ce81, 0x11da0abb, 0x5f9e7b50, 0x23e444b6, 0x25920c78, 0x5fc894f0,
725 /* 72 */ 0x5e338cbb, 0x404237fd, 0x1d60f80f, 0x320a1743, 0x76013d2b, 0x070294ee, 0x695e243b, 0x56b177fd,
726 /* 80 */ 0x752492e1, 0x6decd52f, 0x125f5219, 0x139d2e78, 0x1898d11e, 0x2f7ee785, 0x4db405d8, 0x1a028a35,
727 /* 88 */ 0x63f6f323, 0x1f6d0078, 0x307cfd67, 0x3f32a78a, 0x6980796c, 0x462b3d83, 0x34b639f2, 0x53fce379,
728 /* 96 */ 0x74ba50f4, 0x1abc2c4b, 0x5eeaeb8d, 0x335a7a0d, 0x3973dd20, 0x0462d66b, 0x159813ff, 0x1e4643fd,
729 /* 104 */ 0x06bc5c62, 0x3115e3fc, 0x09101613, 0x47af2515, 0x4f11ec54, 0x78b99911, 0x3db8dd44, 0x1ec10b9b,
730 /* 112 */ 0x5b5506ca, 0x773ce092, 0x567be81a, 0x5475b975, 0x7a2cde1a, 0x494536f5, 0x34737bb4, 0x76d9750b,
731 /* 120 */ 0x2a1f6232, 0x2e49644d, 0x7dddcbe7, 0x500cebdb, 0x619dab9e, 0x48c626fe, 0x1cda3193, 0x52dabe9d };
736 rand
= (*seed
* 0x7fffffed + 0x7fffffc3) % 0x7fffffff;
737 *seed
= (rand
* 0x7fffffed + 0x7fffffc3) % 0x7fffffff;
739 result
= saved_value
[pos
];
740 saved_value
[pos
] = rand
;
745 /*************************************************************************
746 * RtlRandomEx [NTDLL.@]
748 ULONG WINAPI
RtlRandomEx( ULONG
*seed
)
750 WARN( "semi-stub: should use a different algorithm\n" );
751 return RtlRandom( seed
);
754 /*************************************************************************
755 * RtlAreAllAccessesGranted [NTDLL.@]
757 * Check if all desired accesses are granted
760 * TRUE: All desired accesses are granted
763 BOOLEAN WINAPI
RtlAreAllAccessesGranted(
764 ACCESS_MASK GrantedAccess
,
765 ACCESS_MASK DesiredAccess
)
767 return (GrantedAccess
& DesiredAccess
) == DesiredAccess
;
771 /*************************************************************************
772 * RtlAreAnyAccessesGranted [NTDLL.@]
774 * Check if at least one of the desired accesses is granted
777 * GrantedAccess [I] Access mask of granted accesses
778 * DesiredAccess [I] Access mask of desired accesses
781 * TRUE: At least one of the desired accesses is granted
784 BOOLEAN WINAPI
RtlAreAnyAccessesGranted(
785 ACCESS_MASK GrantedAccess
,
786 ACCESS_MASK DesiredAccess
)
788 return (GrantedAccess
& DesiredAccess
) != 0;
792 /*************************************************************************
793 * RtlMapGenericMask [NTDLL.@]
795 * Determine the nongeneric access rights specified by an access mask
800 void WINAPI
RtlMapGenericMask(
801 PACCESS_MASK AccessMask
,
802 const GENERIC_MAPPING
*GenericMapping
)
804 if (*AccessMask
& GENERIC_READ
) {
805 *AccessMask
|= GenericMapping
->GenericRead
;
808 if (*AccessMask
& GENERIC_WRITE
) {
809 *AccessMask
|= GenericMapping
->GenericWrite
;
812 if (*AccessMask
& GENERIC_EXECUTE
) {
813 *AccessMask
|= GenericMapping
->GenericExecute
;
816 if (*AccessMask
& GENERIC_ALL
) {
817 *AccessMask
|= GenericMapping
->GenericAll
;
820 *AccessMask
&= 0x0FFFFFFF;
824 /*************************************************************************
825 * RtlCopyLuid [NTDLL.@]
827 * Copy a local unique ID.
830 * LuidDest [O] Destination for the copied Luid
831 * LuidSrc [I] Source Luid to copy to LuidDest
836 void WINAPI
RtlCopyLuid (PLUID LuidDest
, const LUID
*LuidSrc
)
838 *LuidDest
= *LuidSrc
;
842 /*************************************************************************
843 * RtlEqualLuid [NTDLL.@]
845 * Compare two local unique IDs.
848 * Luid1 [I] First Luid to compare to Luid2
849 * Luid2 [I] Second Luid to compare to Luid1
852 * TRUE: The two LUIDs are equal.
855 BOOLEAN WINAPI
RtlEqualLuid (const LUID
*Luid1
, const LUID
*Luid2
)
857 return (Luid1
->LowPart
== Luid2
->LowPart
&& Luid1
->HighPart
== Luid2
->HighPart
);
861 /*************************************************************************
862 * RtlCopyLuidAndAttributesArray [NTDLL.@]
864 * Copy an array of local unique IDs and attributes.
867 * Count [I] Number of Luid/attributes in Src
868 * Src [I] Source Luid/attributes to copy
869 * Dest [O] Destination for copied Luid/attributes
875 * Dest must be large enough to hold Src.
877 void WINAPI
RtlCopyLuidAndAttributesArray(
879 const LUID_AND_ATTRIBUTES
*Src
,
880 PLUID_AND_ATTRIBUTES Dest
)
884 for (i
= 0; i
< Count
; i
++) Dest
[i
] = Src
[i
];
887 /***********************************************************************
888 * RtlIpv4StringToAddressExW [NTDLL.@]
890 NTSTATUS WINAPI
RtlIpv4StringToAddressExW(const WCHAR
*str
, BOOLEAN strict
, IN_ADDR
*address
, USHORT
*port
)
892 FIXME("(%s, %u, %p, %p): stub\n", debugstr_w(str
), strict
, address
, port
);
893 return STATUS_NOT_IMPLEMENTED
;
896 /***********************************************************************
897 * RtlIpv4StringToAddressW [NTDLL.@]
899 NTSTATUS WINAPI
RtlIpv4StringToAddressW(const WCHAR
*str
, BOOLEAN strict
, const WCHAR
**terminator
, IN_ADDR
*address
)
901 FIXME("(%s, %u, %p, %p): stub\n", debugstr_w(str
), strict
, terminator
, address
);
902 return STATUS_NOT_IMPLEMENTED
;
905 /***********************************************************************
906 * RtlIpv6StringToAddressExW [NTDLL.@]
908 NTSTATUS NTAPI
RtlIpv6StringToAddressExW(const WCHAR
*str
, IN6_ADDR
*address
, ULONG
*scope
, USHORT
*port
)
910 FIXME("(%s, %p, %p, %p): stub\n", debugstr_w(str
), address
, scope
, port
);
911 return STATUS_NOT_IMPLEMENTED
;
914 /***********************************************************************
915 * RtlIpv4AddressToStringExW [NTDLL.@]
917 * Convert the given ipv4 address and optional the port to a string
920 * pin [I] PTR to the ip address to convert (network byte order)
921 * port [I] optional port to convert (network byte order)
922 * buffer [O] destination buffer for the result
923 * psize [IO] PTR to available/used size of the destination buffer
926 * Success: STATUS_SUCCESS
927 * Failure: STATUS_INVALID_PARAMETER
930 NTSTATUS WINAPI
RtlIpv4AddressToStringExW(const IN_ADDR
*pin
, USHORT port
, LPWSTR buffer
, PULONG psize
)
933 static const WCHAR fmt_ip
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
934 static const WCHAR fmt_port
[] = {':','%','u',0};
937 if (!pin
|| !buffer
|| !psize
)
938 return STATUS_INVALID_PARAMETER
;
940 TRACE("(%p:0x%x, %d, %p, %p:%d)\n", pin
, pin
->S_un
.S_addr
, port
, buffer
, psize
, *psize
);
942 needed
= sprintfW(tmp_ip
, fmt_ip
,
943 pin
->S_un
.S_un_b
.s_b1
, pin
->S_un
.S_un_b
.s_b2
,
944 pin
->S_un
.S_un_b
.s_b3
, pin
->S_un
.S_un_b
.s_b4
);
946 if (port
) needed
+= sprintfW(tmp_ip
+ needed
, fmt_port
, ntohs(port
));
948 if (*psize
> needed
) {
950 strcpyW(buffer
, tmp_ip
);
951 return STATUS_SUCCESS
;
955 return STATUS_INVALID_PARAMETER
;
958 /***********************************************************************
959 * RtlIpv4AddressToStringExA [NTDLL.@]
961 * Convert the given ipv4 address and optional the port to a string
963 * See RtlIpv4AddressToStringExW
965 NTSTATUS WINAPI
RtlIpv4AddressToStringExA(const IN_ADDR
*pin
, USHORT port
, LPSTR buffer
, PULONG psize
)
970 if (!pin
|| !buffer
|| !psize
)
971 return STATUS_INVALID_PARAMETER
;
973 TRACE("(%p:0x%x, %d, %p, %p:%d)\n", pin
, pin
->S_un
.S_addr
, port
, buffer
, psize
, *psize
);
975 needed
= sprintf(tmp_ip
, "%u.%u.%u.%u",
976 pin
->S_un
.S_un_b
.s_b1
, pin
->S_un
.S_un_b
.s_b2
,
977 pin
->S_un
.S_un_b
.s_b3
, pin
->S_un
.S_un_b
.s_b4
);
979 if (port
) needed
+= sprintf(tmp_ip
+ needed
, ":%u", ntohs(port
));
981 if (*psize
> needed
) {
983 strcpy(buffer
, tmp_ip
);
984 return STATUS_SUCCESS
;
988 return STATUS_INVALID_PARAMETER
;
991 /***********************************************************************
992 * RtlIpv4AddressToStringW [NTDLL.@]
994 * Convert the given ipv4 address to a string
997 * pin [I] PTR to the ip address to convert (network byte order)
998 * buffer [O] destination buffer for the result (at least 16 character)
1001 * PTR to the 0 character at the end of the converted string
1004 WCHAR
* WINAPI
RtlIpv4AddressToStringW(const IN_ADDR
*pin
, LPWSTR buffer
)
1008 if (RtlIpv4AddressToStringExW(pin
, 0, buffer
, &size
)) size
= 0;
1009 return buffer
+ size
- 1;
1012 /***********************************************************************
1013 * RtlIpv4AddressToStringA [NTDLL.@]
1015 * Convert the given ipv4 address to a string
1017 * See RtlIpv4AddressToStringW
1019 CHAR
* WINAPI
RtlIpv4AddressToStringA(const IN_ADDR
*pin
, LPSTR buffer
)
1023 if (RtlIpv4AddressToStringExA(pin
, 0, buffer
, &size
)) size
= 0;
1024 return buffer
+ size
- 1;
1027 /***********************************************************************
1028 * get_pointer_obfuscator (internal)
1030 static DWORD_PTR
get_pointer_obfuscator( void )
1032 static DWORD_PTR pointer_obfuscator
;
1034 if (!pointer_obfuscator
)
1036 ULONG seed
= NtGetTickCount();
1039 /* generate a random value for the obfuscator */
1040 rand
= RtlUniform( &seed
);
1042 /* handle 64bit pointers */
1043 rand
^= (ULONG_PTR
)RtlUniform( &seed
) << ((sizeof (DWORD_PTR
) - sizeof (ULONG
))*8);
1045 /* set the high bits so dereferencing obfuscated pointers will (usually) crash */
1046 rand
|= (ULONG_PTR
)0xc0000000 << ((sizeof (DWORD_PTR
) - sizeof (ULONG
))*8);
1048 interlocked_cmpxchg_ptr( (void**) &pointer_obfuscator
, (void*) rand
, NULL
);
1051 return pointer_obfuscator
;
1054 /*************************************************************************
1055 * RtlEncodePointer [NTDLL.@]
1057 PVOID WINAPI
RtlEncodePointer( PVOID ptr
)
1059 DWORD_PTR ptrval
= (DWORD_PTR
) ptr
;
1060 return (PVOID
)(ptrval
^ get_pointer_obfuscator());
1063 PVOID WINAPI
RtlDecodePointer( PVOID ptr
)
1065 DWORD_PTR ptrval
= (DWORD_PTR
) ptr
;
1066 return (PVOID
)(ptrval
^ get_pointer_obfuscator());
1069 /*************************************************************************
1070 * RtlInitializeSListHead [NTDLL.@]
1072 VOID WINAPI
RtlInitializeSListHead(PSLIST_HEADER list
)
1075 list
->s
.Alignment
= list
->s
.Region
= 0;
1076 list
->Header16
.HeaderType
= 1; /* we use the 16-byte header */
1078 list
->Alignment
= 0;
1082 /*************************************************************************
1083 * RtlQueryDepthSList [NTDLL.@]
1085 WORD WINAPI
RtlQueryDepthSList(PSLIST_HEADER list
)
1088 return list
->Header16
.Depth
;
1090 return list
->s
.Depth
;
1094 /*************************************************************************
1095 * RtlFirstEntrySList [NTDLL.@]
1097 PSLIST_ENTRY WINAPI
RtlFirstEntrySList(const SLIST_HEADER
* list
)
1100 return (SLIST_ENTRY
*)((ULONG_PTR
)list
->Header16
.NextEntry
<< 4);
1102 return list
->s
.Next
.Next
;
1106 /*************************************************************************
1107 * RtlInterlockedFlushSList [NTDLL.@]
1109 PSLIST_ENTRY WINAPI
RtlInterlockedFlushSList(PSLIST_HEADER list
)
1111 SLIST_HEADER old
, new;
1114 if (!list
->Header16
.NextEntry
) return NULL
;
1115 new.s
.Alignment
= new.s
.Region
= 0;
1116 new.Header16
.HeaderType
= 1; /* we use the 16-byte header */
1120 new.Header16
.Sequence
= old
.Header16
.Sequence
+ 1;
1121 } while (!interlocked_cmpxchg128((__int64
*)list
, new.s
.Region
, new.s
.Alignment
, (__int64
*)&old
));
1122 return (SLIST_ENTRY
*)((ULONG_PTR
)old
.Header16
.NextEntry
<< 4);
1124 if (!list
->s
.Next
.Next
) return NULL
;
1129 new.s
.Sequence
= old
.s
.Sequence
+ 1;
1130 } while (interlocked_cmpxchg64((__int64
*)&list
->Alignment
, new.Alignment
,
1131 old
.Alignment
) != old
.Alignment
);
1132 return old
.s
.Next
.Next
;
1136 /*************************************************************************
1137 * RtlInterlockedPushEntrySList [NTDLL.@]
1139 PSLIST_ENTRY WINAPI
RtlInterlockedPushEntrySList(PSLIST_HEADER list
, PSLIST_ENTRY entry
)
1141 SLIST_HEADER old
, new;
1144 new.Header16
.NextEntry
= (ULONG_PTR
)entry
>> 4;
1148 entry
->Next
= (SLIST_ENTRY
*)((ULONG_PTR
)old
.Header16
.NextEntry
<< 4);
1149 new.Header16
.Depth
= old
.Header16
.Depth
+ 1;
1150 new.Header16
.Sequence
= old
.Header16
.Sequence
+ 1;
1151 } while (!interlocked_cmpxchg128((__int64
*)list
, new.s
.Region
, new.s
.Alignment
, (__int64
*)&old
));
1152 return (SLIST_ENTRY
*)((ULONG_PTR
)old
.Header16
.NextEntry
<< 4);
1154 new.s
.Next
.Next
= entry
;
1158 entry
->Next
= old
.s
.Next
.Next
;
1159 new.s
.Depth
= old
.s
.Depth
+ 1;
1160 new.s
.Sequence
= old
.s
.Sequence
+ 1;
1161 } while (interlocked_cmpxchg64((__int64
*)&list
->Alignment
, new.Alignment
,
1162 old
.Alignment
) != old
.Alignment
);
1163 return old
.s
.Next
.Next
;
1167 /*************************************************************************
1168 * RtlInterlockedPopEntrySList [NTDLL.@]
1170 PSLIST_ENTRY WINAPI
RtlInterlockedPopEntrySList(PSLIST_HEADER list
)
1172 SLIST_HEADER old
, new;
1179 if (!(entry
= (SLIST_ENTRY
*)((ULONG_PTR
)old
.Header16
.NextEntry
<< 4))) return NULL
;
1180 /* entry could be deleted by another thread */
1183 new.Header16
.NextEntry
= (ULONG_PTR
)entry
->Next
>> 4;
1184 new.Header16
.Depth
= old
.Header16
.Depth
- 1;
1185 new.Header16
.Sequence
= old
.Header16
.Sequence
+ 1;
1191 } while (!interlocked_cmpxchg128((__int64
*)list
, new.s
.Region
, new.s
.Alignment
, (__int64
*)&old
));
1196 if (!(entry
= old
.s
.Next
.Next
)) return NULL
;
1197 /* entry could be deleted by another thread */
1200 new.s
.Next
.Next
= entry
->Next
;
1201 new.s
.Depth
= old
.s
.Depth
- 1;
1202 new.s
.Sequence
= old
.s
.Sequence
+ 1;
1208 } while (interlocked_cmpxchg64((__int64
*)&list
->Alignment
, new.Alignment
,
1209 old
.Alignment
) != old
.Alignment
);
1214 /*************************************************************************
1215 * RtlInterlockedPushListSListEx [NTDLL.@]
1217 PSLIST_ENTRY WINAPI
RtlInterlockedPushListSListEx(PSLIST_HEADER list
, PSLIST_ENTRY first
,
1218 PSLIST_ENTRY last
, ULONG count
)
1220 SLIST_HEADER old
, new;
1223 new.Header16
.NextEntry
= (ULONG_PTR
)first
>> 4;
1227 new.Header16
.Depth
= old
.Header16
.Depth
+ count
;
1228 new.Header16
.Sequence
= old
.Header16
.Sequence
+ 1;
1229 last
->Next
= (SLIST_ENTRY
*)((ULONG_PTR
)old
.Header16
.NextEntry
<< 4);
1230 } while (!interlocked_cmpxchg128((__int64
*)list
, new.s
.Region
, new.s
.Alignment
, (__int64
*)&old
));
1231 return (SLIST_ENTRY
*)((ULONG_PTR
)old
.Header16
.NextEntry
<< 4);
1233 new.s
.Next
.Next
= first
;
1237 new.s
.Depth
= old
.s
.Depth
+ count
;
1238 new.s
.Sequence
= old
.s
.Sequence
+ 1;
1239 last
->Next
= old
.s
.Next
.Next
;
1240 } while (interlocked_cmpxchg64((__int64
*)&list
->Alignment
, new.Alignment
,
1241 old
.Alignment
) != old
.Alignment
);
1242 return old
.s
.Next
.Next
;
1246 /*************************************************************************
1247 * RtlInterlockedPushListSList [NTDLL.@]
1249 DEFINE_FASTCALL_WRAPPER(RtlInterlockedPushListSList
, 16)
1250 PSLIST_ENTRY FASTCALL
RtlInterlockedPushListSList(PSLIST_HEADER list
, PSLIST_ENTRY first
,
1251 PSLIST_ENTRY last
, ULONG count
)
1253 return RtlInterlockedPushListSListEx(list
, first
, last
, count
);
1256 /******************************************************************************
1257 * RtlGetCompressionWorkSpaceSize [NTDLL.@]
1259 NTSTATUS WINAPI
RtlGetCompressionWorkSpaceSize(USHORT format
, PULONG compress_workspace
,
1260 PULONG decompress_workspace
)
1262 FIXME("0x%04x, %p, %p: semi-stub\n", format
, compress_workspace
, decompress_workspace
);
1264 switch (format
& ~COMPRESSION_ENGINE_MAXIMUM
)
1266 case COMPRESSION_FORMAT_LZNT1
:
1267 if (compress_workspace
)
1269 /* FIXME: The current implementation of RtlCompressBuffer does not use a
1270 * workspace buffer, but Windows applications might expect a nonzero value. */
1271 *compress_workspace
= 16;
1273 if (decompress_workspace
)
1274 *decompress_workspace
= 0x1000;
1275 return STATUS_SUCCESS
;
1277 case COMPRESSION_FORMAT_NONE
:
1278 case COMPRESSION_FORMAT_DEFAULT
:
1279 return STATUS_INVALID_PARAMETER
;
1282 FIXME("format %u not implemented\n", format
);
1283 return STATUS_UNSUPPORTED_COMPRESSION
;
1287 /* compress data using LZNT1, currently only a stub */
1288 static NTSTATUS
lznt1_compress(UCHAR
*src
, ULONG src_size
, UCHAR
*dst
, ULONG dst_size
,
1289 ULONG chunk_size
, ULONG
*final_size
, UCHAR
*workspace
)
1291 UCHAR
*src_cur
= src
, *src_end
= src
+ src_size
;
1292 UCHAR
*dst_cur
= dst
, *dst_end
= dst
+ dst_size
;
1295 while (src_cur
< src_end
)
1297 /* determine size of current chunk */
1298 block_size
= min(0x1000, src_end
- src_cur
);
1299 if (dst_cur
+ sizeof(WORD
) + block_size
> dst_end
)
1300 return STATUS_BUFFER_TOO_SMALL
;
1302 /* write (uncompressed) chunk header */
1303 *(WORD
*)dst_cur
= 0x3000 | (block_size
- 1);
1304 dst_cur
+= sizeof(WORD
);
1306 /* write chunk content */
1307 memcpy(dst_cur
, src_cur
, block_size
);
1308 dst_cur
+= block_size
;
1309 src_cur
+= block_size
;
1313 *final_size
= dst_cur
- dst
;
1315 return STATUS_SUCCESS
;
1318 /******************************************************************************
1319 * RtlCompressBuffer [NTDLL.@]
1321 NTSTATUS WINAPI
RtlCompressBuffer(USHORT format
, PUCHAR uncompressed
, ULONG uncompressed_size
,
1322 PUCHAR compressed
, ULONG compressed_size
, ULONG chunk_size
,
1323 PULONG final_size
, PVOID workspace
)
1325 FIXME("0x%04x, %p, %u, %p, %u, %u, %p, %p: semi-stub\n", format
, uncompressed
,
1326 uncompressed_size
, compressed
, compressed_size
, chunk_size
, final_size
, workspace
);
1328 switch (format
& ~COMPRESSION_ENGINE_MAXIMUM
)
1330 case COMPRESSION_FORMAT_LZNT1
:
1331 return lznt1_compress(uncompressed
, uncompressed_size
, compressed
,
1332 compressed_size
, chunk_size
, final_size
, workspace
);
1334 case COMPRESSION_FORMAT_NONE
:
1335 case COMPRESSION_FORMAT_DEFAULT
:
1336 return STATUS_INVALID_PARAMETER
;
1339 FIXME("format %u not implemented\n", format
);
1340 return STATUS_UNSUPPORTED_COMPRESSION
;
1344 /* decompress a single LZNT1 chunk */
1345 static UCHAR
*lznt1_decompress_chunk(UCHAR
*dst
, ULONG dst_size
, UCHAR
*src
, ULONG src_size
)
1347 UCHAR
*src_cur
= src
, *src_end
= src
+ src_size
;
1348 UCHAR
*dst_cur
= dst
, *dst_end
= dst
+ dst_size
;
1349 ULONG displacement_bits
, length_bits
;
1350 ULONG code_displacement
, code_length
;
1353 while (src_cur
< src_end
&& dst_cur
< dst_end
)
1355 flags
= 0x8000 | *src_cur
++;
1356 while ((flags
& 0xff00) && src_cur
< src_end
)
1360 /* backwards reference */
1361 if (src_cur
+ sizeof(WORD
) > src_end
)
1364 code
= *(WORD
*)src_cur
;
1365 src_cur
+= sizeof(WORD
);
1367 /* find length / displacement bits */
1368 for (displacement_bits
= 12; displacement_bits
> 4; displacement_bits
--)
1369 if ((1 << (displacement_bits
- 1)) < dst_cur
- dst
) break;
1371 length_bits
= 16 - displacement_bits
;
1372 code_length
= (code
& ((1 << length_bits
) - 1)) + 3;
1373 code_displacement
= (code
>> length_bits
) + 1;
1375 if (dst_cur
< dst
+ code_displacement
)
1378 /* copy bytes of chunk - we can't use memcpy() since source and dest can
1379 * be overlapping, and the same bytes can be repeated over and over again */
1380 while (code_length
--)
1382 if (dst_cur
>= dst_end
) return dst_cur
;
1383 *dst_cur
= *(dst_cur
- code_displacement
);
1389 /* uncompressed data */
1390 if (dst_cur
>= dst_end
) return dst_cur
;
1391 *dst_cur
++ = *src_cur
++;
1400 /* decompress data encoded with LZNT1 */
1401 static NTSTATUS
lznt1_decompress(UCHAR
*dst
, ULONG dst_size
, UCHAR
*src
, ULONG src_size
,
1402 ULONG offset
, ULONG
*final_size
, UCHAR
*workspace
)
1404 UCHAR
*src_cur
= src
, *src_end
= src
+ src_size
;
1405 UCHAR
*dst_cur
= dst
, *dst_end
= dst
+ dst_size
;
1406 ULONG chunk_size
, block_size
;
1410 if (src_cur
+ sizeof(WORD
) > src_end
)
1411 return STATUS_BAD_COMPRESSION_BUFFER
;
1413 /* skip over chunks with a distance >= 0x1000 to the destination offset */
1414 while (offset
>= 0x1000 && src_cur
+ sizeof(WORD
) <= src_end
)
1416 chunk_header
= *(WORD
*)src_cur
;
1417 src_cur
+= sizeof(WORD
);
1418 if (!chunk_header
) goto out
;
1419 chunk_size
= (chunk_header
& 0xfff) + 1;
1421 if (src_cur
+ chunk_size
> src_end
)
1422 return STATUS_BAD_COMPRESSION_BUFFER
;
1424 src_cur
+= chunk_size
;
1428 /* handle partially included chunk */
1429 if (offset
&& src_cur
+ sizeof(WORD
) <= src_end
)
1431 chunk_header
= *(WORD
*)src_cur
;
1432 src_cur
+= sizeof(WORD
);
1433 if (!chunk_header
) goto out
;
1434 chunk_size
= (chunk_header
& 0xfff) + 1;
1436 if (src_cur
+ chunk_size
> src_end
)
1437 return STATUS_BAD_COMPRESSION_BUFFER
;
1439 if (dst_cur
>= dst_end
)
1442 if (chunk_header
& 0x8000)
1444 /* compressed chunk */
1445 if (!workspace
) return STATUS_ACCESS_VIOLATION
;
1446 ptr
= lznt1_decompress_chunk(workspace
, 0x1000, src_cur
, chunk_size
);
1447 if (!ptr
) return STATUS_BAD_COMPRESSION_BUFFER
;
1448 if (ptr
- workspace
> offset
)
1450 block_size
= min((ptr
- workspace
) - offset
, dst_end
- dst_cur
);
1451 memcpy(dst_cur
, workspace
+ offset
, block_size
);
1452 dst_cur
+= block_size
;
1457 /* uncompressed chunk */
1458 if (chunk_size
> offset
)
1460 block_size
= min(chunk_size
- offset
, dst_end
- dst_cur
);
1461 memcpy(dst_cur
, src_cur
+ offset
, block_size
);
1462 dst_cur
+= block_size
;
1466 src_cur
+= chunk_size
;
1469 /* handle remaining chunks */
1470 while (src_cur
+ sizeof(WORD
) <= src_end
)
1472 chunk_header
= *(WORD
*)src_cur
;
1473 src_cur
+= sizeof(WORD
);
1474 if (!chunk_header
) goto out
;
1475 chunk_size
= (chunk_header
& 0xfff) + 1;
1477 if (src_cur
+ chunk_size
> src_end
)
1478 return STATUS_BAD_COMPRESSION_BUFFER
;
1480 /* fill space with padding when the previous chunk was decompressed
1481 * to less than 4096 bytes. no padding is needed for the last chunk
1482 * or when the next chunk is truncated */
1483 block_size
= ((dst_cur
- dst
) + offset
) & 0xfff;
1486 block_size
= 0x1000 - block_size
;
1487 if (dst_cur
+ block_size
>= dst_end
)
1489 memset(dst_cur
, 0, block_size
);
1490 dst_cur
+= block_size
;
1493 if (dst_cur
>= dst_end
)
1496 if (chunk_header
& 0x8000)
1498 /* compressed chunk */
1499 dst_cur
= lznt1_decompress_chunk(dst_cur
, dst_end
- dst_cur
, src_cur
, chunk_size
);
1500 if (!dst_cur
) return STATUS_BAD_COMPRESSION_BUFFER
;
1504 /* uncompressed chunk */
1505 block_size
= min(chunk_size
, dst_end
- dst_cur
);
1506 memcpy(dst_cur
, src_cur
, block_size
);
1507 dst_cur
+= block_size
;
1510 src_cur
+= chunk_size
;
1515 *final_size
= dst_cur
- dst
;
1517 return STATUS_SUCCESS
;
1521 /******************************************************************************
1522 * RtlDecompressFragment [NTDLL.@]
1524 NTSTATUS WINAPI
RtlDecompressFragment(USHORT format
, PUCHAR uncompressed
, ULONG uncompressed_size
,
1525 PUCHAR compressed
, ULONG compressed_size
, ULONG offset
,
1526 PULONG final_size
, PVOID workspace
)
1528 TRACE("0x%04x, %p, %u, %p, %u, %u, %p, %p\n", format
, uncompressed
,
1529 uncompressed_size
, compressed
, compressed_size
, offset
, final_size
, workspace
);
1531 switch (format
& ~COMPRESSION_ENGINE_MAXIMUM
)
1533 case COMPRESSION_FORMAT_LZNT1
:
1534 return lznt1_decompress(uncompressed
, uncompressed_size
, compressed
,
1535 compressed_size
, offset
, final_size
, workspace
);
1537 case COMPRESSION_FORMAT_NONE
:
1538 case COMPRESSION_FORMAT_DEFAULT
:
1539 return STATUS_INVALID_PARAMETER
;
1542 FIXME("format %u not implemented\n", format
);
1543 return STATUS_UNSUPPORTED_COMPRESSION
;
1548 /******************************************************************************
1549 * RtlDecompressBuffer [NTDLL.@]
1551 NTSTATUS WINAPI
RtlDecompressBuffer(USHORT format
, PUCHAR uncompressed
, ULONG uncompressed_size
,
1552 PUCHAR compressed
, ULONG compressed_size
, PULONG final_size
)
1554 TRACE("0x%04x, %p, %u, %p, %u, %p\n", format
, uncompressed
,
1555 uncompressed_size
, compressed
, compressed_size
, final_size
);
1557 return RtlDecompressFragment(format
, uncompressed
, uncompressed_size
,
1558 compressed
, compressed_size
, 0, final_size
, NULL
);
1561 /***********************************************************************
1562 * RtlSetThreadErrorMode [NTDLL.@]
1564 * Set the thread local error mode.
1567 * mode [I] The new error mode
1568 * oldmode [O] Destination of the old error mode (may be NULL)
1571 * Success: STATUS_SUCCESS
1572 * Failure: STATUS_INVALID_PARAMETER_1
1574 NTSTATUS WINAPI
RtlSetThreadErrorMode( DWORD mode
, LPDWORD oldmode
)
1577 return STATUS_INVALID_PARAMETER_1
;
1580 *oldmode
= NtCurrentTeb()->HardErrorDisabled
;
1582 NtCurrentTeb()->HardErrorDisabled
= mode
;
1583 return STATUS_SUCCESS
;
1586 /***********************************************************************
1587 * RtlGetThreadErrorMode [NTDLL.@]
1589 * Get the thread local error mode.
1595 * The current thread local error mode.
1597 DWORD WINAPI
RtlGetThreadErrorMode( void )
1599 return NtCurrentTeb()->HardErrorDisabled
;
1602 /******************************************************************************
1603 * RtlGetCurrentTransaction [NTDLL.@]
1605 HANDLE WINAPI
RtlGetCurrentTransaction(void)
1607 FIXME("() :stub\n");
1611 /******************************************************************************
1612 * RtlSetCurrentTransaction [NTDLL.@]
1614 BOOL WINAPI
RtlSetCurrentTransaction(HANDLE new_transaction
)
1616 FIXME("(%p) :stub\n", new_transaction
);
1620 /**********************************************************************
1621 * RtlGetCurrentProcessorNumberEx [NTDLL.@]
1623 void WINAPI
RtlGetCurrentProcessorNumberEx(PROCESSOR_NUMBER
*processor
)
1625 FIXME("(%p) :semi-stub\n", processor
);
1626 processor
->Group
= 0;
1627 processor
->Number
= NtGetCurrentProcessorNumber();
1628 processor
->Reserved
= 0;
1631 /***********************************************************************
1632 * RtlInitializeGenericTableAvl (NTDLL.@)
1634 void WINAPI
RtlInitializeGenericTableAvl(PRTL_AVL_TABLE table
, PRTL_AVL_COMPARE_ROUTINE compare
,
1635 PRTL_AVL_ALLOCATE_ROUTINE allocate
, PRTL_AVL_FREE_ROUTINE free
, void *context
)
1637 FIXME("%p %p %p %p %p: stub\n", table
, compare
, allocate
, free
, context
);
1640 /***********************************************************************
1641 * RtlInsertElementGenericTableAvl (NTDLL.@)
1643 void WINAPI
RtlInsertElementGenericTableAvl(PRTL_AVL_TABLE table
, void *buffer
, ULONG size
, BOOL
*element
)
1645 FIXME("%p %p %u %p: stub\n", table
, buffer
, size
, element
);
1648 /*********************************************************************
1649 * RtlQueryPackageIdentity [NTDLL.@]
1651 NTSTATUS WINAPI
RtlQueryPackageIdentity(HANDLE token
, WCHAR
*fullname
, SIZE_T
*fullname_size
,
1652 WCHAR
*appid
, SIZE_T
*appid_size
, BOOLEAN
*packaged
)
1654 FIXME("(%p, %p, %p, %p, %p, %p): stub\n", token
, fullname
, fullname_size
, appid
, appid_size
, packaged
);
1655 return STATUS_NOT_FOUND
;