ReactOS 0.4.15-dev-8116-gf69e256
compname.c
Go to the documentation of this file.
1/*
2 * ReactOS kernel
3 * Copyright (C) 2003 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19/*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS system libraries
22 * PURPOSE: Computer name functions
23 * FILE: dll/win32/kernel32/client/compname.c
24 * PROGRAMERS: Eric Kohl
25 * Katayama Hirofumi MZ
26 */
27
28/* INCLUDES ******************************************************************/
29
30#include <k32.h>
31#include <windns.h>
32
33#define NDEBUG
34#include <debug.h>
35
37
38/* FUNCTIONS *****************************************************************/
39
40static
41BOOL
43 LPWSTR ValueNameStr,
46{
52 ULONG KeyInfoSize;
53 ULONG ReturnSize;
55
56 if (lpBuffer != NULL && *nSize > 0)
57 lpBuffer[0] = 0;
58
59 RtlInitUnicodeString(&KeyName, RegistryKey);
61 &KeyName,
63 NULL,
64 NULL);
65
69 if (!NT_SUCCESS(Status))
70 {
72 return FALSE;
73 }
74
75 KeyInfoSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + *nSize * sizeof(WCHAR);
76 KeyInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, KeyInfoSize);
77 if (KeyInfo == NULL)
78 {
81 return FALSE;
82 }
83
84 RtlInitUnicodeString(&ValueName, ValueNameStr);
85
87 &ValueName,
89 KeyInfo,
90 KeyInfoSize,
91 &ReturnSize);
92
94
95 if (!NT_SUCCESS(Status))
96 {
97 *nSize = (ReturnSize - FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data)) / sizeof(WCHAR);
98 goto failed;
99 }
100
101 if (KeyInfo->Type != REG_SZ)
102 {
104 goto failed;
105 }
106
107 if (!lpBuffer || *nSize < (KeyInfo->DataLength / sizeof(WCHAR)))
108 {
109 *nSize = (ReturnSize - FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data)) / sizeof(WCHAR);
111 goto failed;
112 }
113
114 *nSize = KeyInfo->DataLength / sizeof(WCHAR) - 1;
115 RtlCopyMemory(lpBuffer, KeyInfo->Data, KeyInfo->DataLength);
116 lpBuffer[*nSize] = 0;
117
118 RtlFreeHeap(RtlGetProcessHeap(), 0, KeyInfo);
119
120 return TRUE;
121
122failed:
123 RtlFreeHeap(RtlGetProcessHeap(), 0, KeyInfo);
125 return FALSE;
126}
127
128
129static
130BOOL
132 LPCWSTR SubKey,
133 LPCWSTR ValueNameStr,
135{
140 SIZE_T StringLength;
143
144 StringLength = wcslen(lpBuffer);
145 if (StringLength > ((MAXULONG / sizeof(WCHAR)) - 1))
146 {
147 return FALSE;
148 }
149
150 RtlInitUnicodeString(&KeyName, RegistryKey);
152 &KeyName,
154 NULL,
155 NULL);
156
158 KEY_WRITE,
160 if (!NT_SUCCESS(Status))
161 {
163 return FALSE;
164 }
165
168 &KeyName,
170 KeyHandle,
171 NULL);
172
174 KEY_WRITE,
176 0,
177 NULL,
179 &Disposition);
180 if (!NT_SUCCESS(Status))
181 {
184 return FALSE;
185 }
186
187 RtlInitUnicodeString(&ValueName, ValueNameStr);
188
190 &ValueName,
191 0,
192 REG_SZ,
194 (StringLength + 1) * sizeof(WCHAR));
195 if (!NT_SUCCESS(Status))
196 {
200 return FALSE;
201 }
202
206
207 return TRUE;
208}
209
210
211/*
212 * @implemented
213 */
214BOOL
215WINAPI
216GetComputerNameExW(COMPUTER_NAME_FORMAT NameType,
219{
220 UNICODE_STRING ResultString;
221 UNICODE_STRING DomainPart;
224 BOOL ret = TRUE;
225 DWORD HostSize;
226
227 if ((nSize == NULL) ||
228 (lpBuffer == NULL && *nSize > 0))
229 {
231 return FALSE;
232 }
233
234 switch (NameType)
235 {
236 case ComputerNameNetBIOS:
237 ret = GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
238 L"\\Control\\ComputerName\\ActiveComputerName",
239 L"ComputerName",
240 lpBuffer,
241 nSize);
242 if ((ret == FALSE) &&
244 {
245 ret = GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
246 L"\\Control\\ComputerName\\ComputerName",
247 L"ComputerName",
248 lpBuffer,
249 nSize);
250 if (ret)
251 {
252 ret = SetActiveComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
253 L"\\Control\\ComputerName",
254 L"ActiveComputerName",
255 L"ComputerName",
256 lpBuffer);
257 }
258 }
259 return ret;
260
261 case ComputerNameDnsDomain:
262 return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
263 L"\\Services\\Tcpip\\Parameters",
264 L"Domain",
265 lpBuffer,
266 nSize);
267
268 case ComputerNameDnsFullyQualified:
269 ResultString.Length = 0;
270 ResultString.MaximumLength = (USHORT)*nSize * sizeof(WCHAR);
271 ResultString.Buffer = lpBuffer;
272
274 RtlInitUnicodeString(&DomainPart, NULL);
275
276 QueryTable[0].Name = L"HostName";
278 QueryTable[0].EntryContext = &DomainPart;
279
281 L"\\Registry\\Machine\\System"
282 L"\\CurrentControlSet\\Services\\Tcpip"
283 L"\\Parameters",
285 NULL,
286 NULL);
287
288 if (NT_SUCCESS(Status))
289 {
290 Status = RtlAppendUnicodeStringToString(&ResultString, &DomainPart);
291 HostSize = DomainPart.Length;
292
293 if (!NT_SUCCESS(Status))
294 {
295 ret = FALSE;
296 }
297
298 RtlAppendUnicodeToString(&ResultString, L".");
299 RtlFreeUnicodeString(&DomainPart);
300
301 RtlInitUnicodeString(&DomainPart, NULL);
302 QueryTable[0].Name = L"Domain";
304 QueryTable[0].EntryContext = &DomainPart;
305
307 L"\\Registry\\Machine\\System"
308 L"\\CurrentControlSet\\Services\\Tcpip"
309 L"\\Parameters",
311 NULL,
312 NULL);
313
314 if (NT_SUCCESS(Status))
315 {
316 Status = RtlAppendUnicodeStringToString(&ResultString, &DomainPart);
317 if ((!NT_SUCCESS(Status)) || (!ret))
318 {
319 *nSize = HostSize + DomainPart.Length;
321 RtlFreeUnicodeString(&DomainPart);
322 return FALSE;
323 }
324 RtlFreeUnicodeString(&DomainPart);
325 *nSize = ResultString.Length / sizeof(WCHAR) - 1;
326 return TRUE;
327 }
328 }
329 return FALSE;
330
331 case ComputerNameDnsHostname:
332 return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
333 L"\\Services\\Tcpip\\Parameters",
334 L"Hostname",
335 lpBuffer,
336 nSize);
337
338 case ComputerNamePhysicalDnsDomain:
339 return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
340 L"\\Services\\Tcpip\\Parameters",
341 L"NV Domain",
342 lpBuffer,
343 nSize);
344
345 /* XXX Redo this */
346 case ComputerNamePhysicalDnsFullyQualified:
347 return GetComputerNameExW(ComputerNameDnsFullyQualified,
348 lpBuffer,
349 nSize);
350
351 case ComputerNamePhysicalDnsHostname:
352 return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
353 L"\\Services\\Tcpip\\Parameters",
354 L"NV Hostname",
355 lpBuffer,
356 nSize);
357
358 /* XXX Redo this */
359 case ComputerNamePhysicalNetBIOS:
360 return GetComputerNameExW(ComputerNameNetBIOS,
361 lpBuffer,
362 nSize);
363
364 case ComputerNameMax:
365 return FALSE;
366 }
367
368 return FALSE;
369}
370
371/*
372 * @implemented
373 */
374BOOL
375WINAPI
376GetComputerNameExA(COMPUTER_NAME_FORMAT NameType,
379{
382 BOOL Result;
383 PWCHAR TempBuffer = NULL;
384
385 if ((nSize == NULL) ||
386 (lpBuffer == NULL && *nSize > 0))
387 {
389 return FALSE;
390 }
391
392 if (*nSize > 0)
393 {
394 TempBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, *nSize * sizeof(WCHAR));
395 if (!TempBuffer)
396 {
398 return FALSE;
399 }
400 }
401
402 AnsiString.MaximumLength = (USHORT)*nSize;
403 AnsiString.Length = 0;
404 AnsiString.Buffer = lpBuffer;
405
406 Result = GetComputerNameExW(NameType, TempBuffer, nSize);
407
408 if (Result)
409 {
410 UnicodeString.MaximumLength = (USHORT)*nSize * sizeof(WCHAR) + sizeof(WCHAR);
411 UnicodeString.Length = (USHORT)*nSize * sizeof(WCHAR);
412 UnicodeString.Buffer = TempBuffer;
413
416 FALSE);
417 }
418
419 RtlFreeHeap(RtlGetProcessHeap(), 0, TempBuffer);
420
421 return Result;
422}
423
424/*
425 * @implemented
426 */
427BOOL
428WINAPI
430{
431 BOOL ret;
432
433 ret = GetComputerNameExA(ComputerNameNetBIOS, lpBuffer, lpnSize);
434 if (!ret && GetLastError() == ERROR_MORE_DATA)
436
437 return ret;
438}
439
440
441/*
442 * @implemented
443 */
444BOOL
445WINAPI
447{
448 BOOL ret;
449
450 ret = GetComputerNameExW(ComputerNameNetBIOS, lpBuffer, lpnSize);
451 if (!ret && GetLastError() == ERROR_MORE_DATA)
453
454 return ret;
455}
456
457static
458BOOL
460{
461 HINSTANCE hDNSAPI;
462 FN_DnsValidateName_W fnValidate;
464 BOOL ret = FALSE;
465
466 hDNSAPI = LoadLibraryW(L"dnsapi.dll");
467 if (hDNSAPI == NULL)
468 return FALSE;
469
470 fnValidate = (FN_DnsValidateName_W)GetProcAddress(hDNSAPI, "DnsValidateName_W");
471 if (fnValidate)
472 {
473 Status = (*fnValidate)(lpDnsName, DnsNameHostnameLabel);
475 ret = TRUE;
476 }
477
478 FreeLibrary(hDNSAPI);
479
480 return ret;
481}
482
483/*
484 * @implemented
485 */
486static
487BOOL
488IsValidComputerName(COMPUTER_NAME_FORMAT NameType,
490{
491 size_t Length;
492 static const WCHAR s_szInvalidChars[] =
493 L"\"/\\[]:|<>+=;,?"
494 L"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
495 L"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
496
497 if (lpComputerName == NULL)
498 return FALSE;
499
500#define MAX_COMPUTER_NAME_EX 64
501 /* Get string length */
503 return FALSE;
504#undef MAX_COMPUTER_NAME_EX
505
506 /* An empty name is invalid, except a DNS name */
507 if (Length == 0 && NameType != ComputerNamePhysicalDnsDomain)
508 return FALSE;
509
510 /* Leading or trailing spaces are invalid */
511 if (Length > 0 &&
512 (lpComputerName[0] == L' ' || lpComputerName[Length - 1] == L' '))
513 {
514 return FALSE;
515 }
516
517 /* Check whether the name contains any invalid character */
518 if (wcscspn(lpComputerName, s_szInvalidChars) < Length)
519 return FALSE;
520
521 switch (NameType)
522 {
523 case ComputerNamePhysicalNetBIOS:
525 return FALSE;
526 return TRUE;
527
528 case ComputerNamePhysicalDnsDomain:
529 /* An empty DNS name is valid */
530 if (Length != 0)
532 return TRUE;
533
534 case ComputerNamePhysicalDnsHostname:
536
537 default:
538 return FALSE;
539 }
540}
541
542static
543BOOL
545 LPCWSTR ValueNameStr,
547{
552 SIZE_T StringLength;
554
555 StringLength = wcslen(lpBuffer);
556 if (StringLength > ((MAXULONG / sizeof(WCHAR)) - 1))
557 {
558 return FALSE;
559 }
560
561 RtlInitUnicodeString(&KeyName, RegistryKey);
563 &KeyName,
565 NULL,
566 NULL);
567
569 KEY_WRITE,
571 if (!NT_SUCCESS(Status))
572 {
574 return FALSE;
575 }
576
577 RtlInitUnicodeString(&ValueName, ValueNameStr);
578
580 &ValueName,
581 0,
582 REG_SZ,
584 (StringLength + 1) * sizeof(WCHAR));
585 if (!NT_SUCCESS(Status))
586 {
589 return FALSE;
590 }
591
594
596 return TRUE;
597}
598
599
600/*
601 * @implemented
602 */
603BOOL
604WINAPI
606{
607 return SetComputerNameExA(ComputerNamePhysicalNetBIOS, lpComputerName);
608}
609
610
611/*
612 * @implemented
613 */
614BOOL
615WINAPI
617{
618 return SetComputerNameExW(ComputerNamePhysicalNetBIOS, lpComputerName);
619}
620
621
622/*
623 * @implemented
624 */
625BOOL
626WINAPI
627SetComputerNameExA(COMPUTER_NAME_FORMAT NameType,
629{
631 BOOL bResult;
632
634
635 bResult = SetComputerNameExW(NameType, Buffer.Buffer);
636
638
639 return bResult;
640}
641
642
643/*
644 * @implemented
645 */
646BOOL
647WINAPI
648SetComputerNameExW(COMPUTER_NAME_FORMAT NameType,
650{
651 WCHAR szShortName[MAX_COMPUTERNAME_LENGTH + 1];
652 BOOL ret1, ret2;
653
655 {
657 return FALSE;
658 }
659
660 switch (NameType)
661 {
662 case ComputerNamePhysicalDnsDomain:
663 return SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
664 L"\\Services\\Tcpip\\Parameters",
665 L"NV Domain",
666 lpBuffer);
667
668 case ComputerNamePhysicalDnsHostname:
669 ret1 = SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
670 L"\\Services\\Tcpip\\Parameters",
671 L"NV Hostname",
672 lpBuffer);
673
675 ret2 = SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
676 L"\\Control\\ComputerName\\ComputerName",
677 L"ComputerName",
678 szShortName);
679 return (ret1 && ret2);
680
681 case ComputerNamePhysicalNetBIOS:
683 return SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
684 L"\\Control\\ComputerName\\ComputerName",
685 L"ComputerName",
686 szShortName);
687
688 default:
690 return FALSE;
691 }
692}
693
694
695/*
696 * @implemented
697 */
698BOOL
699WINAPI
701 LPSTR ComputerName,
703{
704 DWORD len;
705
706 DPRINT("(%s, %p, %p)\n", Hostname, ComputerName, nSize);
707
708 if (!Hostname || !nSize)
709 return FALSE;
710
711 len = lstrlenA(Hostname);
712
715
716 if (*nSize < len)
717 {
718 *nSize = len;
719 return FALSE;
720 }
721
722 if (!ComputerName) return FALSE;
723
724 memcpy(ComputerName, Hostname, len);
725 ComputerName[len + 1] = 0;
726 return TRUE;
727}
728
729
730/*
731 * @implemented
732 */
733BOOL
734WINAPI
736 LPWSTR computername,
738{
739 DWORD len;
740
741 DPRINT("(%s, %p, %p): stub\n", hostname, computername, size);
742
743 if (!hostname || !size) return FALSE;
745
748
749 if (*size < len)
750 {
751 *size = len;
752 return FALSE;
753 }
754 if (!computername) return FALSE;
755
756 memcpy(computername, hostname, len * sizeof(WCHAR));
757 computername[len + 1] = 0;
758 return TRUE;
759}
760
761DWORD
762WINAPI
764{
765 STUB;
766 return 0;
767}
768
769DWORD
770WINAPI
772{
773 STUB;
774 return 0;
775}
776
777DWORD
778WINAPI
780{
781 STUB;
783}
784
785DWORD
786WINAPI
788{
789 STUB;
791}
792
793DWORD
794WINAPI
796{
797 STUB;
799}
800
801DWORD
802WINAPI
804{
805 STUB;
807}
808
809/*
810 * @unimplemented
811 */
812BOOL
813WINAPI
815 IN DWORD Unknown2)
816{
817 STUB;
818 return FALSE;
819}
820
821/*
822 * @unimplemented
823 */
824BOOL
825WINAPI
827 IN DWORD Unknown2)
828{
829 STUB;
830 return FALSE;
831}
832
833
834/* EOF */
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 NameType
Definition: acpixf.h:658
LONG NTSTATUS
Definition: precomp.h:26
char * hostname
Definition: ftp.c:88
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:590
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:608
Definition: bufpool.h:45
static BOOL SetComputerNameToRegistry(LPCWSTR RegistryKey, LPCWSTR ValueNameStr, LPCWSTR lpBuffer)
Definition: compname.c:544
BOOL WINAPI GetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:216
BOOL WINAPI SetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer)
Definition: compname.c:627
DWORD WINAPI EnumerateLocalComputerNamesW(PVOID pUnknown, DWORD Size, LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:787
BOOL WINAPI SetLocalPrimaryComputerNameW(IN DWORD Unknown1, IN DWORD Unknown2)
Definition: compname.c:826
DWORD WINAPI EnumerateLocalComputerNamesA(PVOID pUnknown, DWORD Size, LPSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:779
DWORD WINAPI AddLocalAlternateComputerNameW(LPWSTR lpName, PNTSTATUS Status)
Definition: compname.c:771
static BOOL SetActiveComputerNameToRegistry(LPCWSTR RegistryKey, LPCWSTR SubKey, LPCWSTR ValueNameStr, LPCWSTR lpBuffer)
Definition: compname.c:131
BOOL WINAPI SetComputerNameA(LPCSTR lpComputerName)
Definition: compname.c:605
DWORD WINAPI RemoveLocalAlternateComputerNameA(LPSTR lpName, DWORD Unknown)
Definition: compname.c:795
BOOL WINAPI SetLocalPrimaryComputerNameA(IN DWORD Unknown1, IN DWORD Unknown2)
Definition: compname.c:814
BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:376
BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize)
Definition: compname.c:700
static BOOL GetComputerNameFromRegistry(LPWSTR RegistryKey, LPWSTR ValueNameStr, LPWSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:42
static BOOL BaseVerifyDnsName(LPCWSTR lpDnsName)
Definition: compname.c:459
BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR hostname, LPWSTR computername, LPDWORD size)
Definition: compname.c:735
BOOL WINAPI GetComputerNameW(LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:446
BOOL WINAPI GetComputerNameA(LPSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:429
#define MAX_COMPUTER_NAME_EX
NTSTATUS(WINAPI * FN_DnsValidateName_W)(LPCWSTR, DNS_NAME_FORMAT)
Definition: compname.c:36
DWORD WINAPI AddLocalAlternateComputerNameA(LPSTR lpName, PNTSTATUS Status)
Definition: compname.c:763
BOOL WINAPI SetComputerNameW(LPCWSTR lpComputerName)
Definition: compname.c:616
DWORD WINAPI RemoveLocalAlternateComputerNameW(LPWSTR lpName, DWORD Unknown)
Definition: compname.c:803
static BOOL IsValidComputerName(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpComputerName)
Definition: compname.c:488
BOOL WINAPI SetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer)
Definition: compname.c:648
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define NTSTATUS
Definition: precomp.h:21
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define GetProcAddress(x, y)
Definition: compat.h:753
#define FreeLibrary(x)
Definition: compat.h:748
#define LoadLibraryW(x)
Definition: compat.h:747
#define lstrlenW
Definition: compat.h:750
@ AnsiString
Definition: dnslib.h:19
_In_ PUNKNOWN pUnknown
Definition: drmk.h:76
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
LPWSTR lpComputerName
Definition: eventvwr.c:74
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
Status
Definition: gdiplustypes.h:25
GLsizeiptr size
Definition: glext.h:5919
GLenum GLsizei len
Definition: glext.h:6722
@ Unknown
Definition: i8042prt.h:114
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
#define STUB
Definition: kernel32.h:27
#define REG_SZ
Definition: layer.c:22
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
* PNTSTATUS
Definition: strlen.c:14
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ PNDIS_STRING _Out_ PNDIS_HANDLE SubKeyHandle
Definition: ndis.h:4726
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE QueryTable
Definition: rtlfuncs.h:4208
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
NTSYSAPI NTSTATUS NTAPI NtSetValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN ULONG TitleIndex OPTIONAL, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)
Definition: ntapi.c:859
@ KeyValuePartialInformation
Definition: nt_native.h:1182
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RTL_REGISTRY_ABSOLUTE
Definition: nt_native.h:161
NTSYSAPI NTSTATUS NTAPI NtQueryValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, IN PULONG ResultLength)
#define RTL_QUERY_REGISTRY_DIRECT
Definition: nt_native.h:144
struct _KEY_VALUE_PARTIAL_INFORMATION KEY_VALUE_PARTIAL_INFORMATION
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define KEY_WRITE
Definition: nt_native.h:1031
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
NTSTATUS NTAPI NtCreateKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG TitleIndex, IN PUNICODE_STRING Class OPTIONAL, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)
Definition: ntapi.c:240
NTSTATUS NTAPI NtFlushKey(IN HANDLE KeyHandle)
Definition: ntapi.c:1085
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NTSTRSAFEAPI RtlStringCchCopyNW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_reads_or_z_(cchToCopy) STRSAFE_LPCWSTR pszSrc, _In_ size_t cchToCopy)
Definition: ntstrsafe.h:363
_Must_inspect_result_ NTSTRSAFEAPI RtlStringCchLengthW(_In_reads_or_z_(cchMax) STRSAFE_LPCWSTR psz, _In_ _In_range_(1, NTSTRSAFE_MAX_CCH) size_t cchMax, _Out_opt_ _Deref_out_range_(<, cchMax) _Deref_out_range_(<=, _String_length_(psz)) size_t *pcchLength)
Definition: ntstrsafe.h:1573
#define L(x)
Definition: ntvdm.h:50
unsigned short USHORT
Definition: pedump.c:61
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
_Check_return_ _CRTIMP size_t __cdecl wcscspn(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_Control)
static LPSTR PULONG lpnSize
Definition: secur32.c:50
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
#define DPRINT
Definition: sndvol32.h:73
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define MAXULONG
Definition: typedefs.h:251
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint32_t * LPDWORD
Definition: typedefs.h:59
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
int ret
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_In_ LPCSTR lpName
Definition: winbase.h:2789
*nSize LPSTR _Inout_ LPDWORD nSize
Definition: winbase.h:2084
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:243
@ DnsNameHostnameLabel
Definition: windns.h:147
enum _DNS_NAME_FORMAT DNS_NAME_FORMAT
#define WINAPI
Definition: msvc.h:6
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
#define DNS_ERROR_NON_RFC_NAME
Definition: winerror.h:1872
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185