push 337eb2e2d902d84a5d689451984c5832d7e04fc4
[wine/hacks.git] / dlls / kernel32 / computername.c
blob7ddbac8ef0f3d69d60d0fab8e7a4e1001bcc80e3
1 /*
2 * Win32 kernel functions
4 * Copyright 1995 Martin von Loewis and Cameron Heide
5 * Copyright 1999 Peter Ganten
6 * Copyright 2002 Martin Wilck
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "config.h"
24 #include "wine/port.h"
26 #include <stdarg.h>
27 #include <string.h>
28 #ifdef HAVE_UNISTD_H
29 # include <unistd.h>
30 #endif
31 #include <stdlib.h>
32 #include <errno.h>
33 #ifdef HAVE_NETDB_H
34 #include <netdb.h>
35 #endif
37 #include "ntstatus.h"
38 #define WIN32_NO_STATUS
39 #include "windef.h"
40 #include "winbase.h"
41 #include "winerror.h"
42 #include "winnls.h"
43 #include "winternl.h"
44 #include "wine/unicode.h"
45 #include "wine/exception.h"
46 #include "wine/debug.h"
48 #include "kernel_private.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(computername);
52 /* Registry key and value names */
53 static const WCHAR ComputerW[] = {'M','a','c','h','i','n','e','\\',
54 'S','y','s','t','e','m','\\',
55 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
56 'C','o','n','t','r','o','l','\\',
57 'C','o','m','p','u','t','e','r','N','a','m','e',0};
58 static const WCHAR ActiveComputerNameW[] = {'A','c','t','i','v','e','C','o','m','p','u','t','e','r','N','a','m','e',0};
59 static const WCHAR ComputerNameW[] = {'C','o','m','p','u','t','e','r','N','a','m','e',0};
61 static const char default_ComputerName[] = "WINE";
63 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
65 /***********************************************************************
66 * dns_gethostbyname (INTERNAL)
68 * From hostname(1):
69 * "The FQDN is the name gethostbyname(2) returns for the host name returned by gethostname(2)."
71 * Wine can use this technique only if the thread-safe gethostbyname_r is available.
73 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
74 static BOOL dns_gethostbyname ( char *name, int *size )
76 struct hostent* host = NULL;
77 char *extrabuf;
78 int ebufsize = 1024;
79 struct hostent hostentry;
80 int locerr = ENOBUFS, res = ENOMEM;
82 extrabuf = HeapAlloc( GetProcessHeap(), 0, ebufsize ) ;
84 while( extrabuf )
86 res = gethostbyname_r ( name, &hostentry, extrabuf, ebufsize, &host, &locerr );
87 if( res != ERANGE ) break;
88 ebufsize *= 2;
89 extrabuf = HeapReAlloc( GetProcessHeap(), 0, extrabuf, ebufsize ) ;
92 if ( res )
93 WARN ("Error in gethostbyname_r %d (%d)\n", res, locerr);
94 else if ( !host )
96 WARN ("gethostbyname_r returned NULL host, locerr = %d\n", locerr);
97 res = 1;
99 else
101 int len = strlen ( host->h_name );
102 if ( len < *size )
104 strcpy ( name, host->h_name );
105 *size = len;
107 else
109 memcpy ( name, host->h_name, *size );
110 name[*size] = 0;
111 SetLastError ( ERROR_MORE_DATA );
112 res = 1;
116 HeapFree( GetProcessHeap(), 0, extrabuf );
117 return !res;
119 #else
120 # define dns_gethostbyname(name,size) 0
121 #endif
123 /***********************************************************************
124 * dns_fqdn (INTERNAL)
126 static BOOL dns_fqdn ( char *name, int *size )
128 if ( gethostname ( name, *size + 1 ) )
130 switch( errno )
132 case ENAMETOOLONG:
133 SetLastError ( ERROR_MORE_DATA );
134 default:
135 SetLastError ( ERROR_INVALID_PARAMETER );
137 return FALSE;
140 if ( !dns_gethostbyname ( name, size ) )
141 *size = strlen ( name );
143 return TRUE;
146 /***********************************************************************
147 * dns_hostname (INTERNAL)
149 static BOOL dns_hostname ( char *name, int *size )
151 char *c;
152 if ( ! dns_fqdn ( name, size ) ) return FALSE;
153 c = strchr ( name, '.' );
154 if (c)
156 *c = 0;
157 *size = (c - name);
159 return TRUE;
162 /***********************************************************************
163 * dns_domainname (INTERNAL)
165 static BOOL dns_domainname ( char *name, int *size )
167 char *c;
168 if ( ! dns_fqdn ( name, size ) ) return FALSE;
169 c = strchr ( name, '.' );
170 if (c)
172 c += 1;
173 *size -= (c - name);
174 memmove ( name, c, *size + 1 );
176 return TRUE;
179 /***********************************************************************
180 * _init_attr (INTERNAL)
182 static inline void _init_attr ( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *name )
184 attr->Length = sizeof (OBJECT_ATTRIBUTES);
185 attr->RootDirectory = 0;
186 attr->ObjectName = name;
187 attr->Attributes = 0;
188 attr->SecurityDescriptor = NULL;
189 attr->SecurityQualityOfService = NULL;
192 /***********************************************************************
193 * get_use_dns_option
195 static BOOL get_use_dns_option(void)
197 static const WCHAR NetworkW[] = {'S','o','f','t','w','a','r','e','\\',
198 'W','i','n','e','\\','N','e','t','w','o','r','k',0};
199 static const WCHAR UseDNSW[] = {'U','s','e','D','n','s','C','o','m','p','u','t','e','r','N','a','m','e',0};
201 char tmp[80];
202 HANDLE root, hkey;
203 DWORD dummy;
204 OBJECT_ATTRIBUTES attr;
205 UNICODE_STRING nameW;
206 BOOL ret = TRUE;
208 _init_attr( &attr, &nameW );
209 RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
210 attr.RootDirectory = root;
211 RtlInitUnicodeString( &nameW, NetworkW );
213 /* @@ Wine registry key: HKCU\Software\Wine\Network */
214 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
216 RtlInitUnicodeString( &nameW, UseDNSW );
217 if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
219 WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
220 ret = IS_OPTION_TRUE( str[0] );
222 NtClose( hkey );
224 NtClose( root );
225 return ret;
229 /***********************************************************************
230 * COMPUTERNAME_Init (INTERNAL)
232 void COMPUTERNAME_Init (void)
234 HANDLE hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
235 OBJECT_ATTRIBUTES attr;
236 UNICODE_STRING nameW;
237 char buf[offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ) + (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR )];
238 DWORD len = sizeof( buf );
239 LPWSTR computer_name = (LPWSTR) (buf + offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
240 NTSTATUS st = STATUS_INTERNAL_ERROR;
242 TRACE("(void)\n");
243 _init_attr ( &attr, &nameW );
245 RtlInitUnicodeString( &nameW, ComputerW );
246 if ( ( st = NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) ) != STATUS_SUCCESS )
247 goto out;
249 attr.RootDirectory = hkey;
250 RtlInitUnicodeString( &nameW, ComputerNameW );
251 if ( (st = NtCreateKey( &hsubkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) ) != STATUS_SUCCESS )
252 goto out;
254 st = NtQueryValueKey( hsubkey, &nameW, KeyValuePartialInformation, buf, len, &len );
256 if ( st != STATUS_SUCCESS || get_use_dns_option() )
258 char hbuf[256];
259 int hlen = sizeof (hbuf);
260 char *dot;
261 TRACE( "retrieving Unix host name\n" );
262 if ( gethostname ( hbuf, hlen ) )
264 strcpy ( hbuf, default_ComputerName );
265 WARN( "gethostname() error: %d, using host name %s\n", errno, hbuf );
267 hbuf[MAX_COMPUTERNAME_LENGTH] = 0;
268 dot = strchr ( hbuf, '.' );
269 if ( dot ) *dot = 0;
270 hlen = strlen ( hbuf );
271 len = MultiByteToWideChar( CP_UNIXCP, 0, hbuf, hlen + 1, computer_name, MAX_COMPUTERNAME_LENGTH + 1 )
272 * sizeof( WCHAR );
273 if ( NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, computer_name, len ) != STATUS_SUCCESS )
274 WARN ( "failed to set ComputerName\n" );
276 else
278 len = (len - offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
279 TRACE( "found in registry\n" );
282 NtClose( hsubkey );
283 TRACE(" ComputerName: %s (%u)\n", debugstr_w (computer_name), len);
285 RtlInitUnicodeString( &nameW, ActiveComputerNameW );
286 if ( ( st = NtCreateKey( &hsubkey, KEY_ALL_ACCESS, &attr, 0, NULL, REG_OPTION_VOLATILE, NULL ) )
287 != STATUS_SUCCESS )
288 goto out;
290 RtlInitUnicodeString( &nameW, ComputerNameW );
291 st = NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, computer_name, len );
293 out:
294 NtClose( hsubkey );
295 NtClose( hkey );
297 if ( st == STATUS_SUCCESS )
298 TRACE( "success\n" );
299 else
301 WARN( "status trying to set ComputerName: %x\n", st );
302 SetLastError ( RtlNtStatusToDosError ( st ) );
307 /***********************************************************************
308 * GetComputerNameW (KERNEL32.@)
310 BOOL WINAPI GetComputerNameW(LPWSTR name,LPDWORD size)
312 UNICODE_STRING nameW;
313 OBJECT_ATTRIBUTES attr;
314 HANDLE hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
315 char buf[offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ) + (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR )];
316 DWORD len = sizeof( buf );
317 LPWSTR theName = (LPWSTR) (buf + offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
318 NTSTATUS st = STATUS_INVALID_PARAMETER;
320 TRACE ("%p %p\n", name, size);
322 _init_attr ( &attr, &nameW );
323 RtlInitUnicodeString( &nameW, ComputerW );
324 if ( ( st = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
325 goto out;
327 attr.RootDirectory = hkey;
328 RtlInitUnicodeString( &nameW, ActiveComputerNameW );
329 if ( ( st = NtOpenKey( &hsubkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
330 goto out;
332 RtlInitUnicodeString( &nameW, ComputerNameW );
333 if ( ( st = NtQueryValueKey( hsubkey, &nameW, KeyValuePartialInformation, buf, len, &len ) )
334 != STATUS_SUCCESS )
335 goto out;
337 len = (len -offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data )) / sizeof (WCHAR) - 1;
338 TRACE ("ComputerName is %s (length %u)\n", debugstr_w ( theName ), len);
340 if ( *size < len + 1 )
342 *size = len + 1;
343 st = STATUS_MORE_ENTRIES;
345 else
347 memcpy ( name, theName, len * sizeof (WCHAR) );
348 name[len] = 0;
349 *size = len;
350 st = STATUS_SUCCESS;
353 out:
354 NtClose ( hsubkey );
355 NtClose ( hkey );
357 if ( st == STATUS_SUCCESS )
358 return TRUE;
359 else
361 SetLastError ( RtlNtStatusToDosError ( st ) );
362 WARN ( "Status %u reading computer name from registry\n", st );
363 return FALSE;
367 /***********************************************************************
368 * GetComputerNameA (KERNEL32.@)
370 BOOL WINAPI GetComputerNameA(LPSTR name, LPDWORD size)
372 WCHAR nameW[ MAX_COMPUTERNAME_LENGTH + 1 ];
373 DWORD sizeW = MAX_COMPUTERNAME_LENGTH + 1;
374 unsigned int len;
375 BOOL ret;
377 if ( !GetComputerNameW (nameW, &sizeW) ) return FALSE;
379 len = WideCharToMultiByte ( CP_ACP, 0, nameW, -1, NULL, 0, NULL, 0 );
380 /* for compatibility with Win9x */
381 __TRY
383 if ( *size < len )
385 *size = len;
386 SetLastError( ERROR_MORE_DATA );
387 ret = FALSE;
389 else
391 WideCharToMultiByte ( CP_ACP, 0, nameW, -1, name, len, NULL, 0 );
392 *size = len - 1;
393 ret = TRUE;
396 __EXCEPT_PAGE_FAULT
398 SetLastError( ERROR_INVALID_PARAMETER );
399 ret = FALSE;
401 __ENDTRY
403 return ret;
406 /***********************************************************************
407 * GetComputerNameExA (KERNEL32.@)
409 BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT type, LPSTR name, LPDWORD size)
411 char buf[256];
412 int len = sizeof(buf) - 1, ret;
413 TRACE("%d, %p, %p\n", type, name, size);
414 switch( type )
416 case ComputerNameNetBIOS:
417 case ComputerNamePhysicalNetBIOS:
418 return GetComputerNameA (name, size);
419 case ComputerNameDnsHostname:
420 case ComputerNamePhysicalDnsHostname:
421 ret = dns_hostname (buf, &len);
422 break;
423 case ComputerNameDnsDomain:
424 case ComputerNamePhysicalDnsDomain:
425 ret = dns_domainname (buf, &len);
426 break;
427 case ComputerNameDnsFullyQualified:
428 case ComputerNamePhysicalDnsFullyQualified:
429 ret = dns_fqdn (buf, &len);
430 break;
431 default:
432 SetLastError (ERROR_INVALID_PARAMETER);
433 return FALSE;
436 if ( ret )
438 TRACE ("-> %s (%d)\n", debugstr_a (buf), len);
439 if ( *size < len + 1 )
441 *size = len + 1;
442 SetLastError( ERROR_MORE_DATA );
443 ret = FALSE;
445 else
447 memcpy( name, buf, len );
448 name[len] = 0;
449 *size = len;
450 ret = TRUE;
454 return ret;
458 /***********************************************************************
459 * GetComputerNameExW (KERNEL32.@)
461 BOOL WINAPI GetComputerNameExW( COMPUTER_NAME_FORMAT type, LPWSTR name, LPDWORD size )
463 char buf[256];
464 int len = sizeof(buf) - 1, ret;
466 TRACE("%d, %p, %p\n", type, name, size);
467 switch( type )
469 case ComputerNameNetBIOS:
470 case ComputerNamePhysicalNetBIOS:
471 return GetComputerNameW (name, size);
472 case ComputerNameDnsHostname:
473 case ComputerNamePhysicalDnsHostname:
474 ret = dns_hostname (buf, &len);
475 break;
476 case ComputerNameDnsDomain:
477 case ComputerNamePhysicalDnsDomain:
478 ret = dns_domainname (buf, &len);
479 break;
480 case ComputerNameDnsFullyQualified:
481 case ComputerNamePhysicalDnsFullyQualified:
482 ret = dns_fqdn (buf, &len);
483 break;
484 default:
485 SetLastError (ERROR_INVALID_PARAMETER);
486 return FALSE;
489 if ( ret )
491 unsigned int lenW;
493 TRACE ("-> %s (%d)\n", debugstr_a (buf), len);
495 lenW = MultiByteToWideChar( CP_ACP, 0, buf, len, NULL, 0 );
496 if ( *size < lenW + 1 )
498 *size = lenW + 1;
499 SetLastError( ERROR_MORE_DATA );
500 ret = FALSE;
502 else
504 MultiByteToWideChar( CP_ACP, 0, buf, len, name, lenW );
505 name[lenW] = 0;
506 *size = lenW;
507 ret = TRUE;
511 return ret;
514 /******************************************************************************
515 * netbios_char (INTERNAL)
517 static WCHAR netbios_char ( WCHAR wc )
519 static const WCHAR special[] = {'!','@','#','$','%','^','&','\'',')','(','-','_','{','}','~'};
520 static const WCHAR deflt = '_';
521 unsigned int i;
523 if ( isalnumW ( wc ) ) return wc;
524 for ( i = 0; i < sizeof (special) / sizeof (WCHAR); i++ )
525 if ( wc == special[i] ) return wc;
526 return deflt;
529 /******************************************************************************
530 * SetComputerNameW [KERNEL32.@]
532 * Set a new NetBIOS name for the local computer.
534 * PARAMS
535 * lpComputerName [I] Address of new computer name
537 * RETURNS
538 * Success: TRUE
539 * Failure: FALSE
541 BOOL WINAPI SetComputerNameW( LPCWSTR lpComputerName )
543 UNICODE_STRING nameW;
544 OBJECT_ATTRIBUTES attr;
545 HANDLE hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
546 int plen = strlenW ( lpComputerName );
547 int i;
548 NTSTATUS st = STATUS_INTERNAL_ERROR;
550 if (get_use_dns_option())
552 /* This check isn't necessary, but may help debugging problems. */
553 WARN( "Disabled by Wine Configuration.\n" );
554 WARN( "Set \"UseDnsComputerName\" = \"N\" in category [Network] to enable.\n" );
555 SetLastError ( ERROR_ACCESS_DENIED );
556 return FALSE;
559 TRACE( "%s\n", debugstr_w (lpComputerName) );
561 /* Check parameter */
562 if ( plen > MAX_COMPUTERNAME_LENGTH )
563 goto out;
565 /* This is NT behaviour. Win 95/98 would coerce characters. */
566 for ( i = 0; i < plen; i++ )
568 WCHAR wc = lpComputerName[i];
569 if ( wc != netbios_char( wc ) )
570 goto out;
573 _init_attr ( &attr, &nameW );
575 RtlInitUnicodeString (&nameW, ComputerW);
576 if ( ( st = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
577 goto out;
578 attr.RootDirectory = hkey;
579 RtlInitUnicodeString( &nameW, ComputerNameW );
580 if ( ( st = NtOpenKey( &hsubkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
581 goto out;
582 if ( ( st = NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, lpComputerName, ( plen + 1) * sizeof(WCHAR) ) )
583 != STATUS_SUCCESS )
584 goto out;
586 out:
587 NtClose( hsubkey );
588 NtClose( hkey );
590 if ( st == STATUS_SUCCESS )
592 TRACE( "ComputerName changed\n" );
593 return TRUE;
596 else
598 SetLastError ( RtlNtStatusToDosError ( st ) );
599 WARN ( "status %u\n", st );
600 return FALSE;
604 /******************************************************************************
605 * SetComputerNameA [KERNEL32.@]
607 * See SetComputerNameW.
609 BOOL WINAPI SetComputerNameA( LPCSTR lpComputerName )
611 BOOL ret;
612 DWORD len = MultiByteToWideChar( CP_ACP, 0, lpComputerName, -1, NULL, 0 );
613 LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
615 MultiByteToWideChar( CP_ACP, 0, lpComputerName, -1, nameW, len );
616 ret = SetComputerNameW( nameW );
617 HeapFree( GetProcessHeap(), 0, nameW );
618 return ret;
621 /******************************************************************************
622 * SetComputerNameExW [KERNEL32.@]
625 BOOL WINAPI SetComputerNameExW( COMPUTER_NAME_FORMAT type, LPCWSTR lpComputerName )
627 TRACE("%d, %s\n", type, debugstr_w (lpComputerName));
628 switch( type )
630 case ComputerNameNetBIOS:
631 case ComputerNamePhysicalNetBIOS:
632 return SetComputerNameW( lpComputerName );
633 default:
634 SetLastError( ERROR_ACCESS_DENIED );
635 return FALSE;
639 /******************************************************************************
640 * SetComputerNameExA [KERNEL32.@]
643 BOOL WINAPI SetComputerNameExA( COMPUTER_NAME_FORMAT type, LPCSTR lpComputerName )
645 TRACE( "%d, %s\n", type, debugstr_a (lpComputerName) );
646 switch( type )
648 case ComputerNameNetBIOS:
649 case ComputerNamePhysicalNetBIOS:
650 return SetComputerNameA( lpComputerName );
651 default:
652 SetLastError( ERROR_ACCESS_DENIED );
653 return FALSE;
657 /***********************************************************************
658 * DnsHostnameToComputerNameA (KERNEL32.@)
660 BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR hostname,
661 LPSTR computername, LPDWORD size)
663 DWORD len;
665 FIXME("(%s, %p, %p): stub\n", debugstr_a(hostname), computername, size);
667 if (!hostname || !size) return FALSE;
668 len = lstrlenA(hostname);
670 if (len > MAX_COMPUTERNAME_LENGTH)
671 len = MAX_COMPUTERNAME_LENGTH;
673 if (*size < len)
675 *size = len;
676 return FALSE;
678 if (!computername) return FALSE;
680 memcpy( computername, hostname, len );
681 computername[len + 1] = 0;
682 return TRUE;
685 /***********************************************************************
686 * DnsHostnameToComputerNameW (KERNEL32.@)
688 BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR hostname,
689 LPWSTR computername, LPDWORD size)
691 DWORD len;
693 FIXME("(%s, %p, %p): stub\n", debugstr_w(hostname), computername, size);
695 if (!hostname || !size) return FALSE;
696 len = lstrlenW(hostname);
698 if (len > MAX_COMPUTERNAME_LENGTH)
699 len = MAX_COMPUTERNAME_LENGTH;
701 if (*size < len)
703 *size = len;
704 return FALSE;
706 if (!computername) return FALSE;
708 memcpy( computername, hostname, len * sizeof(WCHAR) );
709 computername[len + 1] = 0;
710 return TRUE;