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" );
272 else if ( st
== STATUS_SUCCESS
)
274 len
= (len
- offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
));
275 TRACE( "found in registry\n" );
280 TRACE(" ComputerName: %s (%lu)\n", debugstr_w ( computer_name
), len
/ sizeof(WCHAR
));
282 RtlInitUnicodeString( &nameW
, ActiveComputerNameW
);
283 if ( ( st
= NtCreateKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
, 0, NULL
, REG_OPTION_VOLATILE
, NULL
) )
287 RtlInitUnicodeString( &nameW
, ComputerNameW
);
288 st
= NtSetValueKey( hsubkey
, &nameW
, 0, REG_SZ
, computer_name
, len
);
294 if ( st
== STATUS_SUCCESS
)
295 TRACE( "success\n" );
298 WARN( "status trying to set ComputerName: %lx\n", st
);
299 SetLastError ( RtlNtStatusToDosError ( st
) );
304 /***********************************************************************
305 * GetComputerNameW (KERNEL32.@)
307 BOOL WINAPI
GetComputerNameW(LPWSTR name
,LPDWORD size
)
309 UNICODE_STRING nameW
;
310 OBJECT_ATTRIBUTES attr
;
311 HANDLE hkey
= INVALID_HANDLE_VALUE
, hsubkey
= INVALID_HANDLE_VALUE
;
312 char buf
[offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
) + (MAX_COMPUTERNAME_LENGTH
+ 1) * sizeof( WCHAR
)];
313 DWORD len
= sizeof( buf
);
314 LPWSTR theName
= (LPWSTR
) (buf
+ offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
));
315 NTSTATUS st
= STATUS_INVALID_PARAMETER
;
317 TRACE ("%p %p\n", name
, size
);
319 _init_attr ( &attr
, &nameW
);
320 RtlInitUnicodeString( &nameW
, ComputerW
);
321 if ( ( st
= NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
324 attr
.RootDirectory
= hkey
;
325 RtlInitUnicodeString( &nameW
, ActiveComputerNameW
);
326 if ( ( st
= NtOpenKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
329 RtlInitUnicodeString( &nameW
, ComputerNameW
);
330 if ( ( st
= NtQueryValueKey( hsubkey
, &nameW
, KeyValuePartialInformation
, buf
, len
, &len
) )
334 len
= (len
-offsetof( KEY_VALUE_PARTIAL_INFORMATION
, Data
)) / sizeof (WCHAR
) - 1;
335 TRACE ("ComputerName is %s (length %lu)\n", debugstr_w ( theName
), len
);
341 memcpy ( name
, theName
, *size
* sizeof (WCHAR
) );
344 st
= STATUS_MORE_ENTRIES
;
348 memcpy ( name
, theName
, len
* sizeof (WCHAR
) );
356 st
= STATUS_INVALID_PARAMETER
;
364 if ( st
== STATUS_SUCCESS
)
368 SetLastError ( RtlNtStatusToDosError ( st
) );
369 WARN ( "Status %lu reading computer name from registry\n", st
);
374 /***********************************************************************
375 * GetComputerNameA (KERNEL32.@)
377 BOOL WINAPI
GetComputerNameA(LPSTR name
, LPDWORD size
)
379 WCHAR nameW
[ MAX_COMPUTERNAME_LENGTH
+ 1 ];
380 DWORD sizeW
= MAX_COMPUTERNAME_LENGTH
;
384 if ( !GetComputerNameW (nameW
, &sizeW
) ) return FALSE
;
386 len
= WideCharToMultiByte ( CP_ACP
, 0, nameW
, sizeW
, NULL
, 0, NULL
, 0 );
391 WideCharToMultiByte ( CP_ACP
, 0, nameW
, sizeW
, name
, *size
, NULL
, 0 );
394 SetLastError( ERROR_MORE_DATA
);
399 WideCharToMultiByte ( CP_ACP
, 0, nameW
, sizeW
, name
, len
, NULL
, 0 );
407 SetLastError( ERROR_INVALID_PARAMETER
);
415 /***********************************************************************
416 * GetComputerNameExA (KERNEL32.@)
418 BOOL WINAPI
GetComputerNameExA(COMPUTER_NAME_FORMAT type
, LPSTR name
, LPDWORD size
)
421 int len
= sizeof (buf
), ret
;
422 TRACE("%d, %p, %p\n", type
, name
, size
);
425 case ComputerNameNetBIOS
:
426 case ComputerNamePhysicalNetBIOS
:
427 return GetComputerNameA (name
, size
);
428 case ComputerNameDnsHostname
:
429 case ComputerNamePhysicalDnsHostname
:
430 ret
= dns_hostname (buf
, &len
);
432 case ComputerNameDnsDomain
:
433 case ComputerNamePhysicalDnsDomain
:
434 ret
= dns_domainname (buf
, &len
);
436 case ComputerNameDnsFullyQualified
:
437 case ComputerNamePhysicalDnsFullyQualified
:
438 ret
= dns_fqdn (buf
, &len
);
441 SetLastError (ERROR_INVALID_PARAMETER
);
447 TRACE ("-> %s (%d)\n", debugstr_a (buf
), len
);
452 memcpy( name
, buf
, *size
);
455 SetLastError( ERROR_MORE_DATA
);
460 memcpy( name
, buf
, len
);
468 SetLastError( ERROR_INVALID_PARAMETER
);
478 /***********************************************************************
479 * GetComputerNameExW (KERNEL32.@)
481 BOOL WINAPI
GetComputerNameExW( COMPUTER_NAME_FORMAT type
, LPWSTR name
, LPDWORD size
)
484 int len
= sizeof (buf
), ret
;
486 TRACE("%d, %p, %p\n", type
, name
, size
);
489 case ComputerNameNetBIOS
:
490 case ComputerNamePhysicalNetBIOS
:
491 return GetComputerNameW (name
, size
);
492 case ComputerNameDnsHostname
:
493 case ComputerNamePhysicalDnsHostname
:
494 ret
= dns_hostname (buf
, &len
);
496 case ComputerNameDnsDomain
:
497 case ComputerNamePhysicalDnsDomain
:
498 ret
= dns_domainname (buf
, &len
);
500 case ComputerNameDnsFullyQualified
:
501 case ComputerNamePhysicalDnsFullyQualified
:
502 ret
= dns_fqdn (buf
, &len
);
505 SetLastError (ERROR_INVALID_PARAMETER
);
511 TRACE ("-> %s (%d)\n", debugstr_a (buf
), len
);
514 unsigned int lenW
= MultiByteToWideChar( CP_ACP
, 0, buf
, len
, NULL
, 0 );
517 MultiByteToWideChar( CP_ACP
, 0, buf
, len
, name
, *size
);
520 SetLastError( ERROR_MORE_DATA
);
525 MultiByteToWideChar( CP_ACP
, 0, buf
, len
, name
, lenW
);
533 SetLastError( ERROR_INVALID_PARAMETER
);
542 /******************************************************************************
543 * netbios_char (INTERNAL)
545 static WCHAR
netbios_char ( WCHAR wc
)
547 static const WCHAR special
[] = {'!','@','#','$','%','^','&','\'',')','(','-','_','{','}','~'};
548 static const WCHAR deflt
= '_';
551 if ( isalnumW ( wc
) ) return wc
;
552 for ( i
= 0; i
< sizeof (special
) / sizeof (WCHAR
); i
++ )
553 if ( wc
== special
[i
] ) return wc
;
557 /******************************************************************************
558 * SetComputerNameW [KERNEL32.@]
560 * Set a new NetBIOS name for the local computer.
563 * lpComputerName [I] Address of new computer name
569 BOOL WINAPI
SetComputerNameW( LPCWSTR lpComputerName
)
571 UNICODE_STRING nameW
;
572 OBJECT_ATTRIBUTES attr
;
573 HANDLE hkey
= INVALID_HANDLE_VALUE
, hsubkey
= INVALID_HANDLE_VALUE
;
574 int plen
= strlenW ( lpComputerName
);
576 NTSTATUS st
= STATUS_INTERNAL_ERROR
;
578 if (get_use_dns_option())
580 /* This check isn't necessary, but may help debugging problems. */
581 WARN( "Disabled by Wine Configuration.\n" );
582 WARN( "Set \"UseDnsComputerName\" = \"N\" in category [Network] to enable.\n" );
583 SetLastError ( ERROR_ACCESS_DENIED
);
587 TRACE( "%s\n", debugstr_w (lpComputerName
) );
589 /* Check parameter */
590 if ( plen
> MAX_COMPUTERNAME_LENGTH
)
593 /* This is NT behaviour. Win 95/98 would coerce characters. */
594 for ( i
= 0; i
< plen
; i
++ )
596 WCHAR wc
= lpComputerName
[i
];
597 if ( wc
!= netbios_char( wc
) )
601 _init_attr ( &attr
, &nameW
);
603 RtlInitUnicodeString (&nameW
, ComputerW
);
604 if ( ( st
= NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
606 attr
.RootDirectory
= hkey
;
607 RtlInitUnicodeString( &nameW
, ComputerNameW
);
608 if ( ( st
= NtOpenKey( &hsubkey
, KEY_ALL_ACCESS
, &attr
) ) != STATUS_SUCCESS
)
610 if ( ( st
= NtSetValueKey( hsubkey
, &nameW
, 0, REG_SZ
, lpComputerName
, ( plen
+ 1) * sizeof(WCHAR
) ) )
618 if ( st
== STATUS_SUCCESS
)
620 TRACE( "ComputerName changed\n" );
626 SetLastError ( RtlNtStatusToDosError ( st
) );
627 WARN ( "status %lu\n", st
);
632 /******************************************************************************
633 * SetComputerNameA [KERNEL32.@]
635 * See SetComputerNameW.
637 BOOL WINAPI
SetComputerNameA( LPCSTR lpComputerName
)
640 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, lpComputerName
, -1, NULL
, 0 );
641 LPWSTR nameW
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
643 MultiByteToWideChar( CP_ACP
, 0, lpComputerName
, -1, nameW
, len
);
644 ret
= SetComputerNameW( nameW
);
645 HeapFree( GetProcessHeap(), 0, nameW
);
649 /******************************************************************************
650 * SetComputerNameExW [KERNEL32.@]
653 BOOL WINAPI
SetComputerNameExW( COMPUTER_NAME_FORMAT type
, LPCWSTR lpComputerName
)
655 TRACE("%d, %s\n", type
, debugstr_w (lpComputerName
));
658 case ComputerNameNetBIOS
:
659 case ComputerNamePhysicalNetBIOS
:
660 return SetComputerNameW( lpComputerName
);
662 SetLastError( ERROR_ACCESS_DENIED
);
667 /******************************************************************************
668 * SetComputerNameExA [KERNEL32.@]
671 BOOL WINAPI
SetComputerNameExA( COMPUTER_NAME_FORMAT type
, LPCSTR lpComputerName
)
673 TRACE( "%d, %s\n", type
, debugstr_a (lpComputerName
) );
676 case ComputerNameNetBIOS
:
677 case ComputerNamePhysicalNetBIOS
:
678 return SetComputerNameA( lpComputerName
);
680 SetLastError( ERROR_ACCESS_DENIED
);
685 /***********************************************************************
686 * DnsHostnameToComputerNameA (KERNEL32.@)
688 BOOL WINAPI
DnsHostnameToComputerNameA(LPCSTR hostname
,
689 LPSTR computername
, LPDWORD size
)
693 FIXME("(%s, %p, %p): stub\n", debugstr_a(hostname
), computername
, size
);
695 if (!hostname
|| !size
) return FALSE
;
696 len
= lstrlenA(hostname
);
698 if (len
> MAX_COMPUTERNAME_LENGTH
)
699 len
= MAX_COMPUTERNAME_LENGTH
;
706 if (!computername
) return FALSE
;
708 memcpy( computername
, hostname
, len
);
709 computername
[len
+ 1] = 0;
713 /***********************************************************************
714 * DnsHostnameToComputerNameW (KERNEL32.@)
716 BOOL WINAPI
DnsHostnameToComputerNameW(LPCWSTR hostname
,
717 LPWSTR computername
, LPDWORD size
)
721 FIXME("(%s, %p, %p): stub\n", debugstr_w(hostname
), computername
, size
);
723 if (!hostname
|| !size
) return FALSE
;
724 len
= lstrlenW(hostname
);
726 if (len
> MAX_COMPUTERNAME_LENGTH
)
727 len
= MAX_COMPUTERNAME_LENGTH
;
734 if (!computername
) return FALSE
;
736 memcpy( computername
, hostname
, len
* sizeof(WCHAR
) );
737 computername
[len
+ 1] = 0;