git.oblomov.eu Git - wine/blob - dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <string.h>
  27 #ifdef HAVE_UNISTD_H
  28 # include <unistd.h>
  29 #endif
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #ifdef HAVE_NETDB_H
  33 #include <netdb.h>
  34 #endif
  35
  36 #include "ntstatus.h"
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winerror.h"
  40 #include "winnls.h"
  41 #include "winreg.h"
  42 #include "winternl.h"
  43 #include "wine/unicode.h"
  44 #include "wine/exception.h"
  45 #include "excpt.h"
  46 #include "wine/debug.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(computername);
  49
  50 /* Registry key and value names */
  51 static const WCHAR ComputerW[] = {'M','a','c','h','i','n','e','\\',
  52                                   'S','y','s','t','e','m','\\',
  53                                   'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  54                                   'C','o','n','t','r','o','l','\\',
  55                                   'C','o','m','p','u','t','e','r','N','a','m','e',0};
  56 static const WCHAR ActiveComputerNameW[] =   {'A','c','t','i','v','e','C','o','m','p','u','t','e','r','N','a','m','e',0};
  57 static const WCHAR ComputerNameW[] = {'C','o','m','p','u','t','e','r','N','a','m','e',0};
  58
  59 static const char default_ComputerName[] = "WINE";
  60
  61 #define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
  62
  63 /* filter for page-fault exceptions */
  64 static WINE_EXCEPTION_FILTER(page_fault)
  65 {
  66     if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
  67         return EXCEPTION_EXECUTE_HANDLER;
  68     return EXCEPTION_CONTINUE_SEARCH;
  69 }
  70
  71 /***********************************************************************
  72  *                    dns_gethostbyname (INTERNAL)
  73  *
  74  *  From hostname(1):
  75  *  "The FQDN is the name gethostbyname(2) returns for the host name returned by gethostname(2)."
  76  *
  77  *  Wine can use this technique only if the thread-safe gethostbyname_r is available.
  78  */
  79 #ifdef  HAVE_LINUX_GETHOSTBYNAME_R_6
  80 static BOOL dns_gethostbyname ( char *name, int *size )
  81 {
  82     struct hostent* host = NULL;
  83     char *extrabuf;
  84     int ebufsize = 1024;
  85     struct hostent hostentry;
  86     int locerr = ENOBUFS, res = ENOMEM;
  87
  88     extrabuf = HeapAlloc( GetProcessHeap(), 0, ebufsize ) ;
  89
  90     while( extrabuf )
  91     {
  92         res = gethostbyname_r ( name, &hostentry, extrabuf, ebufsize, &host, &locerr );
  93         if( res != ERANGE ) break;
  94         ebufsize *= 2;
  95         extrabuf = HeapReAlloc( GetProcessHeap(), 0, extrabuf, ebufsize ) ;
  96     }
  97
  98     if ( res )
  99         WARN ("Error in gethostbyname_r %d (%d)\n", res, locerr);
 100     else
 101     {
 102         size_t len = strlen ( host->h_name );
 103         if ( len < *size )
 104         {
 105             strcpy ( name, host->h_name );
 106             *size = len;
 107         }
 108         else
 109         {
 110             memcpy ( name, host->h_name, *size );
 111             name[*size] = 0;
 112             SetLastError ( ERROR_MORE_DATA );
 113             res = 1;
 114         }
 115     }
 116
 117     HeapFree( GetProcessHeap(), 0, extrabuf );
 118     return !res;
 119 }
 120 #else
 121 #  define dns_gethostbyname(name,size) 0
 122 #endif
 123
 124 /***********************************************************************
 125  *                     dns_fqdn (INTERNAL)
 126  */
 127 static BOOL dns_fqdn ( char *name, int *size )
 128 {
 129     if ( gethostname ( name, *size + 1 ) )
 130     {
 131         switch( errno )
 132         {
 133         case ENAMETOOLONG:
 134             SetLastError ( ERROR_MORE_DATA );
 135         default:
 136             SetLastError ( ERROR_INVALID_PARAMETER );
 137         }
 138         return FALSE;
 139     }
 140
 141     if ( !dns_gethostbyname ( name, size ) )
 142         *size = strlen ( name );
 143
 144     return TRUE;
 145 }
 146
 147 /***********************************************************************
 148  *                     dns_hostname (INTERNAL)
 149  */
 150 static BOOL dns_hostname ( char *name, int *size )
 151 {
 152     char *c;
 153     if ( ! dns_fqdn ( name, size ) ) return FALSE;
 154     c = strchr ( name, '.' );
 155     if (c)
 156     {
 157         *c = 0;
 158         *size = (c - name);
 159     }
 160     return TRUE;
 161 }
 162
 163 /***********************************************************************
 164  *                     dns_domainname (INTERNAL)
 165  */
 166 static BOOL dns_domainname ( char *name, int *size )
 167 {
 168     char *c;
 169     if ( ! dns_fqdn ( name, size ) ) return FALSE;
 170     c = strchr ( name, '.' );
 171     if (c)
 172     {
 173         c += 1;
 174         *size -= (c - name);
 175         memmove ( name, c, *size + 1 );
 176     }
 177     return TRUE;
 178 }
 179
 180 /***********************************************************************
 181  *                      _init_attr    (INTERNAL)
 182  */
 183 inline static void _init_attr ( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *name )
 184 {
 185     attr->Length = sizeof (OBJECT_ATTRIBUTES);
 186     attr->RootDirectory = 0;
 187     attr->ObjectName = name;
 188     attr->Attributes = 0;
 189     attr->SecurityDescriptor = NULL;
 190     attr->SecurityQualityOfService = NULL;
 191 }
 192
 193 /***********************************************************************
 194  *           get_use_dns_option
 195  */
 196 static BOOL get_use_dns_option(void)
 197 {
 198     static const WCHAR NetworkW[] = {'M','a','c','h','i','n','e','\\',
 199                                   'S','o','f','t','w','a','r','e','\\',
 200                                   'W','i','n','e','\\','W','i','n','e','\\',
 201                                   'C','o','n','f','i','g','\\','N','e','t','w','o','r','k',0};
 202     static const WCHAR UseDNSW[] = {'U','s','e','D','n','s','C','o','m','p','u','t','e','r','N','a','m','e',0};
 203
 204     char tmp[80];
 205     HKEY hkey;
 206     DWORD dummy;
 207     OBJECT_ATTRIBUTES attr;
 208     UNICODE_STRING nameW;
 209     BOOL ret = TRUE;
 210
 211     _init_attr( &attr, &nameW );
 212     RtlInitUnicodeString( &nameW, NetworkW );
 213
 214     if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
 215     {
 216         RtlInitUnicodeString( &nameW, UseDNSW );
 217         if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
 218         {
 219             WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
 220             ret = IS_OPTION_TRUE( str[0] );
 221         }
 222         NtClose( hkey );
 223     }
 224     return ret;
 225 }
 226
 227
 228 /***********************************************************************
 229  *                      COMPUTERNAME_Init    (INTERNAL)
 230  */
 231 void COMPUTERNAME_Init (void)
 232 {
 233     HKEY hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
 234     OBJECT_ATTRIBUTES attr;
 235     UNICODE_STRING nameW;
 236     char buf[offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ) + (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR )];
 237     DWORD len = sizeof( buf );
 238     LPWSTR computer_name = (LPWSTR) (buf + offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
 239     NTSTATUS st = STATUS_INTERNAL_ERROR;
 240
 241     TRACE("(void)\n");
 242     _init_attr ( &attr, &nameW );
 243
 244     RtlInitUnicodeString( &nameW, ComputerW );
 245     if ( ( st = NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) ) != STATUS_SUCCESS )
 246         goto out;
 247
 248     attr.RootDirectory = hkey;
 249     RtlInitUnicodeString( &nameW, ComputerNameW );
 250     if ( (st = NtCreateKey( &hsubkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) ) != STATUS_SUCCESS )
 251         goto out;
 252
 253     st = NtQueryValueKey( hsubkey, &nameW, KeyValuePartialInformation, buf, len, &len );
 254
 255     if ( st == STATUS_OBJECT_NAME_NOT_FOUND || ( st == STATUS_SUCCESS && get_use_dns_option()))
 256     {
 257         char hbuf[256];
 258         int hlen = sizeof (hbuf);
 259         char *dot;
 260         TRACE( "retrieving Unix host name\n" );
 261         if ( gethostname ( hbuf, hlen ) )
 262         {
 263             strcpy ( hbuf, default_ComputerName );
 264             WARN( "gethostname() error: %d, using host name %s\n", errno, hbuf );
 265         }
 266         hbuf[MAX_COMPUTERNAME_LENGTH] = 0;
 267         dot = strchr ( hbuf, '.' );
 268         if ( dot ) *dot = 0;
 269         hlen = strlen ( hbuf );
 270         len = MultiByteToWideChar( CP_ACP, 0, hbuf, hlen + 1, computer_name, MAX_COMPUTERNAME_LENGTH + 1 )
 271             * sizeof( WCHAR );
 272         if ( NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, computer_name, len ) != STATUS_SUCCESS )
 273             WARN ( "failed to set ComputerName" );
 274     }
 275     else if ( st == STATUS_SUCCESS)
 276     {
 277         len = (len - offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
 278         TRACE( "found in registry\n" );
 279     }
 280     else goto out;
 281
 282     NtClose( hsubkey );
 283     TRACE(" ComputerName: %s (%lu)\n", debugstr_w ( computer_name ), len / sizeof(WCHAR));
 284
 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;
 289
 290     RtlInitUnicodeString( &nameW, ComputerNameW );
 291     st = NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, computer_name, len );
 292
 293 out:
 294     NtClose( hsubkey );
 295     NtClose( hkey );
 296
 297     if ( st == STATUS_SUCCESS )
 298         TRACE( "success\n" );
 299     else
 300     {
 301         WARN( "status trying to set ComputerName: %lx\n", st );
 302         SetLastError ( RtlNtStatusToDosError ( st ) );
 303     }
 304 }
 305
 306
 307 /***********************************************************************
 308  *              GetComputerNameW         (KERNEL32.@)
 309  */
 310 BOOL WINAPI GetComputerNameW(LPWSTR name,LPDWORD size)
 311 {
 312     UNICODE_STRING nameW;
 313     OBJECT_ATTRIBUTES attr;
 314     HKEY 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;
 319
 320     TRACE ("%p %p\n", name, size);
 321
 322     _init_attr ( &attr, &nameW );
 323     RtlInitUnicodeString( &nameW, ComputerW );
 324     if ( ( st = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
 325         goto out;
 326
 327     attr.RootDirectory = hkey;
 328     RtlInitUnicodeString( &nameW, ActiveComputerNameW );
 329     if ( ( st = NtOpenKey( &hsubkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
 330         goto out;
 331
 332     RtlInitUnicodeString( &nameW, ComputerNameW );
 333     if ( ( st = NtQueryValueKey( hsubkey, &nameW, KeyValuePartialInformation, buf, len, &len ) )
 334          != STATUS_SUCCESS )
 335         goto out;
 336
 337     len = (len -offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data )) / sizeof (WCHAR) - 1;
 338     TRACE ("ComputerName is %s (length %lu)\n", debugstr_w ( theName ), len);
 339
 340     __TRY
 341     {
 342         if ( *size < len )
 343         {
 344             memcpy ( name, theName, *size * sizeof (WCHAR) );
 345             name[*size] = 0;
 346             *size = len;
 347             st = STATUS_MORE_ENTRIES;
 348         }
 349         else
 350         {
 351             memcpy ( name, theName, len * sizeof (WCHAR) );
 352             name[len] = 0;
 353             *size = len;
 354             st = STATUS_SUCCESS;
 355         }
 356     }
 357     __EXCEPT(page_fault)
 358     {
 359         st = STATUS_INVALID_PARAMETER;
 360     }
 361     __ENDTRY
 362
 363 out:
 364     NtClose ( hsubkey );
 365     NtClose ( hkey );
 366
 367     if ( st == STATUS_SUCCESS )
 368         return TRUE;
 369     else
 370     {
 371         SetLastError ( RtlNtStatusToDosError ( st ) );
 372         WARN ( "Status %lu reading computer name from registry\n", st );
 373         return FALSE;
 374     }
 375 }
 376
 377 /***********************************************************************
 378  *              GetComputerNameA         (KERNEL32.@)
 379  */
 380 BOOL WINAPI GetComputerNameA(LPSTR name, LPDWORD size)
 381 {
 382     WCHAR nameW[ MAX_COMPUTERNAME_LENGTH + 1 ];
 383     DWORD sizeW = MAX_COMPUTERNAME_LENGTH;
 384     int len;
 385     BOOL ret;
 386
 387     if ( !GetComputerNameW (nameW, &sizeW) ) return FALSE;
 388
 389     len = WideCharToMultiByte ( CP_ACP, 0, nameW, sizeW, NULL, 0, NULL, 0 );
 390     __TRY
 391     {
 392         if ( *size < len )
 393         {
 394             WideCharToMultiByte ( CP_ACP, 0, nameW, sizeW, name, *size, NULL, 0 );
 395             name[*size] = 0;
 396             *size = len;
 397             SetLastError( ERROR_MORE_DATA );
 398             ret = FALSE;
 399         }
 400         else
 401         {
 402             WideCharToMultiByte ( CP_ACP, 0, nameW, sizeW, name, len, NULL, 0 );
 403             name[len] = 0;
 404             *size = len;
 405             ret = TRUE;
 406         }
 407     }
 408     __EXCEPT(page_fault)
 409     {
 410         SetLastError( ERROR_INVALID_PARAMETER );
 411         ret = FALSE;
 412     }
 413     __ENDTRY
 414
 415     return ret;
 416 }
 417
 418 /***********************************************************************
 419  *              GetComputerNameExA         (KERNEL32.@)
 420  */
 421 BOOL WINAPI GetComputerNameExA(COMPUTER_NAME_FORMAT type, LPSTR name, LPDWORD size)
 422 {
 423     char buf[256];
 424     int len = sizeof (buf), ret;
 425     TRACE("%d, %p, %p\n", type, name, size);
 426     switch( type )
 427     {
 428     case ComputerNameNetBIOS:
 429     case ComputerNamePhysicalNetBIOS:
 430         return GetComputerNameA (name, size);
 431     case ComputerNameDnsHostname:
 432     case ComputerNamePhysicalDnsHostname:
 433         ret = dns_hostname (buf, &len);
 434         break;
 435     case ComputerNameDnsDomain:
 436     case ComputerNamePhysicalDnsDomain:
 437         ret = dns_domainname (buf, &len);
 438         break;
 439     case ComputerNameDnsFullyQualified:
 440     case ComputerNamePhysicalDnsFullyQualified:
 441         ret = dns_fqdn (buf, &len);
 442         break;
 443     default:
 444         SetLastError (ERROR_INVALID_PARAMETER);
 445         return FALSE;
 446     }
 447
 448     if ( ret )
 449     {
 450         TRACE ("-> %s (%d)\n", debugstr_a (buf), len);
 451         __TRY
 452         {
 453             if ( *size < len )
 454             {
 455                 memcpy( name, buf, *size );
 456                 name[*size] = 0;
 457                 *size = len;
 458                 SetLastError( ERROR_MORE_DATA );
 459                 ret = FALSE;
 460             }
 461             else
 462             {
 463                 memcpy( name, buf, len );
 464                 name[len] = 0;
 465                 *size = len;
 466                 ret = TRUE;
 467             }
 468         }
 469         __EXCEPT(page_fault)
 470         {
 471             SetLastError( ERROR_INVALID_PARAMETER );
 472             return FALSE;
 473         }
 474         __ENDTRY
 475     }
 476
 477     return ret;
 478 }
 479
 480
 481 /***********************************************************************
 482  *              GetComputerNameExW         (KERNEL32.@)
 483  */
 484 BOOL WINAPI GetComputerNameExW( COMPUTER_NAME_FORMAT type, LPWSTR name, LPDWORD size )
 485 {
 486     char buf[256];
 487     int len = sizeof (buf), ret;
 488
 489     TRACE("%d, %p, %p\n", type, name, size);
 490     switch( type )
 491     {
 492     case ComputerNameNetBIOS:
 493     case ComputerNamePhysicalNetBIOS:
 494         return GetComputerNameW (name, size);
 495     case ComputerNameDnsHostname:
 496     case ComputerNamePhysicalDnsHostname:
 497         ret = dns_hostname (buf, &len);
 498         break;
 499     case ComputerNameDnsDomain:
 500     case ComputerNamePhysicalDnsDomain:
 501         ret = dns_domainname (buf, &len);
 502         break;
 503     case ComputerNameDnsFullyQualified:
 504     case ComputerNamePhysicalDnsFullyQualified:
 505         ret = dns_fqdn (buf, &len);
 506         break;
 507     default:
 508         SetLastError (ERROR_INVALID_PARAMETER);
 509         return FALSE;
 510     }
 511
 512     if ( ret )
 513     {
 514         TRACE ("-> %s (%d)\n", debugstr_a (buf), len);
 515         __TRY
 516         {
 517             int lenW = MultiByteToWideChar( CP_ACP, 0, buf, len, NULL, 0 );
 518             if ( *size < lenW )
 519             {
 520                 MultiByteToWideChar( CP_ACP, 0, buf, len, name, *size );
 521                 name[*size] = 0;
 522                 *size = lenW;
 523                 SetLastError( ERROR_MORE_DATA );
 524                 ret = FALSE;
 525             }
 526             else
 527             {
 528                 MultiByteToWideChar( CP_ACP, 0, buf, len, name, lenW );
 529                 name[lenW] = 0;
 530                 *size = lenW;
 531                 ret = TRUE;
 532             }
 533         }
 534         __EXCEPT(page_fault)
 535         {
 536             SetLastError( ERROR_INVALID_PARAMETER );
 537             return FALSE;
 538         }
 539         __ENDTRY
 540     }
 541
 542     return ret;
 543 }
 544
 545 /******************************************************************************
 546  * netbios_char (INTERNAL)
 547  */
 548 static WCHAR netbios_char ( WCHAR wc )
 549 {
 550     static const WCHAR special[] = {'!','@','#','$','%','^','&','\'',')','(','-','_','{','}','~'};
 551     static const WCHAR deflt = '_';
 552     int i;
 553
 554     if ( isalnumW ( wc ) ) return wc;
 555     for ( i = 0; i < sizeof (special) / sizeof (WCHAR); i++ )
 556         if ( wc == special[i] ) return wc;
 557     return deflt;
 558 }
 559
 560 /******************************************************************************
 561  * SetComputerNameW [KERNEL32.@]
 562  *
 563  * PARAMS
 564  *    lpComputerName [I] Address of new computer name
 565  *
 566  * RETURNS STD
 567  */
 568 BOOL WINAPI SetComputerNameW( LPCWSTR lpComputerName )
 569 {
 570     UNICODE_STRING nameW;
 571     OBJECT_ATTRIBUTES attr;
 572     HKEY hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
 573     int plen = strlenW ( lpComputerName );
 574     int i;
 575     NTSTATUS st = STATUS_INTERNAL_ERROR;
 576
 577     if (get_use_dns_option())
 578     {
 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 );
 583         return FALSE;
 584     }
 585
 586     TRACE( "%s\n", debugstr_w (lpComputerName) );
 587
 588     /* Check parameter */
 589     if ( plen > MAX_COMPUTERNAME_LENGTH )
 590         goto out;
 591
 592     /* This is NT behaviour. Win 95/98 would coerce characters. */
 593     for ( i = 0; i < plen; i++ )
 594     {
 595         WCHAR wc = lpComputerName[i];
 596         if ( wc != netbios_char( wc ) )
 597             goto out;
 598     }
 599
 600     _init_attr ( &attr, &nameW );
 601
 602     RtlInitUnicodeString (&nameW, ComputerW);
 603     if ( ( st = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
 604         goto out;
 605     attr.RootDirectory = hkey;
 606     RtlInitUnicodeString( &nameW, ComputerNameW );
 607     if ( ( st = NtOpenKey( &hsubkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
 608         goto out;
 609     if ( ( st = NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, lpComputerName, ( plen + 1) * sizeof(WCHAR) ) )
 610          != STATUS_SUCCESS )
 611         goto out;
 612
 613 out:
 614     NtClose( hsubkey );
 615     NtClose( hkey );
 616
 617     if ( st == STATUS_SUCCESS )
 618     {
 619         TRACE( "ComputerName changed\n" );
 620         return TRUE;
 621     }
 622
 623     else
 624     {
 625         SetLastError ( RtlNtStatusToDosError ( st ) );
 626         WARN ( "status %lu\n", st );
 627         return FALSE;
 628     }
 629 }
 630
 631 /******************************************************************************
 632  * SetComputerNameA [KERNEL32.@]
 633  */
 634 BOOL WINAPI SetComputerNameA( LPCSTR lpComputerName )
 635 {
 636     BOOL ret;
 637     DWORD len = MultiByteToWideChar( CP_ACP, 0, lpComputerName, -1, NULL, 0 );
 638     LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 639
 640     MultiByteToWideChar( CP_ACP, 0, lpComputerName, -1, nameW, len );
 641     ret = SetComputerNameW( nameW );
 642     HeapFree( GetProcessHeap(), 0, nameW );
 643     return ret;
 644 }
 645
 646 /******************************************************************************
 647  * SetComputerNameExW [KERNEL32.@]
 648  *
 649  */
 650 BOOL WINAPI SetComputerNameExW( COMPUTER_NAME_FORMAT type, LPCWSTR lpComputerName )
 651 {
 652     TRACE("%d, %s\n", type, debugstr_w (lpComputerName));
 653     switch( type )
 654     {
 655     case ComputerNameNetBIOS:
 656     case ComputerNamePhysicalNetBIOS:
 657         return SetComputerNameW( lpComputerName );
 658     default:
 659         SetLastError( ERROR_ACCESS_DENIED );
 660         return FALSE;
 661     }
 662 }
 663
 664 /******************************************************************************
 665  * SetComputerNameExA [KERNEL32.@]
 666  *
 667  */
 668 BOOL WINAPI SetComputerNameExA( COMPUTER_NAME_FORMAT type, LPCSTR lpComputerName )
 669 {
 670     TRACE( "%d, %s\n", type, debugstr_a (lpComputerName) );
 671     switch( type )
 672     {
 673     case ComputerNameNetBIOS:
 674     case ComputerNamePhysicalNetBIOS:
 675         return SetComputerNameA( lpComputerName );
 676     default:
 677         SetLastError( ERROR_ACCESS_DENIED );
 678         return FALSE;
 679     }
 680 }
 681
 682 /***********************************************************************
 683  *              DnsHostnameToComputerNameA         (KERNEL32.@)
 684  */
 685 BOOL WINAPI DnsHostnameToComputerNameA(LPCSTR Hostname, LPSTR ComputerName,
 686                               LPDWORD nSize)
 687 {
 688     FIXME("(%s, %s, %08lx): stub\n", debugstr_a(Hostname),
 689           debugstr_a(ComputerName), *nSize);
 690     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 691     return FALSE;
 692 }
 693
 694 /***********************************************************************
 695  *              DnsHostnameToComputerNameW         (KERNEL32.@)
 696  */
 697 BOOL WINAPI DnsHostnameToComputerNameW(LPCWSTR Hostname, LPWSTR ComputerName,
 698                               LPDWORD nSize)
 699 {
 700     FIXME("(%s, %s, %08lx): stub\n", debugstr_w(Hostname),
 701           debugstr_w(ComputerName), *nSize);
 702     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 703     return FALSE;
 704 }