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
24 #include "wine/port.h"
38 #define WIN32_NO_STATUS
44 #include "wine/unicode.h"
45 #include "wine/exception.h"
47 #include "wine/debug.h"
49 #include "kernel_private.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(computername
);
53 /* Registry key and value names */
54 static const WCHAR ComputerW
[] = {'M','a','c','h','i','n','e','\\',
55 'S','y','s','t','e','m','\\',
56 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
57 'C','o','n','t','r','o','l','\\',
58 'C','o','m','p','u','t','e','r','N','a','m','e',0};
59 static const WCHAR ActiveComputerNameW
[] = {'A','c','t','i','v','e','C','o','m','p','u','t','e','r','N','a','m','e',0};
60 static const WCHAR ComputerNameW
[] = {'C','o','m','p','u','t','e','r','N','a','m','e',0};
62 static const char default_ComputerName
[] = "WINE";
64 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
66 /***********************************************************************
67 * dns_gethostbyname (INTERNAL)
70 * "The FQDN is the name gethostbyname(2) returns for the host name returned by gethostname(2)."
72 * Wine can use this technique only if the thread-safe gethostbyname_r is available.
74 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
75 static BOOL
dns_gethostbyname ( char *name
, int *size
)
77 struct hostent
* host
= NULL
;
80 struct hostent hostentry
;
81 int locerr
= ENOBUFS
, res
= ENOMEM
;
83 extrabuf
= HeapAlloc( GetProcessHeap(), 0, ebufsize
) ;
87 res
= gethostbyname_r ( name
, &hostentry
, extrabuf
, ebufsize
, &host
, &locerr
);
88 if( res
!= ERANGE
) break;
90 extrabuf
= HeapReAlloc( GetProcessHeap(), 0, extrabuf
, ebufsize
) ;
94 WARN ("Error in gethostbyname_r %d (%d)\n", res
, locerr
);
97 int len
= strlen ( host
->h_name
);
100 strcpy ( name
, host
->h_name
);
105 memcpy ( name
, host
->h_name
, *size
);
107 SetLastError ( ERROR_MORE_DATA
);
112 HeapFree( GetProcessHeap(), 0, extrabuf
);
116 # define dns_gethostbyname(name,size) 0
119 /***********************************************************************
120 * dns_fqdn (INTERNAL)
122 static BOOL
dns_fqdn ( char *name
, int *size
)
124 if ( gethostname ( name
, *size
+ 1 ) )
129 SetLastError ( ERROR_MORE_DATA
);
131 SetLastError ( ERROR_INVALID_PARAMETER
);
136 if ( !dns_gethostbyname ( name
, size
) )
137 *size
= strlen ( name
);
142 /***********************************************************************
143 * dns_hostname (INTERNAL)
145 static BOOL
dns_hostname ( char *name
, int *size
)
148 if ( ! dns_fqdn ( name
, size
) ) return FALSE
;
149 c
= strchr ( name
, '.' );
158 /***********************************************************************
159 * dns_domainname (INTERNAL)
161 static BOOL
dns_domainname ( char *name
, int *size
)
164 if ( ! dns_fqdn ( name
, size
) ) return FALSE
;
165 c
= strchr ( name
, '.' );
170 memmove ( name
, c
, *size
+ 1 );
175 /***********************************************************************
176 * _init_attr (INTERNAL)
178 inline static void _init_attr ( OBJECT_ATTRIBUTES
*attr
, UNICODE_STRING
*name
)
180 attr
->Length
= sizeof (OBJECT_ATTRIBUTES
);
181 attr
->RootDirectory
= 0;
182 attr
->ObjectName
= name
;
183 attr
->Attributes
= 0;
184 attr
->SecurityDescriptor
= NULL
;
185 attr
->SecurityQualityOfService
= NULL
;
188 /***********************************************************************
191 static BOOL
get_use_dns_option(void)
193 static const WCHAR NetworkW
[] = {'S','o','f','t','w','a','r','e','\\',
194 'W','i','n','e','\\','N','e','t','w','o','r','k',0};
195 static const WCHAR UseDNSW
[] = {'U','s','e','D','n','s','C','o','m','p','u','t','e','r','N','a','m','e',0};
200 OBJECT_ATTRIBUTES attr
;
201 UNICODE_STRING nameW
;
204 _init_attr( &attr
, &nameW
);
205 RtlOpenCurrentUser( KEY_ALL_ACCESS
, &root
);
206 attr
.RootDirectory
= root
;
207 RtlInitUnicodeString( &nameW
, NetworkW
);
209 /* @@ Wine registry key: HKCU\Software\Wine\Network */
210 if (!NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
))
212 RtlInitUnicodeString( &nameW
, UseDNSW
);
213 if (!NtQueryValueKey( hkey
, &nameW
, KeyValuePartialInformation
, tmp
, sizeof(tmp
), &dummy
))
215 WCHAR
*str
= (WCHAR
*)((KEY_VALUE_PARTIAL_INFORMATION
*)tmp
)->Data
;
216 ret
= IS_OPTION_TRUE( str
[0] );
225 /***********************************************************************
226 * COMPUTERNAME_Init (INTERNAL)
228 void COMPUTERNAME_Init (void)
230 HANDLE hkey
= INVALID_HANDLE_VALUE
, hsubkey
= INVALID_HANDLE_VALUE
;
231 OBJECT_ATTRIBUTES attr
;
232 UNICODE_STRING nameW
;
233 char buf
[offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
) + (MAX_COMPUTERNAME_LENGTH
+ 1) * sizeof( WCHAR
)];
234 DWORD len
= sizeof( buf
);
235 LPWSTR computer_name
= (LPWSTR
) (buf
+ offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
));
236 NTSTATUS st
= STATUS_INTERNAL_ERROR
;
239 _init_attr ( &attr
, &nameW
);
241 RtlInitUnicodeString( &nameW
, ComputerW
);
242 if ( ( st
= NtCreateKey( &hkey
, KEY_ALL_ACCESS
, &attr
, 0, NULL
, 0, NULL
) ) != STATUS_SUCCESS
)
245 attr
.RootDirectory
= hkey
;
246 RtlInitUnicodeString( &nameW
, ComputerNameW
);
247 if ( (st
= NtCreateKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
, 0, NULL
, 0, NULL
) ) != STATUS_SUCCESS
)
250 st
= NtQueryValueKey( hsubkey
, &nameW
, KeyValuePartialInformation
, buf
, len
, &len
);
252 if ( st
!= STATUS_SUCCESS
|| get_use_dns_option() )
255 int hlen
= sizeof (hbuf
);
257 TRACE( "retrieving Unix host name\n" );
258 if ( gethostname ( hbuf
, hlen
) )
260 strcpy ( hbuf
, default_ComputerName
);
261 WARN( "gethostname() error: %d, using host name %s\n", errno
, hbuf
);
263 hbuf
[MAX_COMPUTERNAME_LENGTH
] = 0;
264 dot
= strchr ( hbuf
, '.' );
266 hlen
= strlen ( hbuf
);
267 len
= MultiByteToWideChar( CP_ACP
, 0, hbuf
, hlen
+ 1, computer_name
, MAX_COMPUTERNAME_LENGTH
+ 1 )
269 if ( NtSetValueKey( hsubkey
, &nameW
, 0, REG_SZ
, computer_name
, len
) != STATUS_SUCCESS
)
270 WARN ( "failed to set ComputerName\n" );
274 len
= (len
- offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
));
275 TRACE( "found in registry\n" );
279 TRACE(" ComputerName: %s (%u)\n", debugstr_w (computer_name
), len
);
281 RtlInitUnicodeString( &nameW
, ActiveComputerNameW
);
282 if ( ( st
= NtCreateKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
, 0, NULL
, REG_OPTION_VOLATILE
, NULL
) )
286 RtlInitUnicodeString( &nameW
, ComputerNameW
);
287 st
= NtSetValueKey( hsubkey
, &nameW
, 0, REG_SZ
, computer_name
, len
);
293 if ( st
== STATUS_SUCCESS
)
294 TRACE( "success\n" );
297 WARN( "status trying to set ComputerName: %x\n", st
);
298 SetLastError ( RtlNtStatusToDosError ( st
) );
303 /***********************************************************************
304 * GetComputerNameW (KERNEL32.@)
306 BOOL WINAPI
GetComputerNameW(LPWSTR name
,LPDWORD size
)
308 UNICODE_STRING nameW
;
309 OBJECT_ATTRIBUTES attr
;
310 HANDLE hkey
= INVALID_HANDLE_VALUE
, hsubkey
= INVALID_HANDLE_VALUE
;
311 char buf
[offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
) + (MAX_COMPUTERNAME_LENGTH
+ 1) * sizeof( WCHAR
)];
312 DWORD len
= sizeof( buf
);
313 LPWSTR theName
= (LPWSTR
) (buf
+ offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
));
314 NTSTATUS st
= STATUS_INVALID_PARAMETER
;
316 TRACE ("%p %p\n", name
, size
);
318 _init_attr ( &attr
, &nameW
);
319 RtlInitUnicodeString( &nameW
, ComputerW
);
320 if ( ( st
= NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
323 attr
.RootDirectory
= hkey
;
324 RtlInitUnicodeString( &nameW
, ActiveComputerNameW
);
325 if ( ( st
= NtOpenKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
328 RtlInitUnicodeString( &nameW
, ComputerNameW
);
329 if ( ( st
= NtQueryValueKey( hsubkey
, &nameW
, KeyValuePartialInformation
, buf
, len
, &len
) )
333 len
= (len
-offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
)) / sizeof (WCHAR
) - 1;
334 TRACE ("ComputerName is %s (length %u)\n", debugstr_w ( theName
), len
);
340 memcpy ( name
, theName
, *size
* sizeof (WCHAR
) );
343 st
= STATUS_MORE_ENTRIES
;
347 memcpy ( name
, theName
, len
* sizeof (WCHAR
) );
355 st
= STATUS_INVALID_PARAMETER
;
363 if ( st
== STATUS_SUCCESS
)
367 SetLastError ( RtlNtStatusToDosError ( st
) );
368 WARN ( "Status %u reading computer name from registry\n", st
);
373 /***********************************************************************
374 * GetComputerNameA (KERNEL32.@)
376 BOOL WINAPI
GetComputerNameA(LPSTR name
, LPDWORD size
)
378 WCHAR nameW
[ MAX_COMPUTERNAME_LENGTH
+ 1 ];
379 DWORD sizeW
= MAX_COMPUTERNAME_LENGTH
;
383 if ( !GetComputerNameW (nameW
, &sizeW
) ) return FALSE
;
385 len
= WideCharToMultiByte ( CP_ACP
, 0, nameW
, sizeW
, NULL
, 0, NULL
, 0 );
390 WideCharToMultiByte ( CP_ACP
, 0, nameW
, sizeW
, name
, *size
, NULL
, 0 );
393 SetLastError( ERROR_MORE_DATA
);
398 WideCharToMultiByte ( CP_ACP
, 0, nameW
, sizeW
, name
, len
, NULL
, 0 );
406 SetLastError( ERROR_INVALID_PARAMETER
);
414 /***********************************************************************
415 * GetComputerNameExA (KERNEL32.@)
417 BOOL WINAPI
GetComputerNameExA(COMPUTER_NAME_FORMAT type
, LPSTR name
, LPDWORD size
)
420 int len
= sizeof (buf
), ret
;
421 TRACE("%d, %p, %p\n", type
, name
, size
);
424 case ComputerNameNetBIOS
:
425 case ComputerNamePhysicalNetBIOS
:
426 return GetComputerNameA (name
, size
);
427 case ComputerNameDnsHostname
:
428 case ComputerNamePhysicalDnsHostname
:
429 ret
= dns_hostname (buf
, &len
);
431 case ComputerNameDnsDomain
:
432 case ComputerNamePhysicalDnsDomain
:
433 ret
= dns_domainname (buf
, &len
);
435 case ComputerNameDnsFullyQualified
:
436 case ComputerNamePhysicalDnsFullyQualified
:
437 ret
= dns_fqdn (buf
, &len
);
440 SetLastError (ERROR_INVALID_PARAMETER
);
446 TRACE ("-> %s (%d)\n", debugstr_a (buf
), len
);
451 memcpy( name
, buf
, *size
);
454 SetLastError( ERROR_MORE_DATA
);
459 memcpy( name
, buf
, len
);
467 SetLastError( ERROR_INVALID_PARAMETER
);
477 /***********************************************************************
478 * GetComputerNameExW (KERNEL32.@)
480 BOOL WINAPI
GetComputerNameExW( COMPUTER_NAME_FORMAT type
, LPWSTR name
, LPDWORD size
)
483 int len
= sizeof (buf
), ret
;
485 TRACE("%d, %p, %p\n", type
, name
, size
);
488 case ComputerNameNetBIOS
:
489 case ComputerNamePhysicalNetBIOS
:
490 return GetComputerNameW (name
, size
);
491 case ComputerNameDnsHostname
:
492 case ComputerNamePhysicalDnsHostname
:
493 ret
= dns_hostname (buf
, &len
);
495 case ComputerNameDnsDomain
:
496 case ComputerNamePhysicalDnsDomain
:
497 ret
= dns_domainname (buf
, &len
);
499 case ComputerNameDnsFullyQualified
:
500 case ComputerNamePhysicalDnsFullyQualified
:
501 ret
= dns_fqdn (buf
, &len
);
504 SetLastError (ERROR_INVALID_PARAMETER
);
510 TRACE ("-> %s (%d)\n", debugstr_a (buf
), len
);
513 unsigned int lenW
= MultiByteToWideChar( CP_ACP
, 0, buf
, len
, NULL
, 0 );
516 MultiByteToWideChar( CP_ACP
, 0, buf
, len
, name
, *size
);
519 SetLastError( ERROR_MORE_DATA
);
524 MultiByteToWideChar( CP_ACP
, 0, buf
, len
, name
, lenW
);
532 SetLastError( ERROR_INVALID_PARAMETER
);
541 /******************************************************************************
542 * netbios_char (INTERNAL)
544 static WCHAR
netbios_char ( WCHAR wc
)
546 static const WCHAR special
[] = {'!','@','#','$','%','^','&','\'',')','(','-','_','{','}','~'};
547 static const WCHAR deflt
= '_';
550 if ( isalnumW ( wc
) ) return wc
;
551 for ( i
= 0; i
< sizeof (special
) / sizeof (WCHAR
); i
++ )
552 if ( wc
== special
[i
] ) return wc
;
556 /******************************************************************************
557 * SetComputerNameW [KERNEL32.@]
559 * Set a new NetBIOS name for the local computer.
562 * lpComputerName [I] Address of new computer name
568 BOOL WINAPI
SetComputerNameW( LPCWSTR lpComputerName
)
570 UNICODE_STRING nameW
;
571 OBJECT_ATTRIBUTES attr
;
572 HANDLE hkey
= INVALID_HANDLE_VALUE
, hsubkey
= INVALID_HANDLE_VALUE
;
573 int plen
= strlenW ( lpComputerName
);
575 NTSTATUS st
= STATUS_INTERNAL_ERROR
;
577 if (get_use_dns_option())
579 /* This check isn't necessary, but may help debugging problems. */
580 WARN( "Disabled by Wine Configuration.\n" );
581 WARN( "Set \"UseDnsComputerName\" = \"N\" in category [Network] to enable.\n" );
582 SetLastError ( ERROR_ACCESS_DENIED
);
586 TRACE( "%s\n", debugstr_w (lpComputerName
) );
588 /* Check parameter */
589 if ( plen
> MAX_COMPUTERNAME_LENGTH
)
592 /* This is NT behaviour. Win 95/98 would coerce characters. */
593 for ( i
= 0; i
< plen
; i
++ )
595 WCHAR wc
= lpComputerName
[i
];
596 if ( wc
!= netbios_char( wc
) )
600 _init_attr ( &attr
, &nameW
);
602 RtlInitUnicodeString (&nameW
, ComputerW
);
603 if ( ( st
= NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
605 attr
.RootDirectory
= hkey
;
606 RtlInitUnicodeString( &nameW
, ComputerNameW
);
607 if ( ( st
= NtOpenKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
609 if ( ( st
= NtSetValueKey( hsubkey
, &nameW
, 0, REG_SZ
, lpComputerName
, ( plen
+ 1) * sizeof(WCHAR
) ) )
617 if ( st
== STATUS_SUCCESS
)
619 TRACE( "ComputerName changed\n" );
625 SetLastError ( RtlNtStatusToDosError ( st
) );
626 WARN ( "status %u\n", st
);
631 /******************************************************************************
632 * SetComputerNameA [KERNEL32.@]
634 * See SetComputerNameW.
636 BOOL WINAPI
SetComputerNameA( LPCSTR lpComputerName
)
639 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, lpComputerName
, -1, NULL
, 0 );
640 LPWSTR nameW
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
642 MultiByteToWideChar( CP_ACP
, 0, lpComputerName
, -1, nameW
, len
);
643 ret
= SetComputerNameW( nameW
);
644 HeapFree( GetProcessHeap(), 0, nameW
);
648 /******************************************************************************
649 * SetComputerNameExW [KERNEL32.@]
652 BOOL WINAPI
SetComputerNameExW( COMPUTER_NAME_FORMAT type
, LPCWSTR lpComputerName
)
654 TRACE("%d, %s\n", type
, debugstr_w (lpComputerName
));
657 case ComputerNameNetBIOS
:
658 case ComputerNamePhysicalNetBIOS
:
659 return SetComputerNameW( lpComputerName
);
661 SetLastError( ERROR_ACCESS_DENIED
);
666 /******************************************************************************
667 * SetComputerNameExA [KERNEL32.@]
670 BOOL WINAPI
SetComputerNameExA( COMPUTER_NAME_FORMAT type
, LPCSTR lpComputerName
)
672 TRACE( "%d, %s\n", type
, debugstr_a (lpComputerName
) );
675 case ComputerNameNetBIOS
:
676 case ComputerNamePhysicalNetBIOS
:
677 return SetComputerNameA( lpComputerName
);
679 SetLastError( ERROR_ACCESS_DENIED
);
684 /***********************************************************************
685 * DnsHostnameToComputerNameA (KERNEL32.@)
687 BOOL WINAPI
DnsHostnameToComputerNameA(LPCSTR hostname
,
688 LPSTR computername
, LPDWORD size
)
692 FIXME("(%s, %p, %p): stub\n", debugstr_a(hostname
), computername
, size
);
694 if (!hostname
|| !size
) return FALSE
;
695 len
= lstrlenA(hostname
);
697 if (len
> MAX_COMPUTERNAME_LENGTH
)
698 len
= MAX_COMPUTERNAME_LENGTH
;
705 if (!computername
) return FALSE
;
707 memcpy( computername
, hostname
, len
);
708 computername
[len
+ 1] = 0;
712 /***********************************************************************
713 * DnsHostnameToComputerNameW (KERNEL32.@)
715 BOOL WINAPI
DnsHostnameToComputerNameW(LPCWSTR hostname
,
716 LPWSTR computername
, LPDWORD size
)
720 FIXME("(%s, %p, %p): stub\n", debugstr_w(hostname
), computername
, size
);
722 if (!hostname
|| !size
) return FALSE
;
723 len
= lstrlenW(hostname
);
725 if (len
> MAX_COMPUTERNAME_LENGTH
)
726 len
= MAX_COMPUTERNAME_LENGTH
;
733 if (!computername
) return FALSE
;
735 memcpy( computername
, hostname
, len
* sizeof(WCHAR
) );
736 computername
[len
+ 1] = 0;