ReactOS  0.4.15-dev-425-gc40b086
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  * PROGRAMER: Eric Kohl
25  */
26 
27 /* INCLUDES ******************************************************************/
28 
29 #include <k32.h>
30 
31 #define NDEBUG
32 #include <debug.h>
33 
34 
35 /* FUNCTIONS *****************************************************************/
36 
37 static
38 BOOL
40  LPWSTR ValueNameStr,
42  LPDWORD nSize)
43 {
49  ULONG KeyInfoSize;
50  ULONG ReturnSize;
52 
53  if (lpBuffer != NULL && *nSize > 0)
54  lpBuffer[0] = 0;
55 
56  RtlInitUnicodeString(&KeyName, RegistryKey);
58  &KeyName,
60  NULL,
61  NULL);
62 
64  KEY_READ,
66  if (!NT_SUCCESS(Status))
67  {
69  return FALSE;
70  }
71 
72  KeyInfoSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + *nSize * sizeof(WCHAR);
73  KeyInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, KeyInfoSize);
74  if (KeyInfo == NULL)
75  {
78  return FALSE;
79  }
80 
81  RtlInitUnicodeString(&ValueName, ValueNameStr);
82 
84  &ValueName,
86  KeyInfo,
87  KeyInfoSize,
88  &ReturnSize);
89 
91 
92  if (!NT_SUCCESS(Status))
93  {
94  *nSize = (ReturnSize - FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data)) / sizeof(WCHAR);
95  goto failed;
96  }
97 
98  if (KeyInfo->Type != REG_SZ)
99  {
101  goto failed;
102  }
103 
104  if (!lpBuffer || *nSize < (KeyInfo->DataLength / sizeof(WCHAR)))
105  {
106  *nSize = (ReturnSize - FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data)) / sizeof(WCHAR);
108  goto failed;
109  }
110 
111  *nSize = KeyInfo->DataLength / sizeof(WCHAR) - 1;
112  RtlCopyMemory(lpBuffer, KeyInfo->Data, KeyInfo->DataLength);
113  lpBuffer[*nSize] = 0;
114 
115  RtlFreeHeap(RtlGetProcessHeap(), 0, KeyInfo);
116 
117  return TRUE;
118 
119 failed:
120  RtlFreeHeap(RtlGetProcessHeap(), 0, KeyInfo);
122  return FALSE;
123 }
124 
125 
126 static
127 BOOL
129  LPCWSTR SubKey,
130  LPCWSTR ValueNameStr,
132 {
137  SIZE_T StringLength;
140 
141  StringLength = wcslen(lpBuffer);
142  if (StringLength > ((MAXULONG / sizeof(WCHAR)) - 1))
143  {
144  return FALSE;
145  }
146 
147  RtlInitUnicodeString(&KeyName, RegistryKey);
149  &KeyName,
151  NULL,
152  NULL);
153 
155  KEY_WRITE,
157  if (!NT_SUCCESS(Status))
158  {
160  return FALSE;
161  }
162 
163  RtlInitUnicodeString(&KeyName, SubKey);
165  &KeyName,
167  KeyHandle,
168  NULL);
169 
171  KEY_WRITE,
173  0,
174  NULL,
176  &Disposition);
177  if (!NT_SUCCESS(Status))
178  {
181  return FALSE;
182  }
183 
184  RtlInitUnicodeString(&ValueName, ValueNameStr);
185 
187  &ValueName,
188  0,
189  REG_SZ,
190  (PVOID)lpBuffer,
191  (StringLength + 1) * sizeof(WCHAR));
192  if (!NT_SUCCESS(Status))
193  {
197  return FALSE;
198  }
199 
203 
204  return TRUE;
205 }
206 
207 
208 /*
209  * @implemented
210  */
211 BOOL
212 WINAPI
213 GetComputerNameExW(COMPUTER_NAME_FORMAT NameType,
215  LPDWORD nSize)
216 {
217  UNICODE_STRING ResultString;
218  UNICODE_STRING DomainPart;
221  BOOL ret = TRUE;
222  DWORD HostSize;
223 
224  if ((nSize == NULL) ||
225  (lpBuffer == NULL && *nSize > 0))
226  {
228  return FALSE;
229  }
230 
231  switch (NameType)
232  {
233  case ComputerNameNetBIOS:
234  ret = GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
235  L"\\Control\\ComputerName\\ActiveComputerName",
236  L"ComputerName",
237  lpBuffer,
238  nSize);
239  if ((ret == FALSE) &&
241  {
242  ret = GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
243  L"\\Control\\ComputerName\\ComputerName",
244  L"ComputerName",
245  lpBuffer,
246  nSize);
247  if (ret)
248  {
249  ret = SetActiveComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
250  L"\\Control\\ComputerName",
251  L"ActiveComputerName",
252  L"ComputerName",
253  lpBuffer);
254  }
255  }
256  return ret;
257 
258  case ComputerNameDnsDomain:
259  return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
260  L"\\Services\\Tcpip\\Parameters",
261  L"Domain",
262  lpBuffer,
263  nSize);
264 
265  case ComputerNameDnsFullyQualified:
266  ResultString.Length = 0;
267  ResultString.MaximumLength = (USHORT)*nSize * sizeof(WCHAR);
268  ResultString.Buffer = lpBuffer;
269 
271  RtlInitUnicodeString(&DomainPart, NULL);
272 
273  QueryTable[0].Name = L"HostName";
275  QueryTable[0].EntryContext = &DomainPart;
276 
278  L"\\Registry\\Machine\\System"
279  L"\\CurrentControlSet\\Services\\Tcpip"
280  L"\\Parameters",
281  QueryTable,
282  NULL,
283  NULL);
284 
285  if (NT_SUCCESS(Status))
286  {
287  Status = RtlAppendUnicodeStringToString(&ResultString, &DomainPart);
288  HostSize = DomainPart.Length;
289 
290  if (!NT_SUCCESS(Status))
291  {
292  ret = FALSE;
293  }
294 
295  RtlAppendUnicodeToString(&ResultString, L".");
296  RtlFreeUnicodeString(&DomainPart);
297 
298  RtlInitUnicodeString(&DomainPart, NULL);
299  QueryTable[0].Name = L"Domain";
301  QueryTable[0].EntryContext = &DomainPart;
302 
304  L"\\Registry\\Machine\\System"
305  L"\\CurrentControlSet\\Services\\Tcpip"
306  L"\\Parameters",
307  QueryTable,
308  NULL,
309  NULL);
310 
311  if (NT_SUCCESS(Status))
312  {
313  Status = RtlAppendUnicodeStringToString(&ResultString, &DomainPart);
314  if ((!NT_SUCCESS(Status)) || (!ret))
315  {
316  *nSize = HostSize + DomainPart.Length;
318  RtlFreeUnicodeString(&DomainPart);
319  return FALSE;
320  }
321  RtlFreeUnicodeString(&DomainPart);
322  *nSize = ResultString.Length / sizeof(WCHAR) - 1;
323  return TRUE;
324  }
325  }
326  return FALSE;
327 
328  case ComputerNameDnsHostname:
329  return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
330  L"\\Services\\Tcpip\\Parameters",
331  L"Hostname",
332  lpBuffer,
333  nSize);
334 
335  case ComputerNamePhysicalDnsDomain:
336  return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
337  L"\\Services\\Tcpip\\Parameters",
338  L"NV Domain",
339  lpBuffer,
340  nSize);
341 
342  /* XXX Redo this */
343  case ComputerNamePhysicalDnsFullyQualified:
344  return GetComputerNameExW(ComputerNameDnsFullyQualified,
345  lpBuffer,
346  nSize);
347 
348  case ComputerNamePhysicalDnsHostname:
349  return GetComputerNameFromRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
350  L"\\Services\\Tcpip\\Parameters",
351  L"NV Hostname",
352  lpBuffer,
353  nSize);
354 
355  /* XXX Redo this */
356  case ComputerNamePhysicalNetBIOS:
357  return GetComputerNameExW(ComputerNameNetBIOS,
358  lpBuffer,
359  nSize);
360 
361  case ComputerNameMax:
362  return FALSE;
363  }
364 
365  return FALSE;
366 }
367 
368 /*
369  * @implemented
370  */
371 BOOL
372 WINAPI
373 GetComputerNameExA(COMPUTER_NAME_FORMAT NameType,
374  LPSTR lpBuffer,
375  LPDWORD nSize)
376 {
379  BOOL Result;
380  PWCHAR TempBuffer = NULL;
381 
382  if ((nSize == NULL) ||
383  (lpBuffer == NULL && *nSize > 0))
384  {
386  return FALSE;
387  }
388 
389  if (*nSize > 0)
390  {
391  TempBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, *nSize * sizeof(WCHAR));
392  if (!TempBuffer)
393  {
395  return FALSE;
396  }
397  }
398 
399  AnsiString.MaximumLength = (USHORT)*nSize;
400  AnsiString.Length = 0;
401  AnsiString.Buffer = lpBuffer;
402 
403  Result = GetComputerNameExW(NameType, TempBuffer, nSize);
404 
405  if (Result)
406  {
407  UnicodeString.MaximumLength = (USHORT)*nSize * sizeof(WCHAR) + sizeof(WCHAR);
408  UnicodeString.Length = (USHORT)*nSize * sizeof(WCHAR);
409  UnicodeString.Buffer = TempBuffer;
410 
412  &UnicodeString,
413  FALSE);
414  }
415 
416  RtlFreeHeap(RtlGetProcessHeap(), 0, TempBuffer);
417 
418  return Result;
419 }
420 
421 /*
422  * @implemented
423  */
424 BOOL
425 WINAPI
427 {
428  BOOL ret;
429 
430  ret = GetComputerNameExA(ComputerNameNetBIOS, lpBuffer, lpnSize);
431  if (!ret && GetLastError() == ERROR_MORE_DATA)
433 
434  return ret;
435 }
436 
437 
438 /*
439  * @implemented
440  */
441 BOOL
442 WINAPI
444 {
445  BOOL ret;
446 
447  ret = GetComputerNameExW(ComputerNameNetBIOS, lpBuffer, lpnSize);
448  if (!ret && GetLastError() == ERROR_MORE_DATA)
450 
451  return ret;
452 }
453 
454 
455 /*
456  * @implemented
457  */
458 static
459 BOOL
460 IsValidComputerName(COMPUTER_NAME_FORMAT NameType,
462 {
463  PWCHAR p;
464  ULONG Length;
465 
466  /* FIXME: do verification according to NameType */
467 
468  Length = 0;
470 
471  while (*p != 0)
472  {
473  if (!(iswctype(*p, _ALPHA | _DIGIT) || *p == L'!' || *p == L'@' || *p == L'#' ||
474  *p == L'$' || *p == L'%' || *p == L'^' || *p == L'&' || *p == L'\'' ||
475  *p == L')' || *p == L'(' || *p == L'.' || *p == L'-' || *p == L'_' ||
476  *p == L'{' || *p == L'}' || *p == L'~'))
477  return FALSE;
478 
479  Length++;
480  p++;
481  }
482 
483  if (NameType == ComputerNamePhysicalDnsDomain)
484  return TRUE;
485 
486  if (Length == 0)
487  return FALSE;
488 
489  if (NameType == ComputerNamePhysicalNetBIOS &&
491  return FALSE;
492 
493  return TRUE;
494 }
495 
496 
497 static
498 BOOL
500  LPCWSTR ValueNameStr,
502 {
507  SIZE_T StringLength;
509 
510  StringLength = wcslen(lpBuffer);
511  if (StringLength > ((MAXULONG / sizeof(WCHAR)) - 1))
512  {
513  return FALSE;
514  }
515 
516  RtlInitUnicodeString(&KeyName, RegistryKey);
518  &KeyName,
520  NULL,
521  NULL);
522 
524  KEY_WRITE,
526  if (!NT_SUCCESS(Status))
527  {
529  return FALSE;
530  }
531 
532  RtlInitUnicodeString(&ValueName, ValueNameStr);
533 
535  &ValueName,
536  0,
537  REG_SZ,
538  (PVOID)lpBuffer,
539  (StringLength + 1) * sizeof(WCHAR));
540  if (!NT_SUCCESS(Status))
541  {
544  return FALSE;
545  }
546 
549 
550  return TRUE;
551 }
552 
553 
554 /*
555  * @implemented
556  */
557 BOOL
558 WINAPI
560 {
561  return SetComputerNameExA(ComputerNamePhysicalNetBIOS, lpComputerName);
562 }
563 
564 
565 /*
566  * @implemented
567  */
568 BOOL
569 WINAPI
571 {
572  return SetComputerNameExW(ComputerNamePhysicalNetBIOS, lpComputerName);
573 }
574 
575 
576 /*
577  * @implemented
578  */
579 BOOL
580 WINAPI
581 SetComputerNameExA(COMPUTER_NAME_FORMAT NameType,
583 {
585  BOOL bResult;
586 
588 
589  bResult = SetComputerNameExW(NameType, Buffer.Buffer);
590 
592 
593  return bResult;
594 }
595 
596 
597 /*
598  * @implemented
599  */
600 BOOL
601 WINAPI
602 SetComputerNameExW(COMPUTER_NAME_FORMAT NameType,
604 {
605  BOOL ret1, ret2;
606 
608  {
610  return FALSE;
611  }
612 
613  switch (NameType)
614  {
615  case ComputerNamePhysicalDnsDomain:
616  return SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
617  L"\\Services\\Tcpip\\Parameters",
618  L"NV Domain",
619  lpBuffer);
620 
621  case ComputerNamePhysicalDnsHostname:
622  ret1 = SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
623  L"\\Services\\Tcpip\\Parameters",
624  L"NV Hostname",
625  lpBuffer);
626 
627  ret2 = SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
628  L"\\Control\\ComputerName\\ComputerName",
629  L"ComputerName",
630  lpBuffer);
631  return (ret1 && ret2);
632 
633  case ComputerNamePhysicalNetBIOS:
634  return SetComputerNameToRegistry(L"\\Registry\\Machine\\System\\CurrentControlSet"
635  L"\\Control\\ComputerName\\ComputerName",
636  L"ComputerName",
637  lpBuffer);
638 
639  default:
641  return FALSE;
642  }
643 }
644 
645 
646 /*
647  * @implemented
648  */
649 BOOL
650 WINAPI
652  LPSTR ComputerName,
653  LPDWORD nSize)
654 {
655  DWORD len;
656 
657  DPRINT("(%s, %p, %p)\n", Hostname, ComputerName, nSize);
658 
659  if (!Hostname || !nSize)
660  return FALSE;
661 
662  len = lstrlenA(Hostname);
663 
666 
667  if (*nSize < len)
668  {
669  *nSize = len;
670  return FALSE;
671  }
672 
673  if (!ComputerName) return FALSE;
674 
675  memcpy(ComputerName, Hostname, len);
676  ComputerName[len + 1] = 0;
677  return TRUE;
678 }
679 
680 
681 /*
682  * @implemented
683  */
684 BOOL
685 WINAPI
687  LPWSTR computername,
688  LPDWORD size)
689 {
690  DWORD len;
691 
692  DPRINT("(%s, %p, %p): stub\n", hostname, computername, size);
693 
694  if (!hostname || !size) return FALSE;
695  len = lstrlenW(hostname);
696 
699 
700  if (*size < len)
701  {
702  *size = len;
703  return FALSE;
704  }
705  if (!computername) return FALSE;
706 
707  memcpy(computername, hostname, len * sizeof(WCHAR));
708  computername[len + 1] = 0;
709  return TRUE;
710 }
711 
712 DWORD
713 WINAPI
715 {
716  STUB;
717  return 0;
718 }
719 
720 DWORD
721 WINAPI
723 {
724  STUB;
725  return 0;
726 }
727 
728 DWORD
729 WINAPI
731 {
732  STUB;
734 }
735 
736 DWORD
737 WINAPI
739 {
740  STUB;
742 }
743 
744 DWORD
745 WINAPI
747 {
748  STUB;
750 }
751 
752 DWORD
753 WINAPI
755 {
756  STUB;
758 }
759 
760 /*
761  * @unimplemented
762  */
763 BOOL
764 WINAPI
766  IN DWORD Unknown2)
767 {
768  STUB;
769  return FALSE;
770 }
771 
772 /*
773  * @unimplemented
774  */
775 BOOL
776 WINAPI
778  IN DWORD Unknown2)
779 {
780  STUB;
781  return FALSE;
782 }
783 
784 
785 /* EOF */
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
* 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:4050
#define IN
Definition: typedefs.h:39
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
BOOL WINAPI SetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPCSTR lpBuffer)
Definition: compname.c:581
*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
BOOL WINAPI SetComputerNameW(LPCWSTR lpComputerName)
Definition: compname.c:570
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 ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
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
_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:722
uint16_t * PWCHAR
Definition: typedefs.h:55
BOOL WINAPI SetLocalPrimaryComputerNameA(IN DWORD Unknown1, IN DWORD Unknown2)
Definition: compname.c:765
BOOL WINAPI GetComputerNameA(LPSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:426
BOOL WINAPI GetComputerNameW(LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:443
char * LPSTR
Definition: xmlstorage.h:182
#define lstrlenW
Definition: compat.h:416
_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:213
char * hostname
Definition: ftp.c:88
DWORD WINAPI RemoveLocalAlternateComputerNameA(LPSTR lpName, DWORD Unknown)
Definition: compname.c:746
DWORD WINAPI EnumerateLocalComputerNamesW(PVOID pUnknown, DWORD Size, LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:738
_In_ PUNICODE_STRING ValueName
Definition: cmfuncs.h:264
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:460
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:173
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:730
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:686
_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:559
GLsizeiptr size
Definition: glext.h:5919
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#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:418
int __cdecl iswctype(wint_t wc, wctype_t wctypeFlags)
Definition: freeldr.c:97
_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:128
int ret
static const WCHAR L[]
Definition: oid.c:1250
#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:499
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
Status
Definition: gdiplustypes.h:24
#define MAXULONG
Definition: typedefs.h:250
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:240
ULONG_PTR SIZE_T
Definition: typedefs.h:79
DWORD WINAPI RemoveLocalAlternateComputerNameW(LPWSTR lpName, DWORD Unknown)
Definition: compname.c:754
#define _DIGIT
Definition: ctype.h:67
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:777
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
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:714
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:58
BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT NameType, LPSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:373
unsigned int ULONG
Definition: retypes.h:1
#define _ALPHA
Definition: ctype.h:76
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:92
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
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
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
static BOOL GetComputerNameFromRegistry(LPWSTR RegistryKey, LPWSTR ValueNameStr, LPWSTR lpBuffer, LPDWORD nSize)
Definition: compname.c:39
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
BOOL WINAPI SetComputerNameExW(COMPUTER_NAME_FORMAT NameType, LPCWSTR lpBuffer)
Definition: compname.c:602
#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:651
#define REG_SZ
Definition: layer.c:22