dlls/kernel32/computername.c

   1 /*
   2  * Win32 kernel functions
   3  *
   4  * Copyright 1995 Martin von Loewis and Cameron Heide
   5  * Copyright 1999 Peter Ganten
   6  * Copyright 2002 Martin Wilck
   7  *
   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.
  12  *
  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.
  17  *
  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
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  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
  36
  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"
  47
  48 #include "kernel_private.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(computername);
  51
  52 /* Registry key and value names */
  53 static const WCHAR ComputerW[] = {'\\','R','e','g','i','s','t','r','y','\\',
  54                                   '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};
  61
  62 static const WCHAR default_ComputerName[] = {'W','I','N','E',0};
  63
  64 /***********************************************************************
  65  *                    dns_gethostbyname (INTERNAL)
  66  *
  67  *  From hostname(1):
  68  *  "The FQDN is the name gethostbyname(2) returns for the host name returned by gethostname(2)."
  69  *
  70  *  Wine can use this technique only if the thread-safe gethostbyname_r is available.
  71  */
  72 static void dns_gethostbyname ( char *name, int size )
  73 {
  74 #ifdef HAVE_LINUX_GETHOSTBYNAME_R_6
  75     struct hostent* host = NULL;
  76     char *extrabuf;
  77     int ebufsize = 1024;
  78     struct hostent hostentry;
  79     int locerr = ENOBUFS, res;
  80
  81     for (;;)
  82     {
  83         if (!(extrabuf = HeapAlloc( GetProcessHeap(), 0, ebufsize ))) return;
  84         res = gethostbyname_r ( name, &hostentry, extrabuf, ebufsize, &host, &locerr );
  85         if( res != ERANGE ) break;
  86         ebufsize *= 2;
  87         HeapFree( GetProcessHeap(), 0, extrabuf );
  88     }
  89
  90     if ( res )
  91         WARN ("Error in gethostbyname_r %d (%d)\n", res, locerr);
  92     else if ( !host )
  93         WARN ("gethostbyname_r returned NULL host, locerr = %d\n", locerr);
  94     else
  95         if (strlen( host->h_name ) < size) strcpy( name, host->h_name );
  96
  97     HeapFree( GetProcessHeap(), 0, extrabuf );
  98 #endif
  99 }
 100
 101 /***********************************************************************
 102  *                     dns_fqdn (INTERNAL)
 103  */
 104 static BOOL dns_fqdn ( char *name, int size )
 105 {
 106     if (gethostname( name, size ))
 107     {
 108         switch( errno )
 109         {
 110         case ENAMETOOLONG:
 111             SetLastError ( ERROR_MORE_DATA );
 112             break;
 113         default:
 114             SetLastError ( ERROR_INVALID_PARAMETER );
 115             break;
 116         }
 117         return FALSE;
 118     }
 119     dns_gethostbyname( name, size );
 120     return TRUE;
 121 }
 122
 123 /***********************************************************************
 124  *                      COMPUTERNAME_Init    (INTERNAL)
 125  */
 126 void COMPUTERNAME_Init (void)
 127 {
 128     HANDLE hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
 129     OBJECT_ATTRIBUTES attr;
 130     UNICODE_STRING nameW;
 131     char buf[offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ) + (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR )];
 132     DWORD len = sizeof( buf );
 133     const WCHAR *computer_name = (WCHAR *)(buf + offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
 134     NTSTATUS st = STATUS_INTERNAL_ERROR;
 135     char hbuf[256];
 136     WCHAR *dot, bufW[256];
 137
 138     if (dns_fqdn( hbuf, sizeof(hbuf) ))
 139     {
 140         MultiByteToWideChar( CP_UNIXCP, 0, hbuf, -1, bufW, ARRAY_SIZE(bufW) );
 141         dot = strchrW( bufW, '.' );
 142         if (dot) *dot++ = 0;
 143         else dot = bufW + strlenW(bufW);
 144         SetComputerNameExW( ComputerNamePhysicalDnsDomain, dot );
 145         SetComputerNameExW( ComputerNamePhysicalDnsHostname, bufW );
 146     }
 147
 148     TRACE("(void)\n");
 149     InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
 150     RtlInitUnicodeString( &nameW, ComputerW );
 151     if ( ( st = NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) ) != STATUS_SUCCESS )
 152         goto out;
 153
 154     attr.RootDirectory = hkey;
 155     RtlInitUnicodeString( &nameW, ComputerNameW );
 156     if ( (st = NtCreateKey( &hsubkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) ) != STATUS_SUCCESS )
 157         goto out;
 158
 159     st = NtQueryValueKey( hsubkey, &nameW, KeyValuePartialInformation, buf, len, &len );
 160
 161     if ( st != STATUS_SUCCESS)
 162     {
 163         computer_name = default_ComputerName;
 164         len = sizeof(default_ComputerName);
 165     }
 166     else
 167     {
 168         len = (len - offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
 169     }
 170
 171     NtClose( hsubkey );
 172     TRACE(" ComputerName: %s (%u)\n", debugstr_w (computer_name), len);
 173
 174     RtlInitUnicodeString( &nameW, ActiveComputerNameW );
 175     if ( ( st = NtCreateKey( &hsubkey, KEY_ALL_ACCESS, &attr, 0, NULL, REG_OPTION_VOLATILE, NULL ) )
 176          != STATUS_SUCCESS )
 177         goto out;
 178
 179     RtlInitUnicodeString( &nameW, ComputerNameW );
 180     st = NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, computer_name, len );
 181
 182 out:
 183     NtClose( hsubkey );
 184     NtClose( hkey );
 185
 186     if ( st == STATUS_SUCCESS )
 187         TRACE( "success\n" );
 188     else
 189     {
 190         WARN( "status trying to set ComputerName: %x\n", st );
 191         SetLastError ( RtlNtStatusToDosError ( st ) );
 192     }
 193 }
 194
 195
 196 /***********************************************************************
 197  *              GetComputerNameW         (KERNEL32.@)
 198  */
 199 BOOL WINAPI GetComputerNameW(LPWSTR name,LPDWORD size)
 200 {
 201     BOOL ret = GetComputerNameExW( ComputerNameNetBIOS, name, size );
 202     if (!ret && GetLastError() == ERROR_MORE_DATA) SetLastError( ERROR_BUFFER_OVERFLOW );
 203     return ret;
 204 }
 205
 206 /***********************************************************************
 207  *              GetComputerNameA         (KERNEL32.@)
 208  */
 209 BOOL WINAPI GetComputerNameA(LPSTR name, LPDWORD size)
 210 {
 211     WCHAR nameW[ MAX_COMPUTERNAME_LENGTH + 1 ];
 212     DWORD sizeW = MAX_COMPUTERNAME_LENGTH + 1;
 213     unsigned int len;
 214     BOOL ret;
 215
 216     if ( !GetComputerNameW (nameW, &sizeW) ) return FALSE;
 217
 218     len = WideCharToMultiByte ( CP_ACP, 0, nameW, -1, NULL, 0, NULL, 0 );
 219     /* for compatibility with Win9x */
 220     __TRY
 221     {
 222         if ( *size < len )
 223         {
 224             *size = len;
 225             SetLastError( ERROR_BUFFER_OVERFLOW );
 226             ret = FALSE;
 227         }
 228         else
 229         {
 230             WideCharToMultiByte ( CP_ACP, 0, nameW, -1, name, len, NULL, 0 );
 231             *size = len - 1;
 232             ret = TRUE;
 233         }
 234     }
 235     __EXCEPT_PAGE_FAULT
 236     {
 237         SetLastError( ERROR_INVALID_PARAMETER );
 238         ret = FALSE;
 239     }
 240     __ENDTRY
 241
 242     return ret;
 243 }
 244
 245 /***********************************************************************
 246  *              DnsHostnameToComputerNameA         (KERNEL32.@)
 247  */
 248 BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR hostname,
 249     LPSTR computername, LPDWORD size)
 250 {
 251     WCHAR *hostW, nameW[MAX_COMPUTERNAME_LENGTH + 1];
 252     DWORD len;
 253     BOOL ret;
 254
 255     if (!hostname || !size) return FALSE;
 256     len = MultiByteToWideChar( CP_ACP, 0, hostname, -1, NULL, 0 );
 257     if (!(hostW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
 258     MultiByteToWideChar( CP_ACP, 0, hostname, -1, hostW, len );
 259     len = ARRAY_SIZE(nameW);
 260     if ((ret = DnsHostnameToComputerNameW( hostW, nameW, &len )))
 261     {
 262         if (!computername || !WideCharToMultiByte( CP_ACP, 0, nameW, -1, computername, *size, NULL, NULL ))
 263             *size = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL );
 264         else
 265             *size = strlen(computername);
 266     }
 267     HeapFree( GetProcessHeap(), 0, hostW );
 268     return TRUE;
 269 }
 270
 271 /***********************************************************************
 272  *              DnsHostnameToComputerNameW         (KERNEL32.@)
 273  */
 274 BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR hostname,
 275     LPWSTR computername, LPDWORD size)
 276 {
 277     return DnsHostnameToComputerNameExW( hostname, computername, size );
 278 }