ReactOS  0.4.15-dev-1033-gd7d716a
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 
40 static
41 BOOL
43  LPWSTR ValueNameStr,
45  LPDWORD nSize)
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 
67  KEY_READ,
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 
122 failed:
123  RtlFreeHeap(RtlGetProcessHeap(), 0, KeyInfo);
125  return FALSE;
126 }
127 
128 
129 static
130 BOOL
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 
166  RtlInitUnicodeString(&KeyName, SubKey);
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,
193  (PVOID)lpBuffer,
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  */
214 BOOL
215 WINAPI
216 GetComputerNameExW(COMPUTER_NAME_FORMAT NameType,
218  LPDWORD nSize)
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",
284  QueryTable,
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",
310  QueryTable,
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  */
374 BOOL
375 WINAPI
376 GetComputerNameExA(COMPUTER_NAME_FORMAT NameType,
377  LPSTR lpBuffer,
378  LPDWORD nSize)
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 
415  &UnicodeString,
416  FALSE);
417  }
418 
419  RtlFreeHeap(RtlGetProcessHeap(), 0, TempBuffer);
420 
421  return Result;
422 }
423 
424 /*
425  * @implemented
426  */
427 BOOL
428 WINAPI
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  */
444 BOOL
445 WINAPI
447 {
448  BOOL ret;
449 
450  ret = GetComputerNameExW(ComputerNameNetBIOS, lpBuffer, lpnSize);
451  if (!ret && GetLastError() == ERROR_MORE_DATA)
453 
454  return ret;
455 }
456 
457 static
458 BOOL
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  */
486 static
487 BOOL
488 IsValidComputerName(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 
542 static
543 BOOL
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,
583  (PVOID)lpBuffer,
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  */
603 BOOL
604 WINAPI
606 {
607  return SetComputerNameExA(ComputerNamePhysicalNetBIOS, lpComputerName);
608 }
609 
610 
611 /*
612  * @implemented
613  */
614 BOOL
615 WINAPI
617 {
618  return SetComputerNameExW(ComputerNamePhysicalNetBIOS, lpComputerName);
619 }
620 
621 
622 /*
623  * @implemented
624  */
625 BOOL
626 WINAPI
627 SetComputerNameExA(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  */
646 BOOL
647 WINAPI
648 SetComputerNameExW(COMPUTER_NAME_FORMAT NameType,
650 {
651  BOOL ret1, ret2;
652 
654  {
656  return FALSE;
657  }
658 
659  switch (NameType)
660  {
661  case ComputerNamePhysicalDnsDomain:
662  return SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
663  L"\\Services\\Tcpip\\Parameters",
664  L"NV Domain",
665  lpBuffer);
666 
667  case ComputerNamePhysicalDnsHostname:
668  ret1 = SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
669  L"\\Services\\Tcpip\\Parameters",
670  L"NV Hostname",
671  lpBuffer);
672 
673  ret2 = SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
674  L"\\Control\\ComputerName\\ComputerName",
675  L"ComputerName",
676  lpBuffer);
677  return (ret1 && ret2);
678 
679  case ComputerNamePhysicalNetBIOS:
680  return SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
681  L"\\Control\\ComputerName\\ComputerName",
682  L"ComputerName",
683  lpBuffer);
684 
685  default:
687  return FALSE;
688  }
689 }
690 
691 
692 /*
693  * @implemented
694  */
695 BOOL
696 WINAPI
698  LPSTR ComputerName,
699  LPDWORD nSize)
700 {
701  DWORD len;
702 
703  DPRINT("(%s, %p, %p)\n", Hostname, ComputerName, nSize);
704 
705  if (!Hostname || !nSize)
706  return FALSE;
707 
708  len = lstrlenA(Hostname);
709 
712 
713  if (*nSize < len)
714  {
715  *nSize = len;
716  return FALSE;
717  }
718 
719  if (!ComputerName) return FALSE;
720 
721  memcpy(ComputerName, Hostname, len);
722  ComputerName[len + 1] = 0;
723  return TRUE;
724 }
725 
726 
727 /*
728  * @implemented
729  */
730 BOOL
731 WINAPI
733  LPWSTR computername,
734  LPDWORD size)
735 {
736  DWORD len;
737 
738  DPRINT("(%s, %p, %p): stub\n", hostname, computername, size);
739 
740  if (!hostname || !size) return FALSE;
741  len = lstrlenW(hostname);
742 
745 
746  if (*size < len)
747  {
748  *size = len;
749  return FALSE;
750  }
751  if (!computername) return FALSE;
752 
753  memcpy(computername, hostname, len * sizeof(WCHAR));
754  computername[len + 1] = 0;
755  return TRUE;
756 }
757 
758 DWORD
759 WINAPI
761 {
762  STUB;
763  return 0;
764 }
765 
766 DWORD
767 WINAPI
769 {
770  STUB;
771  return 0;
772 }
773 
774 DWORD
775 WINAPI
777 {
778  STUB;
780 }
781 
782 DWORD
783 WINAPI
785 {
786  STUB;
788 }
789 
790 DWORD
791 WINAPI
793 {
794  STUB;
796 }
797 
798 DWORD
799 WINAPI
801 {
802  STUB;
804 }
805 
806 /*
807  * @unimplemented
808  */
809 BOOL
810 WINAPI
812  IN DWORD Unknown2)
813 {
814  STUB;
815  return FALSE;
816 }
817 
818 /*
819  * @unimplemented
820  */
821 BOOL
822 WINAPI
824  IN DWORD Unknown2)
825 {
826  STUB;
827  return FALSE;
828 }
829 
830 
831 /* EOF */
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
* PNTSTATUS
Definition: strlen.c:14
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING KeyName
Definition: ndis.h:4711
_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE QueryTable
Definition: rtlfuncs.h:4142
#define IN
Definition: typedefs.h:39
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define MAX_COMPUTER_NAME_EX
BOOL WINAPI SetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer)
Definition: compname.c:627
*BytesInUnicodeString PWCH UnicodeString
Definition: rtlfuncs.h:1979
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
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOL WINAPI SetComputerNameW(LPCWSTR lpComputerName)
Definition: compname.c:616
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define KEY_READ
Definition: nt_native.h:1023
#define TRUE
Definition: types.h:120
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
_Check_return_ _CRTIMP size_t __cdecl wcscspn(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_Control)
LONG NTSTATUS
Definition: precomp.h:26
*nSize LPSTR _Inout_ LPDWORD nSize
Definition: winbase.h:2037
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define DNS_ERROR_NON_RFC_NAME
Definition: winerror.h:1872
_In_ LPCSTR lpName
Definition: winbase.h:2752
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
DWORD WINAPI AddLocalAlternateComputerNameW(LPWSTR lpName, PNTSTATUS Status)
Definition: compname.c:768
uint16_t * PWCHAR
Definition: typedefs.h:56
BOOL WINAPI SetLocalPrimaryComputerNameA(IN DWORD Unknown1, IN DWORD Unknown2)
Definition: compname.c:811
BOOL WINAPI GetComputerNameA(LPSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:429
BOOL WINAPI GetComputerNameW(LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:446
_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
char * LPSTR
Definition: xmlstorage.h:182
#define lstrlenW
Definition: compat.h:498
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:50
BOOL WINAPI GetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPWSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:216
char * hostname
Definition: ftp.c:88
NTSTATUS(WINAPI * FN_DnsValidateName_W)(LPCWSTR, DNS_NAME_FORMAT)
Definition: compname.c:36
DWORD WINAPI RemoveLocalAlternateComputerNameA(LPSTR lpName, DWORD Unknown)
Definition: compname.c:792
DWORD WINAPI EnumerateLocalComputerNamesW(PVOID pUnknown, DWORD Size, LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:784
_In_ PUNICODE_STRING ValueName
Definition: cmfuncs.h:264
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
static LPSTR PULONG lpnSize
Definition: secur32.c:50
static BOOL IsValidComputerName(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpComputerName)
Definition: compname.c:488
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:173
#define LoadLibraryW(x)
Definition: compat.h:495
smooth NULL
Definition: ftsmooth.c:416
_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:426
void DPRINT(...)
Definition: polytest.cpp:61
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
Definition: bufpool.h:45
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
const char * LPCSTR
Definition: xmlstorage.h:183
DWORD WINAPI EnumerateLocalComputerNamesA(PVOID pUnknown, DWORD Size, LPSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:776
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR hostname, LPWSTR computername, LPDWORD size)
Definition: compname.c:732
_In_ PUNKNOWN pUnknown
Definition: drmk.h:76
#define KEY_WRITE
Definition: nt_native.h:1031
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
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)
BOOL WINAPI SetComputerNameA(LPCSTR lpComputerName)
Definition: compname.c:605
#define FreeLibrary(x)
Definition: compat.h:496
GLsizeiptr size
Definition: glext.h:5919
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
enum _DNS_NAME_FORMAT DNS_NAME_FORMAT
#define WINAPI
Definition: msvc.h:6
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define SetLastError(x)
Definition: compat.h:500
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ PNDIS_STRING _Out_ PNDIS_HANDLE SubKeyHandle
Definition: ndis.h:4723
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
static BOOL SetActiveComputerNameToRegistry(LPCWSTR RegistryKey, LPCWSTR SubKey, LPCWSTR ValueNameStr, LPCWSTR lpBuffer)
Definition: compname.c:131
int ret
Status
Definition: gdiplustypes.h:24
static const WCHAR L[]
Definition: oid.c:1250
static BOOL BaseVerifyDnsName(LPCWSTR lpDnsName)
Definition: compname.c:459
#define NTSTATUS
Definition: precomp.h:20
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
static BOOL SetComputerNameToRegistry(LPCWSTR RegistryKey, LPCWSTR ValueNameStr, LPCWSTR lpBuffer)
Definition: compname.c:544
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
#define RTL_REGISTRY_ABSOLUTE
Definition: nt_native.h:161
#define ERROR_MORE_DATA
Definition: dderror.h:13
LPWSTR lpComputerName
Definition: eventvwr.c:91
#define MAXULONG
Definition: typedefs.h:251
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:240
ULONG_PTR SIZE_T
Definition: typedefs.h:80
DWORD WINAPI RemoveLocalAlternateComputerNameW(LPWSTR lpName, DWORD Unknown)
Definition: compname.c:800
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
#define STUB
Definition: kernel32.h:27
unsigned short USHORT
Definition: pedump.c:61
struct _KEY_VALUE_PARTIAL_INFORMATION KEY_VALUE_PARTIAL_INFORMATION
NTSTATUS NTAPI NtFlushKey(IN HANDLE KeyHandle)
Definition: ntapi.c:1085
BOOL WINAPI SetLocalPrimaryComputerNameW(IN DWORD Unknown1, IN DWORD Unknown2)
Definition: compname.c:823
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
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
DWORD WINAPI AddLocalAlternateComputerNameA(LPSTR lpName, PNTSTATUS Status)
Definition: compname.c:760
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
uint32_t * LPDWORD
Definition: typedefs.h:59
BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:376
unsigned int ULONG
Definition: retypes.h:1
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define GetProcAddress(x, y)
Definition: compat.h:501
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical 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:654
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
WCHAR * LPWSTR
Definition: xmlstorage.h:184
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:3014
static BOOL GetComputerNameFromRegistry(LPWSTR RegistryKey, LPWSTR ValueNameStr, LPWSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:42
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
BOOL WINAPI SetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer)
Definition: compname.c:648
#define RTL_QUERY_REGISTRY_DIRECT
Definition: nt_native.h:144
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR Hostname, LPSTR ComputerName, LPDWORD nSize)
Definition: compname.c:697
#define REG_SZ
Definition: layer.c:22