4 * This file contains the Nt* API functions of NTDLL.DLL.
5 * In the original ntdll.dll they all seem to just call int 0x2e (down to the NTOSKRNL)
7 * Copyright 1996-1998 Marcus Meissner
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #define NONAMELESSUNION
32 #define WIN32_NO_STATUS
33 #include "wine/debug.h"
34 #include "wine/unicode.h"
37 #include "ntdll_misc.h"
38 #include "wine/server.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
46 /******************************************************************************
47 * NtDuplicateToken [NTDLL.@]
48 * ZwDuplicateToken [NTDLL.@]
50 NTSTATUS WINAPI
NtDuplicateToken(
51 IN HANDLE ExistingToken
,
52 IN ACCESS_MASK DesiredAccess
,
53 IN POBJECT_ATTRIBUTES ObjectAttributes
,
54 IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
,
55 IN TOKEN_TYPE TokenType
,
60 TRACE("(%p,0x%08x,%p,0x%08x,0x%08x,%p)\n",
61 ExistingToken
, DesiredAccess
, ObjectAttributes
,
62 ImpersonationLevel
, TokenType
, NewToken
);
63 dump_ObjectAttributes(ObjectAttributes
);
65 if (ObjectAttributes
&& ObjectAttributes
->SecurityQualityOfService
)
67 SECURITY_QUALITY_OF_SERVICE
*SecurityQOS
= ObjectAttributes
->SecurityQualityOfService
;
68 TRACE("ObjectAttributes->SecurityQualityOfService = {%d, %d, %d, %s}\n",
69 SecurityQOS
->Length
, SecurityQOS
->ImpersonationLevel
,
70 SecurityQOS
->ContextTrackingMode
,
71 SecurityQOS
->EffectiveOnly
? "TRUE" : "FALSE");
72 ImpersonationLevel
= SecurityQOS
->ImpersonationLevel
;
75 SERVER_START_REQ( duplicate_token
)
77 req
->handle
= ExistingToken
;
78 req
->access
= DesiredAccess
;
79 req
->attributes
= ObjectAttributes
? ObjectAttributes
->Attributes
: 0;
80 req
->primary
= (TokenType
== TokenPrimary
);
81 req
->impersonation_level
= ImpersonationLevel
;
82 status
= wine_server_call( req
);
83 if (!status
) *NewToken
= reply
->new_handle
;
90 /******************************************************************************
91 * NtOpenProcessToken [NTDLL.@]
92 * ZwOpenProcessToken [NTDLL.@]
94 NTSTATUS WINAPI
NtOpenProcessToken(
99 return NtOpenProcessTokenEx( ProcessHandle
, DesiredAccess
, 0, TokenHandle
);
102 /******************************************************************************
103 * NtOpenProcessTokenEx [NTDLL.@]
104 * ZwOpenProcessTokenEx [NTDLL.@]
106 NTSTATUS WINAPI
NtOpenProcessTokenEx( HANDLE process
, DWORD access
, DWORD attributes
,
111 TRACE("(%p,0x%08x,0x%08x,%p)\n", process
, access
, attributes
, handle
);
113 SERVER_START_REQ( open_token
)
115 req
->handle
= process
;
116 req
->access
= access
;
117 req
->attributes
= attributes
;
119 ret
= wine_server_call( req
);
120 if (!ret
) *handle
= reply
->token
;
126 /******************************************************************************
127 * NtOpenThreadToken [NTDLL.@]
128 * ZwOpenThreadToken [NTDLL.@]
130 NTSTATUS WINAPI
NtOpenThreadToken(
136 return NtOpenThreadTokenEx( ThreadHandle
, DesiredAccess
, OpenAsSelf
, 0, TokenHandle
);
139 /******************************************************************************
140 * NtOpenThreadTokenEx [NTDLL.@]
141 * ZwOpenThreadTokenEx [NTDLL.@]
143 NTSTATUS WINAPI
NtOpenThreadTokenEx( HANDLE thread
, DWORD access
, BOOLEAN as_self
, DWORD attributes
,
148 TRACE("(%p,0x%08x,%u,0x%08x,%p)\n", thread
, access
, as_self
, attributes
, handle
);
150 SERVER_START_REQ( open_token
)
152 req
->handle
= thread
;
153 req
->access
= access
;
154 req
->attributes
= attributes
;
155 req
->flags
= OPEN_TOKEN_THREAD
;
156 if (as_self
) req
->flags
|= OPEN_TOKEN_AS_SELF
;
157 ret
= wine_server_call( req
);
158 if (!ret
) *handle
= reply
->token
;
165 /******************************************************************************
166 * NtAdjustPrivilegesToken [NTDLL.@]
167 * ZwAdjustPrivilegesToken [NTDLL.@]
169 * FIXME: parameters unsafe
171 NTSTATUS WINAPI
NtAdjustPrivilegesToken(
172 IN HANDLE TokenHandle
,
173 IN BOOLEAN DisableAllPrivileges
,
174 IN PTOKEN_PRIVILEGES NewState
,
175 IN DWORD BufferLength
,
176 OUT PTOKEN_PRIVILEGES PreviousState
,
177 OUT PDWORD ReturnLength
)
181 TRACE("(%p,0x%08x,%p,0x%08x,%p,%p)\n",
182 TokenHandle
, DisableAllPrivileges
, NewState
, BufferLength
, PreviousState
, ReturnLength
);
184 SERVER_START_REQ( adjust_token_privileges
)
186 req
->handle
= TokenHandle
;
187 req
->disable_all
= DisableAllPrivileges
;
188 req
->get_modified_state
= (PreviousState
!= NULL
);
189 if (!DisableAllPrivileges
)
191 wine_server_add_data( req
, NewState
->Privileges
,
192 NewState
->PrivilegeCount
* sizeof(NewState
->Privileges
[0]) );
194 if (PreviousState
&& BufferLength
>= FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
))
195 wine_server_set_reply( req
, PreviousState
->Privileges
,
196 BufferLength
- FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
) );
197 ret
= wine_server_call( req
);
200 *ReturnLength
= reply
->len
+ FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
);
201 PreviousState
->PrivilegeCount
= reply
->len
/ sizeof(LUID_AND_ATTRIBUTES
);
209 /******************************************************************************
210 * NtQueryInformationToken [NTDLL.@]
211 * ZwQueryInformationToken [NTDLL.@]
214 * Buffer for TokenUser:
215 * 0x00 TOKEN_USER the PSID field points to the SID
219 NTSTATUS WINAPI
NtQueryInformationToken(
221 TOKEN_INFORMATION_CLASS tokeninfoclass
,
223 ULONG tokeninfolength
,
227 NTSTATUS status
= STATUS_SUCCESS
;
229 TRACE("(%p,%d,%p,%d,%p)\n",
230 token
,tokeninfoclass
,tokeninfo
,tokeninfolength
,retlen
);
232 switch (tokeninfoclass
)
235 len
= sizeof(TOKEN_OWNER
) + sizeof(SID
);
237 case TokenPrimaryGroup
:
238 len
= sizeof(TOKEN_PRIMARY_GROUP
);
240 case TokenDefaultDacl
:
241 len
= sizeof(TOKEN_DEFAULT_DACL
);
244 len
= sizeof(TOKEN_SOURCE
);
247 len
= sizeof (TOKEN_TYPE
);
249 case TokenImpersonationLevel
:
250 len
= sizeof(SECURITY_IMPERSONATION_LEVEL
);
252 case TokenStatistics
:
253 len
= sizeof(TOKEN_STATISTICS
);
259 if (retlen
) *retlen
= len
;
261 if (tokeninfolength
< len
)
262 return STATUS_BUFFER_TOO_SMALL
;
264 switch (tokeninfoclass
)
267 SERVER_START_REQ( get_token_user
)
269 TOKEN_USER
* tuser
= tokeninfo
;
270 PSID sid
= (PSID
) (tuser
+ 1);
271 DWORD sid_len
= tokeninfolength
< sizeof(TOKEN_USER
) ? 0 : tokeninfolength
- sizeof(TOKEN_USER
);
274 wine_server_set_reply( req
, sid
, sid_len
);
275 status
= wine_server_call( req
);
276 if (retlen
) *retlen
= reply
->user_len
+ sizeof(TOKEN_USER
);
277 if (status
== STATUS_SUCCESS
)
279 tuser
->User
.Sid
= sid
;
280 tuser
->User
.Attributes
= 0;
287 char stack_buffer
[256];
288 unsigned int server_buf_len
= sizeof(stack_buffer
);
289 void *buffer
= stack_buffer
;
290 BOOLEAN need_more_memory
= FALSE
;
292 /* we cannot work out the size of the server buffer required for the
293 * input size, since there are two factors affecting how much can be
294 * stored in the buffer - number of groups and lengths of sids */
297 SERVER_START_REQ( get_token_groups
)
299 TOKEN_GROUPS
*groups
= tokeninfo
;
302 wine_server_set_reply( req
, buffer
, server_buf_len
);
303 status
= wine_server_call( req
);
304 if (status
== STATUS_BUFFER_TOO_SMALL
)
306 if (buffer
== stack_buffer
)
307 buffer
= RtlAllocateHeap(GetProcessHeap(), 0, reply
->user_len
);
309 buffer
= RtlReAllocateHeap(GetProcessHeap(), 0, buffer
, reply
->user_len
);
310 if (!buffer
) return STATUS_NO_MEMORY
;
312 server_buf_len
= reply
->user_len
;
313 need_more_memory
= TRUE
;
315 else if (status
== STATUS_SUCCESS
)
317 struct token_groups
*tg
= buffer
;
318 unsigned int *attr
= (unsigned int *)(tg
+ 1);
320 const int non_sid_portion
= (sizeof(struct token_groups
) + tg
->count
* sizeof(unsigned long));
321 SID
*sids
= (SID
*)((char *)tokeninfo
+ FIELD_OFFSET( TOKEN_GROUPS
, Groups
[tg
->count
] ));
322 ULONG needed_bytes
= FIELD_OFFSET( TOKEN_GROUPS
, Groups
[tg
->count
] ) +
323 reply
->user_len
- non_sid_portion
;
325 if (retlen
) *retlen
= needed_bytes
;
327 if (needed_bytes
<= tokeninfolength
)
329 groups
->GroupCount
= tg
->count
;
330 memcpy( sids
, (char *)buffer
+ non_sid_portion
,
331 reply
->user_len
- non_sid_portion
);
333 for (i
= 0; i
< tg
->count
; i
++)
335 groups
->Groups
[i
].Attributes
= attr
[i
];
336 groups
->Groups
[i
].Sid
= sids
;
337 sids
= (SID
*)((char *)sids
+ RtlLengthSid(sids
));
340 else status
= STATUS_BUFFER_TOO_SMALL
;
342 else if (retlen
) *retlen
= 0;
345 } while (need_more_memory
);
346 if (buffer
!= stack_buffer
) RtlFreeHeap(GetProcessHeap(), 0, buffer
);
349 case TokenPrimaryGroup
:
352 TOKEN_PRIMARY_GROUP
*tgroup
= tokeninfo
;
353 SID_IDENTIFIER_AUTHORITY sid
= {SECURITY_NT_AUTHORITY
};
354 RtlAllocateAndInitializeSid( &sid
,
356 SECURITY_BUILTIN_DOMAIN_RID
,
357 DOMAIN_ALIAS_RID_ADMINS
,
359 &(tgroup
->PrimaryGroup
));
362 case TokenPrivileges
:
363 SERVER_START_REQ( get_token_privileges
)
365 TOKEN_PRIVILEGES
*tpriv
= tokeninfo
;
367 if (tpriv
&& tokeninfolength
> FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
))
368 wine_server_set_reply( req
, tpriv
->Privileges
, tokeninfolength
- FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
) );
369 status
= wine_server_call( req
);
370 if (retlen
) *retlen
= FIELD_OFFSET( TOKEN_PRIVILEGES
, Privileges
) + reply
->len
;
371 if (tpriv
) tpriv
->PrivilegeCount
= reply
->len
/ sizeof(LUID_AND_ATTRIBUTES
);
378 TOKEN_OWNER
*owner
= tokeninfo
;
379 PSID sid
= (PSID
) (owner
+ 1);
380 SID_IDENTIFIER_AUTHORITY localSidAuthority
= {SECURITY_NT_AUTHORITY
};
381 RtlInitializeSid(sid
, &localSidAuthority
, 1);
382 *(RtlSubAuthoritySid(sid
, 0)) = SECURITY_INTERACTIVE_RID
;
386 case TokenImpersonationLevel
:
387 SERVER_START_REQ( get_token_impersonation_level
)
389 SECURITY_IMPERSONATION_LEVEL
*impersonation_level
= tokeninfo
;
391 status
= wine_server_call( req
);
392 if (status
== STATUS_SUCCESS
)
393 *impersonation_level
= reply
->impersonation_level
;
397 case TokenStatistics
:
398 SERVER_START_REQ( get_token_statistics
)
400 TOKEN_STATISTICS
*statistics
= tokeninfo
;
402 status
= wine_server_call( req
);
403 if (status
== STATUS_SUCCESS
)
405 statistics
->TokenId
.LowPart
= reply
->token_id
.low_part
;
406 statistics
->TokenId
.HighPart
= reply
->token_id
.high_part
;
407 statistics
->AuthenticationId
.LowPart
= 0; /* FIXME */
408 statistics
->AuthenticationId
.HighPart
= 0; /* FIXME */
409 statistics
->ExpirationTime
.u
.HighPart
= 0x7fffffff;
410 statistics
->ExpirationTime
.u
.LowPart
= 0xffffffff;
411 statistics
->TokenType
= reply
->primary
? TokenPrimary
: TokenImpersonation
;
412 statistics
->ImpersonationLevel
= reply
->impersonation_level
;
414 /* kernel information not relevant to us */
415 statistics
->DynamicCharged
= 0;
416 statistics
->DynamicAvailable
= 0;
418 statistics
->GroupCount
= reply
->group_count
;
419 statistics
->PrivilegeCount
= reply
->privilege_count
;
420 statistics
->ModifiedId
.LowPart
= reply
->modified_id
.low_part
;
421 statistics
->ModifiedId
.HighPart
= reply
->modified_id
.high_part
;
427 SERVER_START_REQ( get_token_statistics
)
429 TOKEN_TYPE
*token_type
= tokeninfo
;
431 status
= wine_server_call( req
);
432 if (status
== STATUS_SUCCESS
)
433 *token_type
= reply
->primary
? TokenPrimary
: TokenImpersonation
;
439 ERR("Unhandled Token Information class %d!\n", tokeninfoclass
);
440 return STATUS_NOT_IMPLEMENTED
;
446 /******************************************************************************
447 * NtSetInformationToken [NTDLL.@]
448 * ZwSetInformationToken [NTDLL.@]
450 NTSTATUS WINAPI
NtSetInformationToken(
452 TOKEN_INFORMATION_CLASS TokenInformationClass
,
453 PVOID TokenInformation
,
454 ULONG TokenInformationLength
)
456 FIXME("%p %d %p %u\n", TokenHandle
, TokenInformationClass
,
457 TokenInformation
, TokenInformationLength
);
458 return STATUS_NOT_IMPLEMENTED
;
461 /******************************************************************************
462 * NtAdjustGroupsToken [NTDLL.@]
463 * ZwAdjustGroupsToken [NTDLL.@]
465 NTSTATUS WINAPI
NtAdjustGroupsToken(
467 BOOLEAN ResetToDefault
,
468 PTOKEN_GROUPS NewState
,
470 PTOKEN_GROUPS PreviousState
,
473 FIXME("%p %d %p %u %p %p\n", TokenHandle
, ResetToDefault
,
474 NewState
, BufferLength
, PreviousState
, ReturnLength
);
475 return STATUS_NOT_IMPLEMENTED
;
478 /******************************************************************************
479 * NtPrivilegeCheck [NTDLL.@]
480 * ZwPrivilegeCheck [NTDLL.@]
482 NTSTATUS WINAPI
NtPrivilegeCheck(
484 PPRIVILEGE_SET RequiredPrivileges
,
488 SERVER_START_REQ( check_token_privileges
)
490 req
->handle
= ClientToken
;
491 req
->all_required
= ((RequiredPrivileges
->Control
& PRIVILEGE_SET_ALL_NECESSARY
) ? TRUE
: FALSE
);
492 wine_server_add_data( req
, RequiredPrivileges
->Privilege
,
493 RequiredPrivileges
->PrivilegeCount
* sizeof(RequiredPrivileges
->Privilege
[0]) );
494 wine_server_set_reply( req
, RequiredPrivileges
->Privilege
,
495 RequiredPrivileges
->PrivilegeCount
* sizeof(RequiredPrivileges
->Privilege
[0]) );
497 status
= wine_server_call( req
);
499 if (status
== STATUS_SUCCESS
)
500 *Result
= (reply
->has_privileges
? TRUE
: FALSE
);
510 /******************************************************************************
511 * NtQuerySection [NTDLL.@]
513 NTSTATUS WINAPI
NtQuerySection(
514 IN HANDLE SectionHandle
,
515 IN SECTION_INFORMATION_CLASS SectionInformationClass
,
516 OUT PVOID SectionInformation
,
518 OUT PULONG ResultLength
)
520 FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
521 SectionHandle
,SectionInformationClass
,SectionInformation
,Length
,ResultLength
);
529 /******************************************************************************
530 * NtCreatePort [NTDLL.@]
531 * ZwCreatePort [NTDLL.@]
533 NTSTATUS WINAPI
NtCreatePort(PHANDLE PortHandle
,POBJECT_ATTRIBUTES ObjectAttributes
,
534 ULONG MaxConnectInfoLength
,ULONG MaxDataLength
,PULONG reserved
)
536 FIXME("(%p,%p,%u,%u,%p),stub!\n",PortHandle
,ObjectAttributes
,
537 MaxConnectInfoLength
,MaxDataLength
,reserved
);
538 return STATUS_NOT_IMPLEMENTED
;
541 /******************************************************************************
542 * NtConnectPort [NTDLL.@]
543 * ZwConnectPort [NTDLL.@]
545 NTSTATUS WINAPI
NtConnectPort(
547 PUNICODE_STRING PortName
,
548 PSECURITY_QUALITY_OF_SERVICE SecurityQos
,
549 PLPC_SECTION_WRITE WriteSection
,
550 PLPC_SECTION_READ ReadSection
,
551 PULONG MaximumMessageLength
,
553 PULONG pConnectInfoLength
)
555 FIXME("(%p,%s,%p,%p,%p,%p,%p,%p),stub!\n",
556 PortHandle
,debugstr_w(PortName
->Buffer
),SecurityQos
,
557 WriteSection
,ReadSection
,MaximumMessageLength
,ConnectInfo
,
559 if (ConnectInfo
&& pConnectInfoLength
)
560 TRACE("\tMessage = %s\n",debugstr_an(ConnectInfo
,*pConnectInfoLength
));
561 return STATUS_NOT_IMPLEMENTED
;
564 /******************************************************************************
565 * NtListenPort [NTDLL.@]
566 * ZwListenPort [NTDLL.@]
568 NTSTATUS WINAPI
NtListenPort(HANDLE PortHandle
,PLPC_MESSAGE pLpcMessage
)
570 FIXME("(%p,%p),stub!\n",PortHandle
,pLpcMessage
);
571 return STATUS_NOT_IMPLEMENTED
;
574 /******************************************************************************
575 * NtAcceptConnectPort [NTDLL.@]
576 * ZwAcceptConnectPort [NTDLL.@]
578 NTSTATUS WINAPI
NtAcceptConnectPort(
580 ULONG PortIdentifier
,
581 PLPC_MESSAGE pLpcMessage
,
583 PLPC_SECTION_WRITE WriteSection
,
584 PLPC_SECTION_READ ReadSection
)
586 FIXME("(%p,%u,%p,%d,%p,%p),stub!\n",
587 PortHandle
,PortIdentifier
,pLpcMessage
,Accept
,WriteSection
,ReadSection
);
588 return STATUS_NOT_IMPLEMENTED
;
591 /******************************************************************************
592 * NtCompleteConnectPort [NTDLL.@]
593 * ZwCompleteConnectPort [NTDLL.@]
595 NTSTATUS WINAPI
NtCompleteConnectPort(HANDLE PortHandle
)
597 FIXME("(%p),stub!\n",PortHandle
);
598 return STATUS_NOT_IMPLEMENTED
;
601 /******************************************************************************
602 * NtRegisterThreadTerminatePort [NTDLL.@]
603 * ZwRegisterThreadTerminatePort [NTDLL.@]
605 NTSTATUS WINAPI
NtRegisterThreadTerminatePort(HANDLE PortHandle
)
607 FIXME("(%p),stub!\n",PortHandle
);
608 return STATUS_NOT_IMPLEMENTED
;
611 /******************************************************************************
612 * NtRequestWaitReplyPort [NTDLL.@]
613 * ZwRequestWaitReplyPort [NTDLL.@]
615 NTSTATUS WINAPI
NtRequestWaitReplyPort(
617 PLPC_MESSAGE pLpcMessageIn
,
618 PLPC_MESSAGE pLpcMessageOut
)
620 FIXME("(%p,%p,%p),stub!\n",PortHandle
,pLpcMessageIn
,pLpcMessageOut
);
623 TRACE("Message to send:\n");
624 TRACE("\tDataSize = %u\n",pLpcMessageIn
->DataSize
);
625 TRACE("\tMessageSize = %u\n",pLpcMessageIn
->MessageSize
);
626 TRACE("\tMessageType = %u\n",pLpcMessageIn
->MessageType
);
627 TRACE("\tVirtualRangesOffset = %u\n",pLpcMessageIn
->VirtualRangesOffset
);
628 TRACE("\tClientId.UniqueProcess = %p\n",pLpcMessageIn
->ClientId
.UniqueProcess
);
629 TRACE("\tClientId.UniqueThread = %p\n",pLpcMessageIn
->ClientId
.UniqueThread
);
630 TRACE("\tMessageId = %u\n",pLpcMessageIn
->MessageId
);
631 TRACE("\tSectionSize = %u\n",pLpcMessageIn
->SectionSize
);
632 TRACE("\tData = %s\n",
633 debugstr_an((const char*)pLpcMessageIn
->Data
,pLpcMessageIn
->DataSize
));
635 return STATUS_NOT_IMPLEMENTED
;
638 /******************************************************************************
639 * NtReplyWaitReceivePort [NTDLL.@]
640 * ZwReplyWaitReceivePort [NTDLL.@]
642 NTSTATUS WINAPI
NtReplyWaitReceivePort(
644 PULONG PortIdentifier
,
645 PLPC_MESSAGE ReplyMessage
,
646 PLPC_MESSAGE Message
)
648 FIXME("(%p,%p,%p,%p),stub!\n",PortHandle
,PortIdentifier
,ReplyMessage
,Message
);
649 return STATUS_NOT_IMPLEMENTED
;
656 /******************************************************************************
657 * NtSetIntervalProfile [NTDLL.@]
658 * ZwSetIntervalProfile [NTDLL.@]
660 NTSTATUS WINAPI
NtSetIntervalProfile(
662 KPROFILE_SOURCE Source
)
664 FIXME("%u,%d\n", Interval
, Source
);
665 return STATUS_SUCCESS
;
668 /******************************************************************************
669 * NtQuerySystemInformation [NTDLL.@]
670 * ZwQuerySystemInformation [NTDLL.@]
673 * SystemInformationClass Index to a certain information structure
674 * SystemTimeAdjustmentInformation SYSTEM_TIME_ADJUSTMENT
675 * SystemCacheInformation SYSTEM_CACHE_INFORMATION
676 * SystemConfigurationInformation CONFIGURATION_INFORMATION
677 * observed (class/len):
683 * SystemInformation caller supplies storage for the information structure
684 * Length size of the structure
685 * ResultLength Data written
687 NTSTATUS WINAPI
NtQuerySystemInformation(
688 IN SYSTEM_INFORMATION_CLASS SystemInformationClass
,
689 OUT PVOID SystemInformation
,
691 OUT PULONG ResultLength
)
693 NTSTATUS ret
= STATUS_SUCCESS
;
696 TRACE("(0x%08x,%p,0x%08x,%p)\n",
697 SystemInformationClass
,SystemInformation
,Length
,ResultLength
);
699 switch (SystemInformationClass
)
701 case SystemBasicInformation
:
703 SYSTEM_BASIC_INFORMATION sbi
;
706 sbi
.uKeMaximumIncrement
= 0;
707 sbi
.uPageSize
= 1024; /* FIXME */
708 sbi
.uMmNumberOfPhysicalPages
= 12345; /* FIXME */
709 sbi
.uMmLowestPhysicalPage
= 0; /* FIXME */
710 sbi
.uMmHighestPhysicalPage
= 12345; /* FIXME */
711 sbi
.uAllocationGranularity
= 65536; /* FIXME */
712 sbi
.pLowestUserAddress
= 0; /* FIXME */
713 sbi
.pMmHighestUserAddress
= (void*)~0; /* FIXME */
714 sbi
.uKeActiveProcessors
= 1; /* FIXME */
715 sbi
.bKeNumberProcessors
= 1; /* FIXME */
720 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
721 else memcpy( SystemInformation
, &sbi
, len
);
723 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
726 case SystemCpuInformation
:
728 SYSTEM_CPU_INFORMATION sci
;
730 /* FIXME: move some code from kernel/cpu.c to process this */
731 sci
.Architecture
= PROCESSOR_ARCHITECTURE_INTEL
;
732 sci
.Level
= 6; /* 686, aka Pentium II+ */
735 sci
.FeatureSet
= 0x1fff;
740 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
741 else memcpy( SystemInformation
, &sci
, len
);
743 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
746 case SystemPerformanceInformation
:
748 SYSTEM_PERFORMANCE_INFORMATION spi
;
750 memset(&spi
, 0 , sizeof(spi
));
755 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
756 else memcpy( SystemInformation
, &spi
, len
);
758 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
759 FIXME("info_class SYSTEM_PERFORMANCE_INFORMATION\n");
762 case SystemTimeOfDayInformation
:
764 SYSTEM_TIMEOFDAY_INFORMATION sti
;
766 memset(&sti
, 0 , sizeof(sti
));
768 /* liKeSystemTime, liExpTimeZoneBias, uCurrentTimeZoneId */
769 sti
.liKeBootTime
.QuadPart
= server_start_time
;
771 if (Length
<= sizeof(sti
))
774 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
775 else memcpy( SystemInformation
, &sti
, Length
);
777 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
780 case SystemProcessInformation
:
782 SYSTEM_PROCESS_INFORMATION
* spi
= (SYSTEM_PROCESS_INFORMATION
*)SystemInformation
;
783 SYSTEM_PROCESS_INFORMATION
* last
= NULL
;
785 WCHAR procname
[1024];
788 DWORD procstructlen
= 0;
790 SERVER_START_REQ( create_snapshot
)
792 req
->flags
= SNAP_PROCESS
| SNAP_THREAD
;
795 if (!(ret
= wine_server_call( req
))) hSnap
= reply
->handle
;
799 while (ret
== STATUS_SUCCESS
)
801 SERVER_START_REQ( next_process
)
804 req
->reset
= (len
== 0);
805 wine_server_set_reply( req
, procname
, sizeof(procname
)-sizeof(WCHAR
) );
806 if (!(ret
= wine_server_call( req
)))
808 /* Make sure procname is 0 terminated */
809 procname
[wine_server_reply_size(reply
) / sizeof(WCHAR
)] = 0;
811 /* Get only the executable name, not the path */
812 if ((exename
= strrchrW(procname
, '\\')) != NULL
) exename
++;
813 else exename
= procname
;
815 wlen
= (strlenW(exename
) + 1) * sizeof(WCHAR
);
817 procstructlen
= sizeof(*spi
) + wlen
+ ((reply
->threads
- 1) * sizeof(SYSTEM_THREAD_INFORMATION
));
819 if (Length
>= len
+ procstructlen
)
821 /* ftCreationTime, ftUserTime, ftKernelTime;
822 * vmCounters, ioCounters
825 memset(spi
, 0, sizeof(*spi
));
827 spi
->dwOffset
= procstructlen
- wlen
;
828 spi
->dwThreadCount
= reply
->threads
;
830 /* spi->pszProcessName will be set later on */
832 spi
->dwBasePriority
= reply
->priority
;
833 spi
->dwProcessID
= (DWORD
)reply
->pid
;
834 spi
->dwParentProcessID
= (DWORD
)reply
->ppid
;
835 spi
->dwHandleCount
= reply
->handles
;
837 /* spi->ti will be set later on */
839 len
+= procstructlen
;
841 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
846 if (ret
!= STATUS_SUCCESS
)
848 if (ret
== STATUS_NO_MORE_FILES
) ret
= STATUS_SUCCESS
;
851 else /* Length is already checked for */
855 /* set thread info */
857 while (ret
== STATUS_SUCCESS
)
859 SERVER_START_REQ( next_thread
)
862 req
->reset
= (j
== 0);
863 if (!(ret
= wine_server_call( req
)))
866 if (reply
->pid
== spi
->dwProcessID
)
868 /* ftKernelTime, ftUserTime, ftCreateTime;
869 * dwTickCount, dwStartAddress
872 memset(&spi
->ti
[i
], 0, sizeof(spi
->ti
));
874 spi
->ti
[i
].dwOwningPID
= reply
->pid
;
875 spi
->ti
[i
].dwThreadID
= reply
->tid
;
876 spi
->ti
[i
].dwCurrentPriority
= reply
->base_pri
+ reply
->delta_pri
;
877 spi
->ti
[i
].dwBasePriority
= reply
->base_pri
;
884 if (ret
== STATUS_NO_MORE_FILES
) ret
= STATUS_SUCCESS
;
886 /* now append process name */
887 spi
->ProcessName
.Buffer
= (WCHAR
*)((char*)spi
+ spi
->dwOffset
);
888 spi
->ProcessName
.Length
= wlen
- sizeof(WCHAR
);
889 spi
->ProcessName
.MaximumLength
= wlen
;
890 memcpy( spi
->ProcessName
.Buffer
, exename
, wlen
);
891 spi
->dwOffset
+= wlen
;
894 spi
= (SYSTEM_PROCESS_INFORMATION
*)((char*)spi
+ spi
->dwOffset
);
897 if (ret
== STATUS_SUCCESS
&& last
) last
->dwOffset
= 0;
898 if (hSnap
) NtClose(hSnap
);
901 case SystemProcessorPerformanceInformation
:
903 SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION sppi
;
905 memset(&sppi
, 0 , sizeof(sppi
)); /* FIXME */
910 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
911 else memcpy( SystemInformation
, &sppi
, len
);
913 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
914 FIXME("info_class SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION\n");
917 case SystemModuleInformation
:
918 /* FIXME: should be system-wide */
919 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
920 else ret
= LdrQueryProcessModuleInformation( SystemInformation
, Length
, &len
);
922 case SystemHandleInformation
:
924 SYSTEM_HANDLE_INFORMATION shi
;
926 memset(&shi
, 0, sizeof(shi
));
931 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
932 else memcpy( SystemInformation
, &shi
, len
);
934 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
935 FIXME("info_class SYSTEM_HANDLE_INFORMATION\n");
938 case SystemCacheInformation
:
940 SYSTEM_CACHE_INFORMATION sci
;
942 memset(&sci
, 0, sizeof(sci
)); /* FIXME */
947 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
948 else memcpy( SystemInformation
, &sci
, len
);
950 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
951 FIXME("info_class SYSTEM_CACHE_INFORMATION\n");
954 case SystemInterruptInformation
:
956 SYSTEM_INTERRUPT_INFORMATION sii
;
958 memset(&sii
, 0, sizeof(sii
));
963 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
964 else memcpy( SystemInformation
, &sii
, len
);
966 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
967 FIXME("info_class SYSTEM_INTERRUPT_INFORMATION\n");
970 case SystemKernelDebuggerInformation
:
972 SYSTEM_KERNEL_DEBUGGER_INFORMATION skdi
;
974 skdi
.DebuggerEnabled
= FALSE
;
975 skdi
.DebuggerNotPresent
= TRUE
;
980 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
981 else memcpy( SystemInformation
, &skdi
, len
);
983 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
986 case SystemRegistryQuotaInformation
:
988 /* Something to do with the size of the registry *
989 * Since we don't have a size limitation, fake it *
990 * This is almost certainly wrong. *
991 * This sets each of the three words in the struct to 32 MB, *
992 * which is enough to make the IE 5 installer happy. */
993 SYSTEM_REGISTRY_QUOTA_INFORMATION srqi
;
995 srqi
.RegistryQuotaAllowed
= 0x2000000;
996 srqi
.RegistryQuotaUsed
= 0x200000;
997 srqi
.Reserved1
= (void*)0x200000;
1002 if (!SystemInformation
) ret
= STATUS_ACCESS_VIOLATION
;
1005 FIXME("SystemRegistryQuotaInformation: faking max registry size of 32 MB\n");
1006 memcpy( SystemInformation
, &srqi
, len
);
1009 else ret
= STATUS_INFO_LENGTH_MISMATCH
;
1013 FIXME("(0x%08x,%p,0x%08x,%p) stub\n",
1014 SystemInformationClass
,SystemInformation
,Length
,ResultLength
);
1016 /* Several Information Classes are not implemented on Windows and return 2 different values
1017 * STATUS_NOT_IMPLEMENTED or STATUS_INVALID_INFO_CLASS
1018 * in 95% of the cases it's STATUS_INVALID_INFO_CLASS, so use this as the default
1020 ret
= STATUS_INVALID_INFO_CLASS
;
1023 if (ResultLength
) *ResultLength
= len
;
1028 /******************************************************************************
1029 * NtSetSystemInformation [NTDLL.@]
1030 * ZwSetSystemInformation [NTDLL.@]
1032 NTSTATUS WINAPI
NtSetSystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass
, PVOID SystemInformation
, ULONG Length
)
1034 FIXME("(0x%08x,%p,0x%08x) stub\n",SystemInformationClass
,SystemInformation
,Length
);
1035 return STATUS_SUCCESS
;
1038 /******************************************************************************
1039 * NtCreatePagingFile [NTDLL.@]
1040 * ZwCreatePagingFile [NTDLL.@]
1042 NTSTATUS WINAPI
NtCreatePagingFile(
1043 PUNICODE_STRING PageFileName
,
1044 PLARGE_INTEGER MinimumSize
,
1045 PLARGE_INTEGER MaximumSize
,
1046 PLARGE_INTEGER ActualSize
)
1048 FIXME("(%p %p %p %p) stub\n", PageFileName
, MinimumSize
, MaximumSize
, ActualSize
);
1049 return STATUS_SUCCESS
;
1052 /******************************************************************************
1053 * NtDisplayString [NTDLL.@]
1055 * writes a string to the nt-textmode screen eg. during startup
1057 NTSTATUS WINAPI
NtDisplayString ( PUNICODE_STRING string
)
1062 if (!(ret
= RtlUnicodeStringToAnsiString( &stringA
, string
, TRUE
)))
1064 MESSAGE( "%.*s", stringA
.Length
, stringA
.Buffer
);
1065 RtlFreeAnsiString( &stringA
);
1070 /******************************************************************************
1071 * NtInitiatePowerAction [NTDLL.@]
1074 NTSTATUS WINAPI
NtInitiatePowerAction(
1075 IN POWER_ACTION SystemAction
,
1076 IN SYSTEM_POWER_STATE MinSystemState
,
1078 IN BOOLEAN Asynchronous
)
1080 FIXME("(%d,%d,0x%08x,%d),stub\n",
1081 SystemAction
,MinSystemState
,Flags
,Asynchronous
);
1082 return STATUS_NOT_IMPLEMENTED
;
1086 /******************************************************************************
1087 * NtPowerInformation [NTDLL.@]
1090 NTSTATUS WINAPI
NtPowerInformation(
1091 IN POWER_INFORMATION_LEVEL InformationLevel
,
1092 IN PVOID lpInputBuffer
,
1093 IN ULONG nInputBufferSize
,
1094 IN PVOID lpOutputBuffer
,
1095 IN ULONG nOutputBufferSize
)
1097 TRACE("(%d,%p,%d,%p,%d)\n",
1098 InformationLevel
,lpInputBuffer
,nInputBufferSize
,lpOutputBuffer
,nOutputBufferSize
);
1099 switch(InformationLevel
) {
1100 case SystemPowerCapabilities
: {
1101 PSYSTEM_POWER_CAPABILITIES PowerCaps
= (PSYSTEM_POWER_CAPABILITIES
)lpOutputBuffer
;
1102 FIXME("semi-stub: SystemPowerCapabilities\n");
1103 if (nOutputBufferSize
< sizeof(SYSTEM_POWER_CAPABILITIES
))
1104 return STATUS_BUFFER_TOO_SMALL
;
1105 /* FIXME: These values are based off a native XP desktop, should probably use APM/ACPI to get the 'real' values */
1106 PowerCaps
->PowerButtonPresent
= TRUE
;
1107 PowerCaps
->SleepButtonPresent
= FALSE
;
1108 PowerCaps
->LidPresent
= FALSE
;
1109 PowerCaps
->SystemS1
= TRUE
;
1110 PowerCaps
->SystemS2
= FALSE
;
1111 PowerCaps
->SystemS3
= FALSE
;
1112 PowerCaps
->SystemS4
= TRUE
;
1113 PowerCaps
->SystemS5
= TRUE
;
1114 PowerCaps
->HiberFilePresent
= TRUE
;
1115 PowerCaps
->FullWake
= TRUE
;
1116 PowerCaps
->VideoDimPresent
= FALSE
;
1117 PowerCaps
->ApmPresent
= FALSE
;
1118 PowerCaps
->UpsPresent
= FALSE
;
1119 PowerCaps
->ThermalControl
= FALSE
;
1120 PowerCaps
->ProcessorThrottle
= FALSE
;
1121 PowerCaps
->ProcessorMinThrottle
= 100;
1122 PowerCaps
->ProcessorMaxThrottle
= 100;
1123 PowerCaps
->DiskSpinDown
= TRUE
;
1124 PowerCaps
->SystemBatteriesPresent
= FALSE
;
1125 PowerCaps
->BatteriesAreShortTerm
= FALSE
;
1126 PowerCaps
->BatteryScale
[0].Granularity
= 0;
1127 PowerCaps
->BatteryScale
[0].Capacity
= 0;
1128 PowerCaps
->BatteryScale
[1].Granularity
= 0;
1129 PowerCaps
->BatteryScale
[1].Capacity
= 0;
1130 PowerCaps
->BatteryScale
[2].Granularity
= 0;
1131 PowerCaps
->BatteryScale
[2].Capacity
= 0;
1132 PowerCaps
->AcOnLineWake
= PowerSystemUnspecified
;
1133 PowerCaps
->SoftLidWake
= PowerSystemUnspecified
;
1134 PowerCaps
->RtcWake
= PowerSystemSleeping1
;
1135 PowerCaps
->MinDeviceWakeState
= PowerSystemUnspecified
;
1136 PowerCaps
->DefaultLowLatencyWake
= PowerSystemUnspecified
;
1137 return STATUS_SUCCESS
;
1140 FIXME("Unimplemented NtPowerInformation action: %d\n", InformationLevel
);
1141 return STATUS_NOT_IMPLEMENTED
;
1145 /******************************************************************************
1146 * NtShutdownSystem [NTDLL.@]
1149 NTSTATUS WINAPI
NtShutdownSystem(SHUTDOWN_ACTION Action
)
1151 FIXME("%d\n",Action
);
1152 return STATUS_SUCCESS
;
1155 /******************************************************************************
1156 * NtAllocateLocallyUniqueId (NTDLL.@)
1158 NTSTATUS WINAPI
NtAllocateLocallyUniqueId(PLUID Luid
)
1162 TRACE("%p\n", Luid
);
1165 return STATUS_ACCESS_VIOLATION
;
1167 SERVER_START_REQ( allocate_locally_unique_id
)
1169 status
= wine_server_call( req
);
1172 Luid
->LowPart
= reply
->luid
.low_part
;
1173 Luid
->HighPart
= reply
->luid
.high_part
;
1181 /******************************************************************************
1182 * VerSetConditionMask (NTDLL.@)
1184 ULONGLONG WINAPI
VerSetConditionMask( ULONGLONG dwlConditionMask
, DWORD dwTypeBitMask
,
1185 BYTE dwConditionMask
)
1187 if(dwTypeBitMask
== 0)
1188 return dwlConditionMask
;
1189 dwConditionMask
&= 0x07;
1190 if(dwConditionMask
== 0)
1191 return dwlConditionMask
;
1193 if(dwTypeBitMask
& VER_PRODUCT_TYPE
)
1194 dwlConditionMask
|= dwConditionMask
<< 7*3;
1195 else if (dwTypeBitMask
& VER_SUITENAME
)
1196 dwlConditionMask
|= dwConditionMask
<< 6*3;
1197 else if (dwTypeBitMask
& VER_SERVICEPACKMAJOR
)
1198 dwlConditionMask
|= dwConditionMask
<< 5*3;
1199 else if (dwTypeBitMask
& VER_SERVICEPACKMINOR
)
1200 dwlConditionMask
|= dwConditionMask
<< 4*3;
1201 else if (dwTypeBitMask
& VER_PLATFORMID
)
1202 dwlConditionMask
|= dwConditionMask
<< 3*3;
1203 else if (dwTypeBitMask
& VER_BUILDNUMBER
)
1204 dwlConditionMask
|= dwConditionMask
<< 2*3;
1205 else if (dwTypeBitMask
& VER_MAJORVERSION
)
1206 dwlConditionMask
|= dwConditionMask
<< 1*3;
1207 else if (dwTypeBitMask
& VER_MINORVERSION
)
1208 dwlConditionMask
|= dwConditionMask
<< 0*3;
1209 return dwlConditionMask
;
1212 /******************************************************************************
1213 * NtAccessCheckAndAuditAlarm (NTDLL.@)
1214 * ZwAccessCheckAndAuditAlarm (NTDLL.@)
1216 NTSTATUS WINAPI
NtAccessCheckAndAuditAlarm(PUNICODE_STRING SubsystemName
, HANDLE HandleId
, PUNICODE_STRING ObjectTypeName
,
1217 PUNICODE_STRING ObjectName
, PSECURITY_DESCRIPTOR SecurityDescriptor
,
1218 ACCESS_MASK DesiredAccess
, PGENERIC_MAPPING GenericMapping
, BOOLEAN ObjectCreation
,
1219 PACCESS_MASK GrantedAccess
, PBOOLEAN AccessStatus
, PBOOLEAN GenerateOnClose
)
1221 FIXME("(%s, %p, %s, %p, 0x%08x, %p, %d, %p, %p, %p), stub\n", debugstr_us(SubsystemName
), HandleId
,
1222 debugstr_us(ObjectTypeName
), SecurityDescriptor
, DesiredAccess
, GenericMapping
, ObjectCreation
,
1223 GrantedAccess
, AccessStatus
, GenerateOnClose
);
1225 return STATUS_NOT_IMPLEMENTED
;