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